From 44d11498479a08f46a64431d60ed19d4aba94dad Mon Sep 17 00:00:00 2001 From: Pablo Neira Ayuso Date: Mon, 7 Sep 2015 18:57:50 +0200 Subject: src: get rid of _attr_ infix in new nftnl_ definitions The function names are already large, trim off the _ATTR_ infix in the attribute definitions. Signed-off-by: Pablo Neira Ayuso --- src/chain.c | 140 +++++++++++++++++++++++++++---------------------------- src/gen.c | 44 ++++++++--------- src/jansson.c | 2 +- src/libnftnl.map | 134 ++++++++++++++++++++++++++-------------------------- src/rule.c | 98 +++++++++++++++++++------------------- src/ruleset.c | 50 ++++++++++---------- src/set.c | 112 ++++++++++++++++++++++---------------------- src/set_elem.c | 60 ++++++++++++------------ src/table.c | 84 ++++++++++++++++----------------- 9 files changed, 362 insertions(+), 362 deletions(-) (limited to 'src') diff --git a/src/chain.c b/src/chain.c index f40e6a3..8a8e8b8 100644 --- a/src/chain.c +++ b/src/chain.c @@ -106,13 +106,13 @@ void nftnl_chain_free(struct nftnl_chain *c) } EXPORT_SYMBOL(nftnl_chain_free, nft_chain_free); -bool nftnl_chain_attr_is_set(const struct nftnl_chain *c, uint16_t attr) +bool nftnl_chain_is_set(const struct nftnl_chain *c, uint16_t attr) { return c->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_chain_attr_is_set, nft_chain_attr_is_set); +EXPORT_SYMBOL(nftnl_chain_is_set, nft_chain_attr_is_set); -void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr) +void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr) { if (!(c->flags & (1 << attr))) return; @@ -153,9 +153,9 @@ void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr) c->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_chain_attr_unset, nft_chain_attr_unset); +EXPORT_SYMBOL(nftnl_chain_unset, nft_chain_attr_unset); -static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_MAX + 1] = { +static uint32_t nftnl_chain_validate[NFTNL_CHAIN_MAX + 1] = { [NFTNL_CHAIN_HOOKNUM] = sizeof(uint32_t), [NFTNL_CHAIN_PRIO] = sizeof(int32_t), [NFTNL_CHAIN_POLICY] = sizeof(uint32_t), @@ -165,13 +165,13 @@ static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_MAX + 1] = { [NFTNL_CHAIN_FAMILY] = sizeof(uint32_t), }; -void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr, +void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr, const void *data, uint32_t data_len) { if (attr > NFTNL_CHAIN_MAX) return; - nftnl_assert_validate(data, nftnl_chain_attr_validate, attr, data_len); + nftnl_assert_validate(data, nftnl_chain_validate, attr, data_len); switch(attr) { case NFTNL_CHAIN_NAME: @@ -222,45 +222,45 @@ void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr, } c->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_chain_attr_set_data, nft_chain_attr_set_data); +EXPORT_SYMBOL(nftnl_chain_set_data, nft_chain_attr_set_data); -void nftnl_chain_attr_set(struct nftnl_chain *c, uint16_t attr, const void *data) +void nftnl_chain_set(struct nftnl_chain *c, uint16_t attr, const void *data) { - nftnl_chain_attr_set_data(c, attr, data, nftnl_chain_attr_validate[attr]); + nftnl_chain_set_data(c, attr, data, nftnl_chain_validate[attr]); } -EXPORT_SYMBOL(nftnl_chain_attr_set, nft_chain_attr_set); +EXPORT_SYMBOL(nftnl_chain_set, nft_chain_attr_set); -void nftnl_chain_attr_set_u32(struct nftnl_chain *c, uint16_t attr, uint32_t data) +void nftnl_chain_set_u32(struct nftnl_chain *c, uint16_t attr, uint32_t data) { - nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint32_t)); + nftnl_chain_set_data(c, attr, &data, sizeof(uint32_t)); } -EXPORT_SYMBOL(nftnl_chain_attr_set_u32, nft_chain_attr_set_u32); +EXPORT_SYMBOL(nftnl_chain_set_u32, nft_chain_attr_set_u32); -void nftnl_chain_attr_set_s32(struct nftnl_chain *c, uint16_t attr, int32_t data) +void nftnl_chain_set_s32(struct nftnl_chain *c, uint16_t attr, int32_t data) { - nftnl_chain_attr_set_data(c, attr, &data, sizeof(int32_t)); + nftnl_chain_set_data(c, attr, &data, sizeof(int32_t)); } -EXPORT_SYMBOL(nftnl_chain_attr_set_s32, nft_chain_attr_set_s32); +EXPORT_SYMBOL(nftnl_chain_set_s32, nft_chain_attr_set_s32); -void nftnl_chain_attr_set_u64(struct nftnl_chain *c, uint16_t attr, uint64_t data) +void nftnl_chain_set_u64(struct nftnl_chain *c, uint16_t attr, uint64_t data) { - nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint64_t)); + nftnl_chain_set_data(c, attr, &data, sizeof(uint64_t)); } -EXPORT_SYMBOL(nftnl_chain_attr_set_u64, nft_chain_attr_set_u64); +EXPORT_SYMBOL(nftnl_chain_set_u64, nft_chain_attr_set_u64); -void nftnl_chain_attr_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data) +void nftnl_chain_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data) { - nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint8_t)); + nftnl_chain_set_data(c, attr, &data, sizeof(uint8_t)); } -EXPORT_SYMBOL(nftnl_chain_attr_set_u8, nft_chain_attr_set_u8); +EXPORT_SYMBOL(nftnl_chain_set_u8, nft_chain_attr_set_u8); -void nftnl_chain_attr_set_str(struct nftnl_chain *c, uint16_t attr, const char *str) +void nftnl_chain_set_str(struct nftnl_chain *c, uint16_t attr, const char *str) { - nftnl_chain_attr_set_data(c, attr, str, strlen(str)); + nftnl_chain_set_data(c, attr, str, strlen(str)); } -EXPORT_SYMBOL(nftnl_chain_attr_set_str, nft_chain_attr_set_str); +EXPORT_SYMBOL(nftnl_chain_set_str, nft_chain_attr_set_str); -const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr, +const void *nftnl_chain_get_data(struct nftnl_chain *c, uint16_t attr, uint32_t *data_len) { if (!(c->flags & (1 << attr))) @@ -303,64 +303,64 @@ const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr, } return NULL; } -EXPORT_SYMBOL(nftnl_chain_attr_get_data, nft_chain_attr_get_data); +EXPORT_SYMBOL(nftnl_chain_get_data, nft_chain_attr_get_data); -const void *nftnl_chain_attr_get(struct nftnl_chain *c, uint16_t attr) +const void *nftnl_chain_get(struct nftnl_chain *c, uint16_t attr) { uint32_t data_len; - return nftnl_chain_attr_get_data(c, attr, &data_len); + return nftnl_chain_get_data(c, attr, &data_len); } -EXPORT_SYMBOL(nftnl_chain_attr_get, nft_chain_attr_get); +EXPORT_SYMBOL(nftnl_chain_get, nft_chain_attr_get); -const char *nftnl_chain_attr_get_str(struct nftnl_chain *c, uint16_t attr) +const char *nftnl_chain_get_str(struct nftnl_chain *c, uint16_t attr) { - return nftnl_chain_attr_get(c, attr); + return nftnl_chain_get(c, attr); } -EXPORT_SYMBOL(nftnl_chain_attr_get_str, nft_chain_attr_get_str); +EXPORT_SYMBOL(nftnl_chain_get_str, nft_chain_attr_get_str); -uint32_t nftnl_chain_attr_get_u32(struct nftnl_chain *c, uint16_t attr) +uint32_t nftnl_chain_get_u32(struct nftnl_chain *c, uint16_t attr) { uint32_t data_len; - const uint32_t *val = nftnl_chain_attr_get_data(c, attr, &data_len); + const uint32_t *val = nftnl_chain_get_data(c, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(uint32_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_chain_attr_get_u32, nft_chain_attr_get_u32); +EXPORT_SYMBOL(nftnl_chain_get_u32, nft_chain_attr_get_u32); -int32_t nftnl_chain_attr_get_s32(struct nftnl_chain *c, uint16_t attr) +int32_t nftnl_chain_get_s32(struct nftnl_chain *c, uint16_t attr) { uint32_t data_len; - const int32_t *val = nftnl_chain_attr_get_data(c, attr, &data_len); + const int32_t *val = nftnl_chain_get_data(c, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(int32_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_chain_attr_get_s32, nft_chain_attr_get_s32); +EXPORT_SYMBOL(nftnl_chain_get_s32, nft_chain_attr_get_s32); -uint64_t nftnl_chain_attr_get_u64(struct nftnl_chain *c, uint16_t attr) +uint64_t nftnl_chain_get_u64(struct nftnl_chain *c, uint16_t attr) { uint32_t data_len; - const uint64_t *val = nftnl_chain_attr_get_data(c, attr, &data_len); + const uint64_t *val = nftnl_chain_get_data(c, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(int64_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_chain_attr_get_u64, nft_chain_attr_get_u64); +EXPORT_SYMBOL(nftnl_chain_get_u64, nft_chain_attr_get_u64); -uint8_t nftnl_chain_attr_get_u8(struct nftnl_chain *c, uint16_t attr) +uint8_t nftnl_chain_get_u8(struct nftnl_chain *c, uint16_t attr) { uint32_t data_len; - const uint8_t *val = nftnl_chain_attr_get_data(c, attr, &data_len); + const uint8_t *val = nftnl_chain_get_data(c, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(int8_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_chain_attr_get_u8, nft_chain_attr_get_u8); +EXPORT_SYMBOL(nftnl_chain_get_u8, nft_chain_attr_get_u8); void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *c) { @@ -601,47 +601,47 @@ int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree, name = nftnl_jansson_parse_str(root, "name", err); if (name != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_NAME, name); + nftnl_chain_set_str(c, NFTNL_CHAIN_NAME, name); if (nftnl_jansson_parse_val(root, "handle", NFTNL_TYPE_U64, &handle, err) == 0) - nftnl_chain_attr_set_u64(c,NFTNL_CHAIN_HANDLE, handle); + nftnl_chain_set_u64(c,NFTNL_CHAIN_HANDLE, handle); if (nftnl_jansson_parse_val(root, "bytes", NFTNL_TYPE_U64, &bytes, err) == 0) - nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_BYTES, bytes); + nftnl_chain_set_u64(c, NFTNL_CHAIN_BYTES, bytes); if (nftnl_jansson_parse_val(root, "packets", NFTNL_TYPE_U64, &packets, err) == 0) - nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets); + nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, packets); if (nftnl_jansson_parse_family(root, &family, err) == 0) - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_FAMILY, family); + nftnl_chain_set_u32(c, NFTNL_CHAIN_FAMILY, family); table = nftnl_jansson_parse_str(root, "table", err); if (table != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TABLE, table); + nftnl_chain_set_str(c, NFTNL_CHAIN_TABLE, table); if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0) - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_USE, use); + nftnl_chain_set_u32(c, NFTNL_CHAIN_USE, use); if (nftnl_jansson_node_exist(root, "hooknum")) { type = nftnl_jansson_parse_str(root, "type", err); if (type != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TYPE, type); + nftnl_chain_set_str(c, NFTNL_CHAIN_TYPE, type); if (nftnl_jansson_parse_val(root, "prio", NFTNL_TYPE_S32, &prio, err) == 0) - nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_PRIO, prio); + nftnl_chain_set_s32(c, NFTNL_CHAIN_PRIO, prio); hooknum_str = nftnl_jansson_parse_str(root, "hooknum", err); if (hooknum_str != NULL) { hooknum = nftnl_str2hooknum(c->family, hooknum_str); if (hooknum == -1) return -1; - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_HOOKNUM, + nftnl_chain_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum); } @@ -653,13 +653,13 @@ int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree, err->error = NFTNL_PARSE_EBADTYPE; return -1; } - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_POLICY, + nftnl_chain_set_u32(c, NFTNL_CHAIN_POLICY, policy_num); } dev = nftnl_jansson_parse_str(root, "device", err); if (dev != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev); + nftnl_chain_set_str(c, NFTNL_CHAIN_DEV, dev); } return 0; @@ -701,35 +701,35 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c, name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (name != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_NAME, name); + nftnl_chain_set_str(c, NFTNL_CHAIN_NAME, name); if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC, &handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) - nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_HANDLE, handle); + nftnl_chain_set_u64(c, NFTNL_CHAIN_HANDLE, handle); if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC, &bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) - nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_BYTES, bytes); + nftnl_chain_set_u64(c, NFTNL_CHAIN_BYTES, bytes); if (nftnl_mxml_num_parse(tree, "packets", MXML_DESCEND_FIRST, BASE_DEC, &packets, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) - nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets); + nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, packets); table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (table != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TABLE, table); + nftnl_chain_set_str(c, NFTNL_CHAIN_TABLE, table); if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND_FIRST, BASE_DEC, &use, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) - nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, use); + nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, use); family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (family >= 0) - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_FAMILY, family); + nftnl_chain_set_u32(c, NFTNL_CHAIN_FAMILY, family); hooknum_str = nftnl_mxml_str_parse(tree, "hooknum", MXML_DESCEND_FIRST, NFTNL_XML_OPT, err); @@ -737,18 +737,18 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c, hooknum = nftnl_str2hooknum(c->family, hooknum_str); if (hooknum < 0) return -1; - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum); + nftnl_chain_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum); type = nftnl_mxml_str_parse(tree, "type", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (type != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TYPE, type); + nftnl_chain_set_str(c, NFTNL_CHAIN_TYPE, type); if (nftnl_mxml_num_parse(tree, "prio", MXML_DESCEND, BASE_DEC, &prio, NFTNL_TYPE_S32, NFTNL_XML_MAND, err) == 0) - nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_PRIO, prio); + nftnl_chain_set_s32(c, NFTNL_CHAIN_PRIO, prio); policy_str = nftnl_mxml_str_parse(tree, "policy", MXML_DESCEND_FIRST, @@ -760,14 +760,14 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c, err->error = NFTNL_PARSE_EBADTYPE; return -1; } - nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_POLICY, + nftnl_chain_set_u32(c, NFTNL_CHAIN_POLICY, policy); } dev = nftnl_mxml_str_parse(tree, "device", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (table != NULL) - nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev); + nftnl_chain_set_str(c, NFTNL_CHAIN_DEV, dev); } return 0; diff --git a/src/gen.c b/src/gen.c index bb66295..eb3b70d 100644 --- a/src/gen.c +++ b/src/gen.c @@ -41,13 +41,13 @@ void nftnl_gen_free(struct nftnl_gen *gen) } EXPORT_SYMBOL(nftnl_gen_free, nft_gen_free); -bool nftnl_gen_attr_is_set(const struct nftnl_gen *gen, uint16_t attr) +bool nftnl_gen_is_set(const struct nftnl_gen *gen, uint16_t attr) { return gen->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_gen_attr_is_set, nft_gen_attr_is_set); +EXPORT_SYMBOL(nftnl_gen_is_set, nft_gen_attr_is_set); -void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr) +void nftnl_gen_unset(struct nftnl_gen *gen, uint16_t attr) { if (!(gen->flags & (1 << attr))) return; @@ -58,19 +58,19 @@ void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr) } gen->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_gen_attr_unset, nft_gen_attr_unset); +EXPORT_SYMBOL(nftnl_gen_unset, nft_gen_attr_unset); -static uint32_t nftnl_gen_attr_validate[NFTNL_GEN_MAX + 1] = { +static uint32_t nftnl_gen_validate[NFTNL_GEN_MAX + 1] = { [NFTNL_GEN_ID] = sizeof(uint32_t), }; -void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr, +void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr, const void *data, uint32_t data_len) { if (attr > NFTNL_GEN_MAX) return; - nftnl_assert_validate(data, nftnl_gen_attr_validate, attr, data_len); + nftnl_assert_validate(data, nftnl_gen_validate, attr, data_len); switch (attr) { case NFTNL_GEN_ID: @@ -79,21 +79,21 @@ void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr, } gen->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_gen_attr_set_data, nft_gen_attr_set_data); +EXPORT_SYMBOL(nftnl_gen_set_data, nft_gen_attr_set_data); -void nftnl_gen_attr_set(struct nftnl_gen *gen, uint16_t attr, const void *data) +void nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data) { - nftnl_gen_attr_set_data(gen, attr, data, nftnl_gen_attr_validate[attr]); + nftnl_gen_set_data(gen, attr, data, nftnl_gen_validate[attr]); } -EXPORT_SYMBOL(nftnl_gen_attr_set, nft_gen_attr_set); +EXPORT_SYMBOL(nftnl_gen_set, nft_gen_attr_set); -void nftnl_gen_attr_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t val) +void nftnl_gen_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t val) { - nftnl_gen_attr_set_data(gen, attr, &val, sizeof(uint32_t)); + nftnl_gen_set_data(gen, attr, &val, sizeof(uint32_t)); } -EXPORT_SYMBOL(nftnl_gen_attr_set_u32, nft_gen_attr_set_u32); +EXPORT_SYMBOL(nftnl_gen_set_u32, nft_gen_attr_set_u32); -const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr, +const void *nftnl_gen_get_data(struct nftnl_gen *gen, uint16_t attr, uint32_t *data_len) { if (!(gen->flags & (1 << attr))) @@ -105,21 +105,21 @@ const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr, } return NULL; } -EXPORT_SYMBOL(nftnl_gen_attr_get_data, nft_gen_attr_get_data); +EXPORT_SYMBOL(nftnl_gen_get_data, nft_gen_attr_get_data); -const void *nftnl_gen_attr_get(struct nftnl_gen *gen, uint16_t attr) +const void *nftnl_gen_get(struct nftnl_gen *gen, uint16_t attr) { uint32_t data_len; - return nftnl_gen_attr_get_data(gen, attr, &data_len); + return nftnl_gen_get_data(gen, attr, &data_len); } -EXPORT_SYMBOL(nftnl_gen_attr_get, nft_gen_attr_get); +EXPORT_SYMBOL(nftnl_gen_get, nft_gen_attr_get); -uint32_t nftnl_gen_attr_get_u32(struct nftnl_gen *gen, uint16_t attr) +uint32_t nftnl_gen_get_u32(struct nftnl_gen *gen, uint16_t attr) { - const void *ret = nftnl_gen_attr_get(gen, attr); + const void *ret = nftnl_gen_get(gen, attr); return ret == NULL ? 0 : *((uint32_t *)ret); } -EXPORT_SYMBOL(nftnl_gen_attr_get_u32, nft_gen_attr_get_u32); +EXPORT_SYMBOL(nftnl_gen_get_u32, nft_gen_attr_get_u32); static int nftnl_gen_parse_attr_cb(const struct nlattr *attr, void *data) { diff --git a/src/jansson.c b/src/jansson.c index 38a6b97..3476ed2 100644 --- a/src/jansson.c +++ b/src/jansson.c @@ -251,7 +251,7 @@ int nftnl_jansson_set_elem_parse(struct nftnl_set_elem *e, json_t *root, uint32_t flags; if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, flags); + nftnl_set_elem_set_u32(e, NFTNL_SET_ELEM_FLAGS, flags); if (nftnl_jansson_data_reg_parse(root, "key", &e->key, err) == DATA_VALUE) e->flags |= (1 << NFTNL_SET_ELEM_KEY); diff --git a/src/libnftnl.map b/src/libnftnl.map index 0ef4b49..14ec88c 100644 --- a/src/libnftnl.map +++ b/src/libnftnl.map @@ -202,16 +202,16 @@ global: nftnl_table_alloc; nftnl_table_free; - nftnl_table_attr_is_set; - nftnl_table_attr_unset; - nftnl_table_attr_set; - nftnl_table_attr_get; - nftnl_table_attr_set_u8; - nftnl_table_attr_set_u32; - nftnl_table_attr_set_str; - nftnl_table_attr_get_u8; - nftnl_table_attr_get_u32; - nftnl_table_attr_get_str; + nftnl_table_is_set; + nftnl_table_unset; + nftnl_table_set; + nftnl_table_get; + nftnl_table_set_u8; + nftnl_table_set_u32; + nftnl_table_set_str; + nftnl_table_get_u8; + nftnl_table_get_u32; + nftnl_table_get_str; nftnl_table_parse; nftnl_table_parse_file; nftnl_table_snprintf; @@ -231,20 +231,20 @@ global: nftnl_chain_alloc; nftnl_chain_free; - nftnl_chain_attr_is_set; - nftnl_chain_attr_unset; - nftnl_chain_attr_set; - nftnl_chain_attr_set_u8; - nftnl_chain_attr_set_u32; - nftnl_chain_attr_set_s32; - nftnl_chain_attr_set_u64; - nftnl_chain_attr_set_str; - nftnl_chain_attr_get; - nftnl_chain_attr_get_u8; - nftnl_chain_attr_get_u32; - nftnl_chain_attr_get_s32; - nftnl_chain_attr_get_u64; - nftnl_chain_attr_get_str; + nftnl_chain_is_set; + nftnl_chain_unset; + nftnl_chain_set; + nftnl_chain_set_u8; + nftnl_chain_set_u32; + nftnl_chain_set_s32; + nftnl_chain_set_u64; + nftnl_chain_set_str; + nftnl_chain_get; + nftnl_chain_get_u8; + nftnl_chain_get_u32; + nftnl_chain_get_s32; + nftnl_chain_get_u64; + nftnl_chain_get_str; nftnl_chain_parse; nftnl_chain_parse_file; nftnl_chain_snprintf; @@ -264,17 +264,17 @@ global: nftnl_rule_alloc; nftnl_rule_free; - nftnl_rule_attr_is_set; - nftnl_rule_attr_unset; - nftnl_rule_attr_set; - nftnl_rule_attr_set_u32; - nftnl_rule_attr_set_u64; - nftnl_rule_attr_set_str; - nftnl_rule_attr_get; - nftnl_rule_attr_get_u8; - nftnl_rule_attr_get_u32; - nftnl_rule_attr_get_u64; - nftnl_rule_attr_get_str; + nftnl_rule_is_set; + nftnl_rule_unset; + nftnl_rule_set; + nftnl_rule_set_u32; + nftnl_rule_set_u64; + nftnl_rule_set_str; + nftnl_rule_get; + nftnl_rule_get_u8; + nftnl_rule_get_u32; + nftnl_rule_get_u64; + nftnl_rule_get_str; nftnl_rule_parse; nftnl_rule_parse_file; nftnl_rule_snprintf; @@ -319,16 +319,16 @@ global: nftnl_set_alloc; nftnl_set_free; - nftnl_set_attr_unset; - nftnl_set_attr_is_set; - nftnl_set_attr_set; - nftnl_set_attr_set_u32; - nftnl_set_attr_set_u64; - nftnl_set_attr_set_str; - nftnl_set_attr_get; - nftnl_set_attr_get_str; - nftnl_set_attr_get_u32; - nftnl_set_attr_get_u64; + nftnl_set_unset; + nftnl_set_is_set; + nftnl_set_set; + nftnl_set_set_u32; + nftnl_set_set_u64; + nftnl_set_set_str; + nftnl_set_get; + nftnl_set_get_str; + nftnl_set_get_u32; + nftnl_set_get_u64; nftnl_set_nlmsg_build_payload; nftnl_set_nlmsg_parse; nftnl_set_parse; @@ -353,16 +353,16 @@ global: nftnl_set_elem_free; nftnl_set_elem_add; nftnl_set_elem_foreach; - nftnl_set_elem_attr_is_set; - nftnl_set_elem_attr_unset; - nftnl_set_elem_attr_set; - nftnl_set_elem_attr_set_u32; - nftnl_set_elem_attr_set_u64; - nftnl_set_elem_attr_set_str; - nftnl_set_elem_attr_get; - nftnl_set_elem_attr_get_str; - nftnl_set_elem_attr_get_u32; - nftnl_set_elem_attr_get_u64; + nftnl_set_elem_is_set; + nftnl_set_elem_unset; + nftnl_set_elem_set; + nftnl_set_elem_set_u32; + nftnl_set_elem_set_u64; + nftnl_set_elem_set_str; + nftnl_set_elem_get; + nftnl_set_elem_get_str; + nftnl_set_elem_get_u32; + nftnl_set_elem_get_u64; nftnl_set_elem_nlmsg_build_payload; nftnl_set_elem_parse; nftnl_set_elem_parse_file; @@ -381,10 +381,10 @@ global: nftnl_ruleset_alloc; nftnl_ruleset_free; - nftnl_ruleset_attr_is_set; - nftnl_ruleset_attr_unset; - nftnl_ruleset_attr_set; - nftnl_ruleset_attr_get; + nftnl_ruleset_is_set; + nftnl_ruleset_unset; + nftnl_ruleset_set; + nftnl_ruleset_get; nftnl_ruleset_parse; nftnl_ruleset_parse_file; nftnl_ruleset_snprintf; @@ -414,14 +414,14 @@ LIBNFTNL_1.1 { # aliases # - nftnl_table_attr_set_data; - nftnl_table_attr_get_data; - nftnl_chain_attr_set_data; - nftnl_chain_attr_get_data; - nftnl_rule_attr_set_data; - nftnl_rule_attr_get_data; - nftnl_set_attr_set_data; - nftnl_set_attr_get_data; + nftnl_table_set_data; + nftnl_table_get_data; + nftnl_chain_set_data; + nftnl_chain_get_data; + nftnl_rule_set_data; + nftnl_rule_get_data; + nftnl_set_set_data; + nftnl_set_get_data; } LIBNFTNL_1.0; diff --git a/src/rule.c b/src/rule.c index c0b1f89..0fb27ed 100644 --- a/src/rule.c +++ b/src/rule.c @@ -80,13 +80,13 @@ void nftnl_rule_free(struct nftnl_rule *r) } EXPORT_SYMBOL(nftnl_rule_free, nft_rule_free); -bool nftnl_rule_attr_is_set(const struct nftnl_rule *r, uint16_t attr) +bool nftnl_rule_is_set(const struct nftnl_rule *r, uint16_t attr) { return r->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_rule_attr_is_set, nft_rule_attr_is_set); +EXPORT_SYMBOL(nftnl_rule_is_set, nft_rule_attr_is_set); -void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr) +void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr) { if (!(r->flags & (1 << attr))) return; @@ -115,9 +115,9 @@ void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr) r->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_rule_attr_unset, nft_rule_attr_unset); +EXPORT_SYMBOL(nftnl_rule_unset, nft_rule_attr_unset); -static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_MAX + 1] = { +static uint32_t nftnl_rule_validate[NFTNL_RULE_MAX + 1] = { [NFTNL_RULE_HANDLE] = sizeof(uint64_t), [NFTNL_RULE_COMPAT_PROTO] = sizeof(uint32_t), [NFTNL_RULE_COMPAT_FLAGS] = sizeof(uint32_t), @@ -125,13 +125,13 @@ static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_MAX + 1] = { [NFTNL_RULE_POSITION] = sizeof(uint64_t), }; -void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr, +void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr, const void *data, uint32_t data_len) { if (attr > NFTNL_RULE_MAX) return; - nftnl_assert_validate(data, nftnl_rule_attr_validate, attr, data_len); + nftnl_assert_validate(data, nftnl_rule_validate, attr, data_len); switch(attr) { case NFTNL_RULE_TABLE: @@ -168,33 +168,33 @@ void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr, } r->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_rule_attr_set_data, nft_rule_attr_set_data); +EXPORT_SYMBOL(nftnl_rule_set_data, nft_rule_attr_set_data); -void nftnl_rule_attr_set(struct nftnl_rule *r, uint16_t attr, const void *data) +void nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data) { - nftnl_rule_attr_set_data(r, attr, data, nftnl_rule_attr_validate[attr]); + nftnl_rule_set_data(r, attr, data, nftnl_rule_validate[attr]); } -EXPORT_SYMBOL(nftnl_rule_attr_set, nft_rule_attr_set); +EXPORT_SYMBOL(nftnl_rule_set, nft_rule_attr_set); -void nftnl_rule_attr_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val) +void nftnl_rule_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val) { - nftnl_rule_attr_set_data(r, attr, &val, sizeof(uint32_t)); + nftnl_rule_set_data(r, attr, &val, sizeof(uint32_t)); } -EXPORT_SYMBOL(nftnl_rule_attr_set_u32, nft_rule_attr_set_u32); +EXPORT_SYMBOL(nftnl_rule_set_u32, nft_rule_attr_set_u32); -void nftnl_rule_attr_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val) +void nftnl_rule_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val) { - nftnl_rule_attr_set_data(r, attr, &val, sizeof(uint64_t)); + nftnl_rule_set_data(r, attr, &val, sizeof(uint64_t)); } -EXPORT_SYMBOL(nftnl_rule_attr_set_u64, nft_rule_attr_set_u64); +EXPORT_SYMBOL(nftnl_rule_set_u64, nft_rule_attr_set_u64); -void nftnl_rule_attr_set_str(struct nftnl_rule *r, uint16_t attr, const char *str) +void nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str) { - nftnl_rule_attr_set_data(r, attr, str, strlen(str)); + nftnl_rule_set_data(r, attr, str, strlen(str)); } -EXPORT_SYMBOL(nftnl_rule_attr_set_str, nft_rule_attr_set_str); +EXPORT_SYMBOL(nftnl_rule_set_str, nft_rule_attr_set_str); -const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr, +const void *nftnl_rule_get_data(const struct nftnl_rule *r, uint16_t attr, uint32_t *data_len) { if (!(r->flags & (1 << attr))) @@ -226,53 +226,53 @@ const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr, } return NULL; } -EXPORT_SYMBOL(nftnl_rule_attr_get_data, nft_rule_attr_get_data); +EXPORT_SYMBOL(nftnl_rule_get_data, nft_rule_attr_get_data); -const void *nftnl_rule_attr_get(const struct nftnl_rule *r, uint16_t attr) +const void *nftnl_rule_get(const struct nftnl_rule *r, uint16_t attr) { uint32_t data_len; - return nftnl_rule_attr_get_data(r, attr, &data_len); + return nftnl_rule_get_data(r, attr, &data_len); } -EXPORT_SYMBOL(nftnl_rule_attr_get, nft_rule_attr_get); +EXPORT_SYMBOL(nftnl_rule_get, nft_rule_attr_get); -const char *nftnl_rule_attr_get_str(const struct nftnl_rule *r, uint16_t attr) +const char *nftnl_rule_get_str(const struct nftnl_rule *r, uint16_t attr) { - return nftnl_rule_attr_get(r, attr); + return nftnl_rule_get(r, attr); } -EXPORT_SYMBOL(nftnl_rule_attr_get_str, nft_rule_attr_get_str); +EXPORT_SYMBOL(nftnl_rule_get_str, nft_rule_attr_get_str); -uint32_t nftnl_rule_attr_get_u32(const struct nftnl_rule *r, uint16_t attr) +uint32_t nftnl_rule_get_u32(const struct nftnl_rule *r, uint16_t attr) { uint32_t data_len; - const uint32_t *val = nftnl_rule_attr_get_data(r, attr, &data_len); + const uint32_t *val = nftnl_rule_get_data(r, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(uint32_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_rule_attr_get_u32, nft_rule_attr_get_u32); +EXPORT_SYMBOL(nftnl_rule_get_u32, nft_rule_attr_get_u32); -uint64_t nftnl_rule_attr_get_u64(const struct nftnl_rule *r, uint16_t attr) +uint64_t nftnl_rule_get_u64(const struct nftnl_rule *r, uint16_t attr) { uint32_t data_len; - const uint64_t *val = nftnl_rule_attr_get_data(r, attr, &data_len); + const uint64_t *val = nftnl_rule_get_data(r, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(uint64_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_rule_attr_get_u64, nft_rule_attr_get_u64); +EXPORT_SYMBOL(nftnl_rule_get_u64, nft_rule_attr_get_u64); -uint8_t nftnl_rule_attr_get_u8(const struct nftnl_rule *r, uint16_t attr) +uint8_t nftnl_rule_get_u8(const struct nftnl_rule *r, uint16_t attr) { uint32_t data_len; - const uint8_t *val = nftnl_rule_attr_get_data(r, attr, &data_len); + const uint8_t *val = nftnl_rule_get_data(r, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(uint8_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_rule_attr_get_u8, nft_rule_attr_get_u8); +EXPORT_SYMBOL(nftnl_rule_get_u8, nft_rule_attr_get_u8); void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r) { @@ -490,7 +490,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree, if (nftnl_jansson_parse_family(root, &family, err) != 0) goto err; - nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family); + nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family); } if (nftnl_jansson_node_exist(root, "table")) { @@ -498,7 +498,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree, if (str == NULL) goto err; - nftnl_rule_attr_set_str(r, NFTNL_RULE_TABLE, str); + nftnl_rule_set_str(r, NFTNL_RULE_TABLE, str); } if (nftnl_jansson_node_exist(root, "chain")) { @@ -506,7 +506,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree, if (str == NULL) goto err; - nftnl_rule_attr_set_str(r, NFTNL_RULE_CHAIN, str); + nftnl_rule_set_str(r, NFTNL_RULE_CHAIN, str); } if (nftnl_jansson_node_exist(root, "handle")) { @@ -514,7 +514,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree, err) < 0) goto err; - nftnl_rule_attr_set_u64(r, NFTNL_RULE_HANDLE, uval64); + nftnl_rule_set_u64(r, NFTNL_RULE_HANDLE, uval64); } if (nftnl_jansson_node_exist(root, "compat_proto") || @@ -523,13 +523,13 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree, &uval32, err) < 0) goto err; - nftnl_rule_attr_set_u32(r, NFTNL_RULE_COMPAT_PROTO, uval32); + nftnl_rule_set_u32(r, NFTNL_RULE_COMPAT_PROTO, uval32); if (nftnl_jansson_parse_val(root, "compat_flags", NFTNL_TYPE_U32, &uval32, err) < 0) goto err; - nftnl_rule_attr_set_u32(r, NFTNL_RULE_COMPAT_FLAGS, uval32); + nftnl_rule_set_u32(r, NFTNL_RULE_COMPAT_FLAGS, uval32); } if (nftnl_jansson_node_exist(root, "position")) { @@ -537,7 +537,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree, &uval64, err) < 0) goto err; - nftnl_rule_attr_set_u64(r, NFTNL_RULE_POSITION, uval64); + nftnl_rule_set_u64(r, NFTNL_RULE_POSITION, uval64); } array = json_object_get(root, "expr"); @@ -600,17 +600,17 @@ int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r, family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (family >= 0) - nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family); + nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family); table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (table != NULL) - nftnl_rule_attr_set_str(r, NFTNL_RULE_TABLE, table); + nftnl_rule_set_str(r, NFTNL_RULE_TABLE, table); chain = nftnl_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (chain != NULL) - nftnl_rule_attr_set_str(r, NFTNL_RULE_CHAIN, chain); + nftnl_rule_set_str(r, NFTNL_RULE_CHAIN, chain); if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC, &r->handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) >= 0) @@ -626,8 +626,8 @@ int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r, NFTNL_XML_OPT, err) >= 0) r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS); - if (nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_PROTO) != - nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) { + if (nftnl_rule_is_set(r, NFTNL_RULE_COMPAT_PROTO) != + nftnl_rule_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) { errno = EINVAL; } diff --git a/src/ruleset.c b/src/ruleset.c index fde24ad..7b1ab7a 100644 --- a/src/ruleset.c +++ b/src/ruleset.c @@ -78,13 +78,13 @@ void nftnl_ruleset_free(struct nftnl_ruleset *r) } EXPORT_SYMBOL(nftnl_ruleset_free, nft_ruleset_free); -bool nftnl_ruleset_attr_is_set(const struct nftnl_ruleset *r, uint16_t attr) +bool nftnl_ruleset_is_set(const struct nftnl_ruleset *r, uint16_t attr) { return r->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_ruleset_attr_is_set, nft_ruleset_attr_is_set); +EXPORT_SYMBOL(nftnl_ruleset_is_set, nft_ruleset_attr_is_set); -void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr) +void nftnl_ruleset_unset(struct nftnl_ruleset *r, uint16_t attr) { if (!(r->flags & (1 << attr))) return; @@ -109,25 +109,25 @@ void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr) } r->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_ruleset_attr_unset, nft_ruleset_attr_unset); +EXPORT_SYMBOL(nftnl_ruleset_unset, nft_ruleset_attr_unset); -void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data) +void nftnl_ruleset_set(struct nftnl_ruleset *r, uint16_t attr, void *data) { switch (attr) { case NFTNL_RULESET_TABLELIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_TABLELIST); + nftnl_ruleset_unset(r, NFTNL_RULESET_TABLELIST); r->table_list = data; break; case NFTNL_RULESET_CHAINLIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_CHAINLIST); + nftnl_ruleset_unset(r, NFTNL_RULESET_CHAINLIST); r->chain_list = data; break; case NFTNL_RULESET_SETLIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_SETLIST); + nftnl_ruleset_unset(r, NFTNL_RULESET_SETLIST); r->set_list = data; break; case NFTNL_RULESET_RULELIST: - nftnl_ruleset_attr_unset(r, NFTNL_RULESET_RULELIST); + nftnl_ruleset_unset(r, NFTNL_RULESET_RULELIST); r->rule_list = data; break; default: @@ -135,9 +135,9 @@ void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data) } r->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_ruleset_attr_set, nft_ruleset_attr_set); +EXPORT_SYMBOL(nftnl_ruleset_set, nft_ruleset_attr_set); -void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr) +void *nftnl_ruleset_get(const struct nftnl_ruleset *r, uint16_t attr) { if (!(r->flags & (1 << attr))) return NULL; @@ -155,7 +155,7 @@ void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr) return NULL; } } -EXPORT_SYMBOL(nftnl_ruleset_attr_get, nft_ruleset_attr_get); +EXPORT_SYMBOL(nftnl_ruleset_get, nft_ruleset_attr_get); void nftnl_ruleset_ctx_free(const struct nftnl_parse_ctx *ctx) { @@ -337,7 +337,7 @@ static int nftnl_ruleset_parse_set(struct nftnl_parse_ctx *ctx, { struct nftnl_set *newset; - nftnl_set_attr_set_u32(set, NFTNL_SET_ID, ctx->set_id++); + nftnl_set_set_u32(set, NFTNL_SET_ID, ctx->set_id++); newset = nftnl_set_clone(set); if (newset == NULL) @@ -776,7 +776,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx) if (r->table_list == NULL) return -1; - nftnl_ruleset_attr_set(r, NFTNL_RULESET_TABLELIST, + nftnl_ruleset_set(r, NFTNL_RULESET_TABLELIST, r->table_list); } nftnl_table_list_add_tail(ctx->table, r->table_list); @@ -787,7 +787,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx) if (r->chain_list == NULL) return -1; - nftnl_ruleset_attr_set(r, NFTNL_RULESET_CHAINLIST, + nftnl_ruleset_set(r, NFTNL_RULESET_CHAINLIST, r->chain_list); } nftnl_chain_list_add_tail(ctx->chain, r->chain_list); @@ -798,7 +798,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx) if (r->set_list == NULL) return -1; - nftnl_ruleset_attr_set(r, NFTNL_RULESET_SETLIST, + nftnl_ruleset_set(r, NFTNL_RULESET_SETLIST, r->set_list); } nftnl_set_list_add_tail(ctx->set, r->set_list); @@ -809,7 +809,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx) if (r->rule_list == NULL) return -1; - nftnl_ruleset_attr_set(r, NFTNL_RULESET_RULELIST, + nftnl_ruleset_set(r, NFTNL_RULESET_RULELIST, r->rule_list); } nftnl_rule_list_add_tail(ctx->rule, r->rule_list); @@ -1009,7 +1009,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_TABLELIST) && + if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST) && (!nftnl_table_list_is_empty(rs->table_list))) { ret = nftnl_ruleset_snprintf_table(buf+offset, len, rs, type, inner_flags); @@ -1019,7 +1019,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs prev = rs->table_list; } - if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_CHAINLIST) && + if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST) && (!nftnl_chain_list_is_empty(rs->chain_list))) { ret = snprintf(buf+offset, len, "%s", nftnl_ruleset_o_separator(prev, type)); @@ -1033,7 +1033,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs prev = rs->chain_list; } - if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_SETLIST) && + if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST) && (!nftnl_set_list_is_empty(rs->set_list))) { ret = snprintf(buf+offset, len, "%s", nftnl_ruleset_o_separator(prev, type)); @@ -1047,7 +1047,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs prev = rs->set_list; } - if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_RULELIST) && + if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST) && (!nftnl_rule_list_is_empty(rs->rule_list))) { ret = snprintf(buf+offset, len, "%s", nftnl_ruleset_o_separator(prev, type)); @@ -1260,7 +1260,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs, ret = nftnl_cmd_header_fprintf(fp, cmd, type, flags); NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len); - if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_TABLELIST)) && + if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST)) && (!nftnl_table_list_is_empty(rs->table_list))) { ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags); NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len); @@ -1269,7 +1269,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs, prev = rs->table_list; } - if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_CHAINLIST)) && + if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST)) && (!nftnl_chain_list_is_empty(rs->chain_list))) { ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type)); NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len); @@ -1281,7 +1281,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs, prev = rs->chain_list; } - if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_SETLIST)) && + if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST)) && (!nftnl_set_list_is_empty(rs->set_list))) { ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type)); NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len); @@ -1293,7 +1293,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs, prev = rs->set_list; } - if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_RULELIST)) && + if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST)) && (!nftnl_rule_list_is_empty(rs->rule_list))) { ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type)); NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len); diff --git a/src/set.c b/src/set.c index 983a8f4..f5a9454 100644 --- a/src/set.c +++ b/src/set.c @@ -57,13 +57,13 @@ void nftnl_set_free(struct nftnl_set *s) } EXPORT_SYMBOL(nftnl_set_free, nft_set_free); -bool nftnl_set_attr_is_set(const struct nftnl_set *s, uint16_t attr) +bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr) { return s->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_set_attr_is_set, nft_set_attr_is_set); +EXPORT_SYMBOL(nftnl_set_is_set, nft_set_attr_is_set); -void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr) +void nftnl_set_unset(struct nftnl_set *s, uint16_t attr) { switch (attr) { case NFTNL_SET_TABLE: @@ -98,9 +98,9 @@ void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr) s->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_set_attr_unset, nft_set_attr_unset); +EXPORT_SYMBOL(nftnl_set_unset, nft_set_attr_unset); -static uint32_t nftnl_set_attr_validate[NFTNL_SET_MAX + 1] = { +static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = { [NFTNL_SET_FLAGS] = sizeof(uint32_t), [NFTNL_SET_KEY_TYPE] = sizeof(uint32_t), [NFTNL_SET_KEY_LEN] = sizeof(uint32_t), @@ -113,13 +113,13 @@ static uint32_t nftnl_set_attr_validate[NFTNL_SET_MAX + 1] = { [NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t), }; -void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *data, +void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data, uint32_t data_len) { if (attr > NFTNL_SET_MAX) return; - nftnl_assert_validate(data, nftnl_set_attr_validate, attr, data_len); + nftnl_assert_validate(data, nftnl_set_validate, attr, data_len); switch(attr) { case NFTNL_SET_TABLE: @@ -170,33 +170,33 @@ void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *dat } s->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_set_attr_set_data, nft_set_attr_set_data); +EXPORT_SYMBOL(nftnl_set_set_data, nft_set_attr_set_data); -void nftnl_set_attr_set(struct nftnl_set *s, uint16_t attr, const void *data) +void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data) { - nftnl_set_attr_set_data(s, attr, data, nftnl_set_attr_validate[attr]); + nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]); } -EXPORT_SYMBOL(nftnl_set_attr_set, nft_set_attr_set); +EXPORT_SYMBOL(nftnl_set_set, nft_set_attr_set); -void nftnl_set_attr_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val) +void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val) { - nftnl_set_attr_set(s, attr, &val); + nftnl_set_set(s, attr, &val); } -EXPORT_SYMBOL(nftnl_set_attr_set_u32, nft_set_attr_set_u32); +EXPORT_SYMBOL(nftnl_set_set_u32, nft_set_attr_set_u32); -void nftnl_set_attr_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val) +void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val) { - nftnl_set_attr_set(s, attr, &val); + nftnl_set_set(s, attr, &val); } -EXPORT_SYMBOL(nftnl_set_attr_set_u64, nft_set_attr_set_u64); +EXPORT_SYMBOL(nftnl_set_set_u64, nft_set_attr_set_u64); -void nftnl_set_attr_set_str(struct nftnl_set *s, uint16_t attr, const char *str) +void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str) { - nftnl_set_attr_set(s, attr, str); + nftnl_set_set(s, attr, str); } -EXPORT_SYMBOL(nftnl_set_attr_set_str, nft_set_attr_set_str); +EXPORT_SYMBOL(nftnl_set_set_str, nft_set_attr_set_str); -const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr, +const void *nftnl_set_get_data(struct nftnl_set *s, uint16_t attr, uint32_t *data_len) { if (!(s->flags & (1 << attr))) @@ -243,42 +243,42 @@ const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr, } return NULL; } -EXPORT_SYMBOL(nftnl_set_attr_get_data, nft_set_attr_get_data); +EXPORT_SYMBOL(nftnl_set_get_data, nft_set_attr_get_data); -const void *nftnl_set_attr_get(struct nftnl_set *s, uint16_t attr) +const void *nftnl_set_get(struct nftnl_set *s, uint16_t attr) { uint32_t data_len; - return nftnl_set_attr_get_data(s, attr, &data_len); + return nftnl_set_get_data(s, attr, &data_len); } -EXPORT_SYMBOL(nftnl_set_attr_get, nft_set_attr_get); +EXPORT_SYMBOL(nftnl_set_get, nft_set_attr_get); -const char *nftnl_set_attr_get_str(struct nftnl_set *s, uint16_t attr) +const char *nftnl_set_get_str(struct nftnl_set *s, uint16_t attr) { - return nftnl_set_attr_get(s, attr); + return nftnl_set_get(s, attr); } -EXPORT_SYMBOL(nftnl_set_attr_get_str, nft_set_attr_get_str); +EXPORT_SYMBOL(nftnl_set_get_str, nft_set_attr_get_str); -uint32_t nftnl_set_attr_get_u32(struct nftnl_set *s, uint16_t attr) +uint32_t nftnl_set_get_u32(struct nftnl_set *s, uint16_t attr) { uint32_t data_len; - const uint32_t *val = nftnl_set_attr_get_data(s, attr, &data_len); + const uint32_t *val = nftnl_set_get_data(s, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(uint32_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_set_attr_get_u32, nft_set_attr_get_u32); +EXPORT_SYMBOL(nftnl_set_get_u32, nft_set_attr_get_u32); -uint64_t nftnl_set_attr_get_u64(struct nftnl_set *s, uint16_t attr) +uint64_t nftnl_set_get_u64(struct nftnl_set *s, uint16_t attr) { uint32_t data_len; - const uint64_t *val = nftnl_set_attr_get_data(s, attr, &data_len); + const uint64_t *val = nftnl_set_get_data(s, attr, &data_len); nftnl_assert(val, attr, data_len == sizeof(uint64_t)); return val ? *val : 0; } -EXPORT_SYMBOL(nftnl_set_attr_get_u64, nft_set_attr_get_u64); +EXPORT_SYMBOL(nftnl_set_get_u64, nft_set_attr_get_u64); struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set) { @@ -504,34 +504,34 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree, if (name == NULL) return -1; - nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name); + nftnl_set_set_str(s, NFTNL_SET_NAME, name); table = nftnl_jansson_parse_str(root, "table", err); if (table == NULL) return -1; - nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table); + nftnl_set_set_str(s, NFTNL_SET_TABLE, table); if (nftnl_jansson_parse_family(root, &family, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family); + nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family); if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, flags); + nftnl_set_set_u32(s, NFTNL_SET_FLAGS, flags); if (nftnl_jansson_parse_val(root, "key_type", NFTNL_TYPE_U32, &key_type, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_TYPE, key_type); + nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type); if (nftnl_jansson_parse_val(root, "key_len", NFTNL_TYPE_U32, &key_len, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, key_len); + nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len); if (nftnl_jansson_node_exist(root, "data_type")) { if (nftnl_jansson_parse_val(root, "data_type", NFTNL_TYPE_U32, &data_type, err) < 0) return -1; - nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_TYPE, data_type); + nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type); } if (nftnl_jansson_node_exist(root, "data_len")) { @@ -539,7 +539,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree, &data_len, err) < 0) return -1; - nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_LEN, data_len); + nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len); } if (nftnl_jansson_node_exist(root, "policy")) { @@ -547,7 +547,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree, &policy, err) < 0) return -1; - nftnl_set_attr_set_u32(s, NFTNL_SET_POLICY, policy); + nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy); } if (nftnl_jansson_node_exist(root, "desc_size")) { @@ -555,7 +555,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree, &size, err) < 0) return -1; - nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, size); + nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, size); } if (nftnl_jansson_node_exist(root, "set_elem")) { @@ -644,54 +644,54 @@ int nftnl_mxml_set_parse(mxml_node_t *tree, struct nftnl_set *s, NFTNL_XML_MAND, err); if (name == NULL) return -1; - nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name); + nftnl_set_set_str(s, NFTNL_SET_NAME, name); table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (table == NULL) return -1; - nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table); + nftnl_set_set_str(s, NFTNL_SET_TABLE, table); family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (family >= 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family); + nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family); if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, &set_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, set_flags); + nftnl_set_set_u32(s, NFTNL_SET_FLAGS, set_flags); if (nftnl_mxml_num_parse(tree, "key_type", MXML_DESCEND_FIRST, BASE_DEC, &key_type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_TYPE, key_type); + nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type); if (nftnl_mxml_num_parse(tree, "key_len", MXML_DESCEND_FIRST, BASE_DEC, &key_len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) < 0) return -1; - nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, key_len); + nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len); if (nftnl_mxml_num_parse(tree, "data_type", MXML_DESCEND_FIRST, BASE_DEC, &data_type, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) == 0) { - nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_TYPE, data_type); + nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type); if (nftnl_mxml_num_parse(tree, "data_len", MXML_DESCEND_FIRST, BASE_DEC, &data_len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_LEN, data_len); + nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len); } if (nftnl_mxml_num_parse(tree, "policy", MXML_DESCEND_FIRST, BASE_DEC, &policy, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_POLICY, policy); + nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy); if (nftnl_mxml_num_parse(tree, "desc_size", MXML_DESCEND_FIRST, BASE_DEC, &size, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) == 0) - nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, policy); + nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, policy); for (node = mxmlFindElement(tree, tree, "set_elem", NULL, NULL, MXML_DESCEND); @@ -1192,7 +1192,7 @@ static struct nftnl_set *nftnl_set_lookup(const char *this_set_name, s = nftnl_set_list_iter_cur(iter); while (s != NULL) { - set_name = nftnl_set_attr_get_str(s, NFTNL_SET_NAME); + set_name = nftnl_set_get_str(s, NFTNL_SET_NAME); if (strcmp(this_set_name, set_name) == 0) break; @@ -1217,6 +1217,6 @@ int nftnl_set_lookup_id(struct nftnl_expr *e, if (s == NULL) return 0; - *set_id = nftnl_set_attr_get_u32(s, NFTNL_SET_ID); + *set_id = nftnl_set_get_u32(s, NFTNL_SET_ID); return 1; } diff --git a/src/set_elem.c b/src/set_elem.c index 3dd1658..293ce15 100644 --- a/src/set_elem.c +++ b/src/set_elem.c @@ -55,13 +55,13 @@ void nftnl_set_elem_free(struct nftnl_set_elem *s) } EXPORT_SYMBOL(nftnl_set_elem_free, nft_set_elem_free); -bool nftnl_set_elem_attr_is_set(const struct nftnl_set_elem *s, uint16_t attr) +bool nftnl_set_elem_is_set(const struct nftnl_set_elem *s, uint16_t attr) { return s->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_set_elem_attr_is_set, nft_set_elem_attr_is_set); +EXPORT_SYMBOL(nftnl_set_elem_is_set, nft_set_elem_attr_is_set); -void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr) +void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr) { switch (attr) { case NFTNL_SET_ELEM_CHAIN: @@ -92,9 +92,9 @@ void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr) s->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_set_elem_attr_unset, nft_set_elem_attr_unset); +EXPORT_SYMBOL(nftnl_set_elem_unset, nft_set_elem_attr_unset); -void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr, +void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len) { switch(attr) { @@ -130,27 +130,27 @@ void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr, } s->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_set_elem_attr_set, nft_set_elem_attr_set); +EXPORT_SYMBOL(nftnl_set_elem_set, nft_set_elem_attr_set); -void nftnl_set_elem_attr_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val) +void nftnl_set_elem_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val) { - nftnl_set_elem_attr_set(s, attr, &val, sizeof(uint32_t)); + nftnl_set_elem_set(s, attr, &val, sizeof(uint32_t)); } -EXPORT_SYMBOL(nftnl_set_elem_attr_set_u32, nft_set_elem_attr_set_u32); +EXPORT_SYMBOL(nftnl_set_elem_set_u32, nft_set_elem_attr_set_u32); -void nftnl_set_elem_attr_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val) +void nftnl_set_elem_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val) { - nftnl_set_elem_attr_set(s, attr, &val, sizeof(uint64_t)); + nftnl_set_elem_set(s, attr, &val, sizeof(uint64_t)); } -EXPORT_SYMBOL(nftnl_set_elem_attr_set_u64, nft_set_elem_attr_set_u64); +EXPORT_SYMBOL(nftnl_set_elem_set_u64, nft_set_elem_attr_set_u64); -void nftnl_set_elem_attr_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str) +void nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str) { - nftnl_set_elem_attr_set(s, attr, str, strlen(str)); + nftnl_set_elem_set(s, attr, str, strlen(str)); } -EXPORT_SYMBOL(nftnl_set_elem_attr_set_str, nft_set_elem_attr_set_str); +EXPORT_SYMBOL(nftnl_set_elem_set_str, nft_set_elem_attr_set_str); -const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len) +const void *nftnl_set_elem_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len) { if (!(s->flags & (1 << attr))) return NULL; @@ -180,31 +180,31 @@ const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uin } return NULL; } -EXPORT_SYMBOL(nftnl_set_elem_attr_get, nft_set_elem_attr_get); +EXPORT_SYMBOL(nftnl_set_elem_get, nft_set_elem_attr_get); -const char *nftnl_set_elem_attr_get_str(struct nftnl_set_elem *s, uint16_t attr) +const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr) { uint32_t size; - return nftnl_set_elem_attr_get(s, attr, &size); + return nftnl_set_elem_get(s, attr, &size); } -EXPORT_SYMBOL(nftnl_set_elem_attr_get_str, nft_set_elem_attr_get_str); +EXPORT_SYMBOL(nftnl_set_elem_get_str, nft_set_elem_attr_get_str); -uint32_t nftnl_set_elem_attr_get_u32(struct nftnl_set_elem *s, uint16_t attr) +uint32_t nftnl_set_elem_get_u32(struct nftnl_set_elem *s, uint16_t attr) { uint32_t size; - uint32_t val = *((uint32_t *)nftnl_set_elem_attr_get(s, attr, &size)); + uint32_t val = *((uint32_t *)nftnl_set_elem_get(s, attr, &size)); return val; } -EXPORT_SYMBOL(nftnl_set_elem_attr_get_u32, nft_set_elem_attr_get_u32); +EXPORT_SYMBOL(nftnl_set_elem_get_u32, nft_set_elem_attr_get_u32); -uint64_t nftnl_set_elem_attr_get_u64(struct nftnl_set_elem *s, uint16_t attr) +uint64_t nftnl_set_elem_get_u64(struct nftnl_set_elem *s, uint16_t attr) { uint32_t size; - uint64_t val = *((uint64_t *)nftnl_set_elem_attr_get(s, attr, &size)); + uint64_t val = *((uint64_t *)nftnl_set_elem_get(s, attr, &size)); return val; } -EXPORT_SYMBOL(nftnl_set_elem_attr_get_u64, nft_set_elem_attr_get_u64); +EXPORT_SYMBOL(nftnl_set_elem_get_u64, nft_set_elem_attr_get_u64); struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem) { @@ -270,7 +270,7 @@ static void nftnl_set_elem_nlmsg_build_def(struct nlmsghdr *nlh, mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_TABLE, s->table); } -static struct nlattr *nftnl_set_elem_attr_build(struct nlmsghdr *nlh, +static struct nlattr *nftnl_set_elem_build(struct nlmsghdr *nlh, struct nftnl_set_elem *elem, int i) { struct nlattr *nest2; @@ -292,7 +292,7 @@ void nftnl_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_LIST_ELEMENTS); list_for_each_entry(elem, &s->element_list, head) - nftnl_set_elem_attr_build(nlh, elem, ++i); + nftnl_set_elem_build(nlh, elem, ++i); mnl_attr_nest_end(nlh, nest1); } @@ -497,7 +497,7 @@ int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e, if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, &set_elem_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, set_elem_flags); + nftnl_set_elem_set_u32(e, NFTNL_SET_ELEM_FLAGS, set_elem_flags); if (nftnl_mxml_data_reg_parse(tree, "key", &e->key, NFTNL_XML_MAND, err) == DATA_VALUE) @@ -886,7 +886,7 @@ int nftnl_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh, nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_LIST_ELEMENTS); elem = nftnl_set_elems_iter_next(iter); while (elem != NULL) { - nest2 = nftnl_set_elem_attr_build(nlh, elem, ++i); + nest2 = nftnl_set_elem_build(nlh, elem, ++i); if (nftnl_attr_nest_overflow(nlh, nest1, nest2)) { /* Go back to previous not to miss this element */ iter->cur = list_entry(iter->cur->head.prev, diff --git a/src/table.c b/src/table.c index 1d119ef..28f6bd6 100644 --- a/src/table.c +++ b/src/table.c @@ -51,13 +51,13 @@ void nftnl_table_free(struct nftnl_table *t) } EXPORT_SYMBOL(nftnl_table_free, nft_table_free); -bool nftnl_table_attr_is_set(const struct nftnl_table *t, uint16_t attr) +bool nftnl_table_is_set(const struct nftnl_table *t, uint16_t attr) { return t->flags & (1 << attr); } -EXPORT_SYMBOL(nftnl_table_attr_is_set, nft_table_attr_is_set); +EXPORT_SYMBOL(nftnl_table_is_set, nft_table_attr_is_set); -void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr) +void nftnl_table_unset(struct nftnl_table *t, uint16_t attr) { if (!(t->flags & (1 << attr))) return; @@ -77,20 +77,20 @@ void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr) } t->flags &= ~(1 << attr); } -EXPORT_SYMBOL(nftnl_table_attr_unset, nft_table_attr_unset); +EXPORT_SYMBOL(nftnl_table_unset, nft_table_attr_unset); -static uint32_t nftnl_table_attr_validate[NFTNL_TABLE_MAX + 1] = { +static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = { [NFTNL_TABLE_FLAGS] = sizeof(uint32_t), [NFTNL_TABLE_FAMILY] = sizeof(uint32_t), }; -void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr, +void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr, const void *data, uint32_t data_len) { if (attr > NFTNL_TABLE_MAX) return; - nftnl_assert_validate(data, nftnl_table_attr_validate, attr, data_len); + nftnl_assert_validate(data, nftnl_table_validate, attr, data_len); switch (attr) { case NFTNL_TABLE_NAME: @@ -111,33 +111,33 @@ void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr, } t->flags |= (1 << attr); } -EXPORT_SYMBOL(nftnl_table_attr_set_data, nft_table_attr_set_data); +EXPORT_SYMBOL(nftnl_table_set_data, nft_table_attr_set_data); -void nftnl_table_attr_set(struct nftnl_table *t, uint16_t attr, const void *data) +void nftnl_table_set(struct nftnl_table *t, uint16_t attr, const void *data) { - nftnl_table_attr_set_data(t, attr, data, nftnl_table_attr_validate[attr]); + nftnl_table_set_data(t, attr, data, nftnl_table_validate[attr]); } -EXPORT_SYMBOL(nftnl_table_attr_set, nft_table_attr_set); +EXPORT_SYMBOL(nftnl_table_set, nft_table_attr_set); -void nftnl_table_attr_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t val) +void nftnl_table_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t val) { - nftnl_table_attr_set_data(t, attr, &val, sizeof(uint32_t)); + nftnl_table_set_data(t, attr, &val, sizeof(uint32_t)); } -EXPORT_SYMBOL(nftnl_table_attr_set_u32, nft_table_attr_set_u32); +EXPORT_SYMBOL(nftnl_table_set_u32, nft_table_attr_set_u32); -void nftnl_table_attr_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t val) +void nftnl_table_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t val) { - nftnl_table_attr_set_data(t, attr, &val, sizeof(uint8_t)); + nftnl_table_set_data(t, attr, &val, sizeof(uint8_t)); } -EXPORT_SYMBOL(nftnl_table_attr_set_u8, nft_table_attr_set_u8); +EXPORT_SYMBOL(nftnl_table_set_u8, nft_table_attr_set_u8); -void nftnl_table_attr_set_str(struct nftnl_table *t, uint16_t attr, const char *str) +void nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str) { - nftnl_table_attr_set_data(t, attr, str, 0); + nftnl_table_set_data(t, attr, str, 0); } -EXPORT_SYMBOL(nftnl_table_attr_set_str, nft_table_attr_set_str); +EXPORT_SYMBOL(nftnl_table_set_str, nft_table_attr_set_str); -const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr, +const void *nftnl_table_get_data(struct nftnl_table *t, uint16_t attr, uint32_t *data_len) { if (!(t->flags & (1 << attr))) @@ -158,34 +158,34 @@ const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr, } return NULL; } -EXPORT_SYMBOL(nftnl_table_attr_get_data, nft_table_attr_get_data); +EXPORT_SYMBOL(nftnl_table_get_data, nft_table_attr_get_data); -const void *nftnl_table_attr_get(struct nftnl_table *t, uint16_t attr) +const void *nftnl_table_get(struct nftnl_table *t, uint16_t attr) { uint32_t data_len; - return nftnl_table_attr_get_data(t, attr, &data_len); + return nftnl_table_get_data(t, attr, &data_len); } -EXPORT_SYMBOL(nftnl_table_attr_get, nft_table_attr_get); +EXPORT_SYMBOL(nftnl_table_get, nft_table_attr_get); -uint32_t nftnl_table_attr_get_u32(struct nftnl_table *t, uint16_t attr) +uint32_t nftnl_table_get_u32(struct nftnl_table *t, uint16_t attr) { - const void *ret = nftnl_table_attr_get(t, attr); + const void *ret = nftnl_table_get(t, attr); return ret == NULL ? 0 : *((uint32_t *)ret); } -EXPORT_SYMBOL(nftnl_table_attr_get_u32, nft_table_attr_get_u32); +EXPORT_SYMBOL(nftnl_table_get_u32, nft_table_attr_get_u32); -uint8_t nftnl_table_attr_get_u8(struct nftnl_table *t, uint16_t attr) +uint8_t nftnl_table_get_u8(struct nftnl_table *t, uint16_t attr) { - const void *ret = nftnl_table_attr_get(t, attr); + const void *ret = nftnl_table_get(t, attr); return ret == NULL ? 0 : *((uint8_t *)ret); } -EXPORT_SYMBOL(nftnl_table_attr_get_u8, nft_table_attr_get_u8); +EXPORT_SYMBOL(nftnl_table_get_u8, nft_table_attr_get_u8); -const char *nftnl_table_attr_get_str(struct nftnl_table *t, uint16_t attr) +const char *nftnl_table_get_str(struct nftnl_table *t, uint16_t attr) { - return nftnl_table_attr_get(t, attr); + return nftnl_table_get(t, attr); } -EXPORT_SYMBOL(nftnl_table_attr_get_str, nft_table_attr_get_str); +EXPORT_SYMBOL(nftnl_table_get_str, nft_table_attr_get_str); void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_table *t) { @@ -260,20 +260,20 @@ int nftnl_mxml_table_parse(mxml_node_t *tree, struct nftnl_table *t, name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (name != NULL) - nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, name); + nftnl_table_set_str(t, NFTNL_TABLE_NAME, name); family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (family >= 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family); + nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family); if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC, &flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags); + nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags); if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND, BASE_DEC, &use, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use); + nftnl_table_set_u32(t, NFTNL_TABLE_USE, use); return 0; } @@ -313,17 +313,17 @@ int nftnl_jansson_parse_table(struct nftnl_table *t, json_t *tree, str = nftnl_jansson_parse_str(root, "name", err); if (str != NULL) - nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, str); + nftnl_table_set_str(t, NFTNL_TABLE_NAME, str); if (nftnl_jansson_parse_family(root, &family, err) == 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family); + nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family); if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags); + nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags); if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0) - nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use); + nftnl_table_set_u32(t, NFTNL_TABLE_USE, use); return 0; } -- cgit v1.2.3