From 0e7b6c4983af4ddd3a50c3ce756638af157c7130 Mon Sep 17 00:00:00 2001 From: Pablo Neira Ayuso Date: Mon, 7 Sep 2015 18:02:50 +0200 Subject: src: get rid of _ATTR_ infix in new nfntl_ definitions The constant names are already large, trim off the _ATTR_ infix in the attribute definitions. Signed-off-by: Pablo Neira Ayuso --- examples/nft-chain-add.c | 8 +- examples/nft-chain-del.c | 4 +- examples/nft-chain-get.c | 4 +- examples/nft-chain-parse-add.c | 4 +- examples/nft-rule-add.c | 10 +- examples/nft-rule-del.c | 6 +- examples/nft-rule-parse-add.c | 4 +- examples/nft-ruleset-get.c | 10 +- examples/nft-ruleset-parse-file.c | 36 +++--- examples/nft-set-add.c | 12 +- examples/nft-set-del.c | 4 +- examples/nft-set-elem-add.c | 8 +- examples/nft-set-elem-del.c | 8 +- examples/nft-set-elem-get.c | 4 +- examples/nft-set-get.c | 2 +- examples/nft-set-parse-add.c | 4 +- examples/nft-table-add.c | 6 +- examples/nft-table-del.c | 6 +- examples/nft-table-get.c | 2 +- examples/nft-table-parse-add.c | 2 +- examples/nft-table-upd.c | 4 +- include/libnftnl/chain.h | 30 ++--- include/libnftnl/rule.h | 22 ++-- include/libnftnl/ruleset.h | 8 +- include/libnftnl/set.h | 50 ++++---- include/libnftnl/table.h | 14 +-- src/chain.c | 214 ++++++++++++++++---------------- src/jansson.c | 10 +- src/rule.c | 158 ++++++++++++------------ src/ruleset.c | 66 +++++----- src/set.c | 252 +++++++++++++++++++------------------- src/set_elem.c | 136 ++++++++++---------- src/table.c | 70 +++++------ tests/nft-chain-test.c | 72 +++++------ tests/nft-rule-test.c | 42 +++---- tests/nft-set-test.c | 44 +++---- tests/nft-table-test.c | 18 +-- 37 files changed, 677 insertions(+), 677 deletions(-) diff --git a/examples/nft-chain-add.c b/examples/nft-chain-add.c index c50369e..173af18 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_ATTR_TABLE, argv[2]); - nftnl_chain_attr_set(t, NFTNL_CHAIN_ATTR_NAME, argv[3]); + nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]); + nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]); if (argc == 6) { - nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_ATTR_HOOKNUM, hooknum); - nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_ATTR_PRIO, atoi(argv[5])); + nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_HOOKNUM, hooknum); + nftnl_chain_attr_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 0b04daa..29953d7 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_ATTR_TABLE, argv[2]); - nftnl_chain_attr_set(t, NFTNL_CHAIN_ATTR_NAME, argv[3]); + nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]); + nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]); return t; } diff --git a/examples/nft-chain-get.c b/examples/nft-chain-get.c index f743ee3..ead14fc 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_ATTR_TABLE, argv[2]); - nftnl_chain_attr_set(t, NFTNL_CHAIN_ATTR_NAME, argv[3]); + nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]); + nftnl_chain_attr_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 57accad..baf0087 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_ATTR_HANDLE); - family = nftnl_chain_attr_get_u32(c, NFTNL_CHAIN_ATTR_FAMILY); + nftnl_chain_attr_unset(c, NFTNL_CHAIN_HANDLE); + family = nftnl_chain_attr_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 6ceacbd..a81f459 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_ATTR_TABLE, table); - nftnl_rule_attr_set(r, NFTNL_RULE_ATTR_CHAIN, chain); - nftnl_rule_attr_set_u32(r, NFTNL_RULE_ATTR_FAMILY, family); + 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); if (handle != NULL) { handle_num = atoll(handle); - nftnl_rule_attr_set_u64(r, NFTNL_RULE_ATTR_POSITION, handle_num); + nftnl_rule_attr_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_ATTR_FAMILY), + nftnl_rule_attr_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 5927c61..d25d5e9 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_ATTR_TABLE, argv[2]); - nftnl_rule_attr_set(r, NFTNL_RULE_ATTR_CHAIN, argv[3]); + nftnl_rule_attr_set(r, NFTNL_RULE_TABLE, argv[2]); + nftnl_rule_attr_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_ATTR_HANDLE, atoi(argv[4])); + nftnl_rule_attr_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 3413070..b296859 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_ATTR_HANDLE); + nftnl_rule_attr_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_ATTR_FAMILY); + family = nftnl_rule_attr_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 014a9e7..5965f79 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_ATTR_FAMILY); + uint32_t family = nftnl_set_attr_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_ATTR_TABLELIST, t); + nftnl_ruleset_attr_set(rs, NFTNL_RULESET_TABLELIST, t); c = mnl_chain_dump(nf_sock, NFPROTO_UNSPEC); if (c != NULL) - nftnl_ruleset_attr_set(rs, NFTNL_RULESET_ATTR_CHAINLIST, c); + nftnl_ruleset_attr_set(rs, NFTNL_RULESET_CHAINLIST, c); s = mnl_set_dump(nf_sock, NFPROTO_UNSPEC); if (s != NULL) - nftnl_ruleset_attr_set(rs, NFTNL_RULESET_ATTR_SETLIST, s); + nftnl_ruleset_attr_set(rs, NFTNL_RULESET_SETLIST, s); r = mnl_rule_dump(nf_sock, NFPROTO_UNSPEC); if (r != NULL) - nftnl_ruleset_attr_set(rs, NFTNL_RULESET_ATTR_RULELIST, r); + nftnl_ruleset_attr_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 2113cd7..7cb328c 100644 --- a/examples/nft-ruleset-parse-file.c +++ b/examples/nft-ruleset-parse-file.c @@ -70,7 +70,7 @@ static int nftnl_ruleset_set_elems(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_ATTR_FAMILY), + NFTNL_SET_FAMILY), nl_flags, seq++); nftnl_set_elems_nlmsg_build_payload_iter(nlh, iter_elems); @@ -113,7 +113,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_ATTR_FAMILY), + 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_ATTR_HANDLE); + nftnl_rule_attr_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_ATTR_HANDLE); + nftnl_rule_attr_unset(rule, NFTNL_RULE_HANDLE); break; default: return -1; @@ -158,7 +158,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_ATTR_FAMILY), + 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_ATTR_TABLE, - nftnl_table_attr_get(nlt, NFTNL_TABLE_ATTR_NAME)); - nftnl_rule_attr_set(nlr, NFTNL_RULE_ATTR_FAMILY, - nftnl_table_attr_get(nlt, NFTNL_TABLE_ATTR_FAMILY)); + 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)); break; case NFTNL_RULESET_CHAIN: nlc = nftnl_ruleset_ctx_get(ctx, NFTNL_RULESET_CTX_CHAIN); - nftnl_rule_attr_set(nlr, NFTNL_RULE_ATTR_TABLE, + nftnl_rule_attr_set(nlr, NFTNL_RULE_TABLE, nftnl_chain_attr_get(nlc, - NFTNL_CHAIN_ATTR_TABLE)); - nftnl_rule_attr_set(nlr, NFTNL_RULE_ATTR_CHAIN, + NFTNL_CHAIN_TABLE)); + nftnl_rule_attr_set(nlr, NFTNL_RULE_CHAIN, nftnl_chain_attr_get(nlc, - NFTNL_CHAIN_ATTR_NAME)); - nftnl_rule_attr_set(nlr, NFTNL_RULE_ATTR_FAMILY, - nftnl_chain_attr_get(nlc, NFTNL_TABLE_ATTR_FAMILY)); + NFTNL_CHAIN_NAME)); + nftnl_rule_attr_set(nlr, NFTNL_RULE_FAMILY, + nftnl_chain_attr_get(nlc, NFTNL_TABLE_FAMILY)); break; default: goto err; @@ -258,11 +258,11 @@ static int nftnl_ruleset_chain(const struct nftnl_parse_ctx *ctx) goto err; } - nftnl_chain_attr_unset(chain, NFTNL_CHAIN_ATTR_HANDLE); + nftnl_chain_attr_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_ATTR_FAMILY), + NFTNL_CHAIN_FAMILY), nl_flags, seq++); @@ -298,7 +298,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_ATTR_FAMILY), + NFTNL_TABLE_FAMILY), nl_flags, seq++); diff --git a/examples/nft-set-add.c b/examples/nft-set-add.c index 593627b..a29115c 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_ATTR_TABLE, table); - nftnl_set_attr_set_str(s, NFTNL_SET_ATTR_NAME, name); - nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FAMILY, family); - nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_KEY_LEN, 2); - nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_ID, 1); - nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FLAGS, NFT_SET_CONSTANT); + 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); return s; } diff --git a/examples/nft-set-del.c b/examples/nft-set-del.c index 897793a..ae87608 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_ATTR_TABLE, argv[2]); - nftnl_set_attr_set(t, NFTNL_SET_ATTR_NAME, argv[3]); + nftnl_set_attr_set(t, NFTNL_SET_TABLE, argv[2]); + nftnl_set_attr_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 ef155b3..178c1a2 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_ATTR_TABLE, argv[2]); - nftnl_set_attr_set(s, NFTNL_SET_ATTR_NAME, argv[3]); + nftnl_set_attr_set(s, NFTNL_SET_TABLE, argv[2]); + nftnl_set_attr_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_ATTR_KEY, &data, sizeof(data)); + nftnl_set_elem_attr_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_ATTR_KEY, &data, sizeof(data)); + nftnl_set_elem_attr_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 e770224..9897ff7 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_ATTR_TABLE, argv[2]); - nftnl_set_attr_set(s, NFTNL_SET_ATTR_NAME, argv[3]); + nftnl_set_attr_set(s, NFTNL_SET_TABLE, argv[2]); + nftnl_set_attr_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_ATTR_KEY, &data, sizeof(data)); + nftnl_set_elem_attr_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_ATTR_KEY, &data, sizeof(data)); + nftnl_set_elem_attr_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 66b5524..f8d184b 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_ATTR_NAME, argv[3]); - nftnl_set_attr_set(t, NFTNL_SET_ATTR_TABLE, argv[2]); + nftnl_set_attr_set(t, NFTNL_SET_NAME, argv[3]); + nftnl_set_attr_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 aec76e8..a8a133f 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_ATTR_TABLE, argv[2]); */ +/* nftnl_set_attr_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 57326ee..b3fffc5 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_ATTR_ID, 1); + nftnl_set_attr_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_ATTR_FAMILY); + family = nftnl_set_attr_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 f8ae46f..bc36333 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_ATTR_FAMILY, family); - nftnl_table_attr_set_str(t, NFTNL_TABLE_ATTR_NAME, argv[2]); + nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family); + nftnl_table_attr_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_ATTR_FAMILY); + family = nftnl_table_attr_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 a321bca..f3699c7 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_ATTR_NAME, argv[2]); - nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FAMILY, family); + nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, argv[2]); + nftnl_table_attr_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_ATTR_FAMILY); + family = nftnl_table_attr_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 8e37556..84524b0 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_ATTR_NAME, argv[2]); + nftnl_table_attr_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 794db97..6a34f56 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_ATTR_FAMILY); + family = nftnl_table_attr_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 7deb8fd..5b14e54 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_ATTR_NAME, argv[2]); - nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FLAGS, flags); + nftnl_table_attr_set(t, NFTNL_TABLE_NAME, argv[2]); + nftnl_table_attr_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 d952ce9..9fd637d 100644 --- a/include/libnftnl/chain.h +++ b/include/libnftnl/chain.h @@ -17,22 +17,22 @@ struct nftnl_chain; struct nftnl_chain *nftnl_chain_alloc(void); void nftnl_chain_free(struct nftnl_chain *); -enum { - NFTNL_CHAIN_ATTR_NAME = 0, - NFTNL_CHAIN_ATTR_FAMILY, - NFTNL_CHAIN_ATTR_TABLE, - NFTNL_CHAIN_ATTR_HOOKNUM, - NFTNL_CHAIN_ATTR_PRIO = 4, - NFTNL_CHAIN_ATTR_POLICY, - NFTNL_CHAIN_ATTR_USE, - NFTNL_CHAIN_ATTR_BYTES, - NFTNL_CHAIN_ATTR_PACKETS = 8, - NFTNL_CHAIN_ATTR_HANDLE, - NFTNL_CHAIN_ATTR_TYPE, - NFTNL_CHAIN_ATTR_DEV, - __NFTNL_CHAIN_ATTR_MAX +enum nftnl_chain_attr { + NFTNL_CHAIN_NAME = 0, + NFTNL_CHAIN_FAMILY, + NFTNL_CHAIN_TABLE, + NFTNL_CHAIN_HOOKNUM, + NFTNL_CHAIN_PRIO = 4, + NFTNL_CHAIN_POLICY, + NFTNL_CHAIN_USE, + NFTNL_CHAIN_BYTES, + NFTNL_CHAIN_PACKETS = 8, + NFTNL_CHAIN_HANDLE, + NFTNL_CHAIN_TYPE, + NFTNL_CHAIN_DEV, + __NFTNL_CHAIN_MAX }; -#define NFTNL_CHAIN_ATTR_MAX (__NFTNL_CHAIN_ATTR_MAX - 1) +#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); diff --git a/include/libnftnl/rule.h b/include/libnftnl/rule.h index f5f8555..3cc79bd 100644 --- a/include/libnftnl/rule.h +++ b/include/libnftnl/rule.h @@ -18,18 +18,18 @@ struct nftnl_expr; struct nftnl_rule *nftnl_rule_alloc(void); void nftnl_rule_free(struct nftnl_rule *); -enum { - NFTNL_RULE_ATTR_FAMILY = 0, - NFTNL_RULE_ATTR_TABLE, - NFTNL_RULE_ATTR_CHAIN, - NFTNL_RULE_ATTR_HANDLE, - NFTNL_RULE_ATTR_COMPAT_PROTO, - NFTNL_RULE_ATTR_COMPAT_FLAGS, - NFTNL_RULE_ATTR_POSITION, - NFTNL_RULE_ATTR_USERDATA, - __NFTNL_RULE_ATTR_MAX +enum nftnl_rule_attr { + NFTNL_RULE_FAMILY = 0, + NFTNL_RULE_TABLE, + NFTNL_RULE_CHAIN, + NFTNL_RULE_HANDLE, + NFTNL_RULE_COMPAT_PROTO, + NFTNL_RULE_COMPAT_FLAGS, + NFTNL_RULE_POSITION, + NFTNL_RULE_USERDATA, + __NFTNL_RULE_MAX }; -#define NFTNL_RULE_ATTR_MAX (__NFTNL_RULE_ATTR_MAX - 1) +#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); diff --git a/include/libnftnl/ruleset.h b/include/libnftnl/ruleset.h index 6c304dc..a627e1d 100644 --- a/include/libnftnl/ruleset.h +++ b/include/libnftnl/ruleset.h @@ -19,10 +19,10 @@ struct nftnl_ruleset *nftnl_ruleset_alloc(void); void nftnl_ruleset_free(struct nftnl_ruleset *r); enum { - NFTNL_RULESET_ATTR_TABLELIST = 0, - NFTNL_RULESET_ATTR_CHAINLIST, - NFTNL_RULESET_ATTR_SETLIST, - NFTNL_RULESET_ATTR_RULELIST, + NFTNL_RULESET_TABLELIST = 0, + NFTNL_RULESET_CHAINLIST, + NFTNL_RULESET_SETLIST, + NFTNL_RULESET_RULELIST, }; enum nftnl_ruleset_type { diff --git a/include/libnftnl/set.h b/include/libnftnl/set.h index 4420d03..bee8dfa 100644 --- a/include/libnftnl/set.h +++ b/include/libnftnl/set.h @@ -8,23 +8,23 @@ #include -enum { - NFTNL_SET_ATTR_TABLE, - NFTNL_SET_ATTR_NAME, - NFTNL_SET_ATTR_FLAGS, - NFTNL_SET_ATTR_KEY_TYPE, - NFTNL_SET_ATTR_KEY_LEN, - NFTNL_SET_ATTR_DATA_TYPE, - NFTNL_SET_ATTR_DATA_LEN, - NFTNL_SET_ATTR_FAMILY, - NFTNL_SET_ATTR_ID, - NFTNL_SET_ATTR_POLICY, - NFTNL_SET_ATTR_DESC_SIZE, - NFTNL_SET_ATTR_TIMEOUT, - NFTNL_SET_ATTR_GC_INTERVAL, - __NFTNL_SET_ATTR_MAX +enum nftnl_set_attr { + NFTNL_SET_TABLE, + NFTNL_SET_NAME, + NFTNL_SET_FLAGS, + NFTNL_SET_KEY_TYPE, + NFTNL_SET_KEY_LEN, + NFTNL_SET_DATA_TYPE, + NFTNL_SET_DATA_LEN, + NFTNL_SET_FAMILY, + NFTNL_SET_ID, + NFTNL_SET_POLICY, + NFTNL_SET_DESC_SIZE, + NFTNL_SET_TIMEOUT, + NFTNL_SET_GC_INTERVAL, + __NFTNL_SET_MAX }; -#define NFTNL_SET_ATTR_MAX (__NFTNL_SET_ATTR_MAX - 1) +#define NFTNL_SET_MAX (__NFTNL_SET_MAX - 1) struct nftnl_set; @@ -85,15 +85,15 @@ int nftnl_set_parse_file(struct nftnl_set *s, enum nftnl_parse_type type, */ enum { - NFTNL_SET_ELEM_ATTR_FLAGS, - NFTNL_SET_ELEM_ATTR_KEY, - NFTNL_SET_ELEM_ATTR_VERDICT, - NFTNL_SET_ELEM_ATTR_CHAIN, - NFTNL_SET_ELEM_ATTR_DATA, - NFTNL_SET_ELEM_ATTR_TIMEOUT, - NFTNL_SET_ELEM_ATTR_EXPIRATION, - NFTNL_SET_ELEM_ATTR_USERDATA, - NFTNL_SET_ELEM_ATTR_EXPR, + NFTNL_SET_ELEM_FLAGS, + NFTNL_SET_ELEM_KEY, + NFTNL_SET_ELEM_VERDICT, + NFTNL_SET_ELEM_CHAIN, + NFTNL_SET_ELEM_DATA, + NFTNL_SET_ELEM_TIMEOUT, + NFTNL_SET_ELEM_EXPIRATION, + NFTNL_SET_ELEM_USERDATA, + NFTNL_SET_ELEM_EXPR, }; struct nftnl_set_elem; diff --git a/include/libnftnl/table.h b/include/libnftnl/table.h index ca9a5c6..d18d348 100644 --- a/include/libnftnl/table.h +++ b/include/libnftnl/table.h @@ -17,14 +17,14 @@ struct nftnl_table; struct nftnl_table *nftnl_table_alloc(void); void nftnl_table_free(struct nftnl_table *); -enum { - NFTNL_TABLE_ATTR_NAME = 0, - NFTNL_TABLE_ATTR_FAMILY, - NFTNL_TABLE_ATTR_FLAGS, - NFTNL_TABLE_ATTR_USE, - __NFTNL_TABLE_ATTR_MAX +enum nftnl_table_attr { + NFTNL_TABLE_NAME = 0, + NFTNL_TABLE_FAMILY, + NFTNL_TABLE_FLAGS, + NFTNL_TABLE_USE, + __NFTNL_TABLE_MAX }; -#define NFTNL_TABLE_ATTR_MAX (__NFTNL_TABLE_ATTR_MAX - 1) +#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); diff --git a/src/chain.c b/src/chain.c index 63cb91a..f40e6a3 100644 --- a/src/chain.c +++ b/src/chain.c @@ -118,30 +118,30 @@ void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr) return; switch (attr) { - case NFTNL_CHAIN_ATTR_TABLE: + case NFTNL_CHAIN_TABLE: if (c->table) { xfree(c->table); c->table = NULL; } break; - case NFTNL_CHAIN_ATTR_USE: + case NFTNL_CHAIN_USE: break; - case NFTNL_CHAIN_ATTR_TYPE: + case NFTNL_CHAIN_TYPE: if (c->type) { xfree(c->type); c->type = NULL; } break; - case NFTNL_CHAIN_ATTR_NAME: - case NFTNL_CHAIN_ATTR_HOOKNUM: - case NFTNL_CHAIN_ATTR_PRIO: - case NFTNL_CHAIN_ATTR_POLICY: - case NFTNL_CHAIN_ATTR_BYTES: - case NFTNL_CHAIN_ATTR_PACKETS: - case NFTNL_CHAIN_ATTR_HANDLE: - case NFTNL_CHAIN_ATTR_FAMILY: + case NFTNL_CHAIN_NAME: + case NFTNL_CHAIN_HOOKNUM: + case NFTNL_CHAIN_PRIO: + case NFTNL_CHAIN_POLICY: + case NFTNL_CHAIN_BYTES: + case NFTNL_CHAIN_PACKETS: + case NFTNL_CHAIN_HANDLE: + case NFTNL_CHAIN_FAMILY: break; - case NFTNL_CHAIN_ATTR_DEV: + case NFTNL_CHAIN_DEV: if (c->dev) { xfree(c->dev); c->dev = NULL; @@ -155,65 +155,65 @@ void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr) } EXPORT_SYMBOL(nftnl_chain_attr_unset, nft_chain_attr_unset); -static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_ATTR_MAX + 1] = { - [NFTNL_CHAIN_ATTR_HOOKNUM] = sizeof(uint32_t), - [NFTNL_CHAIN_ATTR_PRIO] = sizeof(int32_t), - [NFTNL_CHAIN_ATTR_POLICY] = sizeof(uint32_t), - [NFTNL_CHAIN_ATTR_BYTES] = sizeof(uint64_t), - [NFTNL_CHAIN_ATTR_PACKETS] = sizeof(uint64_t), - [NFTNL_CHAIN_ATTR_HANDLE] = sizeof(uint64_t), - [NFTNL_CHAIN_ATTR_FAMILY] = sizeof(uint32_t), +static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_MAX + 1] = { + [NFTNL_CHAIN_HOOKNUM] = sizeof(uint32_t), + [NFTNL_CHAIN_PRIO] = sizeof(int32_t), + [NFTNL_CHAIN_POLICY] = sizeof(uint32_t), + [NFTNL_CHAIN_BYTES] = sizeof(uint64_t), + [NFTNL_CHAIN_PACKETS] = sizeof(uint64_t), + [NFTNL_CHAIN_HANDLE] = sizeof(uint64_t), + [NFTNL_CHAIN_FAMILY] = sizeof(uint32_t), }; void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr, const void *data, uint32_t data_len) { - if (attr > NFTNL_CHAIN_ATTR_MAX) + if (attr > NFTNL_CHAIN_MAX) return; nftnl_assert_validate(data, nftnl_chain_attr_validate, attr, data_len); switch(attr) { - case NFTNL_CHAIN_ATTR_NAME: + case NFTNL_CHAIN_NAME: strncpy(c->name, data, NFT_CHAIN_MAXNAMELEN); break; - case NFTNL_CHAIN_ATTR_TABLE: + case NFTNL_CHAIN_TABLE: if (c->table) xfree(c->table); c->table = strdup(data); break; - case NFTNL_CHAIN_ATTR_HOOKNUM: + case NFTNL_CHAIN_HOOKNUM: memcpy(&c->hooknum, data, sizeof(c->hooknum)); break; - case NFTNL_CHAIN_ATTR_PRIO: + case NFTNL_CHAIN_PRIO: memcpy(&c->prio, data, sizeof(c->prio)); break; - case NFTNL_CHAIN_ATTR_POLICY: + case NFTNL_CHAIN_POLICY: c->policy = *((uint32_t *)data); break; - case NFTNL_CHAIN_ATTR_USE: + case NFTNL_CHAIN_USE: c->use = *((uint32_t *)data); break; - case NFTNL_CHAIN_ATTR_BYTES: + case NFTNL_CHAIN_BYTES: c->bytes = *((uint64_t *)data); break; - case NFTNL_CHAIN_ATTR_PACKETS: + case NFTNL_CHAIN_PACKETS: c->packets = *((uint64_t *)data); break; - case NFTNL_CHAIN_ATTR_HANDLE: + case NFTNL_CHAIN_HANDLE: c->handle = *((uint64_t *)data); break; - case NFTNL_CHAIN_ATTR_FAMILY: + case NFTNL_CHAIN_FAMILY: c->family = *((uint32_t *)data); break; - case NFTNL_CHAIN_ATTR_TYPE: + case NFTNL_CHAIN_TYPE: if (c->type) xfree(c->type); c->type = strdup(data); break; - case NFTNL_CHAIN_ATTR_DEV: + case NFTNL_CHAIN_DEV: if (c->dev) xfree(c->dev); @@ -267,38 +267,38 @@ const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr, return NULL; switch(attr) { - case NFTNL_CHAIN_ATTR_NAME: + case NFTNL_CHAIN_NAME: return c->name; - case NFTNL_CHAIN_ATTR_TABLE: + case NFTNL_CHAIN_TABLE: return c->table; - case NFTNL_CHAIN_ATTR_HOOKNUM: + case NFTNL_CHAIN_HOOKNUM: *data_len = sizeof(uint32_t); return &c->hooknum; - case NFTNL_CHAIN_ATTR_PRIO: + case NFTNL_CHAIN_PRIO: *data_len = sizeof(int32_t); return &c->prio; - case NFTNL_CHAIN_ATTR_POLICY: + case NFTNL_CHAIN_POLICY: *data_len = sizeof(uint32_t); return &c->policy; - case NFTNL_CHAIN_ATTR_USE: + case NFTNL_CHAIN_USE: *data_len = sizeof(uint32_t); return &c->use; - case NFTNL_CHAIN_ATTR_BYTES: + case NFTNL_CHAIN_BYTES: *data_len = sizeof(uint64_t); return &c->bytes; - case NFTNL_CHAIN_ATTR_PACKETS: + case NFTNL_CHAIN_PACKETS: *data_len = sizeof(uint64_t); return &c->packets; - case NFTNL_CHAIN_ATTR_HANDLE: + case NFTNL_CHAIN_HANDLE: *data_len = sizeof(uint64_t); return &c->handle; - case NFTNL_CHAIN_ATTR_FAMILY: + case NFTNL_CHAIN_FAMILY: *data_len = sizeof(uint32_t); return &c->family; - case NFTNL_CHAIN_ATTR_TYPE: + case NFTNL_CHAIN_TYPE: *data_len = sizeof(uint32_t); return c->type; - case NFTNL_CHAIN_ATTR_DEV: + case NFTNL_CHAIN_DEV: return c->dev; } return NULL; @@ -364,27 +364,27 @@ EXPORT_SYMBOL(nftnl_chain_attr_get_u8, nft_chain_attr_get_u8); void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *c) { - if (c->flags & (1 << NFTNL_CHAIN_ATTR_TABLE)) + if (c->flags & (1 << NFTNL_CHAIN_TABLE)) mnl_attr_put_strz(nlh, NFTA_CHAIN_TABLE, c->table); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_NAME)) + if (c->flags & (1 << NFTNL_CHAIN_NAME)) mnl_attr_put_strz(nlh, NFTA_CHAIN_NAME, c->name); - if ((c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) && - (c->flags & (1 << NFTNL_CHAIN_ATTR_PRIO))) { + if ((c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) && + (c->flags & (1 << NFTNL_CHAIN_PRIO))) { struct nlattr *nest; nest = mnl_attr_nest_start(nlh, NFTA_CHAIN_HOOK); mnl_attr_put_u32(nlh, NFTA_HOOK_HOOKNUM, htonl(c->hooknum)); mnl_attr_put_u32(nlh, NFTA_HOOK_PRIORITY, htonl(c->prio)); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV)) + if (c->flags & (1 << NFTNL_CHAIN_DEV)) mnl_attr_put_strz(nlh, NFTA_HOOK_DEV, c->dev); mnl_attr_nest_end(nlh, nest); } - if (c->flags & (1 << NFTNL_CHAIN_ATTR_POLICY)) + if (c->flags & (1 << NFTNL_CHAIN_POLICY)) mnl_attr_put_u32(nlh, NFTA_CHAIN_POLICY, htonl(c->policy)); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_USE)) + if (c->flags & (1 << NFTNL_CHAIN_USE)) mnl_attr_put_u32(nlh, NFTA_CHAIN_USE, htonl(c->use)); - if ((c->flags & (1 << NFTNL_CHAIN_ATTR_PACKETS)) && - (c->flags & (1 << NFTNL_CHAIN_ATTR_BYTES))) { + if ((c->flags & (1 << NFTNL_CHAIN_PACKETS)) && + (c->flags & (1 << NFTNL_CHAIN_BYTES))) { struct nlattr *nest; nest = mnl_attr_nest_start(nlh, NFTA_CHAIN_COUNTERS); @@ -392,9 +392,9 @@ void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_ch mnl_attr_put_u64(nlh, NFTA_COUNTER_BYTES, be64toh(c->bytes)); mnl_attr_nest_end(nlh, nest); } - if (c->flags & (1 << NFTNL_CHAIN_ATTR_HANDLE)) + if (c->flags & (1 << NFTNL_CHAIN_HANDLE)) mnl_attr_put_u64(nlh, NFTA_CHAIN_HANDLE, be64toh(c->handle)); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_TYPE)) + if (c->flags & (1 << NFTNL_CHAIN_TYPE)) mnl_attr_put_strz(nlh, NFTA_CHAIN_TYPE, c->type); } EXPORT_SYMBOL(nftnl_chain_nlmsg_build_payload, nft_chain_nlmsg_build_payload); @@ -463,11 +463,11 @@ static int nftnl_chain_parse_counters(struct nlattr *attr, struct nftnl_chain *c if (tb[NFTA_COUNTER_PACKETS]) { c->packets = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_PACKETS])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_PACKETS); + c->flags |= (1 << NFTNL_CHAIN_PACKETS); } if (tb[NFTA_COUNTER_BYTES]) { c->bytes = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_BYTES])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_BYTES); + c->flags |= (1 << NFTNL_CHAIN_BYTES); } return 0; @@ -506,15 +506,15 @@ static int nftnl_chain_parse_hook(struct nlattr *attr, struct nftnl_chain *c) if (tb[NFTA_HOOK_HOOKNUM]) { c->hooknum = ntohl(mnl_attr_get_u32(tb[NFTA_HOOK_HOOKNUM])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_HOOKNUM); + c->flags |= (1 << NFTNL_CHAIN_HOOKNUM); } if (tb[NFTA_HOOK_PRIORITY]) { c->prio = ntohl(mnl_attr_get_u32(tb[NFTA_HOOK_PRIORITY])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_PRIO); + c->flags |= (1 << NFTNL_CHAIN_PRIO); } if (tb[NFTA_HOOK_DEV]) { c->dev = strdup(mnl_attr_get_str(tb[NFTA_HOOK_DEV])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_DEV); + c->flags |= (1 << NFTNL_CHAIN_DEV); } return 0; @@ -532,12 +532,12 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c) if (tb[NFTA_CHAIN_NAME]) { strncpy(c->name, mnl_attr_get_str(tb[NFTA_CHAIN_NAME]), NFT_CHAIN_MAXNAMELEN); - c->flags |= (1 << NFTNL_CHAIN_ATTR_NAME); + c->flags |= (1 << NFTNL_CHAIN_NAME); } if (tb[NFTA_CHAIN_TABLE]) { xfree(c->table); c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_TABLE); + c->flags |= (1 << NFTNL_CHAIN_TABLE); } if (tb[NFTA_CHAIN_HOOK]) { ret = nftnl_chain_parse_hook(tb[NFTA_CHAIN_HOOK], c); @@ -546,11 +546,11 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c) } if (tb[NFTA_CHAIN_POLICY]) { c->policy = ntohl(mnl_attr_get_u32(tb[NFTA_CHAIN_POLICY])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_POLICY); + c->flags |= (1 << NFTNL_CHAIN_POLICY); } if (tb[NFTA_CHAIN_USE]) { c->use = ntohl(mnl_attr_get_u32(tb[NFTA_CHAIN_USE])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_USE); + c->flags |= (1 << NFTNL_CHAIN_USE); } if (tb[NFTA_CHAIN_COUNTERS]) { ret = nftnl_chain_parse_counters(tb[NFTA_CHAIN_COUNTERS], c); @@ -559,16 +559,16 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c) } if (tb[NFTA_CHAIN_HANDLE]) { c->handle = be64toh(mnl_attr_get_u64(tb[NFTA_CHAIN_HANDLE])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_HANDLE); + c->flags |= (1 << NFTNL_CHAIN_HANDLE); } if (tb[NFTA_CHAIN_TYPE]) { xfree(c->type); c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE])); - c->flags |= (1 << NFTNL_CHAIN_ATTR_TYPE); + c->flags |= (1 << NFTNL_CHAIN_TYPE); } c->family = nfg->nfgen_family; - c->flags |= (1 << NFTNL_CHAIN_ATTR_FAMILY); + c->flags |= (1 << NFTNL_CHAIN_FAMILY); return ret; } @@ -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_ATTR_NAME, name); + nftnl_chain_attr_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_ATTR_HANDLE, handle); + nftnl_chain_attr_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_ATTR_BYTES, bytes); + nftnl_chain_attr_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_ATTR_PACKETS, packets); + nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets); if (nftnl_jansson_parse_family(root, &family, err) == 0) - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_FAMILY, family); + nftnl_chain_attr_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_ATTR_TABLE, table); + nftnl_chain_attr_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_ATTR_USE, use); + nftnl_chain_attr_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_ATTR_TYPE, type); + nftnl_chain_attr_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_ATTR_PRIO, prio); + nftnl_chain_attr_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_ATTR_HOOKNUM, + nftnl_chain_attr_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_ATTR_POLICY, + nftnl_chain_attr_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_ATTR_DEV, dev); + nftnl_chain_attr_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_ATTR_NAME, name); + nftnl_chain_attr_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_ATTR_HANDLE, handle); + nftnl_chain_attr_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_ATTR_BYTES, bytes); + nftnl_chain_attr_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_ATTR_PACKETS, packets); + nftnl_chain_attr_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_ATTR_TABLE, table); + nftnl_chain_attr_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_ATTR_PACKETS, use); + nftnl_chain_attr_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_ATTR_FAMILY, family); + nftnl_chain_attr_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_ATTR_HOOKNUM, hooknum); + nftnl_chain_attr_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_ATTR_TYPE, type); + nftnl_chain_attr_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_ATTR_PRIO, prio); + nftnl_chain_attr_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_ATTR_POLICY, + nftnl_chain_attr_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_ATTR_DEV, dev); + nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev); } return 0; @@ -839,31 +839,31 @@ static int nftnl_chain_export(char *buf, size_t size, struct nftnl_chain *c, NFTNL_BUF_INIT(b, buf, size); nftnl_buf_open(&b, type, CHAIN); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_NAME)) + if (c->flags & (1 << NFTNL_CHAIN_NAME)) nftnl_buf_str(&b, type, c->name, NAME); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_HANDLE)) + if (c->flags & (1 << NFTNL_CHAIN_HANDLE)) nftnl_buf_u64(&b, type, c->handle, HANDLE); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_BYTES)) + if (c->flags & (1 << NFTNL_CHAIN_BYTES)) nftnl_buf_u64(&b, type, c->bytes, BYTES); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_PACKETS)) + if (c->flags & (1 << NFTNL_CHAIN_PACKETS)) nftnl_buf_u64(&b, type, c->packets, PACKETS); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_TABLE)) + if (c->flags & (1 << NFTNL_CHAIN_TABLE)) nftnl_buf_str(&b, type, c->table, TABLE); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_FAMILY)) + if (c->flags & (1 << NFTNL_CHAIN_FAMILY)) nftnl_buf_str(&b, type, nftnl_family2str(c->family), FAMILY); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_USE)) + if (c->flags & (1 << NFTNL_CHAIN_USE)) nftnl_buf_u32(&b, type, c->use, USE); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) { - if (c->flags & (1 << NFTNL_CHAIN_ATTR_TYPE)) + if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) { + if (c->flags & (1 << NFTNL_CHAIN_TYPE)) nftnl_buf_str(&b, type, c->type, TYPE); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) + if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) nftnl_buf_str(&b, type, nftnl_hooknum2str(c->family, c->hooknum), HOOKNUM); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_PRIO)) + if (c->flags & (1 << NFTNL_CHAIN_PRIO)) nftnl_buf_s32(&b, type, c->prio, PRIO); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_POLICY)) + if (c->flags & (1 << NFTNL_CHAIN_POLICY)) nftnl_buf_str(&b, type, nftnl_verdict2str(c->policy), POLICY); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV)) + if (c->flags & (1 << NFTNL_CHAIN_DEV)) nftnl_buf_str(&b, type, c->dev, DEVICE); } @@ -881,7 +881,7 @@ static int nftnl_chain_snprintf_default(char *buf, size_t size, nftnl_family2str(c->family), c->table, c->name, c->use); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) { + if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) { ret = snprintf(buf+offset, len, " type %s hook %s prio %d policy %s " "packets %"PRIu64" bytes %"PRIu64"", @@ -890,7 +890,7 @@ static int nftnl_chain_snprintf_default(char *buf, size_t size, c->packets, c->bytes); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV)) { + if (c->flags & (1 << NFTNL_CHAIN_DEV)) { ret = snprintf(buf+offset, len, " dev %s ", c->dev); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } diff --git a/src/jansson.c b/src/jansson.c index 5c89ec7..38a6b97 100644 --- a/src/jansson.c +++ b/src/jansson.c @@ -251,22 +251,22 @@ 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_ATTR_FLAGS, flags); + nftnl_set_elem_attr_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_ATTR_KEY); + e->flags |= (1 << NFTNL_SET_ELEM_KEY); if (nftnl_jansson_node_exist(root, "data")) { set_elem_data = nftnl_jansson_data_reg_parse(root, "data", &e->data, err); switch (set_elem_data) { case DATA_VALUE: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA); + e->flags |= (1 << NFTNL_SET_ELEM_DATA); break; case DATA_VERDICT: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT); + e->flags |= (1 << NFTNL_SET_ELEM_VERDICT); if (e->data.chain != NULL) - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_CHAIN); + e->flags |= (1 << NFTNL_SET_ELEM_CHAIN); break; case DATA_NONE: default: diff --git a/src/rule.c b/src/rule.c index 1682c66..c0b1f89 100644 --- a/src/rule.c +++ b/src/rule.c @@ -92,24 +92,24 @@ void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr) return; switch (attr) { - case NFTNL_RULE_ATTR_TABLE: + case NFTNL_RULE_TABLE: if (r->table) { xfree(r->table); r->table = NULL; } break; - case NFTNL_RULE_ATTR_CHAIN: + case NFTNL_RULE_CHAIN: if (r->chain) { xfree(r->chain); r->chain = NULL; } break; - case NFTNL_RULE_ATTR_HANDLE: - case NFTNL_RULE_ATTR_COMPAT_PROTO: - case NFTNL_RULE_ATTR_COMPAT_FLAGS: - case NFTNL_RULE_ATTR_POSITION: - case NFTNL_RULE_ATTR_FAMILY: - case NFTNL_RULE_ATTR_USERDATA: + case NFTNL_RULE_HANDLE: + case NFTNL_RULE_COMPAT_PROTO: + case NFTNL_RULE_COMPAT_FLAGS: + case NFTNL_RULE_POSITION: + case NFTNL_RULE_FAMILY: + case NFTNL_RULE_USERDATA: break; } @@ -117,51 +117,51 @@ void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr) } EXPORT_SYMBOL(nftnl_rule_attr_unset, nft_rule_attr_unset); -static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_ATTR_MAX + 1] = { - [NFTNL_RULE_ATTR_HANDLE] = sizeof(uint64_t), - [NFTNL_RULE_ATTR_COMPAT_PROTO] = sizeof(uint32_t), - [NFTNL_RULE_ATTR_COMPAT_FLAGS] = sizeof(uint32_t), - [NFTNL_RULE_ATTR_FAMILY] = sizeof(uint32_t), - [NFTNL_RULE_ATTR_POSITION] = sizeof(uint64_t), +static uint32_t nftnl_rule_attr_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), + [NFTNL_RULE_FAMILY] = sizeof(uint32_t), + [NFTNL_RULE_POSITION] = sizeof(uint64_t), }; void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr, const void *data, uint32_t data_len) { - if (attr > NFTNL_RULE_ATTR_MAX) + if (attr > NFTNL_RULE_MAX) return; nftnl_assert_validate(data, nftnl_rule_attr_validate, attr, data_len); switch(attr) { - case NFTNL_RULE_ATTR_TABLE: + case NFTNL_RULE_TABLE: if (r->table) xfree(r->table); r->table = strdup(data); break; - case NFTNL_RULE_ATTR_CHAIN: + case NFTNL_RULE_CHAIN: if (r->chain) xfree(r->chain); r->chain = strdup(data); break; - case NFTNL_RULE_ATTR_HANDLE: + case NFTNL_RULE_HANDLE: r->handle = *((uint64_t *)data); break; - case NFTNL_RULE_ATTR_COMPAT_PROTO: + case NFTNL_RULE_COMPAT_PROTO: r->compat.proto = *((uint32_t *)data); break; - case NFTNL_RULE_ATTR_COMPAT_FLAGS: + case NFTNL_RULE_COMPAT_FLAGS: r->compat.flags = *((uint32_t *)data); break; - case NFTNL_RULE_ATTR_FAMILY: + case NFTNL_RULE_FAMILY: r->family = *((uint32_t *)data); break; - case NFTNL_RULE_ATTR_POSITION: + case NFTNL_RULE_POSITION: r->position = *((uint64_t *)data); break; - case NFTNL_RULE_ATTR_USERDATA: + case NFTNL_RULE_USERDATA: r->user.data = (void *)data; r->user.len = data_len; break; @@ -201,26 +201,26 @@ const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr, return NULL; switch(attr) { - case NFTNL_RULE_ATTR_FAMILY: + case NFTNL_RULE_FAMILY: *data_len = sizeof(uint32_t); return &r->family; - case NFTNL_RULE_ATTR_TABLE: + case NFTNL_RULE_TABLE: return r->table; - case NFTNL_RULE_ATTR_CHAIN: + case NFTNL_RULE_CHAIN: return r->chain; - case NFTNL_RULE_ATTR_HANDLE: + case NFTNL_RULE_HANDLE: *data_len = sizeof(uint64_t); return &r->handle; - case NFTNL_RULE_ATTR_COMPAT_PROTO: + case NFTNL_RULE_COMPAT_PROTO: *data_len = sizeof(uint32_t); return &r->compat.proto; - case NFTNL_RULE_ATTR_COMPAT_FLAGS: + case NFTNL_RULE_COMPAT_FLAGS: *data_len = sizeof(uint32_t); return &r->compat.flags; - case NFTNL_RULE_ATTR_POSITION: + case NFTNL_RULE_POSITION: *data_len = sizeof(uint64_t); return &r->position; - case NFTNL_RULE_ATTR_USERDATA: + case NFTNL_RULE_USERDATA: *data_len = r->user.len; return r->user.data; } @@ -279,15 +279,15 @@ void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r) struct nftnl_expr *expr; struct nlattr *nest, *nest2; - if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) + if (r->flags & (1 << NFTNL_RULE_TABLE)) mnl_attr_put_strz(nlh, NFTA_RULE_TABLE, r->table); - if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) + if (r->flags & (1 << NFTNL_RULE_CHAIN)) mnl_attr_put_strz(nlh, NFTA_RULE_CHAIN, r->chain); - if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) + if (r->flags & (1 << NFTNL_RULE_HANDLE)) mnl_attr_put_u64(nlh, NFTA_RULE_HANDLE, htobe64(r->handle)); - if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) + if (r->flags & (1 << NFTNL_RULE_POSITION)) mnl_attr_put_u64(nlh, NFTA_RULE_POSITION, htobe64(r->position)); - if (r->flags & (1 << NFTNL_RULE_ATTR_USERDATA)) { + if (r->flags & (1 << NFTNL_RULE_USERDATA)) { mnl_attr_put(nlh, NFTA_RULE_USERDATA, r->user.len, r->user.data); } @@ -302,8 +302,8 @@ void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r) mnl_attr_nest_end(nlh, nest); } - if (r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_PROTO) && - r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS)) { + if (r->flags & (1 << NFTNL_RULE_COMPAT_PROTO) && + r->flags & (1 << NFTNL_RULE_COMPAT_FLAGS)) { nest = mnl_attr_nest_start(nlh, NFTA_RULE_COMPAT); mnl_attr_put_u32(nlh, NFTA_RULE_COMPAT_PROTO, @@ -405,12 +405,12 @@ static int nftnl_rule_parse_compat(struct nlattr *nest, struct nftnl_rule *r) if (tb[NFTA_RULE_COMPAT_PROTO]) { r->compat.proto = ntohl(mnl_attr_get_u32(tb[NFTA_RULE_COMPAT_PROTO])); - r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_PROTO); + r->flags |= (1 << NFTNL_RULE_COMPAT_PROTO); } if (tb[NFTA_RULE_COMPAT_FLAGS]) { r->compat.flags = ntohl(mnl_attr_get_u32(tb[NFTA_RULE_COMPAT_FLAGS])); - r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS); + r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS); } return 0; } @@ -427,16 +427,16 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r) if (tb[NFTA_RULE_TABLE]) { xfree(r->table); r->table = strdup(mnl_attr_get_str(tb[NFTA_RULE_TABLE])); - r->flags |= (1 << NFTNL_RULE_ATTR_TABLE); + r->flags |= (1 << NFTNL_RULE_TABLE); } if (tb[NFTA_RULE_CHAIN]) { xfree(r->chain); r->chain = strdup(mnl_attr_get_str(tb[NFTA_RULE_CHAIN])); - r->flags |= (1 << NFTNL_RULE_ATTR_CHAIN); + r->flags |= (1 << NFTNL_RULE_CHAIN); } if (tb[NFTA_RULE_HANDLE]) { r->handle = be64toh(mnl_attr_get_u64(tb[NFTA_RULE_HANDLE])); - r->flags |= (1 << NFTNL_RULE_ATTR_HANDLE); + r->flags |= (1 << NFTNL_RULE_HANDLE); } if (tb[NFTA_RULE_EXPRESSIONS]) ret = nftnl_rule_parse_expr(tb[NFTA_RULE_EXPRESSIONS], r); @@ -444,7 +444,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r) ret = nftnl_rule_parse_compat(tb[NFTA_RULE_COMPAT], r); if (tb[NFTA_RULE_POSITION]) { r->position = be64toh(mnl_attr_get_u64(tb[NFTA_RULE_POSITION])); - r->flags |= (1 << NFTNL_RULE_ATTR_POSITION); + r->flags |= (1 << NFTNL_RULE_POSITION); } if (tb[NFTA_RULE_USERDATA]) { const void *udata = @@ -460,11 +460,11 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r) return -1; memcpy(r->user.data, udata, r->user.len); - r->flags |= (1 << NFTNL_RULE_ATTR_USERDATA); + r->flags |= (1 << NFTNL_RULE_USERDATA); } r->family = nfg->nfgen_family; - r->flags |= (1 << NFTNL_RULE_ATTR_FAMILY); + r->flags |= (1 << NFTNL_RULE_FAMILY); return ret; } @@ -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_ATTR_FAMILY, family); + nftnl_rule_attr_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_ATTR_TABLE, str); + nftnl_rule_attr_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_ATTR_CHAIN, str); + nftnl_rule_attr_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_ATTR_HANDLE, uval64); + nftnl_rule_attr_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_ATTR_COMPAT_PROTO, uval32); + nftnl_rule_attr_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_ATTR_COMPAT_FLAGS, uval32); + nftnl_rule_attr_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_ATTR_POSITION, uval64); + nftnl_rule_attr_set_u64(r, NFTNL_RULE_POSITION, uval64); } array = json_object_get(root, "expr"); @@ -600,41 +600,41 @@ 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_ATTR_FAMILY, family); + nftnl_rule_attr_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_ATTR_TABLE, table); + nftnl_rule_attr_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_ATTR_CHAIN, chain); + nftnl_rule_attr_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) - r->flags |= (1 << NFTNL_RULE_ATTR_HANDLE); + r->flags |= (1 << NFTNL_RULE_HANDLE); if (nftnl_mxml_num_parse(tree, "compat_proto", MXML_DESCEND_FIRST, BASE_DEC, &r->compat.proto, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) >= 0) - r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_PROTO); + r->flags |= (1 << NFTNL_RULE_COMPAT_PROTO); if (nftnl_mxml_num_parse(tree, "compat_flags", MXML_DESCEND_FIRST, BASE_DEC, &r->compat.flags, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) >= 0) - r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS); + r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS); - if (nftnl_rule_attr_is_set(r, NFTNL_RULE_ATTR_COMPAT_PROTO) != - nftnl_rule_attr_is_set(r, NFTNL_RULE_ATTR_COMPAT_FLAGS)) { + if (nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_PROTO) != + nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) { errno = EINVAL; } if (nftnl_mxml_num_parse(tree, "position", MXML_DESCEND_FIRST, BASE_DEC, &r->position, NFTNL_TYPE_U64, NFTNL_XML_OPT, err) >= 0) - r->flags |= (1 << NFTNL_RULE_ATTR_POSITION); + r->flags |= (1 << NFTNL_RULE_POSITION); /* Iterating over */ for (node = mxmlFindElement(tree, tree, "expr", "type", @@ -720,38 +720,38 @@ static int nftnl_rule_snprintf_json(char *buf, size_t size, struct nftnl_rule *r ret = snprintf(buf, len, "{\"rule\":{"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (r->flags & (1 << NFTNL_RULE_ATTR_FAMILY)) { + if (r->flags & (1 << NFTNL_RULE_FAMILY)) { ret = snprintf(buf+offset, len, "\"family\":\"%s\",", nftnl_family2str(r->family)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) { + if (r->flags & (1 << NFTNL_RULE_TABLE)) { ret = snprintf(buf+offset, len, "\"table\":\"%s\",", r->table); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) { + if (r->flags & (1 << NFTNL_RULE_CHAIN)) { ret = snprintf(buf+offset, len, "\"chain\":\"%s\",", r->chain); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) { + if (r->flags & (1 << NFTNL_RULE_HANDLE)) { ret = snprintf(buf+offset, len, "\"handle\":%llu,", (unsigned long long)r->handle); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_PROTO) || - r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS)) { + if (r->flags & (1 << NFTNL_RULE_COMPAT_PROTO) || + r->flags & (1 << NFTNL_RULE_COMPAT_FLAGS)) { ret = snprintf(buf+offset, len, "\"compat_flags\":%u," "\"compat_proto\":%u,", r->compat.flags, r->compat.proto); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) { + if (r->flags & (1 << NFTNL_RULE_POSITION)) { ret = snprintf(buf+offset, len, "\"position\":%"PRIu64",", r->position); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -798,24 +798,24 @@ static int nftnl_rule_snprintf_xml(char *buf, size_t size, struct nftnl_rule *r, ret = snprintf(buf, len, ""); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (r->flags & (1 << NFTNL_RULE_ATTR_FAMILY)) { + if (r->flags & (1 << NFTNL_RULE_FAMILY)) { ret = snprintf(buf+offset, len, "%s", nftnl_family2str(r->family)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) { + if (r->flags & (1 << NFTNL_RULE_TABLE)) { ret = snprintf(buf+offset, len, "%s
", r->table); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) { + if (r->flags & (1 << NFTNL_RULE_CHAIN)) { ret = snprintf(buf+offset, len, "%s", r->chain); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) { + if (r->flags & (1 << NFTNL_RULE_HANDLE)) { ret = snprintf(buf+offset, len, "%llu", (unsigned long long)r->handle); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -829,7 +829,7 @@ static int nftnl_rule_snprintf_xml(char *buf, size_t size, struct nftnl_rule *r, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) { + if (r->flags & (1 << NFTNL_RULE_POSITION)) { ret = snprintf(buf+offset, len, "%"PRIu64"", r->position); @@ -861,30 +861,30 @@ static int nftnl_rule_snprintf_default(char *buf, size_t size, struct nftnl_rule struct nftnl_expr *expr; int ret, len = size, offset = 0, i; - if (r->flags & (1 << NFTNL_RULE_ATTR_FAMILY)) { + if (r->flags & (1 << NFTNL_RULE_FAMILY)) { ret = snprintf(buf+offset, len, "%s ", nftnl_family2str(r->family)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) { + if (r->flags & (1 << NFTNL_RULE_TABLE)) { ret = snprintf(buf+offset, len, "%s ", r->table); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) { + if (r->flags & (1 << NFTNL_RULE_CHAIN)) { ret = snprintf(buf+offset, len, "%s ", r->chain); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) { + if (r->flags & (1 << NFTNL_RULE_HANDLE)) { ret = snprintf(buf+offset, len, "%llu ", (unsigned long long)r->handle); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) { + if (r->flags & (1 << NFTNL_RULE_POSITION)) { ret = snprintf(buf+offset, len, "%llu ", (unsigned long long)r->position); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); diff --git a/src/ruleset.c b/src/ruleset.c index 969b862..fde24ad 100644 --- a/src/ruleset.c +++ b/src/ruleset.c @@ -66,13 +66,13 @@ EXPORT_SYMBOL(nftnl_ruleset_alloc, nft_ruleset_alloc); void nftnl_ruleset_free(struct nftnl_ruleset *r) { - if (r->flags & (1 << NFTNL_RULESET_ATTR_TABLELIST)) + if (r->flags & (1 << NFTNL_RULESET_TABLELIST)) nftnl_table_list_free(r->table_list); - if (r->flags & (1 << NFTNL_RULESET_ATTR_CHAINLIST)) + if (r->flags & (1 << NFTNL_RULESET_CHAINLIST)) nftnl_chain_list_free(r->chain_list); - if (r->flags & (1 << NFTNL_RULESET_ATTR_SETLIST)) + if (r->flags & (1 << NFTNL_RULESET_SETLIST)) nftnl_set_list_free(r->set_list); - if (r->flags & (1 << NFTNL_RULESET_ATTR_RULELIST)) + if (r->flags & (1 << NFTNL_RULESET_RULELIST)) nftnl_rule_list_free(r->rule_list); xfree(r); } @@ -90,19 +90,19 @@ void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr) return; switch (attr) { - case NFTNL_RULESET_ATTR_TABLELIST: + case NFTNL_RULESET_TABLELIST: nftnl_table_list_free(r->table_list); r->table_list = NULL; break; - case NFTNL_RULESET_ATTR_CHAINLIST: + case NFTNL_RULESET_CHAINLIST: nftnl_chain_list_free(r->chain_list); r->chain_list = NULL; break; - case NFTNL_RULESET_ATTR_SETLIST: + case NFTNL_RULESET_SETLIST: nftnl_set_list_free(r->set_list); r->set_list = NULL; break; - case NFTNL_RULESET_ATTR_RULELIST: + case NFTNL_RULESET_RULELIST: nftnl_rule_list_free(r->rule_list); r->rule_list = NULL; break; @@ -114,20 +114,20 @@ EXPORT_SYMBOL(nftnl_ruleset_attr_unset, nft_ruleset_attr_unset); void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data) { switch (attr) { - case NFTNL_RULESET_ATTR_TABLELIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_TABLELIST); + case NFTNL_RULESET_TABLELIST: + nftnl_ruleset_attr_unset(r, NFTNL_RULESET_TABLELIST); r->table_list = data; break; - case NFTNL_RULESET_ATTR_CHAINLIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_CHAINLIST); + case NFTNL_RULESET_CHAINLIST: + nftnl_ruleset_attr_unset(r, NFTNL_RULESET_CHAINLIST); r->chain_list = data; break; - case NFTNL_RULESET_ATTR_SETLIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_SETLIST); + case NFTNL_RULESET_SETLIST: + nftnl_ruleset_attr_unset(r, NFTNL_RULESET_SETLIST); r->set_list = data; break; - case NFTNL_RULESET_ATTR_RULELIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_RULELIST); + case NFTNL_RULESET_RULELIST: + nftnl_ruleset_attr_unset(r, NFTNL_RULESET_RULELIST); r->rule_list = data; break; default: @@ -143,13 +143,13 @@ void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr) return NULL; switch (attr) { - case NFTNL_RULESET_ATTR_TABLELIST: + case NFTNL_RULESET_TABLELIST: return r->table_list; - case NFTNL_RULESET_ATTR_CHAINLIST: + case NFTNL_RULESET_CHAINLIST: return r->chain_list; - case NFTNL_RULESET_ATTR_SETLIST: + case NFTNL_RULESET_SETLIST: return r->set_list; - case NFTNL_RULESET_ATTR_RULELIST: + case NFTNL_RULESET_RULELIST: return r->rule_list; default: return NULL; @@ -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_ATTR_ID, ctx->set_id++); + nftnl_set_attr_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_ATTR_TABLELIST, + nftnl_ruleset_attr_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_ATTR_CHAINLIST, + nftnl_ruleset_attr_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_ATTR_SETLIST, + nftnl_ruleset_attr_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_ATTR_RULELIST, + nftnl_ruleset_attr_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_ATTR_TABLELIST) && + if (nftnl_ruleset_attr_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_ATTR_CHAINLIST) && + if (nftnl_ruleset_attr_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_ATTR_SETLIST) && + if (nftnl_ruleset_attr_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_ATTR_RULELIST) && + if (nftnl_ruleset_attr_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_ATTR_TABLELIST)) && + if ((nftnl_ruleset_attr_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_ATTR_CHAINLIST)) && + if ((nftnl_ruleset_attr_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_ATTR_SETLIST)) && + if ((nftnl_ruleset_attr_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_ATTR_RULELIST)) && + if ((nftnl_ruleset_attr_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 befa6d1..983a8f4 100644 --- a/src/set.c +++ b/src/set.c @@ -66,31 +66,31 @@ EXPORT_SYMBOL(nftnl_set_attr_is_set, nft_set_attr_is_set); void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr) { switch (attr) { - case NFTNL_SET_ATTR_TABLE: - if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) + case NFTNL_SET_TABLE: + if (s->flags & (1 << NFTNL_SET_TABLE)) if (s->table) { xfree(s->table); s->table = NULL; } break; - case NFTNL_SET_ATTR_NAME: - if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) + case NFTNL_SET_NAME: + if (s->flags & (1 << NFTNL_SET_NAME)) if (s->name) { xfree(s->name); s->name = NULL; } break; - case NFTNL_SET_ATTR_FLAGS: - case NFTNL_SET_ATTR_KEY_TYPE: - case NFTNL_SET_ATTR_KEY_LEN: - case NFTNL_SET_ATTR_DATA_TYPE: - case NFTNL_SET_ATTR_DATA_LEN: - case NFTNL_SET_ATTR_FAMILY: - case NFTNL_SET_ATTR_ID: - case NFTNL_SET_ATTR_POLICY: - case NFTNL_SET_ATTR_DESC_SIZE: - case NFTNL_SET_ATTR_TIMEOUT: - case NFTNL_SET_ATTR_GC_INTERVAL: + case NFTNL_SET_FLAGS: + case NFTNL_SET_KEY_TYPE: + case NFTNL_SET_KEY_LEN: + case NFTNL_SET_DATA_TYPE: + case NFTNL_SET_DATA_LEN: + case NFTNL_SET_FAMILY: + case NFTNL_SET_ID: + case NFTNL_SET_POLICY: + case NFTNL_SET_DESC_SIZE: + case NFTNL_SET_TIMEOUT: + case NFTNL_SET_GC_INTERVAL: break; default: return; @@ -100,71 +100,71 @@ void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr) } EXPORT_SYMBOL(nftnl_set_attr_unset, nft_set_attr_unset); -static uint32_t nftnl_set_attr_validate[NFTNL_SET_ATTR_MAX + 1] = { - [NFTNL_SET_ATTR_FLAGS] = sizeof(uint32_t), - [NFTNL_SET_ATTR_KEY_TYPE] = sizeof(uint32_t), - [NFTNL_SET_ATTR_KEY_LEN] = sizeof(uint32_t), - [NFTNL_SET_ATTR_DATA_TYPE] = sizeof(uint32_t), - [NFTNL_SET_ATTR_DATA_LEN] = sizeof(uint32_t), - [NFTNL_SET_ATTR_FAMILY] = sizeof(uint32_t), - [NFTNL_SET_ATTR_POLICY] = sizeof(uint32_t), - [NFTNL_SET_ATTR_DESC_SIZE] = sizeof(uint32_t), - [NFTNL_SET_ATTR_TIMEOUT] = sizeof(uint64_t), - [NFTNL_SET_ATTR_GC_INTERVAL] = sizeof(uint32_t), +static uint32_t nftnl_set_attr_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), + [NFTNL_SET_DATA_TYPE] = sizeof(uint32_t), + [NFTNL_SET_DATA_LEN] = sizeof(uint32_t), + [NFTNL_SET_FAMILY] = sizeof(uint32_t), + [NFTNL_SET_POLICY] = sizeof(uint32_t), + [NFTNL_SET_DESC_SIZE] = sizeof(uint32_t), + [NFTNL_SET_TIMEOUT] = sizeof(uint64_t), + [NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t), }; void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *data, uint32_t data_len) { - if (attr > NFTNL_SET_ATTR_MAX) + if (attr > NFTNL_SET_MAX) return; nftnl_assert_validate(data, nftnl_set_attr_validate, attr, data_len); switch(attr) { - case NFTNL_SET_ATTR_TABLE: + case NFTNL_SET_TABLE: if (s->table) xfree(s->table); s->table = strdup(data); break; - case NFTNL_SET_ATTR_NAME: + case NFTNL_SET_NAME: if (s->name) xfree(s->name); s->name = strdup(data); break; - case NFTNL_SET_ATTR_FLAGS: + case NFTNL_SET_FLAGS: s->set_flags = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_KEY_TYPE: + case NFTNL_SET_KEY_TYPE: s->key_type = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_KEY_LEN: + case NFTNL_SET_KEY_LEN: s->key_len = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_DATA_TYPE: + case NFTNL_SET_DATA_TYPE: s->data_type = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_DATA_LEN: + case NFTNL_SET_DATA_LEN: s->data_len = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_FAMILY: + case NFTNL_SET_FAMILY: s->family = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_ID: + case NFTNL_SET_ID: s->id = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_POLICY: + case NFTNL_SET_POLICY: s->policy = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_DESC_SIZE: + case NFTNL_SET_DESC_SIZE: s->desc.size = *((uint32_t *)data); break; - case NFTNL_SET_ATTR_TIMEOUT: + case NFTNL_SET_TIMEOUT: s->timeout = *((uint64_t *)data); break; - case NFTNL_SET_ATTR_GC_INTERVAL: + case NFTNL_SET_GC_INTERVAL: s->gc_interval = *((uint32_t *)data); break; } @@ -203,41 +203,41 @@ const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr, return NULL; switch(attr) { - case NFTNL_SET_ATTR_TABLE: + case NFTNL_SET_TABLE: return s->table; - case NFTNL_SET_ATTR_NAME: + case NFTNL_SET_NAME: return s->name; - case NFTNL_SET_ATTR_FLAGS: + case NFTNL_SET_FLAGS: *data_len = sizeof(uint32_t); return &s->set_flags; - case NFTNL_SET_ATTR_KEY_TYPE: + case NFTNL_SET_KEY_TYPE: *data_len = sizeof(uint32_t); return &s->key_type; - case NFTNL_SET_ATTR_KEY_LEN: + case NFTNL_SET_KEY_LEN: *data_len = sizeof(uint32_t); return &s->key_len; - case NFTNL_SET_ATTR_DATA_TYPE: + case NFTNL_SET_DATA_TYPE: *data_len = sizeof(uint32_t); return &s->data_type; - case NFTNL_SET_ATTR_DATA_LEN: + case NFTNL_SET_DATA_LEN: *data_len = sizeof(uint32_t); return &s->data_len; - case NFTNL_SET_ATTR_FAMILY: + case NFTNL_SET_FAMILY: *data_len = sizeof(uint32_t); return &s->family; - case NFTNL_SET_ATTR_ID: + case NFTNL_SET_ID: *data_len = sizeof(uint32_t); return &s->id; - case NFTNL_SET_ATTR_POLICY: + case NFTNL_SET_POLICY: *data_len = sizeof(uint32_t); return &s->policy; - case NFTNL_SET_ATTR_DESC_SIZE: + case NFTNL_SET_DESC_SIZE: *data_len = sizeof(uint32_t); return &s->desc.size; - case NFTNL_SET_ATTR_TIMEOUT: + case NFTNL_SET_TIMEOUT: *data_len = sizeof(uint64_t); return &s->timeout; - case NFTNL_SET_ATTR_GC_INTERVAL: + case NFTNL_SET_GC_INTERVAL: *data_len = sizeof(uint32_t); return &s->gc_interval; } @@ -291,9 +291,9 @@ struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set) memcpy(newset, set, sizeof(*set)); - if (set->flags & (1 << NFTNL_SET_ATTR_TABLE)) + if (set->flags & (1 << NFTNL_SET_TABLE)) newset->table = strdup(set->table); - if (set->flags & (1 << NFTNL_SET_ATTR_NAME)) + if (set->flags & (1 << NFTNL_SET_NAME)) newset->name = strdup(set->name); INIT_LIST_HEAD(&newset->element_list); @@ -323,30 +323,30 @@ nftnl_set_nlmsg_build_desc_payload(struct nlmsghdr *nlh, struct nftnl_set *s) void nftnl_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s) { - if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) + if (s->flags & (1 << NFTNL_SET_TABLE)) mnl_attr_put_strz(nlh, NFTA_SET_TABLE, s->table); - if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) + if (s->flags & (1 << NFTNL_SET_NAME)) mnl_attr_put_strz(nlh, NFTA_SET_NAME, s->name); - if (s->flags & (1 << NFTNL_SET_ATTR_FLAGS)) + if (s->flags & (1 << NFTNL_SET_FLAGS)) mnl_attr_put_u32(nlh, NFTA_SET_FLAGS, htonl(s->set_flags)); - if (s->flags & (1 << NFTNL_SET_ATTR_KEY_TYPE)) + if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) mnl_attr_put_u32(nlh, NFTA_SET_KEY_TYPE, htonl(s->key_type)); - if (s->flags & (1 << NFTNL_SET_ATTR_KEY_LEN)) + if (s->flags & (1 << NFTNL_SET_KEY_LEN)) mnl_attr_put_u32(nlh, NFTA_SET_KEY_LEN, htonl(s->key_len)); /* These are only used to map matching -> action (1:1) */ - if (s->flags & (1 << NFTNL_SET_ATTR_DATA_TYPE)) + if (s->flags & (1 << NFTNL_SET_DATA_TYPE)) mnl_attr_put_u32(nlh, NFTA_SET_DATA_TYPE, htonl(s->data_type)); - if (s->flags & (1 << NFTNL_SET_ATTR_DATA_LEN)) + if (s->flags & (1 << NFTNL_SET_DATA_LEN)) mnl_attr_put_u32(nlh, NFTA_SET_DATA_LEN, htonl(s->data_len)); - if (s->flags & (1 << NFTNL_SET_ATTR_ID)) + if (s->flags & (1 << NFTNL_SET_ID)) mnl_attr_put_u32(nlh, NFTA_SET_ID, htonl(s->id)); - if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) + if (s->flags & (1 << NFTNL_SET_POLICY)) mnl_attr_put_u32(nlh, NFTA_SET_POLICY, htonl(s->policy)); - if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) + if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) nftnl_set_nlmsg_build_desc_payload(nlh, s); - if (s->flags & (1 << NFTNL_SET_ATTR_TIMEOUT)) + if (s->flags & (1 << NFTNL_SET_TIMEOUT)) mnl_attr_put_u64(nlh, NFTA_SET_TIMEOUT, htobe64(s->timeout)); - if (s->flags & (1 << NFTNL_SET_ATTR_GC_INTERVAL)) + if (s->flags & (1 << NFTNL_SET_GC_INTERVAL)) mnl_attr_put_u32(nlh, NFTA_SET_GC_INTERVAL, htonl(s->gc_interval)); } EXPORT_SYMBOL(nftnl_set_nlmsg_build_payload, nft_set_nlmsg_build_payload); @@ -419,7 +419,7 @@ static int nftnl_set_desc_parse(struct nftnl_set *s, if (tb[NFTA_SET_DESC_SIZE]) { s->desc.size = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DESC_SIZE])); - s->flags |= (1 << NFTNL_SET_ATTR_DESC_SIZE); + s->flags |= (1 << NFTNL_SET_DESC_SIZE); } return 0; @@ -437,54 +437,54 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s) if (tb[NFTA_SET_TABLE]) { xfree(s->table); s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE])); - s->flags |= (1 << NFTNL_SET_ATTR_TABLE); + s->flags |= (1 << NFTNL_SET_TABLE); } if (tb[NFTA_SET_NAME]) { xfree(s->name); s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME])); - s->flags |= (1 << NFTNL_SET_ATTR_NAME); + s->flags |= (1 << NFTNL_SET_NAME); } if (tb[NFTA_SET_FLAGS]) { s->set_flags = ntohl(mnl_attr_get_u32(tb[NFTA_SET_FLAGS])); - s->flags |= (1 << NFTNL_SET_ATTR_FLAGS); + s->flags |= (1 << NFTNL_SET_FLAGS); } if (tb[NFTA_SET_KEY_TYPE]) { s->key_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_TYPE])); - s->flags |= (1 << NFTNL_SET_ATTR_KEY_TYPE); + s->flags |= (1 << NFTNL_SET_KEY_TYPE); } if (tb[NFTA_SET_KEY_LEN]) { s->key_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_LEN])); - s->flags |= (1 << NFTNL_SET_ATTR_KEY_LEN); + s->flags |= (1 << NFTNL_SET_KEY_LEN); } if (tb[NFTA_SET_DATA_TYPE]) { s->data_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_TYPE])); - s->flags |= (1 << NFTNL_SET_ATTR_DATA_TYPE); + s->flags |= (1 << NFTNL_SET_DATA_TYPE); } if (tb[NFTA_SET_DATA_LEN]) { s->data_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_LEN])); - s->flags |= (1 << NFTNL_SET_ATTR_DATA_LEN); + s->flags |= (1 << NFTNL_SET_DATA_LEN); } if (tb[NFTA_SET_ID]) { s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ID])); - s->flags |= (1 << NFTNL_SET_ATTR_ID); + s->flags |= (1 << NFTNL_SET_ID); } if (tb[NFTA_SET_POLICY]) { s->policy = ntohl(mnl_attr_get_u32(tb[NFTA_SET_POLICY])); - s->flags |= (1 << NFTNL_SET_ATTR_POLICY); + s->flags |= (1 << NFTNL_SET_POLICY); } if (tb[NFTA_SET_TIMEOUT]) { s->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_TIMEOUT])); - s->flags |= (1 << NFTNL_SET_ATTR_TIMEOUT); + s->flags |= (1 << NFTNL_SET_TIMEOUT); } if (tb[NFTA_SET_GC_INTERVAL]) { s->gc_interval = ntohl(mnl_attr_get_u32(tb[NFTA_SET_GC_INTERVAL])); - s->flags |= (1 << NFTNL_SET_ATTR_GC_INTERVAL); + s->flags |= (1 << NFTNL_SET_GC_INTERVAL); } if (tb[NFTA_SET_DESC]) ret = nftnl_set_desc_parse(s, tb[NFTA_SET_DESC]); s->family = nfg->nfgen_family; - s->flags |= (1 << NFTNL_SET_ATTR_FAMILY); + s->flags |= (1 << NFTNL_SET_FAMILY); return ret; } @@ -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_ATTR_NAME, name); + nftnl_set_attr_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_ATTR_TABLE, table); + nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table); if (nftnl_jansson_parse_family(root, &family, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FAMILY, family); + nftnl_set_attr_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_ATTR_FLAGS, flags); + nftnl_set_attr_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_ATTR_KEY_TYPE, key_type); + nftnl_set_attr_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_ATTR_KEY_LEN, key_len); + nftnl_set_attr_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_ATTR_DATA_TYPE, data_type); + nftnl_set_attr_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_ATTR_DATA_LEN, data_len); + nftnl_set_attr_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_ATTR_POLICY, policy); + nftnl_set_attr_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_ATTR_DESC_SIZE, size); + nftnl_set_attr_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_ATTR_NAME, name); + nftnl_set_attr_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_ATTR_TABLE, table); + nftnl_set_attr_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_ATTR_FAMILY, family); + nftnl_set_attr_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_ATTR_FLAGS, set_flags); + nftnl_set_attr_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_ATTR_KEY_TYPE, key_type); + nftnl_set_attr_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_ATTR_KEY_LEN, key_len); + nftnl_set_attr_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_ATTR_DATA_TYPE, data_type); + nftnl_set_attr_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_ATTR_DATA_LEN, data_len); + nftnl_set_attr_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_ATTR_POLICY, policy); + nftnl_set_attr_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_ATTR_DESC_SIZE, policy); + nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, policy); for (node = mxmlFindElement(tree, tree, "set_elem", NULL, NULL, MXML_DESCEND); @@ -780,53 +780,53 @@ static int nftnl_set_snprintf_json(char *buf, size_t size, struct nftnl_set *s, ret = snprintf(buf, len, "{\"set\":{"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) { + if (s->flags & (1 << NFTNL_SET_NAME)) { ret = snprintf(buf + offset, len, "\"name\":\"%s\"", s->name); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) { + if (s->flags & (1 << NFTNL_SET_TABLE)) { ret = snprintf(buf + offset, len, ",\"table\":\"%s\"", s->table); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_FLAGS)) { + if (s->flags & (1 << NFTNL_SET_FLAGS)) { ret = snprintf(buf + offset, len, ",\"flags\":%u", s->set_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_FAMILY)) { + if (s->flags & (1 << NFTNL_SET_FAMILY)) { ret = snprintf(buf + offset, len, ",\"family\":\"%s\"", nftnl_family2str(s->family)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_KEY_TYPE)) { + if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) { ret = snprintf(buf + offset, len, ",\"key_type\":%u", s->key_type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_KEY_LEN)) { + if (s->flags & (1 << NFTNL_SET_KEY_LEN)) { ret = snprintf(buf + offset, len, ",\"key_len\":%u", s->key_len); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if(s->flags & (1 << NFTNL_SET_ATTR_DATA_TYPE)) { + if(s->flags & (1 << NFTNL_SET_DATA_TYPE)) { ret = snprintf(buf + offset, len, ",\"data_type\":%u", s->data_type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if(s->flags & (1 << NFTNL_SET_ATTR_DATA_LEN)) { + if(s->flags & (1 << NFTNL_SET_DATA_LEN)) { ret = snprintf(buf + offset, len, ",\"data_len\":%u", s->data_len); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) { + if (s->flags & (1 << NFTNL_SET_POLICY)) { ret = snprintf(buf + offset, len, ",\"policy\":%u", s->policy); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) { + if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) { ret = snprintf(buf + offset, len, ",\"desc_size\":%u", s->desc.size); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -873,24 +873,24 @@ static int nftnl_set_snprintf_default(char *buf, size_t size, struct nftnl_set * s->name, s->table, s->set_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (s->flags & (1 << NFTNL_SET_ATTR_TIMEOUT)) { + if (s->flags & (1 << NFTNL_SET_TIMEOUT)) { ret = snprintf(buf + offset, len, " timeout %"PRIu64"ms", s->timeout); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_GC_INTERVAL)) { + if (s->flags & (1 << NFTNL_SET_GC_INTERVAL)) { ret = snprintf(buf + offset, len, " gc_interval %ums", s->gc_interval); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) { + if (s->flags & (1 << NFTNL_SET_POLICY)) { ret = snprintf(buf + offset, len, " policy %u", s->policy); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) { + if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) { ret = snprintf(buf + offset, len, " size %u", s->desc.size); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -923,58 +923,58 @@ static int nftnl_set_snprintf_xml(char *buf, size_t size, struct nftnl_set *s, ret = snprintf(buf, len, ""); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (s->flags & (1 << NFTNL_SET_ATTR_FAMILY)) { + if (s->flags & (1 << NFTNL_SET_FAMILY)) { ret = snprintf(buf + offset, len, "%s", nftnl_family2str(s->family)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) { + if (s->flags & (1 << NFTNL_SET_TABLE)) { ret = snprintf(buf + offset, len, "%s
", s->table); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) { + if (s->flags & (1 << NFTNL_SET_NAME)) { ret = snprintf(buf + offset, len, "%s", s->name); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_FLAGS)) { + if (s->flags & (1 << NFTNL_SET_FLAGS)) { ret = snprintf(buf + offset, len, "%u", s->set_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_KEY_TYPE)) { + if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) { ret = snprintf(buf + offset, len, "%u", s->key_type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_KEY_LEN)) { + if (s->flags & (1 << NFTNL_SET_KEY_LEN)) { ret = snprintf(buf + offset, len, "%u", s->key_len); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_DATA_TYPE)) { + if (s->flags & (1 << NFTNL_SET_DATA_TYPE)) { ret = snprintf(buf + offset, len, "%u", s->data_type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_DATA_LEN)) { + if (s->flags & (1 << NFTNL_SET_DATA_LEN)) { ret = snprintf(buf + offset, len, "%u", s->data_len); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) { + if (s->flags & (1 << NFTNL_SET_POLICY)) { ret = snprintf(buf + offset, len, "%u", s->policy); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) { + if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) { ret = snprintf(buf + offset, len, "%u", s->desc.size); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -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_ATTR_NAME); + set_name = nftnl_set_attr_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_ATTR_ID); + *set_id = nftnl_set_attr_get_u32(s, NFTNL_SET_ID); return 1; } diff --git a/src/set_elem.c b/src/set_elem.c index b66af58..3dd1658 100644 --- a/src/set_elem.c +++ b/src/set_elem.c @@ -41,14 +41,14 @@ EXPORT_SYMBOL(nftnl_set_elem_alloc, nft_set_elem_alloc); void nftnl_set_elem_free(struct nftnl_set_elem *s) { - if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) { + if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) { if (s->data.chain) { xfree(s->data.chain); s->data.chain = NULL; } } - if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR)) + if (s->flags & (1 << NFTNL_SET_ELEM_EXPR)) nftnl_expr_free(s->expr); xfree(s); @@ -64,24 +64,24 @@ EXPORT_SYMBOL(nftnl_set_elem_attr_is_set, nft_set_elem_attr_is_set); void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr) { switch (attr) { - case NFTNL_SET_ELEM_ATTR_CHAIN: - if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) { + case NFTNL_SET_ELEM_CHAIN: + if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) { if (s->data.chain) { xfree(s->data.chain); s->data.chain = NULL; } } break; - case NFTNL_SET_ELEM_ATTR_FLAGS: - case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ - case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ - case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ - case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ - case NFTNL_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ - case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */ + case NFTNL_SET_ELEM_FLAGS: + case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */ + case NFTNL_SET_ELEM_VERDICT: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ + case NFTNL_SET_ELEM_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ + case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */ break; - case NFTNL_SET_ELEM_ATTR_EXPR: - if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR)) { + case NFTNL_SET_ELEM_EXPR: + if (s->flags & (1 << NFTNL_SET_ELEM_EXPR)) { nftnl_expr_free(s->expr); s->expr = NULL; } @@ -98,30 +98,30 @@ void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len) { switch(attr) { - case NFTNL_SET_ELEM_ATTR_FLAGS: + case NFTNL_SET_ELEM_FLAGS: s->set_elem_flags = *((uint32_t *)data); break; - case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ + case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */ memcpy(&s->key.val, data, data_len); s->key.len = data_len; break; - case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_VERDICT: /* NFTA_SET_ELEM_DATA */ s->data.verdict = *((uint32_t *)data); break; - case NFTNL_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_CHAIN: /* NFTA_SET_ELEM_DATA */ if (s->data.chain) xfree(s->data.chain); s->data.chain = strdup(data); break; - case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */ memcpy(s->data.val, data, data_len); s->data.len = data_len; break; - case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ + case NFTNL_SET_ELEM_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ s->timeout = *((uint64_t *)data); break; - case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */ + case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */ s->user.data = (void *)data; s->user.len = data_len; break; @@ -156,26 +156,26 @@ const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uin return NULL; switch(attr) { - case NFTNL_SET_ELEM_ATTR_FLAGS: + case NFTNL_SET_ELEM_FLAGS: return &s->set_elem_flags; - case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ + case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */ *data_len = s->key.len; return &s->key.val; - case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_VERDICT: /* NFTA_SET_ELEM_DATA */ return &s->data.verdict; - case NFTNL_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_CHAIN: /* NFTA_SET_ELEM_DATA */ return s->data.chain; - case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */ *data_len = s->data.len; return &s->data.val; - case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ + case NFTNL_SET_ELEM_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ return &s->timeout; - case NFTNL_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ + case NFTNL_SET_ELEM_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ return &s->expiration; - case NFTNL_SET_ELEM_ATTR_USERDATA: + case NFTNL_SET_ELEM_USERDATA: *data_len = s->user.len; return s->user.data; - case NFTNL_SET_ELEM_ATTR_EXPR: + case NFTNL_SET_ELEM_EXPR: return s->expr; } return NULL; @@ -216,7 +216,7 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem) memcpy(newelem, elem, sizeof(*elem)); - if (elem->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) + if (elem->flags & (1 << NFTNL_SET_ELEM_CHAIN)) newelem->data.chain = strdup(elem->data.chain); return newelem; @@ -225,48 +225,48 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem) void nftnl_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set_elem *e) { - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) + if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) mnl_attr_put_u32(nlh, NFTA_SET_ELEM_FLAGS, htonl(e->set_elem_flags)); - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT)) + if (e->flags & (1 << NFTNL_SET_ELEM_TIMEOUT)) mnl_attr_put_u64(nlh, NFTA_SET_ELEM_TIMEOUT, htobe64(e->timeout)); - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) { + if (e->flags & (1 << NFTNL_SET_ELEM_KEY)) { struct nlattr *nest1; nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_KEY); mnl_attr_put(nlh, NFTA_DATA_VALUE, e->key.len, e->key.val); mnl_attr_nest_end(nlh, nest1); } - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) { + if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT)) { struct nlattr *nest1, *nest2; nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA); nest2 = mnl_attr_nest_start(nlh, NFTA_DATA_VERDICT); mnl_attr_put_u32(nlh, NFTA_VERDICT_CODE, htonl(e->data.verdict)); - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) + if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN)) mnl_attr_put_strz(nlh, NFTA_VERDICT_CHAIN, e->data.chain); mnl_attr_nest_end(nlh, nest1); mnl_attr_nest_end(nlh, nest2); } - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) { + if (e->flags & (1 << NFTNL_SET_ELEM_DATA)) { struct nlattr *nest1; nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA); mnl_attr_put(nlh, NFTA_DATA_VALUE, e->data.len, e->data.val); mnl_attr_nest_end(nlh, nest1); } - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_USERDATA)) + if (e->flags & (1 << NFTNL_SET_ELEM_USERDATA)) mnl_attr_put(nlh, NFTA_SET_ELEM_USERDATA, e->user.len, e->user.data); } static void nftnl_set_elem_nlmsg_build_def(struct nlmsghdr *nlh, struct nftnl_set *s) { - if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) + if (s->flags & (1 << NFTNL_SET_NAME)) mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_SET, s->name); - if (s->flags & (1 << NFTNL_SET_ATTR_ID)) + if (s->flags & (1 << NFTNL_SET_ID)) mnl_attr_put_u32(nlh, NFTA_SET_ELEM_LIST_SET_ID, htonl(s->id)); - if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) + if (s->flags & (1 << NFTNL_SET_TABLE)) mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_TABLE, s->table); } @@ -350,32 +350,32 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest if (tb[NFTA_SET_ELEM_FLAGS]) { e->set_elem_flags = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_FLAGS])); - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_FLAGS); + e->flags |= (1 << NFTNL_SET_ELEM_FLAGS); } if (tb[NFTA_SET_ELEM_TIMEOUT]) { e->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_TIMEOUT])); - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT); + e->flags |= (1 << NFTNL_SET_ELEM_TIMEOUT); } if (tb[NFTA_SET_ELEM_EXPIRATION]) { e->expiration = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_EXPIRATION])); - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPIRATION); + e->flags |= (1 << NFTNL_SET_ELEM_EXPIRATION); } if (tb[NFTA_SET_ELEM_KEY]) { ret = nftnl_parse_data(&e->key, tb[NFTA_SET_ELEM_KEY], &type); - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY); + e->flags |= (1 << NFTNL_SET_ELEM_KEY); } if (tb[NFTA_SET_ELEM_DATA]) { ret = nftnl_parse_data(&e->data, tb[NFTA_SET_ELEM_DATA], &type); switch(type) { case DATA_VERDICT: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT); + e->flags |= (1 << NFTNL_SET_ELEM_VERDICT); break; case DATA_CHAIN: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT) | - (1 << NFTNL_SET_ELEM_ATTR_CHAIN); + e->flags |= (1 << NFTNL_SET_ELEM_VERDICT) | + (1 << NFTNL_SET_ELEM_CHAIN); break; case DATA_VALUE: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA); + e->flags |= (1 << NFTNL_SET_ELEM_DATA); break; } } @@ -383,7 +383,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest e->expr = nftnl_expr_parse(tb[NFTA_SET_ELEM_EXPR]); if (e->expr == NULL) goto err; - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPR); + e->flags |= (1 << NFTNL_SET_ELEM_EXPR); } if (tb[NFTA_SET_ELEM_USERDATA]) { const void *udata = @@ -397,7 +397,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest if (e->user.data == NULL) goto err; memcpy(e->user.data, udata, e->user.len); - e->flags |= (1 << NFTNL_RULE_ATTR_USERDATA); + e->flags |= (1 << NFTNL_RULE_USERDATA); } if (ret < 0) { @@ -465,23 +465,23 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s) xfree(s->table); s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE])); - s->flags |= (1 << NFTNL_SET_ATTR_TABLE); + s->flags |= (1 << NFTNL_SET_TABLE); } if (tb[NFTA_SET_ELEM_LIST_SET]) { xfree(s->name); s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET])); - s->flags |= (1 << NFTNL_SET_ATTR_NAME); + s->flags |= (1 << NFTNL_SET_NAME); } if (tb[NFTA_SET_ELEM_LIST_SET_ID]) { s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_LIST_SET_ID])); - s->flags |= (1 << NFTNL_SET_ATTR_ID); + s->flags |= (1 << NFTNL_SET_ID); } if (tb[NFTA_SET_ELEM_LIST_ELEMENTS]) ret = nftnl_set_elems_parse(s, tb[NFTA_SET_ELEM_LIST_ELEMENTS]); s->family = nfg->nfgen_family; - s->flags |= (1 << NFTNL_SET_ATTR_FAMILY); + s->flags |= (1 << NFTNL_SET_FAMILY); return ret; } @@ -497,23 +497,23 @@ 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_ATTR_FLAGS, set_elem_flags); + nftnl_set_elem_attr_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) - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY); + e->flags |= (1 << NFTNL_SET_ELEM_KEY); /* is not mandatory */ set_elem_data = nftnl_mxml_data_reg_parse(tree, "data", &e->data, NFTNL_XML_OPT, err); switch (set_elem_data) { case DATA_VALUE: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA); + e->flags |= (1 << NFTNL_SET_ELEM_DATA); break; case DATA_VERDICT: - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT); + e->flags |= (1 << NFTNL_SET_ELEM_VERDICT); if (e->data.chain != NULL) - e->flags |= (1 << NFTNL_SET_ELEM_ATTR_CHAIN); + e->flags |= (1 << NFTNL_SET_ELEM_CHAIN); break; } @@ -603,7 +603,7 @@ static int nftnl_set_elem_snprintf_json(char *buf, size_t size, { int ret, len = size, offset = 0, type = -1; - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) { + if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) { ret = snprintf(buf, len, "\"flags\":%u,", e->set_elem_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -618,11 +618,11 @@ static int nftnl_set_elem_snprintf_json(char *buf, size_t size, ret = snprintf(buf + offset, len, "}"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) + if (e->flags & (1 << NFTNL_SET_ELEM_DATA)) type = DATA_VALUE; - else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) + else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN)) type = DATA_CHAIN; - else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) + else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT)) type = DATA_VERDICT; if (type != -1) { @@ -691,13 +691,13 @@ static int nftnl_set_elem_snprintf_xml(char *buf, size_t size, ret = snprintf(buf, size, ""); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) { + if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) { ret = snprintf(buf + offset, size, "%u", e->set_elem_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) { + if (e->flags & (1 << NFTNL_SET_ELEM_KEY)) { ret = snprintf(buf + offset, len, ""); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -709,11 +709,11 @@ static int nftnl_set_elem_snprintf_xml(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) + if (e->flags & (1 << NFTNL_SET_ELEM_DATA)) type = DATA_VALUE; - else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) + else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN)) type = DATA_CHAIN; - else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) + else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT)) type = DATA_VERDICT; if (type != DATA_NONE) { diff --git a/src/table.c b/src/table.c index 4adfba8..1d119ef 100644 --- a/src/table.c +++ b/src/table.c @@ -44,7 +44,7 @@ EXPORT_SYMBOL(nftnl_table_alloc, nft_table_alloc); void nftnl_table_free(struct nftnl_table *t) { - if (t->flags & (1 << NFTNL_TABLE_ATTR_NAME)) + if (t->flags & (1 << NFTNL_TABLE_NAME)) xfree(t->name); xfree(t); @@ -63,49 +63,49 @@ void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr) return; switch (attr) { - case NFTNL_TABLE_ATTR_NAME: + case NFTNL_TABLE_NAME: if (t->name) { xfree(t->name); t->name = NULL; } break; - case NFTNL_TABLE_ATTR_FLAGS: - case NFTNL_TABLE_ATTR_FAMILY: + case NFTNL_TABLE_FLAGS: + case NFTNL_TABLE_FAMILY: break; - case NFTNL_TABLE_ATTR_USE: + case NFTNL_TABLE_USE: break; } t->flags &= ~(1 << attr); } EXPORT_SYMBOL(nftnl_table_attr_unset, nft_table_attr_unset); -static uint32_t nftnl_table_attr_validate[NFTNL_TABLE_ATTR_MAX + 1] = { - [NFTNL_TABLE_ATTR_FLAGS] = sizeof(uint32_t), - [NFTNL_TABLE_ATTR_FAMILY] = sizeof(uint32_t), +static uint32_t nftnl_table_attr_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, const void *data, uint32_t data_len) { - if (attr > NFTNL_TABLE_ATTR_MAX) + if (attr > NFTNL_TABLE_MAX) return; nftnl_assert_validate(data, nftnl_table_attr_validate, attr, data_len); switch (attr) { - case NFTNL_TABLE_ATTR_NAME: + case NFTNL_TABLE_NAME: if (t->name) xfree(t->name); t->name = strdup(data); break; - case NFTNL_TABLE_ATTR_FLAGS: + case NFTNL_TABLE_FLAGS: t->table_flags = *((uint32_t *)data); break; - case NFTNL_TABLE_ATTR_FAMILY: + case NFTNL_TABLE_FAMILY: t->family = *((uint32_t *)data); break; - case NFTNL_TABLE_ATTR_USE: + case NFTNL_TABLE_USE: t->use = *((uint32_t *)data); break; } @@ -144,15 +144,15 @@ const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr, return NULL; switch(attr) { - case NFTNL_TABLE_ATTR_NAME: + case NFTNL_TABLE_NAME: return t->name; - case NFTNL_TABLE_ATTR_FLAGS: + case NFTNL_TABLE_FLAGS: *data_len = sizeof(uint32_t); return &t->table_flags; - case NFTNL_TABLE_ATTR_FAMILY: + case NFTNL_TABLE_FAMILY: *data_len = sizeof(uint32_t); return &t->family; - case NFTNL_TABLE_ATTR_USE: + case NFTNL_TABLE_USE: *data_len = sizeof(uint32_t); return &t->use; } @@ -189,9 +189,9 @@ EXPORT_SYMBOL(nftnl_table_attr_get_str, nft_table_attr_get_str); void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_table *t) { - if (t->flags & (1 << NFTNL_TABLE_ATTR_NAME)) + if (t->flags & (1 << NFTNL_TABLE_NAME)) mnl_attr_put_strz(nlh, NFTA_TABLE_NAME, t->name); - if (t->flags & (1 << NFTNL_TABLE_ATTR_FLAGS)) + if (t->flags & (1 << NFTNL_TABLE_FLAGS)) mnl_attr_put_u32(nlh, NFTA_TABLE_FLAGS, htonl(t->table_flags)); } EXPORT_SYMBOL(nftnl_table_nlmsg_build_payload, nft_table_nlmsg_build_payload); @@ -231,19 +231,19 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t) if (tb[NFTA_TABLE_NAME]) { xfree(t->name); t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME])); - t->flags |= (1 << NFTNL_TABLE_ATTR_NAME); + t->flags |= (1 << NFTNL_TABLE_NAME); } if (tb[NFTA_TABLE_FLAGS]) { t->table_flags = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_FLAGS])); - t->flags |= (1 << NFTNL_TABLE_ATTR_FLAGS); + t->flags |= (1 << NFTNL_TABLE_FLAGS); } if (tb[NFTA_TABLE_USE]) { t->use = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_USE])); - t->flags |= (1 << NFTNL_TABLE_ATTR_USE); + t->flags |= (1 << NFTNL_TABLE_USE); } t->family = nfg->nfgen_family; - t->flags |= (1 << NFTNL_TABLE_ATTR_FAMILY); + t->flags |= (1 << NFTNL_TABLE_FAMILY); return 0; } @@ -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_ATTR_NAME, name); + nftnl_table_attr_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_ATTR_FAMILY, family); + nftnl_table_attr_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_ATTR_FLAGS, flags); + nftnl_table_attr_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_ATTR_USE, use); + nftnl_table_attr_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_ATTR_NAME, str); + nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, str); if (nftnl_jansson_parse_family(root, &family, err) == 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FAMILY, family); + nftnl_table_attr_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_ATTR_FLAGS, flags); + nftnl_table_attr_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_ATTR_USE, use); + nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use); return 0; } @@ -399,13 +399,13 @@ static int nftnl_table_export(char *buf, size_t size, struct nftnl_table *t, NFTNL_BUF_INIT(b, buf, size); nftnl_buf_open(&b, type, TABLE); - if (t->flags & (1 << NFTNL_TABLE_ATTR_NAME)) + if (t->flags & (1 << NFTNL_TABLE_NAME)) nftnl_buf_str(&b, type, t->name, NAME); - if (t->flags & (1 << NFTNL_TABLE_ATTR_FAMILY)) + if (t->flags & (1 << NFTNL_TABLE_FAMILY)) nftnl_buf_str(&b, type, nftnl_family2str(t->family), FAMILY); - if (t->flags & (1 << NFTNL_TABLE_ATTR_FLAGS)) + if (t->flags & (1 << NFTNL_TABLE_FLAGS)) nftnl_buf_u32(&b, type, t->table_flags, FLAGS); - if (t->flags & (1 << NFTNL_TABLE_ATTR_USE)) + if (t->flags & (1 << NFTNL_TABLE_USE)) nftnl_buf_u32(&b, type, t->use, USE); nftnl_buf_close(&b, type, TABLE); diff --git a/tests/nft-chain-test.c b/tests/nft-chain-test.c index e8f449e..8ae98df 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_ATTR_NAME), - nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_NAME)) != 0) + if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_NAME), + nftnl_chain_attr_get_str(b, NFTNL_CHAIN_NAME)) != 0) print_err("Chain name mismatches"); - if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_TABLE), - nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_TABLE)) != 0) + if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_TABLE), + nftnl_chain_attr_get_str(b, NFTNL_CHAIN_TABLE)) != 0) print_err("Chain table mismatches"); - if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_FAMILY) != - nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_FAMILY)) + if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_FAMILY) != + nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_FAMILY)) print_err("Chain family mismatches"); - if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_POLICY) != - nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_POLICY)) + if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_POLICY) != + nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_POLICY)) print_err("Chain policy mismatches"); - if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_HOOKNUM) != - nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_HOOKNUM)) + if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_HOOKNUM) != + nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_HOOKNUM)) print_err("Chain hooknum mismatches"); - if (nftnl_chain_attr_get_s32(a, NFTNL_CHAIN_ATTR_PRIO) != - nftnl_chain_attr_get_s32(b, NFTNL_CHAIN_ATTR_PRIO)) + if (nftnl_chain_attr_get_s32(a, NFTNL_CHAIN_PRIO) != + nftnl_chain_attr_get_s32(b, NFTNL_CHAIN_PRIO)) print_err("Chain Prio mismatches"); - if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_USE) != - nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_USE)) + if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_USE) != + nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_USE)) print_err("Chain use mismatches"); - if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_ATTR_PACKETS) != - nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_ATTR_PACKETS)) + if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_PACKETS) != + nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_PACKETS)) print_err("Chain packets mismatches"); - if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_ATTR_BYTES) != - nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_ATTR_BYTES)) + if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_BYTES) != + nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_BYTES)) print_err("Chain bytes mismatches"); - if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_ATTR_HANDLE) != - nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_ATTR_HANDLE)) + if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_HANDLE) != + nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_HANDLE)) print_err("Chain handle mismatches"); - if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_TYPE), - nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_TYPE)) != 0) + if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_TYPE), + nftnl_chain_attr_get_str(b, NFTNL_CHAIN_TYPE)) != 0) print_err("Chain type mismatches"); - if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_DEV), - nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_DEV)) != 0) + if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_DEV), + nftnl_chain_attr_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_ATTR_NAME, "test"); - nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_FAMILY, AF_INET); - nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_TABLE, "Table"); - nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_POLICY,0x12345678); - nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_HOOKNUM, 0x12345678); - nftnl_chain_attr_set_s32(a, NFTNL_CHAIN_ATTR_PRIO, 0x12345678); - nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_USE, 0x12345678 ); - nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_ATTR_PACKETS, 0x1234567812345678); - nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_ATTR_BYTES, 0x1234567812345678); - nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_ATTR_HANDLE, 0x1234567812345678); - nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_TYPE, "Prueba"); - nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_DEV, "eth0"); + 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"); /* 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 9365444..ce2fbd7 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_ATTR_FAMILY) != - nftnl_rule_attr_get_u32(b, NFTNL_RULE_ATTR_FAMILY)) + if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_FAMILY) != + nftnl_rule_attr_get_u32(b, NFTNL_RULE_FAMILY)) print_err("Rule family mismatches"); - if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_ATTR_TABLE), - nftnl_rule_attr_get_str(b, NFTNL_RULE_ATTR_TABLE)) != 0) + if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_TABLE), + nftnl_rule_attr_get_str(b, NFTNL_RULE_TABLE)) != 0) print_err("Rule table mismatches"); - if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_ATTR_CHAIN), - nftnl_rule_attr_get_str(b, NFTNL_RULE_ATTR_CHAIN)) != 0) + if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_CHAIN), + nftnl_rule_attr_get_str(b, NFTNL_RULE_CHAIN)) != 0) print_err("Rule table mismatches"); - if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_ATTR_HANDLE) != - nftnl_rule_attr_get_u64(b, NFTNL_RULE_ATTR_HANDLE)) + if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_HANDLE) != + nftnl_rule_attr_get_u64(b, NFTNL_RULE_HANDLE)) print_err("Rule handle mismatches"); - if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_ATTR_COMPAT_PROTO) != - nftnl_rule_attr_get_u32(b, NFTNL_RULE_ATTR_COMPAT_PROTO)) + if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_COMPAT_PROTO) != + nftnl_rule_attr_get_u32(b, NFTNL_RULE_COMPAT_PROTO)) print_err("Rule compat_proto mismatches"); - if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_ATTR_COMPAT_FLAGS) != - nftnl_rule_attr_get_u32(b, NFTNL_RULE_ATTR_COMPAT_FLAGS)) + if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_COMPAT_FLAGS) != + nftnl_rule_attr_get_u32(b, NFTNL_RULE_COMPAT_FLAGS)) print_err("Rule compat_flags mismatches"); - if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_ATTR_POSITION) != - nftnl_rule_attr_get_u64(b, NFTNL_RULE_ATTR_POSITION)) + if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_POSITION) != + nftnl_rule_attr_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_ATTR_FAMILY, AF_INET); - nftnl_rule_attr_set_str(a, NFTNL_RULE_ATTR_TABLE, "table"); - nftnl_rule_attr_set_str(a, NFTNL_RULE_ATTR_CHAIN, "chain"); - nftnl_rule_attr_set_u64(a, NFTNL_RULE_ATTR_HANDLE, 0x1234567812345678); - nftnl_rule_attr_set_u32(a, NFTNL_RULE_ATTR_COMPAT_PROTO, 0x12345678); - nftnl_rule_attr_set_u32(a, NFTNL_RULE_ATTR_COMPAT_FLAGS, 0x12345678); - nftnl_rule_attr_set_u64(a, NFTNL_RULE_ATTR_POSITION, 0x1234567812345678); + 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); 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 222b7f2..a9577d8 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_ATTR_TABLE), - nftnl_set_attr_get_str(b, NFTNL_SET_ATTR_TABLE)) != 0) + if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_TABLE), + nftnl_set_attr_get_str(b, NFTNL_SET_TABLE)) != 0) print_err("Set table mismatches"); - if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_ATTR_NAME), - nftnl_set_attr_get_str(b, NFTNL_SET_ATTR_NAME)) != 0) + if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_NAME), + nftnl_set_attr_get_str(b, NFTNL_SET_NAME)) != 0) print_err("Set name mismatches"); - if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_FLAGS) != - nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_FLAGS)) + if (nftnl_set_attr_get_u32(a, NFTNL_SET_FLAGS) != + nftnl_set_attr_get_u32(b, NFTNL_SET_FLAGS)) print_err("Set flags mismatches"); - if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_KEY_TYPE) != - nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_KEY_TYPE)) + if (nftnl_set_attr_get_u32(a, NFTNL_SET_KEY_TYPE) != + nftnl_set_attr_get_u32(b, NFTNL_SET_KEY_TYPE)) print_err("Set key-type mismatches"); - if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_KEY_LEN) != - nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_KEY_LEN)) + if (nftnl_set_attr_get_u32(a, NFTNL_SET_KEY_LEN) != + nftnl_set_attr_get_u32(b, NFTNL_SET_KEY_LEN)) print_err("Set key-len mismatches"); - if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_DATA_TYPE) != - nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_DATA_TYPE)) + if (nftnl_set_attr_get_u32(a, NFTNL_SET_DATA_TYPE) != + nftnl_set_attr_get_u32(b, NFTNL_SET_DATA_TYPE)) print_err("Set data-type mismatches"); - if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_DATA_LEN) != - nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_DATA_LEN)) + if (nftnl_set_attr_get_u32(a, NFTNL_SET_DATA_LEN) != + nftnl_set_attr_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_ATTR_TABLE, "test-table"); - nftnl_set_attr_set_str(a, NFTNL_SET_ATTR_NAME, "test-name"); - nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_FLAGS, 0x12345678); - nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_KEY_TYPE, 0x12345678); - nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_KEY_LEN, 0x12345678); - nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_DATA_TYPE, 0x12345678); - nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_DATA_LEN, 0x12345678); - nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_FAMILY, 0x12345678); + 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); /* 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 9ae8f48..2aad037 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_ATTR_NAME), - nftnl_table_attr_get_str(b, NFTNL_TABLE_ATTR_NAME)) != 0) + if (strcmp(nftnl_table_attr_get_str(a, NFTNL_TABLE_NAME), + nftnl_table_attr_get_str(b, NFTNL_TABLE_NAME)) != 0) print_err("table name mismatches"); - if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_ATTR_FLAGS) != - nftnl_table_attr_get_u32(b, NFTNL_TABLE_ATTR_FLAGS)) + if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_FLAGS) != + nftnl_table_attr_get_u32(b, NFTNL_TABLE_FLAGS)) print_err("table flags mismatches"); - if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_ATTR_FAMILY) != - nftnl_table_attr_get_u32(b, NFTNL_TABLE_ATTR_FAMILY)) + if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_FAMILY) != + nftnl_table_attr_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_ATTR_NAME, "test"); - nftnl_table_attr_set_u32(a, NFTNL_TABLE_ATTR_FAMILY, AF_INET); - nftnl_table_attr_set_u32(a, NFTNL_TABLE_ATTR_FLAGS, 0); + 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); /* cmd extracted from include/linux/netfilter/nf_tables.h */ nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE, AF_INET, 0, -- cgit v1.2.3