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 <pablo@netfilter.org>

9 files changed, 362 insertions, 362 deletions

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;
 }