summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--examples/nft-chain-add.c8
-rw-r--r--examples/nft-chain-del.c4
-rw-r--r--examples/nft-chain-get.c4
-rw-r--r--examples/nft-chain-parse-add.c4
-rw-r--r--examples/nft-rule-add.c10
-rw-r--r--examples/nft-rule-del.c6
-rw-r--r--examples/nft-rule-parse-add.c4
-rw-r--r--examples/nft-ruleset-get.c10
-rw-r--r--examples/nft-ruleset-parse-file.c40
-rw-r--r--examples/nft-set-add.c12
-rw-r--r--examples/nft-set-del.c4
-rw-r--r--examples/nft-set-elem-add.c8
-rw-r--r--examples/nft-set-elem-del.c8
-rw-r--r--examples/nft-set-elem-get.c4
-rw-r--r--examples/nft-set-get.c2
-rw-r--r--examples/nft-set-parse-add.c4
-rw-r--r--examples/nft-table-add.c6
-rw-r--r--examples/nft-table-del.c6
-rw-r--r--examples/nft-table-get.c2
-rw-r--r--examples/nft-table-parse-add.c2
-rw-r--r--examples/nft-table-upd.c4
-rw-r--r--include/libnftnl/chain.h34
-rw-r--r--include/libnftnl/gen.h16
-rw-r--r--include/libnftnl/rule.h26
-rw-r--r--include/libnftnl/ruleset.h8
-rw-r--r--include/libnftnl/set.h44
-rw-r--r--include/libnftnl/table.h24
-rw-r--r--src/chain.c140
-rw-r--r--src/gen.c44
-rw-r--r--src/jansson.c2
-rw-r--r--src/libnftnl.map134
-rw-r--r--src/rule.c98
-rw-r--r--src/ruleset.c50
-rw-r--r--src/set.c112
-rw-r--r--src/set_elem.c60
-rw-r--r--src/table.c84
-rw-r--r--tests/nft-chain-test.c72
-rw-r--r--tests/nft-rule-test.c42
-rw-r--r--tests/nft-set-test.c44
-rw-r--r--tests/nft-table-test.c18
40 files changed, 602 insertions, 602 deletions
diff --git a/examples/nft-chain-add.c b/examples/nft-chain-add.c
index 173af18..3afc06e 100644
--- a/examples/nft-chain-add.c
+++ b/examples/nft-chain-add.c
@@ -48,11 +48,11 @@ static struct nftnl_chain *chain_add_parse(int argc, char *argv[])
perror("OOM");
return NULL;
}
- nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]);
- nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]);
+ nftnl_chain_set(t, NFTNL_CHAIN_TABLE, argv[2]);
+ nftnl_chain_set(t, NFTNL_CHAIN_NAME, argv[3]);
if (argc == 6) {
- nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_HOOKNUM, hooknum);
- nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_PRIO, atoi(argv[5]));
+ nftnl_chain_set_u32(t, NFTNL_CHAIN_HOOKNUM, hooknum);
+ nftnl_chain_set_u32(t, NFTNL_CHAIN_PRIO, atoi(argv[5]));
}
return t;
diff --git a/examples/nft-chain-del.c b/examples/nft-chain-del.c
index 29953d7..b756b46 100644
--- a/examples/nft-chain-del.c
+++ b/examples/nft-chain-del.c
@@ -30,8 +30,8 @@ static struct nftnl_chain *chain_del_parse(int argc, char *argv[])
return NULL;
}
- nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]);
- nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]);
+ nftnl_chain_set(t, NFTNL_CHAIN_TABLE, argv[2]);
+ nftnl_chain_set(t, NFTNL_CHAIN_NAME, argv[3]);
return t;
}
diff --git a/examples/nft-chain-get.c b/examples/nft-chain-get.c
index ead14fc..f5d4593 100644
--- a/examples/nft-chain-get.c
+++ b/examples/nft-chain-get.c
@@ -86,8 +86,8 @@ int main(int argc, char *argv[])
}
nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_GETCHAIN, family,
NLM_F_ACK, seq);
- nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]);
- nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]);
+ nftnl_chain_set(t, NFTNL_CHAIN_TABLE, argv[2]);
+ nftnl_chain_set(t, NFTNL_CHAIN_NAME, argv[3]);
nftnl_chain_nlmsg_build_payload(nlh, t);
nftnl_chain_free(t);
} else if (argc >= 2) {
diff --git a/examples/nft-chain-parse-add.c b/examples/nft-chain-parse-add.c
index baf0087..cf43cc2 100644
--- a/examples/nft-chain-parse-add.c
+++ b/examples/nft-chain-parse-add.c
@@ -103,8 +103,8 @@ int main(int argc, char *argv[])
nftnl_chain_fprintf(stdout, c, outformat, 0);
fprintf(stdout, "\n");
- nftnl_chain_attr_unset(c, NFTNL_CHAIN_HANDLE);
- family = nftnl_chain_attr_get_u32(c, NFTNL_CHAIN_FAMILY);
+ nftnl_chain_unset(c, NFTNL_CHAIN_HANDLE);
+ family = nftnl_chain_get_u32(c, NFTNL_CHAIN_FAMILY);
seq = time(NULL);
batching = nftnl_batch_is_supported();
diff --git a/examples/nft-rule-add.c b/examples/nft-rule-add.c
index a81f459..d27c6d7 100644
--- a/examples/nft-rule-add.c
+++ b/examples/nft-rule-add.c
@@ -93,13 +93,13 @@ static struct nftnl_rule *setup_rule(uint8_t family, const char *table,
exit(EXIT_FAILURE);
}
- nftnl_rule_attr_set(r, NFTNL_RULE_TABLE, table);
- nftnl_rule_attr_set(r, NFTNL_RULE_CHAIN, chain);
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family);
+ nftnl_rule_set(r, NFTNL_RULE_TABLE, table);
+ nftnl_rule_set(r, NFTNL_RULE_CHAIN, chain);
+ nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family);
if (handle != NULL) {
handle_num = atoll(handle);
- nftnl_rule_attr_set_u64(r, NFTNL_RULE_POSITION, handle_num);
+ nftnl_rule_set_u64(r, NFTNL_RULE_POSITION, handle_num);
}
proto = IPPROTO_TCP;
@@ -182,7 +182,7 @@ int main(int argc, char *argv[])
nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWRULE,
- nftnl_rule_attr_get_u32(r, NFTNL_RULE_FAMILY),
+ nftnl_rule_get_u32(r, NFTNL_RULE_FAMILY),
NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK, seq++);
nftnl_rule_nlmsg_build_payload(nlh, r);
diff --git a/examples/nft-rule-del.c b/examples/nft-rule-del.c
index d25d5e9..4bc9727 100644
--- a/examples/nft-rule-del.c
+++ b/examples/nft-rule-del.c
@@ -74,12 +74,12 @@ int main(int argc, char *argv[])
}
seq = time(NULL);
- nftnl_rule_attr_set(r, NFTNL_RULE_TABLE, argv[2]);
- nftnl_rule_attr_set(r, NFTNL_RULE_CHAIN, argv[3]);
+ nftnl_rule_set(r, NFTNL_RULE_TABLE, argv[2]);
+ nftnl_rule_set(r, NFTNL_RULE_CHAIN, argv[3]);
/* If no handle is specified, delete all rules in the chain */
if (argc == 5)
- nftnl_rule_attr_set_u64(r, NFTNL_RULE_HANDLE, atoi(argv[4]));
+ nftnl_rule_set_u64(r, NFTNL_RULE_HANDLE, atoi(argv[4]));
batch = mnl_nlmsg_batch_start(buf, sizeof(buf));
diff --git a/examples/nft-rule-parse-add.c b/examples/nft-rule-parse-add.c
index b296859..3707de3 100644
--- a/examples/nft-rule-parse-add.c
+++ b/examples/nft-rule-parse-add.c
@@ -66,7 +66,7 @@ static struct nftnl_rule *rule_parse_file(const char *file, uint16_t format)
return NULL;
}
- nftnl_rule_attr_unset(r, NFTNL_RULE_HANDLE);
+ nftnl_rule_unset(r, NFTNL_RULE_HANDLE);
nftnl_parse_err_free(err);
return r;
@@ -121,7 +121,7 @@ int main(int argc, char *argv[])
}
rule_seq = seq;
- family = nftnl_rule_attr_get_u32(r, NFTNL_RULE_FAMILY);
+ family = nftnl_rule_get_u32(r, NFTNL_RULE_FAMILY);
nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWRULE, family,
NLM_F_CREATE|NLM_F_APPEND|NLM_F_ACK,
diff --git a/examples/nft-ruleset-get.c b/examples/nft-ruleset-get.c
index 5965f79..2c9d775 100644
--- a/examples/nft-ruleset-get.c
+++ b/examples/nft-ruleset-get.c
@@ -219,7 +219,7 @@ static int mnl_setelem_get(struct mnl_socket *nf_sock, struct nftnl_set *nls)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- uint32_t family = nftnl_set_attr_get_u32(nls, NFTNL_SET_FAMILY);
+ uint32_t family = nftnl_set_get_u32(nls, NFTNL_SET_FAMILY);
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM, family,
NLM_F_DUMP|NLM_F_ACK, seq);
@@ -319,19 +319,19 @@ static struct nftnl_ruleset *mnl_ruleset_dump(struct mnl_socket *nf_sock)
t = mnl_table_dump(nf_sock, NFPROTO_UNSPEC);
if (t != NULL)
- nftnl_ruleset_attr_set(rs, NFTNL_RULESET_TABLELIST, t);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_TABLELIST, t);
c = mnl_chain_dump(nf_sock, NFPROTO_UNSPEC);
if (c != NULL)
- nftnl_ruleset_attr_set(rs, NFTNL_RULESET_CHAINLIST, c);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_CHAINLIST, c);
s = mnl_set_dump(nf_sock, NFPROTO_UNSPEC);
if (s != NULL)
- nftnl_ruleset_attr_set(rs, NFTNL_RULESET_SETLIST, s);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_SETLIST, s);
r = mnl_rule_dump(nf_sock, NFPROTO_UNSPEC);
if (r != NULL)
- nftnl_ruleset_attr_set(rs, NFTNL_RULESET_RULELIST, r);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_RULELIST, r);
return rs;
}
diff --git a/examples/nft-ruleset-parse-file.c b/examples/nft-ruleset-parse-file.c
index 7cb328c..84dc304 100644
--- a/examples/nft-ruleset-parse-file.c
+++ b/examples/nft-ruleset-parse-file.c
@@ -69,7 +69,7 @@ static int nftnl_ruleset_set_elems(const struct nftnl_parse_ctx *ctx)
goto err;
nlh = nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch), nl_type,
- nftnl_set_attr_get_u32(set,
+ nftnl_set_get_u32(set,
NFTNL_SET_FAMILY),
nl_flags, seq++);
@@ -82,7 +82,7 @@ err:
return -1;
}
-static int nftnl_ruleset_set(const struct nftnl_parse_ctx *ctx)
+static int nftnl_ruleset_parse_set(const struct nftnl_parse_ctx *ctx)
{
struct nlmsghdr *nlh;
@@ -112,7 +112,7 @@ static int nftnl_ruleset_set(const struct nftnl_parse_ctx *ctx)
nlh = nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
nl_type,
- nftnl_set_attr_get_u32(set,
+ nftnl_set_get_u32(set,
NFTNL_SET_FAMILY),
nl_flags,
seq++);
@@ -136,7 +136,7 @@ static int nftnl_ruleset_rule_build_msg(const struct nftnl_parse_ctx *ctx,
case NFTNL_CMD_ADD:
nl_type = NFT_MSG_NEWRULE;
nl_flags = NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK;
- nftnl_rule_attr_unset(rule, NFTNL_RULE_HANDLE);
+ nftnl_rule_unset(rule, NFTNL_RULE_HANDLE);
break;
case NFTNL_CMD_DELETE:
nl_type = NFT_MSG_DELRULE;
@@ -149,7 +149,7 @@ static int nftnl_ruleset_rule_build_msg(const struct nftnl_parse_ctx *ctx,
case NFTNL_CMD_INSERT:
nl_type = NFT_MSG_NEWRULE;
nl_flags = NLM_F_CREATE|NLM_F_ACK;
- nftnl_rule_attr_unset(rule, NFTNL_RULE_HANDLE);
+ nftnl_rule_unset(rule, NFTNL_RULE_HANDLE);
break;
default:
return -1;
@@ -157,7 +157,7 @@ static int nftnl_ruleset_rule_build_msg(const struct nftnl_parse_ctx *ctx,
nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
nl_type,
- nftnl_rule_attr_get_u32(rule,
+ nftnl_rule_get_u32(rule,
NFTNL_RULE_FAMILY),
nl_flags,
seq++);
@@ -201,21 +201,21 @@ static int nftnl_ruleset_flush_rules(const struct nftnl_parse_ctx *ctx)
switch (type) {
case NFTNL_RULESET_TABLE:
nlt = nftnl_ruleset_ctx_get(ctx, NFTNL_RULESET_CTX_TABLE);
- nftnl_rule_attr_set(nlr, NFTNL_RULE_TABLE,
- nftnl_table_attr_get(nlt, NFTNL_TABLE_NAME));
- nftnl_rule_attr_set(nlr, NFTNL_RULE_FAMILY,
- nftnl_table_attr_get(nlt, NFTNL_TABLE_FAMILY));
+ nftnl_rule_set(nlr, NFTNL_RULE_TABLE,
+ nftnl_table_get(nlt, NFTNL_TABLE_NAME));
+ nftnl_rule_set(nlr, NFTNL_RULE_FAMILY,
+ nftnl_table_get(nlt, NFTNL_TABLE_FAMILY));
break;
case NFTNL_RULESET_CHAIN:
nlc = nftnl_ruleset_ctx_get(ctx, NFTNL_RULESET_CTX_CHAIN);
- nftnl_rule_attr_set(nlr, NFTNL_RULE_TABLE,
- nftnl_chain_attr_get(nlc,
+ nftnl_rule_set(nlr, NFTNL_RULE_TABLE,
+ nftnl_chain_get(nlc,
NFTNL_CHAIN_TABLE));
- nftnl_rule_attr_set(nlr, NFTNL_RULE_CHAIN,
- nftnl_chain_attr_get(nlc,
+ nftnl_rule_set(nlr, NFTNL_RULE_CHAIN,
+ nftnl_chain_get(nlc,
NFTNL_CHAIN_NAME));
- nftnl_rule_attr_set(nlr, NFTNL_RULE_FAMILY,
- nftnl_chain_attr_get(nlc, NFTNL_TABLE_FAMILY));
+ nftnl_rule_set(nlr, NFTNL_RULE_FAMILY,
+ nftnl_chain_get(nlc, NFTNL_TABLE_FAMILY));
break;
default:
goto err;
@@ -258,10 +258,10 @@ static int nftnl_ruleset_chain(const struct nftnl_parse_ctx *ctx)
goto err;
}
- nftnl_chain_attr_unset(chain, NFTNL_CHAIN_HANDLE);
+ nftnl_chain_unset(chain, NFTNL_CHAIN_HANDLE);
nlh = nftnl_chain_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
nl_type,
- nftnl_chain_attr_get_u32(chain,
+ nftnl_chain_get_u32(chain,
NFTNL_CHAIN_FAMILY),
nl_flags,
seq++);
@@ -297,7 +297,7 @@ static int nftnl_ruleset_table_build_msg(const struct nftnl_parse_ctx *ctx,
nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
nl_type,
- nftnl_table_attr_get_u32(table,
+ nftnl_table_get_u32(table,
NFTNL_TABLE_FAMILY),
nl_flags,
seq++);
@@ -358,7 +358,7 @@ static int ruleset_elems_cb(const struct nftnl_parse_ctx *ctx)
ret = nftnl_ruleset_rule(ctx);
break;
case NFTNL_RULESET_SET:
- ret = nftnl_ruleset_set(ctx);
+ ret = nftnl_ruleset_parse_set(ctx);
break;
case NFTNL_RULESET_SET_ELEMS:
ret = nftnl_ruleset_set_elems(ctx);
diff --git a/examples/nft-set-add.c b/examples/nft-set-add.c
index a29115c..e040aca 100644
--- a/examples/nft-set-add.c
+++ b/examples/nft-set-add.c
@@ -39,12 +39,12 @@ static struct nftnl_set *setup_set(uint8_t family, const char *table,
exit(EXIT_FAILURE);
}
- nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table);
- nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name);
- nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family);
- nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, 2);
- nftnl_set_attr_set_u32(s, NFTNL_SET_ID, 1);
- nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, NFT_SET_CONSTANT);
+ nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
+ nftnl_set_set_str(s, NFTNL_SET_NAME, name);
+ nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
+ nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, 2);
+ nftnl_set_set_u32(s, NFTNL_SET_ID, 1);
+ nftnl_set_set_u32(s, NFTNL_SET_FLAGS, NFT_SET_CONSTANT);
return s;
}
diff --git a/examples/nft-set-del.c b/examples/nft-set-del.c
index ae87608..5e1fad3 100644
--- a/examples/nft-set-del.c
+++ b/examples/nft-set-del.c
@@ -56,8 +56,8 @@ int main(int argc, char *argv[])
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_DELSET, family,
NLM_F_ACK, seq);
- nftnl_set_attr_set(t, NFTNL_SET_TABLE, argv[2]);
- nftnl_set_attr_set(t, NFTNL_SET_NAME, argv[3]);
+ nftnl_set_set(t, NFTNL_SET_TABLE, argv[2]);
+ nftnl_set_set(t, NFTNL_SET_NAME, argv[3]);
nftnl_set_nlmsg_build_payload(nlh, t);
nftnl_set_free(t);
diff --git a/examples/nft-set-elem-add.c b/examples/nft-set-elem-add.c
index 178c1a2..609b7bb 100644
--- a/examples/nft-set-elem-add.c
+++ b/examples/nft-set-elem-add.c
@@ -55,8 +55,8 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
- nftnl_set_attr_set(s, NFTNL_SET_TABLE, argv[2]);
- nftnl_set_attr_set(s, NFTNL_SET_NAME, argv[3]);
+ nftnl_set_set(s, NFTNL_SET_TABLE, argv[2]);
+ nftnl_set_set(s, NFTNL_SET_NAME, argv[3]);
/* Add to dummy elements to set */
e = nftnl_set_elem_alloc();
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
}
data = 0x1;
- nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+ nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
nftnl_set_elem_add(s, e);
e = nftnl_set_elem_alloc();
@@ -75,7 +75,7 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
data = 0x2;
- nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+ nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
nftnl_set_elem_add(s, e);
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSETELEM, family,
diff --git a/examples/nft-set-elem-del.c b/examples/nft-set-elem-del.c
index 9897ff7..b53a86b 100644
--- a/examples/nft-set-elem-del.c
+++ b/examples/nft-set-elem-del.c
@@ -55,8 +55,8 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
- nftnl_set_attr_set(s, NFTNL_SET_TABLE, argv[2]);
- nftnl_set_attr_set(s, NFTNL_SET_NAME, argv[3]);
+ nftnl_set_set(s, NFTNL_SET_TABLE, argv[2]);
+ nftnl_set_set(s, NFTNL_SET_NAME, argv[3]);
/* Add to dummy elements to set */
e = nftnl_set_elem_alloc();
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
}
data = 0x1;
- nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+ nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
nftnl_set_elem_add(s, e);
e = nftnl_set_elem_alloc();
@@ -75,7 +75,7 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
data = 0x2;
- nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+ nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
nftnl_set_elem_add(s, e);
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_DELSETELEM, family,
diff --git a/examples/nft-set-elem-get.c b/examples/nft-set-elem-get.c
index f8d184b..9c637ee 100644
--- a/examples/nft-set-elem-get.c
+++ b/examples/nft-set-elem-get.c
@@ -87,8 +87,8 @@ int main(int argc, char *argv[])
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM, family,
NLM_F_DUMP|NLM_F_ACK, seq);
- nftnl_set_attr_set(t, NFTNL_SET_NAME, argv[3]);
- nftnl_set_attr_set(t, NFTNL_SET_TABLE, argv[2]);
+ nftnl_set_set(t, NFTNL_SET_NAME, argv[3]);
+ nftnl_set_set(t, NFTNL_SET_TABLE, argv[2]);
nftnl_set_elems_nlmsg_build_payload(nlh, t);
nftnl_set_free(t);
diff --git a/examples/nft-set-get.c b/examples/nft-set-get.c
index a8a133f..245ac5f 100644
--- a/examples/nft-set-get.c
+++ b/examples/nft-set-get.c
@@ -89,7 +89,7 @@ int main(int argc, char *argv[])
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET, family,
NLM_F_DUMP|NLM_F_ACK, seq);
/* Use this below if you want to obtain sets per table */
-/* nftnl_set_attr_set(t, NFT_SET_TABLE, argv[2]); */
+/* nftnl_set_set(t, NFT_SET_TABLE, argv[2]); */
nftnl_set_nlmsg_build_payload(nlh, t);
nftnl_set_free(t);
diff --git a/examples/nft-set-parse-add.c b/examples/nft-set-parse-add.c
index b3fffc5..3648730 100644
--- a/examples/nft-set-parse-add.c
+++ b/examples/nft-set-parse-add.c
@@ -68,7 +68,7 @@ static struct nftnl_set *set_parse_file(const char *file, uint16_t format)
nftnl_parse_err_free(err);
- nftnl_set_attr_set_u32(s, NFTNL_SET_ID, 1);
+ nftnl_set_set_u32(s, NFTNL_SET_ID, 1);
return s;
}
@@ -121,7 +121,7 @@ int main(int argc, char *argv[])
mnl_nlmsg_batch_next(batch);
}
- family = nftnl_set_attr_get_u32(s, NFTNL_SET_FAMILY);
+ family = nftnl_set_get_u32(s, NFTNL_SET_FAMILY);
set_seq = seq;
nlh = nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
diff --git a/examples/nft-table-add.c b/examples/nft-table-add.c
index bc36333..db6e39e 100644
--- a/examples/nft-table-add.c
+++ b/examples/nft-table-add.c
@@ -44,8 +44,8 @@ static struct nftnl_table *table_add_parse(int argc, char *argv[])
return NULL;
}
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
- nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, argv[2]);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
+ nftnl_table_set_str(t, NFTNL_TABLE_NAME, argv[2]);
return t;
}
@@ -84,7 +84,7 @@ int main(int argc, char *argv[])
}
table_seq = seq;
- family = nftnl_table_attr_get_u32(t, NFTNL_TABLE_FAMILY);
+ family = nftnl_table_get_u32(t, NFTNL_TABLE_FAMILY);
nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWTABLE, family,
NLM_F_ACK, seq++);
diff --git a/examples/nft-table-del.c b/examples/nft-table-del.c
index f3699c7..9d1f3be 100644
--- a/examples/nft-table-del.c
+++ b/examples/nft-table-del.c
@@ -44,8 +44,8 @@ static struct nftnl_table *table_del_parse(int argc, char *argv[])
return NULL;
}
- nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, argv[2]);
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
+ nftnl_table_set_str(t, NFTNL_TABLE_NAME, argv[2]);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
return t;
}
@@ -84,7 +84,7 @@ int main(int argc, char *argv[])
}
table_seq = seq;
- family = nftnl_table_attr_get_u32(t, NFTNL_TABLE_FAMILY);
+ family = nftnl_table_get_u32(t, NFTNL_TABLE_FAMILY);
nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_DELTABLE, family,
NLM_F_ACK, seq++);
diff --git a/examples/nft-table-get.c b/examples/nft-table-get.c
index 84524b0..d648a11 100644
--- a/examples/nft-table-get.c
+++ b/examples/nft-table-get.c
@@ -104,7 +104,7 @@ int main(int argc, char *argv[])
} else {
nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_GETTABLE, family,
NLM_F_ACK, seq);
- nftnl_table_attr_set(t, NFTNL_TABLE_NAME, argv[2]);
+ nftnl_table_set(t, NFTNL_TABLE_NAME, argv[2]);
nftnl_table_nlmsg_build_payload(nlh, t);
nftnl_table_free(t);
}
diff --git a/examples/nft-table-parse-add.c b/examples/nft-table-parse-add.c
index 6a34f56..31d31cc 100644
--- a/examples/nft-table-parse-add.c
+++ b/examples/nft-table-parse-add.c
@@ -116,7 +116,7 @@ int main(int argc, char *argv[])
mnl_nlmsg_batch_next(batch);
}
- family = nftnl_table_attr_get_u32(t, NFTNL_TABLE_FAMILY);
+ family = nftnl_table_get_u32(t, NFTNL_TABLE_FAMILY);
table_seq = seq;
nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
diff --git a/examples/nft-table-upd.c b/examples/nft-table-upd.c
index 5b14e54..686b5a7 100644
--- a/examples/nft-table-upd.c
+++ b/examples/nft-table-upd.c
@@ -63,8 +63,8 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
- nftnl_table_attr_set(t, NFTNL_TABLE_NAME, argv[2]);
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags);
+ nftnl_table_set(t, NFTNL_TABLE_NAME, argv[2]);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags);
nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE, family,
NLM_F_ACK, seq);
diff --git a/include/libnftnl/chain.h b/include/libnftnl/chain.h
index 9fd637d..9ac8830 100644
--- a/include/libnftnl/chain.h
+++ b/include/libnftnl/chain.h
@@ -34,25 +34,25 @@ enum nftnl_chain_attr {
};
#define NFTNL_CHAIN_MAX (__NFTNL_CHAIN_MAX - 1)
-bool nftnl_chain_attr_is_set(const struct nftnl_chain *c, uint16_t attr);
-void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr);
-void nftnl_chain_attr_set(struct nftnl_chain *t, uint16_t attr, const void *data);
-void nftnl_chain_attr_set_data(struct nftnl_chain *t, uint16_t attr,
+bool nftnl_chain_is_set(const struct nftnl_chain *c, uint16_t attr);
+void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr);
+void nftnl_chain_set(struct nftnl_chain *t, uint16_t attr, const void *data);
+void nftnl_chain_set_data(struct nftnl_chain *t, uint16_t attr,
const void *data, uint32_t data_len);
-void nftnl_chain_attr_set_u8(struct nftnl_chain *t, uint16_t attr, uint8_t data);
-void nftnl_chain_attr_set_u32(struct nftnl_chain *t, uint16_t attr, uint32_t data);
-void nftnl_chain_attr_set_s32(struct nftnl_chain *t, uint16_t attr, int32_t data);
-void nftnl_chain_attr_set_u64(struct nftnl_chain *t, uint16_t attr, uint64_t data);
-void nftnl_chain_attr_set_str(struct nftnl_chain *t, uint16_t attr, const char *str);
-
-const void *nftnl_chain_attr_get(struct nftnl_chain *c, uint16_t attr);
-const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr,
+void nftnl_chain_set_u8(struct nftnl_chain *t, uint16_t attr, uint8_t data);
+void nftnl_chain_set_u32(struct nftnl_chain *t, uint16_t attr, uint32_t data);
+void nftnl_chain_set_s32(struct nftnl_chain *t, uint16_t attr, int32_t data);
+void nftnl_chain_set_u64(struct nftnl_chain *t, uint16_t attr, uint64_t data);
+void nftnl_chain_set_str(struct nftnl_chain *t, uint16_t attr, const char *str);
+
+const void *nftnl_chain_get(struct nftnl_chain *c, uint16_t attr);
+const void *nftnl_chain_get_data(struct nftnl_chain *c, uint16_t attr,
uint32_t *data_len);
-const char *nftnl_chain_attr_get_str(struct nftnl_chain *c, uint16_t attr);
-uint8_t nftnl_chain_attr_get_u8(struct nftnl_chain *c, uint16_t attr);
-uint32_t nftnl_chain_attr_get_u32(struct nftnl_chain *c, uint16_t attr);
-int32_t nftnl_chain_attr_get_s32(struct nftnl_chain *c, uint16_t attr);
-uint64_t nftnl_chain_attr_get_u64(struct nftnl_chain *c, uint16_t attr);
+const char *nftnl_chain_get_str(struct nftnl_chain *c, uint16_t attr);
+uint8_t nftnl_chain_get_u8(struct nftnl_chain *c, uint16_t attr);
+uint32_t nftnl_chain_get_u32(struct nftnl_chain *c, uint16_t attr);
+int32_t nftnl_chain_get_s32(struct nftnl_chain *c, uint16_t attr);
+uint64_t nftnl_chain_get_u64(struct nftnl_chain *c, uint16_t attr);
struct nlmsghdr;
diff --git a/include/libnftnl/gen.h b/include/libnftnl/gen.h
index 1bb2d56..3eb8470 100644
--- a/include/libnftnl/gen.h
+++ b/include/libnftnl/gen.h
@@ -23,17 +23,17 @@ enum {
};
#define NFTNL_GEN_MAX (__NFTNL_GEN_MAX - 1)
-bool nftnl_gen_attr_is_set(const struct nftnl_gen *gen, uint16_t attr);
-void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr);
-void nftnl_gen_attr_set(struct nftnl_gen *gen, uint16_t attr, const void *data);
-void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr,
+bool nftnl_gen_is_set(const struct nftnl_gen *gen, uint16_t attr);
+void nftnl_gen_unset(struct nftnl_gen *gen, uint16_t attr);
+void nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data);
+void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
const void *data, uint32_t data_len);
-const void *nftnl_gen_attr_get(struct nftnl_gen *gen, uint16_t attr);
-const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr,
+const void *nftnl_gen_get(struct nftnl_gen *gen, uint16_t attr);
+const void *nftnl_gen_get_data(struct nftnl_gen *gen, uint16_t attr,
uint32_t *data_len);
-void nftnl_gen_attr_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t data);
-uint32_t nftnl_gen_attr_get_u32(struct nftnl_gen *gen, uint16_t attr);
+void nftnl_gen_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t data);
+uint32_t nftnl_gen_get_u32(struct nftnl_gen *gen, uint16_t attr);
struct nlmsghdr;
int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen);
diff --git a/include/libnftnl/rule.h b/include/libnftnl/rule.h
index 3cc79bd..d5b50ad 100644
--- a/include/libnftnl/rule.h
+++ b/include/libnftnl/rule.h
@@ -31,22 +31,22 @@ enum nftnl_rule_attr {
};
#define NFTNL_RULE_MAX (__NFTNL_RULE_MAX - 1)
-void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr);
-bool nftnl_rule_attr_is_set(const struct nftnl_rule *r, uint16_t attr);
-void nftnl_rule_attr_set(struct nftnl_rule *r, uint16_t attr, const void *data);
-void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr,
+void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr);
+bool nftnl_rule_is_set(const struct nftnl_rule *r, uint16_t attr);
+void nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data);
+void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
const void *data, uint32_t data_len);
-void nftnl_rule_attr_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val);
-void nftnl_rule_attr_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val);
-void nftnl_rule_attr_set_str(struct nftnl_rule *r, uint16_t attr, const char *str);
+void nftnl_rule_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val);
+void nftnl_rule_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val);
+void nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str);
-const void *nftnl_rule_attr_get(const struct nftnl_rule *r, uint16_t attr);
-const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr,
+const void *nftnl_rule_get(const struct nftnl_rule *r, uint16_t attr);
+const void *nftnl_rule_get_data(const struct nftnl_rule *r, uint16_t attr,
uint32_t *data_len);
-const char *nftnl_rule_attr_get_str(const struct nftnl_rule *r, uint16_t attr);
-uint8_t nftnl_rule_attr_get_u8(const struct nftnl_rule *r, uint16_t attr);
-uint32_t nftnl_rule_attr_get_u32(const struct nftnl_rule *r, uint16_t attr);
-uint64_t nftnl_rule_attr_get_u64(const struct nftnl_rule *r, uint16_t attr);
+const char *nftnl_rule_get_str(const struct nftnl_rule *r, uint16_t attr);
+uint8_t nftnl_rule_get_u8(const struct nftnl_rule *r, uint16_t attr);
+uint32_t nftnl_rule_get_u32(const struct nftnl_rule *r, uint16_t attr);
+uint64_t nftnl_rule_get_u64(const struct nftnl_rule *r, uint16_t attr);
void nftnl_rule_add_expr(struct nftnl_rule *r, struct nftnl_expr *expr);
diff --git a/include/libnftnl/ruleset.h b/include/libnftnl/ruleset.h
index a627e1d..c184af6 100644
--- a/include/libnftnl/ruleset.h
+++ b/include/libnftnl/ruleset.h
@@ -35,10 +35,10 @@ enum nftnl_ruleset_type {
NFTNL_RULESET_SET_ELEMS,
};
-bool nftnl_ruleset_attr_is_set(const struct nftnl_ruleset *r, uint16_t attr);
-void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr);
-void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data);
-void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr);
+bool nftnl_ruleset_is_set(const struct nftnl_ruleset *r, uint16_t attr);
+void nftnl_ruleset_unset(struct nftnl_ruleset *r, uint16_t attr);
+void nftnl_ruleset_set(struct nftnl_ruleset *r, uint16_t attr, void *data);
+void *nftnl_ruleset_get(const struct nftnl_ruleset *r, uint16_t attr);
enum {
NFTNL_RULESET_CTX_CMD = 0,
diff --git a/include/libnftnl/set.h b/include/libnftnl/set.h
index bee8dfa..11243f5 100644
--- a/include/libnftnl/set.h
+++ b/include/libnftnl/set.h
@@ -33,21 +33,21 @@ void nftnl_set_free(struct nftnl_set *s);
struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set);
-bool nftnl_set_attr_is_set(const struct nftnl_set *s, uint16_t attr);
-void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr);
-void nftnl_set_attr_set(struct nftnl_set *s, uint16_t attr, const void *data);
-void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
+bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr);
+void nftnl_set_unset(struct nftnl_set *s, uint16_t attr);
+void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data);
+void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
uint32_t data_len);
-void nftnl_set_attr_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val);
-void nftnl_set_attr_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val);
-void nftnl_set_attr_set_str(struct nftnl_set *s, uint16_t attr, const char *str);
+void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val);
+void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val);
+void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str);
-const void *nftnl_set_attr_get(struct nftnl_set *s, uint16_t attr);
-const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr,
+const void *nftnl_set_get(struct nftnl_set *s, uint16_t attr);
+const void *nftnl_set_get_data(struct nftnl_set *s, uint16_t attr,
uint32_t *data_len);
-const char *nftnl_set_attr_get_str(struct nftnl_set *s, uint16_t attr);
-uint32_t nftnl_set_attr_get_u32(struct nftnl_set *s, uint16_t attr);
-uint64_t nftnl_set_attr_get_u64(struct nftnl_set *s, uint16_t attr);
+const char *nftnl_set_get_str(struct nftnl_set *s, uint16_t attr);
+uint32_t nftnl_set_get_u32(struct nftnl_set *s, uint16_t attr);
+uint64_t nftnl_set_get_u64(struct nftnl_set *s, uint16_t attr);
struct nlmsghdr;
@@ -105,18 +105,18 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem);
void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem);
-void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr);
-void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len);
-void nftnl_set_elem_attr_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val);
-void nftnl_set_elem_attr_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val);
-void nftnl_set_elem_attr_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str);
+void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr);
+void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len);
+void nftnl_set_elem_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val);
+void nftnl_set_elem_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val);
+void nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str);
-const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len);
-const char *nftnl_set_elem_attr_get_str(struct nftnl_set_elem *s, uint16_t attr);
-uint32_t nftnl_set_elem_attr_get_u32(struct nftnl_set_elem *s, uint16_t attr);
-uint64_t nftnl_set_elem_attr_get_u64(struct nftnl_set_elem *s, uint16_t attr);
+const void *nftnl_set_elem_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len);
+const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr);
+uint32_t nftnl_set_elem_get_u32(struct nftnl_set_elem *s, uint16_t attr);
+uint64_t nftnl_set_elem_get_u64(struct nftnl_set_elem *s, uint16_t attr);
-bool nftnl_set_elem_attr_is_set(const struct nftnl_set_elem *s, uint16_t attr);
+bool nftnl_set_elem_is_set(const struct nftnl_set_elem *s, uint16_t attr);
#define nftnl_set_elem_nlmsg_build_hdr nftnl_nlmsg_build_hdr
void nftnl_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s);
diff --git a/include/libnftnl/table.h b/include/libnftnl/table.h
index d18d348..c52d579 100644
--- a/include/libnftnl/table.h
+++ b/include/libnftnl/table.h
@@ -26,21 +26,21 @@ enum nftnl_table_attr {
};
#define NFTNL_TABLE_MAX (__NFTNL_TABLE_MAX - 1)
-bool nftnl_table_attr_is_set(const struct nftnl_table *t, uint16_t attr);
-void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr);
-void nftnl_table_attr_set(struct nftnl_table *t, uint16_t attr, const void *data);
-void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr,
+bool nftnl_table_is_set(const struct nftnl_table *t, uint16_t attr);
+void nftnl_table_unset(struct nftnl_table *t, uint16_t attr);
+void nftnl_table_set(struct nftnl_table *t, uint16_t attr, const void *data);
+void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
const void *data, uint32_t data_len);
-const void *nftnl_table_attr_get(struct nftnl_table *t, uint16_t attr);
-const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr,
+const void *nftnl_table_get(struct nftnl_table *t, uint16_t attr);
+const void *nftnl_table_get_data(struct nftnl_table *t, uint16_t attr,
uint32_t *data_len);
-void nftnl_table_attr_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t data);
-void nftnl_table_attr_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t data);
-void nftnl_table_attr_set_str(struct nftnl_table *t, uint16_t attr, const char *str);
-uint8_t nftnl_table_attr_get_u8(struct nftnl_table *t, uint16_t attr);
-uint32_t nftnl_table_attr_get_u32(struct nftnl_table *t, uint16_t attr);
-const char *nftnl_table_attr_get_str(struct nftnl_table *t, uint16_t attr);
+void nftnl_table_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t data);
+void nftnl_table_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t data);
+void nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str);
+uint8_t nftnl_table_get_u8(struct nftnl_table *t, uint16_t attr);
+uint32_t nftnl_table_get_u32(struct nftnl_table *t, uint16_t attr);
+const char *nftnl_table_get_str(struct nftnl_table *t, uint16_t attr);
struct nlmsghdr;
diff --git a/src/chain.c b/src/chain.c
index f40e6a3..8a8e8b8 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -106,13 +106,13 @@ void nftnl_chain_free(struct nftnl_chain *c)
}
EXPORT_SYMBOL(nftnl_chain_free, nft_chain_free);
-bool nftnl_chain_attr_is_set(const struct nftnl_chain *c, uint16_t attr)
+bool nftnl_chain_is_set(const struct nftnl_chain *c, uint16_t attr)
{
return c->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_chain_attr_is_set, nft_chain_attr_is_set);
+EXPORT_SYMBOL(nftnl_chain_is_set, nft_chain_attr_is_set);
-void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr)
+void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
{
if (!(c->flags & (1 << attr)))
return;
@@ -153,9 +153,9 @@ void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr)
c->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_chain_attr_unset, nft_chain_attr_unset);
+EXPORT_SYMBOL(nftnl_chain_unset, nft_chain_attr_unset);
-static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_MAX + 1] = {
+static uint32_t nftnl_chain_validate[NFTNL_CHAIN_MAX + 1] = {
[NFTNL_CHAIN_HOOKNUM] = sizeof(uint32_t),
[NFTNL_CHAIN_PRIO] = sizeof(int32_t),
[NFTNL_CHAIN_POLICY] = sizeof(uint32_t),
@@ -165,13 +165,13 @@ static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_MAX + 1] = {
[NFTNL_CHAIN_FAMILY] = sizeof(uint32_t),
};
-void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr,
+void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
const void *data, uint32_t data_len)
{
if (attr > NFTNL_CHAIN_MAX)
return;
- nftnl_assert_validate(data, nftnl_chain_attr_validate, attr, data_len);
+ nftnl_assert_validate(data, nftnl_chain_validate, attr, data_len);
switch(attr) {
case NFTNL_CHAIN_NAME:
@@ -222,45 +222,45 @@ void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr,
}
c->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_chain_attr_set_data, nft_chain_attr_set_data);
+EXPORT_SYMBOL(nftnl_chain_set_data, nft_chain_attr_set_data);
-void nftnl_chain_attr_set(struct nftnl_chain *c, uint16_t attr, const void *data)
+void nftnl_chain_set(struct nftnl_chain *c, uint16_t attr, const void *data)
{
- nftnl_chain_attr_set_data(c, attr, data, nftnl_chain_attr_validate[attr]);
+ nftnl_chain_set_data(c, attr, data, nftnl_chain_validate[attr]);
}
-EXPORT_SYMBOL(nftnl_chain_attr_set, nft_chain_attr_set);
+EXPORT_SYMBOL(nftnl_chain_set, nft_chain_attr_set);
-void nftnl_chain_attr_set_u32(struct nftnl_chain *c, uint16_t attr, uint32_t data)
+void nftnl_chain_set_u32(struct nftnl_chain *c, uint16_t attr, uint32_t data)
{
- nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint32_t));
+ nftnl_chain_set_data(c, attr, &data, sizeof(uint32_t));
}
-EXPORT_SYMBOL(nftnl_chain_attr_set_u32, nft_chain_attr_set_u32);
+EXPORT_SYMBOL(nftnl_chain_set_u32, nft_chain_attr_set_u32);
-void nftnl_chain_attr_set_s32(struct nftnl_chain *c, uint16_t attr, int32_t data)
+void nftnl_chain_set_s32(struct nftnl_chain *c, uint16_t attr, int32_t data)
{
- nftnl_chain_attr_set_data(c, attr, &data, sizeof(int32_t));
+ nftnl_chain_set_data(c, attr, &data, sizeof(int32_t));
}
-EXPORT_SYMBOL(nftnl_chain_attr_set_s32, nft_chain_attr_set_s32);
+EXPORT_SYMBOL(nftnl_chain_set_s32, nft_chain_attr_set_s32);
-void nftnl_chain_attr_set_u64(struct nftnl_chain *c, uint16_t attr, uint64_t data)
+void nftnl_chain_set_u64(struct nftnl_chain *c, uint16_t attr, uint64_t data)
{
- nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint64_t));
+ nftnl_chain_set_data(c, attr, &data, sizeof(uint64_t));
}
-EXPORT_SYMBOL(nftnl_chain_attr_set_u64, nft_chain_attr_set_u64);
+EXPORT_SYMBOL(nftnl_chain_set_u64, nft_chain_attr_set_u64);
-void nftnl_chain_attr_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data)
+void nftnl_chain_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data)
{
- nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint8_t));
+ nftnl_chain_set_data(c, attr, &data, sizeof(uint8_t));
}
-EXPORT_SYMBOL(nftnl_chain_attr_set_u8, nft_chain_attr_set_u8);
+EXPORT_SYMBOL(nftnl_chain_set_u8, nft_chain_attr_set_u8);
-void nftnl_chain_attr_set_str(struct nftnl_chain *c, uint16_t attr, const char *str)
+void nftnl_chain_set_str(struct nftnl_chain *c, uint16_t attr, const char *str)
{
- nftnl_chain_attr_set_data(c, attr, str, strlen(str));
+ nftnl_chain_set_data(c, attr, str, strlen(str));
}
-EXPORT_SYMBOL(nftnl_chain_attr_set_str, nft_chain_attr_set_str);
+EXPORT_SYMBOL(nftnl_chain_set_str, nft_chain_attr_set_str);
-const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr,
+const void *nftnl_chain_get_data(struct nftnl_chain *c, uint16_t attr,
uint32_t *data_len)
{
if (!(c->flags & (1 << attr)))
@@ -303,64 +303,64 @@ const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL(nftnl_chain_attr_get_data, nft_chain_attr_get_data);
+EXPORT_SYMBOL(nftnl_chain_get_data, nft_chain_attr_get_data);
-const void *nftnl_chain_attr_get(struct nftnl_chain *c, uint16_t attr)
+const void *nftnl_chain_get(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- return nftnl_chain_attr_get_data(c, attr, &data_len);
+ return nftnl_chain_get_data(c, attr, &data_len);
}
-EXPORT_SYMBOL(nftnl_chain_attr_get, nft_chain_attr_get);
+EXPORT_SYMBOL(nftnl_chain_get, nft_chain_attr_get);
-const char *nftnl_chain_attr_get_str(struct nftnl_chain *c, uint16_t attr)
+const char *nftnl_chain_get_str(struct nftnl_chain *c, uint16_t attr)
{
- return nftnl_chain_attr_get(c, attr);
+ return nftnl_chain_get(c, attr);
}
-EXPORT_SYMBOL(nftnl_chain_attr_get_str, nft_chain_attr_get_str);
+EXPORT_SYMBOL(nftnl_chain_get_str, nft_chain_attr_get_str);
-uint32_t nftnl_chain_attr_get_u32(struct nftnl_chain *c, uint16_t attr)
+uint32_t nftnl_chain_get_u32(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const uint32_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
+ const uint32_t *val = nftnl_chain_get_data(c, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(uint32_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_chain_attr_get_u32, nft_chain_attr_get_u32);
+EXPORT_SYMBOL(nftnl_chain_get_u32, nft_chain_attr_get_u32);
-int32_t nftnl_chain_attr_get_s32(struct nftnl_chain *c, uint16_t attr)
+int32_t nftnl_chain_get_s32(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const int32_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
+ const int32_t *val = nftnl_chain_get_data(c, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(int32_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_chain_attr_get_s32, nft_chain_attr_get_s32);
+EXPORT_SYMBOL(nftnl_chain_get_s32, nft_chain_attr_get_s32);
-uint64_t nftnl_chain_attr_get_u64(struct nftnl_chain *c, uint16_t attr)
+uint64_t nftnl_chain_get_u64(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const uint64_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
+ const uint64_t *val = nftnl_chain_get_data(c, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(int64_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_chain_attr_get_u64, nft_chain_attr_get_u64);
+EXPORT_SYMBOL(nftnl_chain_get_u64, nft_chain_attr_get_u64);
-uint8_t nftnl_chain_attr_get_u8(struct nftnl_chain *c, uint16_t attr)
+uint8_t nftnl_chain_get_u8(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const uint8_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
+ const uint8_t *val = nftnl_chain_get_data(c, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(int8_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_chain_attr_get_u8, nft_chain_attr_get_u8);
+EXPORT_SYMBOL(nftnl_chain_get_u8, nft_chain_attr_get_u8);
void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *c)
{
@@ -601,47 +601,47 @@ int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree,
name = nftnl_jansson_parse_str(root, "name", err);
if (name != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_NAME, name);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_NAME, name);
if (nftnl_jansson_parse_val(root, "handle", NFTNL_TYPE_U64, &handle,
err) == 0)
- nftnl_chain_attr_set_u64(c,NFTNL_CHAIN_HANDLE, handle);
+ nftnl_chain_set_u64(c,NFTNL_CHAIN_HANDLE, handle);
if (nftnl_jansson_parse_val(root, "bytes", NFTNL_TYPE_U64, &bytes,
err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
+ nftnl_chain_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
if (nftnl_jansson_parse_val(root, "packets", NFTNL_TYPE_U64, &packets,
err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
+ nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
if (nftnl_jansson_parse_family(root, &family, err) == 0)
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_FAMILY, family);
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_FAMILY, family);
table = nftnl_jansson_parse_str(root, "table", err);
if (table != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TABLE, table);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_TABLE, table);
if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0)
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_USE, use);
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_USE, use);
if (nftnl_jansson_node_exist(root, "hooknum")) {
type = nftnl_jansson_parse_str(root, "type", err);
if (type != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TYPE, type);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_TYPE, type);
if (nftnl_jansson_parse_val(root, "prio", NFTNL_TYPE_S32,
&prio, err) == 0)
- nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_PRIO, prio);
+ nftnl_chain_set_s32(c, NFTNL_CHAIN_PRIO, prio);
hooknum_str = nftnl_jansson_parse_str(root, "hooknum", err);
if (hooknum_str != NULL) {
hooknum = nftnl_str2hooknum(c->family, hooknum_str);
if (hooknum == -1)
return -1;
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_HOOKNUM,
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_HOOKNUM,
hooknum);
}
@@ -653,13 +653,13 @@ int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree,
err->error = NFTNL_PARSE_EBADTYPE;
return -1;
}
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_POLICY,
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_POLICY,
policy_num);
}
dev = nftnl_jansson_parse_str(root, "device", err);
if (dev != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_DEV, dev);
}
return 0;
@@ -701,35 +701,35 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (name != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_NAME, name);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_NAME, name);
if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
&handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_HANDLE, handle);
+ nftnl_chain_set_u64(c, NFTNL_CHAIN_HANDLE, handle);
if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC,
&bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
+ nftnl_chain_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
if (nftnl_mxml_num_parse(tree, "packets", MXML_DESCEND_FIRST, BASE_DEC,
&packets, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
+ nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TABLE, table);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_TABLE, table);
if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND_FIRST, BASE_DEC,
&use, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, use);
+ nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, use);
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_FAMILY, family);
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_FAMILY, family);
hooknum_str = nftnl_mxml_str_parse(tree, "hooknum", MXML_DESCEND_FIRST,
NFTNL_XML_OPT, err);
@@ -737,18 +737,18 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
hooknum = nftnl_str2hooknum(c->family, hooknum_str);
if (hooknum < 0)
return -1;
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum);
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum);
type = nftnl_mxml_str_parse(tree, "type", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (type != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TYPE, type);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_TYPE, type);
if (nftnl_mxml_num_parse(tree, "prio", MXML_DESCEND, BASE_DEC,
&prio, NFTNL_TYPE_S32, NFTNL_XML_MAND,
err) == 0)
- nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_PRIO, prio);
+ nftnl_chain_set_s32(c, NFTNL_CHAIN_PRIO, prio);
policy_str = nftnl_mxml_str_parse(tree, "policy",
MXML_DESCEND_FIRST,
@@ -760,14 +760,14 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
err->error = NFTNL_PARSE_EBADTYPE;
return -1;
}
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_POLICY,
+ nftnl_chain_set_u32(c, NFTNL_CHAIN_POLICY,
policy);
}
dev = nftnl_mxml_str_parse(tree, "device", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev);
+ nftnl_chain_set_str(c, NFTNL_CHAIN_DEV, dev);
}
return 0;
diff --git a/src/gen.c b/src/gen.c
index bb66295..eb3b70d 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -41,13 +41,13 @@ void nftnl_gen_free(struct nftnl_gen *gen)
}
EXPORT_SYMBOL(nftnl_gen_free, nft_gen_free);
-bool nftnl_gen_attr_is_set(const struct nftnl_gen *gen, uint16_t attr)
+bool nftnl_gen_is_set(const struct nftnl_gen *gen, uint16_t attr)
{
return gen->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_gen_attr_is_set, nft_gen_attr_is_set);
+EXPORT_SYMBOL(nftnl_gen_is_set, nft_gen_attr_is_set);
-void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr)
+void nftnl_gen_unset(struct nftnl_gen *gen, uint16_t attr)
{
if (!(gen->flags & (1 << attr)))
return;
@@ -58,19 +58,19 @@ void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr)
}
gen->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_gen_attr_unset, nft_gen_attr_unset);
+EXPORT_SYMBOL(nftnl_gen_unset, nft_gen_attr_unset);
-static uint32_t nftnl_gen_attr_validate[NFTNL_GEN_MAX + 1] = {
+static uint32_t nftnl_gen_validate[NFTNL_GEN_MAX + 1] = {
[NFTNL_GEN_ID] = sizeof(uint32_t),
};
-void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr,
+void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
const void *data, uint32_t data_len)
{
if (attr > NFTNL_GEN_MAX)
return;
- nftnl_assert_validate(data, nftnl_gen_attr_validate, attr, data_len);
+ nftnl_assert_validate(data, nftnl_gen_validate, attr, data_len);
switch (attr) {
case NFTNL_GEN_ID:
@@ -79,21 +79,21 @@ void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr,
}
gen->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_gen_attr_set_data, nft_gen_attr_set_data);
+EXPORT_SYMBOL(nftnl_gen_set_data, nft_gen_attr_set_data);
-void nftnl_gen_attr_set(struct nftnl_gen *gen, uint16_t attr, const void *data)
+void nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data)
{
- nftnl_gen_attr_set_data(gen, attr, data, nftnl_gen_attr_validate[attr]);
+ nftnl_gen_set_data(gen, attr, data, nftnl_gen_validate[attr]);
}
-EXPORT_SYMBOL(nftnl_gen_attr_set, nft_gen_attr_set);
+EXPORT_SYMBOL(nftnl_gen_set, nft_gen_attr_set);
-void nftnl_gen_attr_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t val)
+void nftnl_gen_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t val)
{
- nftnl_gen_attr_set_data(gen, attr, &val, sizeof(uint32_t));
+ nftnl_gen_set_data(gen, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL(nftnl_gen_attr_set_u32, nft_gen_attr_set_u32);
+EXPORT_SYMBOL(nftnl_gen_set_u32, nft_gen_attr_set_u32);
-const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr,
+const void *nftnl_gen_get_data(struct nftnl_gen *gen, uint16_t attr,
uint32_t *data_len)
{
if (!(gen->flags & (1 << attr)))
@@ -105,21 +105,21 @@ const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL(nftnl_gen_attr_get_data, nft_gen_attr_get_data);
+EXPORT_SYMBOL(nftnl_gen_get_data, nft_gen_attr_get_data);
-const void *nftnl_gen_attr_get(struct nftnl_gen *gen, uint16_t attr)
+const void *nftnl_gen_get(struct nftnl_gen *gen, uint16_t attr)
{
uint32_t data_len;
- return nftnl_gen_attr_get_data(gen, attr, &data_len);
+ return nftnl_gen_get_data(gen, attr, &data_len);
}
-EXPORT_SYMBOL(nftnl_gen_attr_get, nft_gen_attr_get);
+EXPORT_SYMBOL(nftnl_gen_get, nft_gen_attr_get);
-uint32_t nftnl_gen_attr_get_u32(struct nftnl_gen *gen, uint16_t attr)
+uint32_t nftnl_gen_get_u32(struct nftnl_gen *gen, uint16_t attr)
{
- const void *ret = nftnl_gen_attr_get(gen, attr);
+ const void *ret = nftnl_gen_get(gen, attr);
return ret == NULL ? 0 : *((uint32_t *)ret);
}
-EXPORT_SYMBOL(nftnl_gen_attr_get_u32, nft_gen_attr_get_u32);
+EXPORT_SYMBOL(nftnl_gen_get_u32, nft_gen_attr_get_u32);
static int nftnl_gen_parse_attr_cb(const struct nlattr *attr, void *data)
{
diff --git a/src/jansson.c b/src/jansson.c
index 38a6b97..3476ed2 100644
--- a/src/jansson.c
+++ b/src/jansson.c
@@ -251,7 +251,7 @@ int nftnl_jansson_set_elem_parse(struct nftnl_set_elem *e, json_t *root,
uint32_t flags;
if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0)
- nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, flags);
+ nftnl_set_elem_set_u32(e, NFTNL_SET_ELEM_FLAGS, flags);
if (nftnl_jansson_data_reg_parse(root, "key", &e->key, err) == DATA_VALUE)
e->flags |= (1 << NFTNL_SET_ELEM_KEY);
diff --git a/src/libnftnl.map b/src/libnftnl.map
index 0ef4b49..14ec88c 100644
--- a/src/libnftnl.map
+++ b/src/libnftnl.map
@@ -202,16 +202,16 @@ global:
nftnl_table_alloc;
nftnl_table_free;
- nftnl_table_attr_is_set;
- nftnl_table_attr_unset;
- nftnl_table_attr_set;
- nftnl_table_attr_get;
- nftnl_table_attr_set_u8;
- nftnl_table_attr_set_u32;
- nftnl_table_attr_set_str;
- nftnl_table_attr_get_u8;
- nftnl_table_attr_get_u32;
- nftnl_table_attr_get_str;
+ nftnl_table_is_set;
+ nftnl_table_unset;
+ nftnl_table_set;
+ nftnl_table_get;
+ nftnl_table_set_u8;
+ nftnl_table_set_u32;
+ nftnl_table_set_str;
+ nftnl_table_get_u8;
+ nftnl_table_get_u32;
+ nftnl_table_get_str;
nftnl_table_parse;
nftnl_table_parse_file;
nftnl_table_snprintf;
@@ -231,20 +231,20 @@ global:
nftnl_chain_alloc;
nftnl_chain_free;
- nftnl_chain_attr_is_set;
- nftnl_chain_attr_unset;
- nftnl_chain_attr_set;
- nftnl_chain_attr_set_u8;
- nftnl_chain_attr_set_u32;
- nftnl_chain_attr_set_s32;
- nftnl_chain_attr_set_u64;
- nftnl_chain_attr_set_str;
- nftnl_chain_attr_get;
- nftnl_chain_attr_get_u8;
- nftnl_chain_attr_get_u32;
- nftnl_chain_attr_get_s32;
- nftnl_chain_attr_get_u64;
- nftnl_chain_attr_get_str;
+ nftnl_chain_is_set;
+ nftnl_chain_unset;
+ nftnl_chain_set;
+ nftnl_chain_set_u8;
+ nftnl_chain_set_u32;
+ nftnl_chain_set_s32;
+ nftnl_chain_set_u64;
+ nftnl_chain_set_str;
+ nftnl_chain_get;
+ nftnl_chain_get_u8;
+ nftnl_chain_get_u32;
+ nftnl_chain_get_s32;
+ nftnl_chain_get_u64;
+ nftnl_chain_get_str;
nftnl_chain_parse;
nftnl_chain_parse_file;
nftnl_chain_snprintf;
@@ -264,17 +264,17 @@ global:
nftnl_rule_alloc;
nftnl_rule_free;
- nftnl_rule_attr_is_set;
- nftnl_rule_attr_unset;
- nftnl_rule_attr_set;
- nftnl_rule_attr_set_u32;
- nftnl_rule_attr_set_u64;
- nftnl_rule_attr_set_str;
- nftnl_rule_attr_get;
- nftnl_rule_attr_get_u8;
- nftnl_rule_attr_get_u32;
- nftnl_rule_attr_get_u64;
- nftnl_rule_attr_get_str;
+ nftnl_rule_is_set;
+ nftnl_rule_unset;
+ nftnl_rule_set;
+ nftnl_rule_set_u32;
+ nftnl_rule_set_u64;
+ nftnl_rule_set_str;
+ nftnl_rule_get;
+ nftnl_rule_get_u8;
+ nftnl_rule_get_u32;
+ nftnl_rule_get_u64;
+ nftnl_rule_get_str;
nftnl_rule_parse;
nftnl_rule_parse_file;
nftnl_rule_snprintf;
@@ -319,16 +319,16 @@ global:
nftnl_set_alloc;
nftnl_set_free;
- nftnl_set_attr_unset;
- nftnl_set_attr_is_set;
- nftnl_set_attr_set;
- nftnl_set_attr_set_u32;
- nftnl_set_attr_set_u64;
- nftnl_set_attr_set_str;
- nftnl_set_attr_get;
- nftnl_set_attr_get_str;
- nftnl_set_attr_get_u32;
- nftnl_set_attr_get_u64;
+ nftnl_set_unset;
+ nftnl_set_is_set;
+ nftnl_set_set;
+ nftnl_set_set_u32;
+ nftnl_set_set_u64;
+ nftnl_set_set_str;
+ nftnl_set_get;
+ nftnl_set_get_str;
+ nftnl_set_get_u32;
+ nftnl_set_get_u64;
nftnl_set_nlmsg_build_payload;
nftnl_set_nlmsg_parse;
nftnl_set_parse;
@@ -353,16 +353,16 @@ global:
nftnl_set_elem_free;
nftnl_set_elem_add;
nftnl_set_elem_foreach;
- nftnl_set_elem_attr_is_set;
- nftnl_set_elem_attr_unset;
- nftnl_set_elem_attr_set;
- nftnl_set_elem_attr_set_u32;
- nftnl_set_elem_attr_set_u64;
- nftnl_set_elem_attr_set_str;
- nftnl_set_elem_attr_get;
- nftnl_set_elem_attr_get_str;
- nftnl_set_elem_attr_get_u32;
- nftnl_set_elem_attr_get_u64;
+ nftnl_set_elem_is_set;
+ nftnl_set_elem_unset;
+ nftnl_set_elem_set;
+ nftnl_set_elem_set_u32;
+ nftnl_set_elem_set_u64;
+ nftnl_set_elem_set_str;
+ nftnl_set_elem_get;
+ nftnl_set_elem_get_str;
+ nftnl_set_elem_get_u32;
+ nftnl_set_elem_get_u64;
nftnl_set_elem_nlmsg_build_payload;
nftnl_set_elem_parse;
nftnl_set_elem_parse_file;
@@ -381,10 +381,10 @@ global:
nftnl_ruleset_alloc;
nftnl_ruleset_free;
- nftnl_ruleset_attr_is_set;
- nftnl_ruleset_attr_unset;
- nftnl_ruleset_attr_set;
- nftnl_ruleset_attr_get;
+ nftnl_ruleset_is_set;
+ nftnl_ruleset_unset;
+ nftnl_ruleset_set;
+ nftnl_ruleset_get;
nftnl_ruleset_parse;
nftnl_ruleset_parse_file;
nftnl_ruleset_snprintf;
@@ -414,14 +414,14 @@ LIBNFTNL_1.1 {
# aliases
#
- nftnl_table_attr_set_data;
- nftnl_table_attr_get_data;
- nftnl_chain_attr_set_data;
- nftnl_chain_attr_get_data;
- nftnl_rule_attr_set_data;
- nftnl_rule_attr_get_data;
- nftnl_set_attr_set_data;
- nftnl_set_attr_get_data;
+ nftnl_table_set_data;
+ nftnl_table_get_data;
+ nftnl_chain_set_data;
+ nftnl_chain_get_data;
+ nftnl_rule_set_data;
+ nftnl_rule_get_data;
+ nftnl_set_set_data;
+ nftnl_set_get_data;
} LIBNFTNL_1.0;
diff --git a/src/rule.c b/src/rule.c
index c0b1f89..0fb27ed 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -80,13 +80,13 @@ void nftnl_rule_free(struct nftnl_rule *r)
}
EXPORT_SYMBOL(nftnl_rule_free, nft_rule_free);
-bool nftnl_rule_attr_is_set(const struct nftnl_rule *r, uint16_t attr)
+bool nftnl_rule_is_set(const struct nftnl_rule *r, uint16_t attr)
{
return r->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_rule_attr_is_set, nft_rule_attr_is_set);
+EXPORT_SYMBOL(nftnl_rule_is_set, nft_rule_attr_is_set);
-void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr)
+void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
{
if (!(r->flags & (1 << attr)))
return;
@@ -115,9 +115,9 @@ void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr)
r->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_rule_attr_unset, nft_rule_attr_unset);
+EXPORT_SYMBOL(nftnl_rule_unset, nft_rule_attr_unset);
-static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_MAX + 1] = {
+static uint32_t nftnl_rule_validate[NFTNL_RULE_MAX + 1] = {
[NFTNL_RULE_HANDLE] = sizeof(uint64_t),
[NFTNL_RULE_COMPAT_PROTO] = sizeof(uint32_t),
[NFTNL_RULE_COMPAT_FLAGS] = sizeof(uint32_t),
@@ -125,13 +125,13 @@ static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_MAX + 1] = {
[NFTNL_RULE_POSITION] = sizeof(uint64_t),
};
-void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr,
+void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
const void *data, uint32_t data_len)
{
if (attr > NFTNL_RULE_MAX)
return;
- nftnl_assert_validate(data, nftnl_rule_attr_validate, attr, data_len);
+ nftnl_assert_validate(data, nftnl_rule_validate, attr, data_len);
switch(attr) {
case NFTNL_RULE_TABLE:
@@ -168,33 +168,33 @@ void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr,
}
r->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_rule_attr_set_data, nft_rule_attr_set_data);
+EXPORT_SYMBOL(nftnl_rule_set_data, nft_rule_attr_set_data);
-void nftnl_rule_attr_set(struct nftnl_rule *r, uint16_t attr, const void *data)
+void nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data)
{
- nftnl_rule_attr_set_data(r, attr, data, nftnl_rule_attr_validate[attr]);
+ nftnl_rule_set_data(r, attr, data, nftnl_rule_validate[attr]);
}
-EXPORT_SYMBOL(nftnl_rule_attr_set, nft_rule_attr_set);
+EXPORT_SYMBOL(nftnl_rule_set, nft_rule_attr_set);
-void nftnl_rule_attr_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val)
+void nftnl_rule_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val)
{
- nftnl_rule_attr_set_data(r, attr, &val, sizeof(uint32_t));
+ nftnl_rule_set_data(r, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL(nftnl_rule_attr_set_u32, nft_rule_attr_set_u32);
+EXPORT_SYMBOL(nftnl_rule_set_u32, nft_rule_attr_set_u32);
-void nftnl_rule_attr_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val)
+void nftnl_rule_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val)
{
- nftnl_rule_attr_set_data(r, attr, &val, sizeof(uint64_t));
+ nftnl_rule_set_data(r, attr, &val, sizeof(uint64_t));
}
-EXPORT_SYMBOL(nftnl_rule_attr_set_u64, nft_rule_attr_set_u64);
+EXPORT_SYMBOL(nftnl_rule_set_u64, nft_rule_attr_set_u64);
-void nftnl_rule_attr_set_str(struct nftnl_rule *r, uint16_t attr, const char *str)
+void nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str)
{
- nftnl_rule_attr_set_data(r, attr, str, strlen(str));
+ nftnl_rule_set_data(r, attr, str, strlen(str));
}
-EXPORT_SYMBOL(nftnl_rule_attr_set_str, nft_rule_attr_set_str);
+EXPORT_SYMBOL(nftnl_rule_set_str, nft_rule_attr_set_str);
-const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr,
+const void *nftnl_rule_get_data(const struct nftnl_rule *r, uint16_t attr,
uint32_t *data_len)
{
if (!(r->flags & (1 << attr)))
@@ -226,53 +226,53 @@ const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL(nftnl_rule_attr_get_data, nft_rule_attr_get_data);
+EXPORT_SYMBOL(nftnl_rule_get_data, nft_rule_attr_get_data);
-const void *nftnl_rule_attr_get(const struct nftnl_rule *r, uint16_t attr)
+const void *nftnl_rule_get(const struct nftnl_rule *r, uint16_t attr)
{
uint32_t data_len;
- return nftnl_rule_attr_get_data(r, attr, &data_len);
+ return nftnl_rule_get_data(r, attr, &data_len);
}
-EXPORT_SYMBOL(nftnl_rule_attr_get, nft_rule_attr_get);
+EXPORT_SYMBOL(nftnl_rule_get, nft_rule_attr_get);
-const char *nftnl_rule_attr_get_str(const struct nftnl_rule *r, uint16_t attr)
+const char *nftnl_rule_get_str(const struct nftnl_rule *r, uint16_t attr)
{
- return nftnl_rule_attr_get(r, attr);
+ return nftnl_rule_get(r, attr);
}
-EXPORT_SYMBOL(nftnl_rule_attr_get_str, nft_rule_attr_get_str);
+EXPORT_SYMBOL(nftnl_rule_get_str, nft_rule_attr_get_str);
-uint32_t nftnl_rule_attr_get_u32(const struct nftnl_rule *r, uint16_t attr)
+uint32_t nftnl_rule_get_u32(const struct nftnl_rule *r, uint16_t attr)
{
uint32_t data_len;
- const uint32_t *val = nftnl_rule_attr_get_data(r, attr, &data_len);
+ const uint32_t *val = nftnl_rule_get_data(r, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(uint32_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_rule_attr_get_u32, nft_rule_attr_get_u32);
+EXPORT_SYMBOL(nftnl_rule_get_u32, nft_rule_attr_get_u32);
-uint64_t nftnl_rule_attr_get_u64(const struct nftnl_rule *r, uint16_t attr)
+uint64_t nftnl_rule_get_u64(const struct nftnl_rule *r, uint16_t attr)
{
uint32_t data_len;
- const uint64_t *val = nftnl_rule_attr_get_data(r, attr, &data_len);
+ const uint64_t *val = nftnl_rule_get_data(r, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(uint64_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_rule_attr_get_u64, nft_rule_attr_get_u64);
+EXPORT_SYMBOL(nftnl_rule_get_u64, nft_rule_attr_get_u64);
-uint8_t nftnl_rule_attr_get_u8(const struct nftnl_rule *r, uint16_t attr)
+uint8_t nftnl_rule_get_u8(const struct nftnl_rule *r, uint16_t attr)
{
uint32_t data_len;
- const uint8_t *val = nftnl_rule_attr_get_data(r, attr, &data_len);
+ const uint8_t *val = nftnl_rule_get_data(r, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(uint8_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_rule_attr_get_u8, nft_rule_attr_get_u8);
+EXPORT_SYMBOL(nftnl_rule_get_u8, nft_rule_attr_get_u8);
void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r)
{
@@ -490,7 +490,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
if (nftnl_jansson_parse_family(root, &family, err) != 0)
goto err;
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family);
+ nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family);
}
if (nftnl_jansson_node_exist(root, "table")) {
@@ -498,7 +498,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
if (str == NULL)
goto err;
- nftnl_rule_attr_set_str(r, NFTNL_RULE_TABLE, str);
+ nftnl_rule_set_str(r, NFTNL_RULE_TABLE, str);
}
if (nftnl_jansson_node_exist(root, "chain")) {
@@ -506,7 +506,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
if (str == NULL)
goto err;
- nftnl_rule_attr_set_str(r, NFTNL_RULE_CHAIN, str);
+ nftnl_rule_set_str(r, NFTNL_RULE_CHAIN, str);
}
if (nftnl_jansson_node_exist(root, "handle")) {
@@ -514,7 +514,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
err) < 0)
goto err;
- nftnl_rule_attr_set_u64(r, NFTNL_RULE_HANDLE, uval64);
+ nftnl_rule_set_u64(r, NFTNL_RULE_HANDLE, uval64);
}
if (nftnl_jansson_node_exist(root, "compat_proto") ||
@@ -523,13 +523,13 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
&uval32, err) < 0)
goto err;
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_COMPAT_PROTO, uval32);
+ nftnl_rule_set_u32(r, NFTNL_RULE_COMPAT_PROTO, uval32);
if (nftnl_jansson_parse_val(root, "compat_flags", NFTNL_TYPE_U32,
&uval32, err) < 0)
goto err;
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_COMPAT_FLAGS, uval32);
+ nftnl_rule_set_u32(r, NFTNL_RULE_COMPAT_FLAGS, uval32);
}
if (nftnl_jansson_node_exist(root, "position")) {
@@ -537,7 +537,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
&uval64, err) < 0)
goto err;
- nftnl_rule_attr_set_u64(r, NFTNL_RULE_POSITION, uval64);
+ nftnl_rule_set_u64(r, NFTNL_RULE_POSITION, uval64);
}
array = json_object_get(root, "expr");
@@ -600,17 +600,17 @@ int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r,
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family);
+ nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family);
table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table != NULL)
- nftnl_rule_attr_set_str(r, NFTNL_RULE_TABLE, table);
+ nftnl_rule_set_str(r, NFTNL_RULE_TABLE, table);
chain = nftnl_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (chain != NULL)
- nftnl_rule_attr_set_str(r, NFTNL_RULE_CHAIN, chain);
+ nftnl_rule_set_str(r, NFTNL_RULE_CHAIN, chain);
if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
&r->handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) >= 0)
@@ -626,8 +626,8 @@ int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r,
NFTNL_XML_OPT, err) >= 0)
r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS);
- if (nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_PROTO) !=
- nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) {
+ if (nftnl_rule_is_set(r, NFTNL_RULE_COMPAT_PROTO) !=
+ nftnl_rule_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) {
errno = EINVAL;
}
diff --git a/src/ruleset.c b/src/ruleset.c
index fde24ad..7b1ab7a 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -78,13 +78,13 @@ void nftnl_ruleset_free(struct nftnl_ruleset *r)
}
EXPORT_SYMBOL(nftnl_ruleset_free, nft_ruleset_free);
-bool nftnl_ruleset_attr_is_set(const struct nftnl_ruleset *r, uint16_t attr)
+bool nftnl_ruleset_is_set(const struct nftnl_ruleset *r, uint16_t attr)
{
return r->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_ruleset_attr_is_set, nft_ruleset_attr_is_set);
+EXPORT_SYMBOL(nftnl_ruleset_is_set, nft_ruleset_attr_is_set);
-void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr)
+void nftnl_ruleset_unset(struct nftnl_ruleset *r, uint16_t attr)
{
if (!(r->flags & (1 << attr)))
return;
@@ -109,25 +109,25 @@ void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr)
}
r->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_ruleset_attr_unset, nft_ruleset_attr_unset);
+EXPORT_SYMBOL(nftnl_ruleset_unset, nft_ruleset_attr_unset);
-void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data)
+void nftnl_ruleset_set(struct nftnl_ruleset *r, uint16_t attr, void *data)
{
switch (attr) {
case NFTNL_RULESET_TABLELIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_TABLELIST);
+ nftnl_ruleset_unset(r, NFTNL_RULESET_TABLELIST);
r->table_list = data;
break;
case NFTNL_RULESET_CHAINLIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_CHAINLIST);
+ nftnl_ruleset_unset(r, NFTNL_RULESET_CHAINLIST);
r->chain_list = data;
break;
case NFTNL_RULESET_SETLIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_SETLIST);
+ nftnl_ruleset_unset(r, NFTNL_RULESET_SETLIST);
r->set_list = data;
break;
case NFTNL_RULESET_RULELIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_RULELIST);
+ nftnl_ruleset_unset(r, NFTNL_RULESET_RULELIST);
r->rule_list = data;
break;
default:
@@ -135,9 +135,9 @@ void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data)
}
r->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_ruleset_attr_set, nft_ruleset_attr_set);
+EXPORT_SYMBOL(nftnl_ruleset_set, nft_ruleset_attr_set);
-void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr)
+void *nftnl_ruleset_get(const struct nftnl_ruleset *r, uint16_t attr)
{
if (!(r->flags & (1 << attr)))
return NULL;
@@ -155,7 +155,7 @@ void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr)
return NULL;
}
}
-EXPORT_SYMBOL(nftnl_ruleset_attr_get, nft_ruleset_attr_get);
+EXPORT_SYMBOL(nftnl_ruleset_get, nft_ruleset_attr_get);
void nftnl_ruleset_ctx_free(const struct nftnl_parse_ctx *ctx)
{
@@ -337,7 +337,7 @@ static int nftnl_ruleset_parse_set(struct nftnl_parse_ctx *ctx,
{
struct nftnl_set *newset;
- nftnl_set_attr_set_u32(set, NFTNL_SET_ID, ctx->set_id++);
+ nftnl_set_set_u32(set, NFTNL_SET_ID, ctx->set_id++);
newset = nftnl_set_clone(set);
if (newset == NULL)
@@ -776,7 +776,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->table_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_TABLELIST,
+ nftnl_ruleset_set(r, NFTNL_RULESET_TABLELIST,
r->table_list);
}
nftnl_table_list_add_tail(ctx->table, r->table_list);
@@ -787,7 +787,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->chain_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_CHAINLIST,
+ nftnl_ruleset_set(r, NFTNL_RULESET_CHAINLIST,
r->chain_list);
}
nftnl_chain_list_add_tail(ctx->chain, r->chain_list);
@@ -798,7 +798,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->set_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_SETLIST,
+ nftnl_ruleset_set(r, NFTNL_RULESET_SETLIST,
r->set_list);
}
nftnl_set_list_add_tail(ctx->set, r->set_list);
@@ -809,7 +809,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->rule_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_RULELIST,
+ nftnl_ruleset_set(r, NFTNL_RULESET_RULELIST,
r->rule_list);
}
nftnl_rule_list_add_tail(ctx->rule, r->rule_list);
@@ -1009,7 +1009,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_TABLELIST) &&
+ if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST) &&
(!nftnl_table_list_is_empty(rs->table_list))) {
ret = nftnl_ruleset_snprintf_table(buf+offset, len, rs,
type, inner_flags);
@@ -1019,7 +1019,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
prev = rs->table_list;
}
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
+ if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
(!nftnl_chain_list_is_empty(rs->chain_list))) {
ret = snprintf(buf+offset, len, "%s",
nftnl_ruleset_o_separator(prev, type));
@@ -1033,7 +1033,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
prev = rs->chain_list;
}
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_SETLIST) &&
+ if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST) &&
(!nftnl_set_list_is_empty(rs->set_list))) {
ret = snprintf(buf+offset, len, "%s",
nftnl_ruleset_o_separator(prev, type));
@@ -1047,7 +1047,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
prev = rs->set_list;
}
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_RULELIST) &&
+ if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST) &&
(!nftnl_rule_list_is_empty(rs->rule_list))) {
ret = snprintf(buf+offset, len, "%s",
nftnl_ruleset_o_separator(prev, type));
@@ -1260,7 +1260,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
ret = nftnl_cmd_header_fprintf(fp, cmd, type, flags);
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
+ if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
(!nftnl_table_list_is_empty(rs->table_list))) {
ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags);
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
@@ -1269,7 +1269,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
prev = rs->table_list;
}
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
+ if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
(!nftnl_chain_list_is_empty(rs->chain_list))) {
ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type));
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
@@ -1281,7 +1281,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
prev = rs->chain_list;
}
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_SETLIST)) &&
+ if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST)) &&
(!nftnl_set_list_is_empty(rs->set_list))) {
ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type));
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
@@ -1293,7 +1293,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
prev = rs->set_list;
}
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_RULELIST)) &&
+ if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST)) &&
(!nftnl_rule_list_is_empty(rs->rule_list))) {
ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type));
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
diff --git a/src/set.c b/src/set.c
index 983a8f4..f5a9454 100644
--- a/src/set.c
+++ b/src/set.c
@@ -57,13 +57,13 @@ void nftnl_set_free(struct nftnl_set *s)
}
EXPORT_SYMBOL(nftnl_set_free, nft_set_free);
-bool nftnl_set_attr_is_set(const struct nftnl_set *s, uint16_t attr)
+bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr)
{
return s->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_set_attr_is_set, nft_set_attr_is_set);
+EXPORT_SYMBOL(nftnl_set_is_set, nft_set_attr_is_set);
-void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr)
+void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
{
switch (attr) {
case NFTNL_SET_TABLE:
@@ -98,9 +98,9 @@ void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr)
s->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_set_attr_unset, nft_set_attr_unset);
+EXPORT_SYMBOL(nftnl_set_unset, nft_set_attr_unset);
-static uint32_t nftnl_set_attr_validate[NFTNL_SET_MAX + 1] = {
+static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = {
[NFTNL_SET_FLAGS] = sizeof(uint32_t),
[NFTNL_SET_KEY_TYPE] = sizeof(uint32_t),
[NFTNL_SET_KEY_LEN] = sizeof(uint32_t),
@@ -113,13 +113,13 @@ static uint32_t nftnl_set_attr_validate[NFTNL_SET_MAX + 1] = {
[NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t),
};
-void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
+void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
uint32_t data_len)
{
if (attr > NFTNL_SET_MAX)
return;
- nftnl_assert_validate(data, nftnl_set_attr_validate, attr, data_len);
+ nftnl_assert_validate(data, nftnl_set_validate, attr, data_len);
switch(attr) {
case NFTNL_SET_TABLE:
@@ -170,33 +170,33 @@ void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *dat
}
s->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_set_attr_set_data, nft_set_attr_set_data);
+EXPORT_SYMBOL(nftnl_set_set_data, nft_set_attr_set_data);
-void nftnl_set_attr_set(struct nftnl_set *s, uint16_t attr, const void *data)
+void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data)
{
- nftnl_set_attr_set_data(s, attr, data, nftnl_set_attr_validate[attr]);
+ nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]);
}
-EXPORT_SYMBOL(nftnl_set_attr_set, nft_set_attr_set);
+EXPORT_SYMBOL(nftnl_set_set, nft_set_attr_set);
-void nftnl_set_attr_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val)
+void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val)
{
- nftnl_set_attr_set(s, attr, &val);
+ nftnl_set_set(s, attr, &val);
}
-EXPORT_SYMBOL(nftnl_set_attr_set_u32, nft_set_attr_set_u32);
+EXPORT_SYMBOL(nftnl_set_set_u32, nft_set_attr_set_u32);
-void nftnl_set_attr_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val)
+void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val)
{
- nftnl_set_attr_set(s, attr, &val);
+ nftnl_set_set(s, attr, &val);
}
-EXPORT_SYMBOL(nftnl_set_attr_set_u64, nft_set_attr_set_u64);
+EXPORT_SYMBOL(nftnl_set_set_u64, nft_set_attr_set_u64);
-void nftnl_set_attr_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
+void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
{
- nftnl_set_attr_set(s, attr, str);
+ nftnl_set_set(s, attr, str);
}
-EXPORT_SYMBOL(nftnl_set_attr_set_str, nft_set_attr_set_str);
+EXPORT_SYMBOL(nftnl_set_set_str, nft_set_attr_set_str);
-const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr,
+const void *nftnl_set_get_data(struct nftnl_set *s, uint16_t attr,
uint32_t *data_len)
{
if (!(s->flags & (1 << attr)))
@@ -243,42 +243,42 @@ const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL(nftnl_set_attr_get_data, nft_set_attr_get_data);
+EXPORT_SYMBOL(nftnl_set_get_data, nft_set_attr_get_data);
-const void *nftnl_set_attr_get(struct nftnl_set *s, uint16_t attr)
+const void *nftnl_set_get(struct nftnl_set *s, uint16_t attr)
{
uint32_t data_len;
- return nftnl_set_attr_get_data(s, attr, &data_len);
+ return nftnl_set_get_data(s, attr, &data_len);
}
-EXPORT_SYMBOL(nftnl_set_attr_get, nft_set_attr_get);
+EXPORT_SYMBOL(nftnl_set_get, nft_set_attr_get);
-const char *nftnl_set_attr_get_str(struct nftnl_set *s, uint16_t attr)
+const char *nftnl_set_get_str(struct nftnl_set *s, uint16_t attr)
{
- return nftnl_set_attr_get(s, attr);
+ return nftnl_set_get(s, attr);
}
-EXPORT_SYMBOL(nftnl_set_attr_get_str, nft_set_attr_get_str);
+EXPORT_SYMBOL(nftnl_set_get_str, nft_set_attr_get_str);
-uint32_t nftnl_set_attr_get_u32(struct nftnl_set *s, uint16_t attr)
+uint32_t nftnl_set_get_u32(struct nftnl_set *s, uint16_t attr)
{
uint32_t data_len;
- const uint32_t *val = nftnl_set_attr_get_data(s, attr, &data_len);
+ const uint32_t *val = nftnl_set_get_data(s, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(uint32_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_set_attr_get_u32, nft_set_attr_get_u32);
+EXPORT_SYMBOL(nftnl_set_get_u32, nft_set_attr_get_u32);
-uint64_t nftnl_set_attr_get_u64(struct nftnl_set *s, uint16_t attr)
+uint64_t nftnl_set_get_u64(struct nftnl_set *s, uint16_t attr)
{
uint32_t data_len;
- const uint64_t *val = nftnl_set_attr_get_data(s, attr, &data_len);
+ const uint64_t *val = nftnl_set_get_data(s, attr, &data_len);
nftnl_assert(val, attr, data_len == sizeof(uint64_t));
return val ? *val : 0;
}
-EXPORT_SYMBOL(nftnl_set_attr_get_u64, nft_set_attr_get_u64);
+EXPORT_SYMBOL(nftnl_set_get_u64, nft_set_attr_get_u64);
struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set)
{
@@ -504,34 +504,34 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
if (name == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name);
+ nftnl_set_set_str(s, NFTNL_SET_NAME, name);
table = nftnl_jansson_parse_str(root, "table", err);
if (table == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table);
+ nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
if (nftnl_jansson_parse_family(root, &family, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family);
+ nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, flags);
+ nftnl_set_set_u32(s, NFTNL_SET_FLAGS, flags);
if (nftnl_jansson_parse_val(root, "key_type", NFTNL_TYPE_U32, &key_type,
err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
+ nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
if (nftnl_jansson_parse_val(root, "key_len", NFTNL_TYPE_U32, &key_len,
err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
+ nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
if (nftnl_jansson_node_exist(root, "data_type")) {
if (nftnl_jansson_parse_val(root, "data_type", NFTNL_TYPE_U32,
&data_type, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
+ nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
}
if (nftnl_jansson_node_exist(root, "data_len")) {
@@ -539,7 +539,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
&data_len, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
+ nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
}
if (nftnl_jansson_node_exist(root, "policy")) {
@@ -547,7 +547,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
&policy, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_POLICY, policy);
+ nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy);
}
if (nftnl_jansson_node_exist(root, "desc_size")) {
@@ -555,7 +555,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
&size, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, size);
+ nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, size);
}
if (nftnl_jansson_node_exist(root, "set_elem")) {
@@ -644,54 +644,54 @@ int nftnl_mxml_set_parse(mxml_node_t *tree, struct nftnl_set *s,
NFTNL_XML_MAND, err);
if (name == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name);
+ nftnl_set_set_str(s, NFTNL_SET_NAME, name);
table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table);
+ nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family);
+ nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
&set_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, set_flags);
+ nftnl_set_set_u32(s, NFTNL_SET_FLAGS, set_flags);
if (nftnl_mxml_num_parse(tree, "key_type", MXML_DESCEND_FIRST, BASE_DEC,
&key_type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
+ nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
if (nftnl_mxml_num_parse(tree, "key_len", MXML_DESCEND_FIRST, BASE_DEC,
&key_len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
+ nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
if (nftnl_mxml_num_parse(tree, "data_type", MXML_DESCEND_FIRST, BASE_DEC,
&data_type, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) == 0) {
- nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
+ nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
if (nftnl_mxml_num_parse(tree, "data_len", MXML_DESCEND_FIRST,
BASE_DEC, &data_len, NFTNL_TYPE_U32,
NFTNL_XML_MAND, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
+ nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
}
if (nftnl_mxml_num_parse(tree, "policy", MXML_DESCEND_FIRST,
BASE_DEC, &policy, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_POLICY, policy);
+ nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy);
if (nftnl_mxml_num_parse(tree, "desc_size", MXML_DESCEND_FIRST,
BASE_DEC, &size, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, policy);
+ nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, policy);
for (node = mxmlFindElement(tree, tree, "set_elem", NULL,
NULL, MXML_DESCEND);
@@ -1192,7 +1192,7 @@ static struct nftnl_set *nftnl_set_lookup(const char *this_set_name,
s = nftnl_set_list_iter_cur(iter);
while (s != NULL) {
- set_name = nftnl_set_attr_get_str(s, NFTNL_SET_NAME);
+ set_name = nftnl_set_get_str(s, NFTNL_SET_NAME);
if (strcmp(this_set_name, set_name) == 0)
break;
@@ -1217,6 +1217,6 @@ int nftnl_set_lookup_id(struct nftnl_expr *e,
if (s == NULL)
return 0;
- *set_id = nftnl_set_attr_get_u32(s, NFTNL_SET_ID);
+ *set_id = nftnl_set_get_u32(s, NFTNL_SET_ID);
return 1;
}
diff --git a/src/set_elem.c b/src/set_elem.c
index 3dd1658..293ce15 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -55,13 +55,13 @@ void nftnl_set_elem_free(struct nftnl_set_elem *s)
}
EXPORT_SYMBOL(nftnl_set_elem_free, nft_set_elem_free);
-bool nftnl_set_elem_attr_is_set(const struct nftnl_set_elem *s, uint16_t attr)
+bool nftnl_set_elem_is_set(const struct nftnl_set_elem *s, uint16_t attr)
{
return s->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_is_set, nft_set_elem_attr_is_set);
+EXPORT_SYMBOL(nftnl_set_elem_is_set, nft_set_elem_attr_is_set);
-void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr)
+void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
{
switch (attr) {
case NFTNL_SET_ELEM_CHAIN:
@@ -92,9 +92,9 @@ void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr)
s->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_unset, nft_set_elem_attr_unset);
+EXPORT_SYMBOL(nftnl_set_elem_unset, nft_set_elem_attr_unset);
-void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr,
+void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
const void *data, uint32_t data_len)
{
switch(attr) {
@@ -130,27 +130,27 @@ void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr,
}
s->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_set, nft_set_elem_attr_set);
+EXPORT_SYMBOL(nftnl_set_elem_set, nft_set_elem_attr_set);
-void nftnl_set_elem_attr_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val)
+void nftnl_set_elem_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val)
{
- nftnl_set_elem_attr_set(s, attr, &val, sizeof(uint32_t));
+ nftnl_set_elem_set(s, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_set_u32, nft_set_elem_attr_set_u32);
+EXPORT_SYMBOL(nftnl_set_elem_set_u32, nft_set_elem_attr_set_u32);
-void nftnl_set_elem_attr_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val)
+void nftnl_set_elem_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val)
{
- nftnl_set_elem_attr_set(s, attr, &val, sizeof(uint64_t));
+ nftnl_set_elem_set(s, attr, &val, sizeof(uint64_t));
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_set_u64, nft_set_elem_attr_set_u64);
+EXPORT_SYMBOL(nftnl_set_elem_set_u64, nft_set_elem_attr_set_u64);
-void nftnl_set_elem_attr_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str)
+void nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str)
{
- nftnl_set_elem_attr_set(s, attr, str, strlen(str));
+ nftnl_set_elem_set(s, attr, str, strlen(str));
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_set_str, nft_set_elem_attr_set_str);
+EXPORT_SYMBOL(nftnl_set_elem_set_str, nft_set_elem_attr_set_str);
-const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len)
+const void *nftnl_set_elem_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len)
{
if (!(s->flags & (1 << attr)))
return NULL;
@@ -180,31 +180,31 @@ const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uin
}
return NULL;
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_get, nft_set_elem_attr_get);
+EXPORT_SYMBOL(nftnl_set_elem_get, nft_set_elem_attr_get);
-const char *nftnl_set_elem_attr_get_str(struct nftnl_set_elem *s, uint16_t attr)
+const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr)
{
uint32_t size;
- return nftnl_set_elem_attr_get(s, attr, &size);
+ return nftnl_set_elem_get(s, attr, &size);
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_get_str, nft_set_elem_attr_get_str);
+EXPORT_SYMBOL(nftnl_set_elem_get_str, nft_set_elem_attr_get_str);
-uint32_t nftnl_set_elem_attr_get_u32(struct nftnl_set_elem *s, uint16_t attr)
+uint32_t nftnl_set_elem_get_u32(struct nftnl_set_elem *s, uint16_t attr)
{
uint32_t size;
- uint32_t val = *((uint32_t *)nftnl_set_elem_attr_get(s, attr, &size));
+ uint32_t val = *((uint32_t *)nftnl_set_elem_get(s, attr, &size));
return val;
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_get_u32, nft_set_elem_attr_get_u32);
+EXPORT_SYMBOL(nftnl_set_elem_get_u32, nft_set_elem_attr_get_u32);
-uint64_t nftnl_set_elem_attr_get_u64(struct nftnl_set_elem *s, uint16_t attr)
+uint64_t nftnl_set_elem_get_u64(struct nftnl_set_elem *s, uint16_t attr)
{
uint32_t size;
- uint64_t val = *((uint64_t *)nftnl_set_elem_attr_get(s, attr, &size));
+ uint64_t val = *((uint64_t *)nftnl_set_elem_get(s, attr, &size));
return val;
}
-EXPORT_SYMBOL(nftnl_set_elem_attr_get_u64, nft_set_elem_attr_get_u64);
+EXPORT_SYMBOL(nftnl_set_elem_get_u64, nft_set_elem_attr_get_u64);
struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
{
@@ -270,7 +270,7 @@ static void nftnl_set_elem_nlmsg_build_def(struct nlmsghdr *nlh,
mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_TABLE, s->table);
}
-static struct nlattr *nftnl_set_elem_attr_build(struct nlmsghdr *nlh,
+static struct nlattr *nftnl_set_elem_build(struct nlmsghdr *nlh,
struct nftnl_set_elem *elem, int i)
{
struct nlattr *nest2;
@@ -292,7 +292,7 @@ void nftnl_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set
nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_LIST_ELEMENTS);
list_for_each_entry(elem, &s->element_list, head)
- nftnl_set_elem_attr_build(nlh, elem, ++i);
+ nftnl_set_elem_build(nlh, elem, ++i);
mnl_attr_nest_end(nlh, nest1);
}
@@ -497,7 +497,7 @@ int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e,
if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
&set_elem_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
err) == 0)
- nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, set_elem_flags);
+ nftnl_set_elem_set_u32(e, NFTNL_SET_ELEM_FLAGS, set_elem_flags);
if (nftnl_mxml_data_reg_parse(tree, "key", &e->key,
NFTNL_XML_MAND, err) == DATA_VALUE)
@@ -886,7 +886,7 @@ int nftnl_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh,
nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_LIST_ELEMENTS);
elem = nftnl_set_elems_iter_next(iter);
while (elem != NULL) {
- nest2 = nftnl_set_elem_attr_build(nlh, elem, ++i);
+ nest2 = nftnl_set_elem_build(nlh, elem, ++i);
if (nftnl_attr_nest_overflow(nlh, nest1, nest2)) {
/* Go back to previous not to miss this element */
iter->cur = list_entry(iter->cur->head.prev,
diff --git a/src/table.c b/src/table.c
index 1d119ef..28f6bd6 100644
--- a/src/table.c
+++ b/src/table.c
@@ -51,13 +51,13 @@ void nftnl_table_free(struct nftnl_table *t)
}
EXPORT_SYMBOL(nftnl_table_free, nft_table_free);
-bool nftnl_table_attr_is_set(const struct nftnl_table *t, uint16_t attr)
+bool nftnl_table_is_set(const struct nftnl_table *t, uint16_t attr)
{
return t->flags & (1 << attr);
}
-EXPORT_SYMBOL(nftnl_table_attr_is_set, nft_table_attr_is_set);
+EXPORT_SYMBOL(nftnl_table_is_set, nft_table_attr_is_set);
-void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr)
+void nftnl_table_unset(struct nftnl_table *t, uint16_t attr)
{
if (!(t->flags & (1 << attr)))
return;
@@ -77,20 +77,20 @@ void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr)
}
t->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL(nftnl_table_attr_unset, nft_table_attr_unset);
+EXPORT_SYMBOL(nftnl_table_unset, nft_table_attr_unset);
-static uint32_t nftnl_table_attr_validate[NFTNL_TABLE_MAX + 1] = {
+static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = {
[NFTNL_TABLE_FLAGS] = sizeof(uint32_t),
[NFTNL_TABLE_FAMILY] = sizeof(uint32_t),
};
-void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr,
+void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
const void *data, uint32_t data_len)
{
if (attr > NFTNL_TABLE_MAX)
return;
- nftnl_assert_validate(data, nftnl_table_attr_validate, attr, data_len);
+ nftnl_assert_validate(data, nftnl_table_validate, attr, data_len);
switch (attr) {
case NFTNL_TABLE_NAME:
@@ -111,33 +111,33 @@ void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr,
}
t->flags |= (1 << attr);
}
-EXPORT_SYMBOL(nftnl_table_attr_set_data, nft_table_attr_set_data);
+EXPORT_SYMBOL(nftnl_table_set_data, nft_table_attr_set_data);
-void nftnl_table_attr_set(struct nftnl_table *t, uint16_t attr, const void *data)
+void nftnl_table_set(struct nftnl_table *t, uint16_t attr, const void *data)
{
- nftnl_table_attr_set_data(t, attr, data, nftnl_table_attr_validate[attr]);
+ nftnl_table_set_data(t, attr, data, nftnl_table_validate[attr]);
}
-EXPORT_SYMBOL(nftnl_table_attr_set, nft_table_attr_set);
+EXPORT_SYMBOL(nftnl_table_set, nft_table_attr_set);
-void nftnl_table_attr_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t val)
+void nftnl_table_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t val)
{
- nftnl_table_attr_set_data(t, attr, &val, sizeof(uint32_t));
+ nftnl_table_set_data(t, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL(nftnl_table_attr_set_u32, nft_table_attr_set_u32);
+EXPORT_SYMBOL(nftnl_table_set_u32, nft_table_attr_set_u32);
-void nftnl_table_attr_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t val)
+void nftnl_table_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t val)
{
- nftnl_table_attr_set_data(t, attr, &val, sizeof(uint8_t));
+ nftnl_table_set_data(t, attr, &val, sizeof(uint8_t));
}
-EXPORT_SYMBOL(nftnl_table_attr_set_u8, nft_table_attr_set_u8);
+EXPORT_SYMBOL(nftnl_table_set_u8, nft_table_attr_set_u8);
-void nftnl_table_attr_set_str(struct nftnl_table *t, uint16_t attr, const char *str)
+void nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str)
{
- nftnl_table_attr_set_data(t, attr, str, 0);
+ nftnl_table_set_data(t, attr, str, 0);
}
-EXPORT_SYMBOL(nftnl_table_attr_set_str, nft_table_attr_set_str);
+EXPORT_SYMBOL(nftnl_table_set_str, nft_table_attr_set_str);
-const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr,
+const void *nftnl_table_get_data(struct nftnl_table *t, uint16_t attr,
uint32_t *data_len)
{
if (!(t->flags & (1 << attr)))
@@ -158,34 +158,34 @@ const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL(nftnl_table_attr_get_data, nft_table_attr_get_data);
+EXPORT_SYMBOL(nftnl_table_get_data, nft_table_attr_get_data);
-const void *nftnl_table_attr_get(struct nftnl_table *t, uint16_t attr)
+const void *nftnl_table_get(struct nftnl_table *t, uint16_t attr)
{
uint32_t data_len;
- return nftnl_table_attr_get_data(t, attr, &data_len);
+ return nftnl_table_get_data(t, attr, &data_len);
}
-EXPORT_SYMBOL(nftnl_table_attr_get, nft_table_attr_get);
+EXPORT_SYMBOL(nftnl_table_get, nft_table_attr_get);
-uint32_t nftnl_table_attr_get_u32(struct nftnl_table *t, uint16_t attr)
+uint32_t nftnl_table_get_u32(struct nftnl_table *t, uint16_t attr)
{
- const void *ret = nftnl_table_attr_get(t, attr);
+ const void *ret = nftnl_table_get(t, attr);
return ret == NULL ? 0 : *((uint32_t *)ret);
}
-EXPORT_SYMBOL(nftnl_table_attr_get_u32, nft_table_attr_get_u32);
+EXPORT_SYMBOL(nftnl_table_get_u32, nft_table_attr_get_u32);
-uint8_t nftnl_table_attr_get_u8(struct nftnl_table *t, uint16_t attr)
+uint8_t nftnl_table_get_u8(struct nftnl_table *t, uint16_t attr)
{
- const void *ret = nftnl_table_attr_get(t, attr);
+ const void *ret = nftnl_table_get(t, attr);
return ret == NULL ? 0 : *((uint8_t *)ret);
}
-EXPORT_SYMBOL(nftnl_table_attr_get_u8, nft_table_attr_get_u8);
+EXPORT_SYMBOL(nftnl_table_get_u8, nft_table_attr_get_u8);
-const char *nftnl_table_attr_get_str(struct nftnl_table *t, uint16_t attr)
+const char *nftnl_table_get_str(struct nftnl_table *t, uint16_t attr)
{
- return nftnl_table_attr_get(t, attr);
+ return nftnl_table_get(t, attr);
}
-EXPORT_SYMBOL(nftnl_table_attr_get_str, nft_table_attr_get_str);
+EXPORT_SYMBOL(nftnl_table_get_str, nft_table_attr_get_str);
void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_table *t)
{
@@ -260,20 +260,20 @@ int nftnl_mxml_table_parse(mxml_node_t *tree, struct nftnl_table *t,
name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (name != NULL)
- nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, name);
+ nftnl_table_set_str(t, NFTNL_TABLE_NAME, name);
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC,
&flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags);
if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND, BASE_DEC,
&use, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use);
+ nftnl_table_set_u32(t, NFTNL_TABLE_USE, use);
return 0;
}
@@ -313,17 +313,17 @@ int nftnl_jansson_parse_table(struct nftnl_table *t, json_t *tree,
str = nftnl_jansson_parse_str(root, "name", err);
if (str != NULL)
- nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, str);
+ nftnl_table_set_str(t, NFTNL_TABLE_NAME, str);
if (nftnl_jansson_parse_family(root, &family, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags,
err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags);
+ nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags);
if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use);
+ nftnl_table_set_u32(t, NFTNL_TABLE_USE, use);
return 0;
}
diff --git a/tests/nft-chain-test.c b/tests/nft-chain-test.c
index 8ae98df..3f5c5a5 100644
--- a/tests/nft-chain-test.c
+++ b/tests/nft-chain-test.c
@@ -26,41 +26,41 @@ static void print_err(const char *msg)
static void cmp_nftnl_chain(struct nftnl_chain *a, struct nftnl_chain *b)
{
- if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_NAME),
- nftnl_chain_attr_get_str(b, NFTNL_CHAIN_NAME)) != 0)
+ if (strcmp(nftnl_chain_get_str(a, NFTNL_CHAIN_NAME),
+ nftnl_chain_get_str(b, NFTNL_CHAIN_NAME)) != 0)
print_err("Chain name mismatches");
- if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_TABLE),
- nftnl_chain_attr_get_str(b, NFTNL_CHAIN_TABLE)) != 0)
+ if (strcmp(nftnl_chain_get_str(a, NFTNL_CHAIN_TABLE),
+ nftnl_chain_get_str(b, NFTNL_CHAIN_TABLE)) != 0)
print_err("Chain table mismatches");
- if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_FAMILY) !=
- nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_FAMILY))
+ if (nftnl_chain_get_u32(a, NFTNL_CHAIN_FAMILY) !=
+ nftnl_chain_get_u32(b, NFTNL_CHAIN_FAMILY))
print_err("Chain family mismatches");
- if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_POLICY) !=
- nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_POLICY))
+ if (nftnl_chain_get_u32(a, NFTNL_CHAIN_POLICY) !=
+ nftnl_chain_get_u32(b, NFTNL_CHAIN_POLICY))
print_err("Chain policy mismatches");
- if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_HOOKNUM) !=
- nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_HOOKNUM))
+ if (nftnl_chain_get_u32(a, NFTNL_CHAIN_HOOKNUM) !=
+ nftnl_chain_get_u32(b, NFTNL_CHAIN_HOOKNUM))
print_err("Chain hooknum mismatches");
- if (nftnl_chain_attr_get_s32(a, NFTNL_CHAIN_PRIO) !=
- nftnl_chain_attr_get_s32(b, NFTNL_CHAIN_PRIO))
+ if (nftnl_chain_get_s32(a, NFTNL_CHAIN_PRIO) !=
+ nftnl_chain_get_s32(b, NFTNL_CHAIN_PRIO))
print_err("Chain Prio mismatches");
- if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_USE) !=
- nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_USE))
+ if (nftnl_chain_get_u32(a, NFTNL_CHAIN_USE) !=
+ nftnl_chain_get_u32(b, NFTNL_CHAIN_USE))
print_err("Chain use mismatches");
- if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_PACKETS) !=
- nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_PACKETS))
+ if (nftnl_chain_get_u64(a, NFTNL_CHAIN_PACKETS) !=
+ nftnl_chain_get_u64(b, NFTNL_CHAIN_PACKETS))
print_err("Chain packets mismatches");
- if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_BYTES) !=
- nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_BYTES))
+ if (nftnl_chain_get_u64(a, NFTNL_CHAIN_BYTES) !=
+ nftnl_chain_get_u64(b, NFTNL_CHAIN_BYTES))
print_err("Chain bytes mismatches");
- if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_HANDLE) !=
- nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_HANDLE))
+ if (nftnl_chain_get_u64(a, NFTNL_CHAIN_HANDLE) !=
+ nftnl_chain_get_u64(b, NFTNL_CHAIN_HANDLE))
print_err("Chain handle mismatches");
- if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_TYPE),
- nftnl_chain_attr_get_str(b, NFTNL_CHAIN_TYPE)) != 0)
+ if (strcmp(nftnl_chain_get_str(a, NFTNL_CHAIN_TYPE),
+ nftnl_chain_get_str(b, NFTNL_CHAIN_TYPE)) != 0)
print_err("Chain type mismatches");
- if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_DEV),
- nftnl_chain_attr_get_str(b, NFTNL_CHAIN_DEV)) != 0)
+ if (strcmp(nftnl_chain_get_str(a, NFTNL_CHAIN_DEV),
+ nftnl_chain_get_str(b, NFTNL_CHAIN_DEV)) != 0)
print_err("Chain device mismatches");
}
@@ -75,18 +75,18 @@ int main(int argc, char *argv[])
if (a == NULL || b == NULL)
print_err("OOM");
- nftnl_chain_attr_set_str(a, NFTNL_CHAIN_NAME, "test");
- nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_FAMILY, AF_INET);
- nftnl_chain_attr_set_str(a, NFTNL_CHAIN_TABLE, "Table");
- nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_POLICY,0x12345678);
- nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_HOOKNUM, 0x12345678);
- nftnl_chain_attr_set_s32(a, NFTNL_CHAIN_PRIO, 0x12345678);
- nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_USE, 0x12345678 );
- nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_PACKETS, 0x1234567812345678);
- nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_BYTES, 0x1234567812345678);
- nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_HANDLE, 0x1234567812345678);
- nftnl_chain_attr_set_str(a, NFTNL_CHAIN_TYPE, "Prueba");
- nftnl_chain_attr_set_str(a, NFTNL_CHAIN_DEV, "eth0");
+ nftnl_chain_set_str(a, NFTNL_CHAIN_NAME, "test");
+ nftnl_chain_set_u32(a, NFTNL_CHAIN_FAMILY, AF_INET);
+ nftnl_chain_set_str(a, NFTNL_CHAIN_TABLE, "Table");
+ nftnl_chain_set_u32(a, NFTNL_CHAIN_POLICY,0x12345678);
+ nftnl_chain_set_u32(a, NFTNL_CHAIN_HOOKNUM, 0x12345678);
+ nftnl_chain_set_s32(a, NFTNL_CHAIN_PRIO, 0x12345678);
+ nftnl_chain_set_u32(a, NFTNL_CHAIN_USE, 0x12345678 );
+ nftnl_chain_set_u64(a, NFTNL_CHAIN_PACKETS, 0x1234567812345678);
+ nftnl_chain_set_u64(a, NFTNL_CHAIN_BYTES, 0x1234567812345678);
+ nftnl_chain_set_u64(a, NFTNL_CHAIN_HANDLE, 0x1234567812345678);
+ nftnl_chain_set_str(a, NFTNL_CHAIN_TYPE, "Prueba");
+ nftnl_chain_set_str(a, NFTNL_CHAIN_DEV, "eth0");
/* cmd extracted from include/linux/netfilter/nf_tables.h */
nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_NEWCHAIN, AF_INET,
diff --git a/tests/nft-rule-test.c b/tests/nft-rule-test.c
index ce2fbd7..dff9634 100644
--- a/tests/nft-rule-test.c
+++ b/tests/nft-rule-test.c
@@ -26,26 +26,26 @@ static void print_err(const char *msg)
static void cmp_nftnl_rule(struct nftnl_rule *a, struct nftnl_rule *b)
{
- if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_FAMILY) !=
- nftnl_rule_attr_get_u32(b, NFTNL_RULE_FAMILY))
+ if (nftnl_rule_get_u32(a, NFTNL_RULE_FAMILY) !=
+ nftnl_rule_get_u32(b, NFTNL_RULE_FAMILY))
print_err("Rule family mismatches");
- if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_TABLE),
- nftnl_rule_attr_get_str(b, NFTNL_RULE_TABLE)) != 0)
+ if (strcmp(nftnl_rule_get_str(a, NFTNL_RULE_TABLE),
+ nftnl_rule_get_str(b, NFTNL_RULE_TABLE)) != 0)
print_err("Rule table mismatches");
- if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_CHAIN),
- nftnl_rule_attr_get_str(b, NFTNL_RULE_CHAIN)) != 0)
+ if (strcmp(nftnl_rule_get_str(a, NFTNL_RULE_CHAIN),
+ nftnl_rule_get_str(b, NFTNL_RULE_CHAIN)) != 0)
print_err("Rule table mismatches");
- if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_HANDLE) !=
- nftnl_rule_attr_get_u64(b, NFTNL_RULE_HANDLE))
+ if (nftnl_rule_get_u64(a, NFTNL_RULE_HANDLE) !=
+ nftnl_rule_get_u64(b, NFTNL_RULE_HANDLE))
print_err("Rule handle mismatches");
- if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_COMPAT_PROTO) !=
- nftnl_rule_attr_get_u32(b, NFTNL_RULE_COMPAT_PROTO))
+ if (nftnl_rule_get_u32(a, NFTNL_RULE_COMPAT_PROTO) !=
+ nftnl_rule_get_u32(b, NFTNL_RULE_COMPAT_PROTO))
print_err("Rule compat_proto mismatches");
- if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_COMPAT_FLAGS) !=
- nftnl_rule_attr_get_u32(b, NFTNL_RULE_COMPAT_FLAGS))
+ if (nftnl_rule_get_u32(a, NFTNL_RULE_COMPAT_FLAGS) !=
+ nftnl_rule_get_u32(b, NFTNL_RULE_COMPAT_FLAGS))
print_err("Rule compat_flags mismatches");
- if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_POSITION) !=
- nftnl_rule_attr_get_u64(b, NFTNL_RULE_POSITION))
+ if (nftnl_rule_get_u64(a, NFTNL_RULE_POSITION) !=
+ nftnl_rule_get_u64(b, NFTNL_RULE_POSITION))
print_err("Rule compat_position mismatches");
}
@@ -60,13 +60,13 @@ int main(int argc, char *argv[])
if (a == NULL || b == NULL)
print_err("OOM");
- nftnl_rule_attr_set_u32(a, NFTNL_RULE_FAMILY, AF_INET);
- nftnl_rule_attr_set_str(a, NFTNL_RULE_TABLE, "table");
- nftnl_rule_attr_set_str(a, NFTNL_RULE_CHAIN, "chain");
- nftnl_rule_attr_set_u64(a, NFTNL_RULE_HANDLE, 0x1234567812345678);
- nftnl_rule_attr_set_u32(a, NFTNL_RULE_COMPAT_PROTO, 0x12345678);
- nftnl_rule_attr_set_u32(a, NFTNL_RULE_COMPAT_FLAGS, 0x12345678);
- nftnl_rule_attr_set_u64(a, NFTNL_RULE_POSITION, 0x1234567812345678);
+ nftnl_rule_set_u32(a, NFTNL_RULE_FAMILY, AF_INET);
+ nftnl_rule_set_str(a, NFTNL_RULE_TABLE, "table");
+ nftnl_rule_set_str(a, NFTNL_RULE_CHAIN, "chain");
+ nftnl_rule_set_u64(a, NFTNL_RULE_HANDLE, 0x1234567812345678);
+ nftnl_rule_set_u32(a, NFTNL_RULE_COMPAT_PROTO, 0x12345678);
+ nftnl_rule_set_u32(a, NFTNL_RULE_COMPAT_FLAGS, 0x12345678);
+ nftnl_rule_set_u64(a, NFTNL_RULE_POSITION, 0x1234567812345678);
nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
nftnl_rule_nlmsg_build_payload(nlh, a);
diff --git a/tests/nft-set-test.c b/tests/nft-set-test.c
index a9577d8..f6fbfb5 100644
--- a/tests/nft-set-test.c
+++ b/tests/nft-set-test.c
@@ -26,26 +26,26 @@ static void print_err(const char *msg)
static void cmp_nftnl_set(struct nftnl_set *a, struct nftnl_set *b)
{
- if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_TABLE),
- nftnl_set_attr_get_str(b, NFTNL_SET_TABLE)) != 0)
+ if (strcmp(nftnl_set_get_str(a, NFTNL_SET_TABLE),
+ nftnl_set_get_str(b, NFTNL_SET_TABLE)) != 0)
print_err("Set table mismatches");
- if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_NAME),
- nftnl_set_attr_get_str(b, NFTNL_SET_NAME)) != 0)
+ if (strcmp(nftnl_set_get_str(a, NFTNL_SET_NAME),
+ nftnl_set_get_str(b, NFTNL_SET_NAME)) != 0)
print_err("Set name mismatches");
- if (nftnl_set_attr_get_u32(a, NFTNL_SET_FLAGS) !=
- nftnl_set_attr_get_u32(b, NFTNL_SET_FLAGS))
+ if (nftnl_set_get_u32(a, NFTNL_SET_FLAGS) !=
+ nftnl_set_get_u32(b, NFTNL_SET_FLAGS))
print_err("Set flags mismatches");
- if (nftnl_set_attr_get_u32(a, NFTNL_SET_KEY_TYPE) !=
- nftnl_set_attr_get_u32(b, NFTNL_SET_KEY_TYPE))
+ if (nftnl_set_get_u32(a, NFTNL_SET_KEY_TYPE) !=
+ nftnl_set_get_u32(b, NFTNL_SET_KEY_TYPE))
print_err("Set key-type mismatches");
- if (nftnl_set_attr_get_u32(a, NFTNL_SET_KEY_LEN) !=
- nftnl_set_attr_get_u32(b, NFTNL_SET_KEY_LEN))
+ if (nftnl_set_get_u32(a, NFTNL_SET_KEY_LEN) !=
+ nftnl_set_get_u32(b, NFTNL_SET_KEY_LEN))
print_err("Set key-len mismatches");
- if (nftnl_set_attr_get_u32(a, NFTNL_SET_DATA_TYPE) !=
- nftnl_set_attr_get_u32(b, NFTNL_SET_DATA_TYPE))
+ if (nftnl_set_get_u32(a, NFTNL_SET_DATA_TYPE) !=
+ nftnl_set_get_u32(b, NFTNL_SET_DATA_TYPE))
print_err("Set data-type mismatches");
- if (nftnl_set_attr_get_u32(a, NFTNL_SET_DATA_LEN) !=
- nftnl_set_attr_get_u32(b, NFTNL_SET_DATA_LEN))
+ if (nftnl_set_get_u32(a, NFTNL_SET_DATA_LEN) !=
+ nftnl_set_get_u32(b, NFTNL_SET_DATA_LEN))
print_err("Set data-len mismatches");
}
@@ -60,14 +60,14 @@ int main(int argc, char *argv[])
if (a == NULL || b == NULL)
print_err("OOM");
- nftnl_set_attr_set_str(a, NFTNL_SET_TABLE, "test-table");
- nftnl_set_attr_set_str(a, NFTNL_SET_NAME, "test-name");
- nftnl_set_attr_set_u32(a, NFTNL_SET_FLAGS, 0x12345678);
- nftnl_set_attr_set_u32(a, NFTNL_SET_KEY_TYPE, 0x12345678);
- nftnl_set_attr_set_u32(a, NFTNL_SET_KEY_LEN, 0x12345678);
- nftnl_set_attr_set_u32(a, NFTNL_SET_DATA_TYPE, 0x12345678);
- nftnl_set_attr_set_u32(a, NFTNL_SET_DATA_LEN, 0x12345678);
- nftnl_set_attr_set_u32(a, NFTNL_SET_FAMILY, 0x12345678);
+ nftnl_set_set_str(a, NFTNL_SET_TABLE, "test-table");
+ nftnl_set_set_str(a, NFTNL_SET_NAME, "test-name");
+ nftnl_set_set_u32(a, NFTNL_SET_FLAGS, 0x12345678);
+ nftnl_set_set_u32(a, NFTNL_SET_KEY_TYPE, 0x12345678);
+ nftnl_set_set_u32(a, NFTNL_SET_KEY_LEN, 0x12345678);
+ nftnl_set_set_u32(a, NFTNL_SET_DATA_TYPE, 0x12345678);
+ nftnl_set_set_u32(a, NFTNL_SET_DATA_LEN, 0x12345678);
+ nftnl_set_set_u32(a, NFTNL_SET_FAMILY, 0x12345678);
/* cmd extracted from include/linux/netfilter/nf_tables.h */
nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSET, AF_INET, 0, 1234);
diff --git a/tests/nft-table-test.c b/tests/nft-table-test.c
index 2aad037..1031ffe 100644
--- a/tests/nft-table-test.c
+++ b/tests/nft-table-test.c
@@ -26,14 +26,14 @@ static void print_err(const char *msg)
static void cmp_nftnl_table(struct nftnl_table *a, struct nftnl_table *b)
{
- if (strcmp(nftnl_table_attr_get_str(a, NFTNL_TABLE_NAME),
- nftnl_table_attr_get_str(b, NFTNL_TABLE_NAME)) != 0)
+ if (strcmp(nftnl_table_get_str(a, NFTNL_TABLE_NAME),
+ nftnl_table_get_str(b, NFTNL_TABLE_NAME)) != 0)
print_err("table name mismatches");
- if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_FLAGS) !=
- nftnl_table_attr_get_u32(b, NFTNL_TABLE_FLAGS))
+ if (nftnl_table_get_u32(a, NFTNL_TABLE_FLAGS) !=
+ nftnl_table_get_u32(b, NFTNL_TABLE_FLAGS))
print_err("table flags mismatches");
- if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_FAMILY) !=
- nftnl_table_attr_get_u32(b, NFTNL_TABLE_FAMILY))
+ if (nftnl_table_get_u32(a, NFTNL_TABLE_FAMILY) !=
+ nftnl_table_get_u32(b, NFTNL_TABLE_FAMILY))
print_err("tabke family mismatches");
}
@@ -50,9 +50,9 @@ int main(int argc, char *argv[])
if (a == NULL || b == NULL)
print_err("OOM");
- nftnl_table_attr_set_str(a, NFTNL_TABLE_NAME, "test");
- nftnl_table_attr_set_u32(a, NFTNL_TABLE_FAMILY, AF_INET);
- nftnl_table_attr_set_u32(a, NFTNL_TABLE_FLAGS, 0);
+ nftnl_table_set_str(a, NFTNL_TABLE_NAME, "test");
+ nftnl_table_set_u32(a, NFTNL_TABLE_FAMILY, AF_INET);
+ nftnl_table_set_u32(a, NFTNL_TABLE_FLAGS, 0);
/* cmd extracted from include/linux/netfilter/nf_tables.h */
nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE, AF_INET, 0,