src: rename existing functions to use the nftnl_ prefix

So we can use the nft_* prefix anytime soon for our upcoming higher level
library.

After this patch, the nft_* symbols become an alias of the nftnl_* symbols.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

1 files changed, 40 insertions, 40 deletions

diff --git a/src/gen.c b/src/gen.c
index 2c9e561..bb66295 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -23,57 +23,57 @@
 
 #include <libnftnl/gen.h>
 
-struct nft_gen {
+struct nftnl_gen {
 	uint32_t id;
 
 	uint32_t flags;
 };
 
-struct nft_gen *nft_gen_alloc(void)
+struct nftnl_gen *nftnl_gen_alloc(void)
 {
-	return calloc(1, sizeof(struct nft_gen));
+	return calloc(1, sizeof(struct nftnl_gen));
 }
 EXPORT_SYMBOL(nftnl_gen_alloc, nft_gen_alloc);
 
-void nft_gen_free(struct nft_gen *gen)
+void nftnl_gen_free(struct nftnl_gen *gen)
 {
 	xfree(gen);
 }
 EXPORT_SYMBOL(nftnl_gen_free, nft_gen_free);
 
-bool nft_gen_attr_is_set(const struct nft_gen *gen, uint16_t attr)
+bool nftnl_gen_attr_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);
 
-void nft_gen_attr_unset(struct nft_gen *gen, uint16_t attr)
+void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr)
 {
 	if (!(gen->flags & (1 << attr)))
 		return;
 
 	switch (attr) {
-	case NFT_GEN_ID:
+	case NFTNL_GEN_ID:
 		break;
 	}
 	gen->flags &= ~(1 << attr);
 }
 EXPORT_SYMBOL(nftnl_gen_attr_unset, nft_gen_attr_unset);
 
-static uint32_t nft_gen_attr_validate[NFT_GEN_MAX + 1] = {
-	[NFT_GEN_ID]	= sizeof(uint32_t),
+static uint32_t nftnl_gen_attr_validate[NFTNL_GEN_MAX + 1] = {
+	[NFTNL_GEN_ID]	= sizeof(uint32_t),
 };
 
-void nft_gen_attr_set_data(struct nft_gen *gen, uint16_t attr,
+void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr,
 			   const void *data, uint32_t data_len)
 {
-	if (attr > NFT_GEN_MAX)
+	if (attr > NFTNL_GEN_MAX)
 		return;
 
-	nft_assert_validate(data, nft_gen_attr_validate, attr, data_len);
+	nftnl_assert_validate(data, nftnl_gen_attr_validate, attr, data_len);
 
 	switch (attr) {
-	case NFT_GEN_ID:
+	case NFTNL_GEN_ID:
 		gen->id = *((uint32_t *)data);
 		break;
 	}
@@ -81,47 +81,47 @@ void nft_gen_attr_set_data(struct nft_gen *gen, uint16_t attr,
 }
 EXPORT_SYMBOL(nftnl_gen_attr_set_data, nft_gen_attr_set_data);
 
-void nft_gen_attr_set(struct nft_gen *gen, uint16_t attr, const void *data)
+void nftnl_gen_attr_set(struct nftnl_gen *gen, uint16_t attr, const void *data)
 {
-	nft_gen_attr_set_data(gen, attr, data, nft_gen_attr_validate[attr]);
+	nftnl_gen_attr_set_data(gen, attr, data, nftnl_gen_attr_validate[attr]);
 }
 EXPORT_SYMBOL(nftnl_gen_attr_set, nft_gen_attr_set);
 
-void nft_gen_attr_set_u32(struct nft_gen *gen, uint16_t attr, uint32_t val)
+void nftnl_gen_attr_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t val)
 {
-	nft_gen_attr_set_data(gen, attr, &val, sizeof(uint32_t));
+	nftnl_gen_attr_set_data(gen, attr, &val, sizeof(uint32_t));
 }
 EXPORT_SYMBOL(nftnl_gen_attr_set_u32, nft_gen_attr_set_u32);
 
-const void *nft_gen_attr_get_data(struct nft_gen *gen, uint16_t attr,
+const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr,
 				  uint32_t *data_len)
 {
 	if (!(gen->flags & (1 << attr)))
 		return NULL;
 
 	switch(attr) {
-	case NFT_GEN_ID:
+	case NFTNL_GEN_ID:
 		return &gen->id;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL(nftnl_gen_attr_get_data, nft_gen_attr_get_data);
 
-const void *nft_gen_attr_get(struct nft_gen *gen, uint16_t attr)
+const void *nftnl_gen_attr_get(struct nftnl_gen *gen, uint16_t attr)
 {
 	uint32_t data_len;
-	return nft_gen_attr_get_data(gen, attr, &data_len);
+	return nftnl_gen_attr_get_data(gen, attr, &data_len);
 }
 EXPORT_SYMBOL(nftnl_gen_attr_get, nft_gen_attr_get);
 
-uint32_t nft_gen_attr_get_u32(struct nft_gen *gen, uint16_t attr)
+uint32_t nftnl_gen_attr_get_u32(struct nftnl_gen *gen, uint16_t attr)
 {
-	const void *ret = nft_gen_attr_get(gen, attr);
+	const void *ret = nftnl_gen_attr_get(gen, attr);
 	return ret == NULL ? 0 : *((uint32_t *)ret);
 }
 EXPORT_SYMBOL(nftnl_gen_attr_get_u32, nft_gen_attr_get_u32);
 
-static int nft_gen_parse_attr_cb(const struct nlattr *attr, void *data)
+static int nftnl_gen_parse_attr_cb(const struct nlattr *attr, void *data)
 {
 	const struct nlattr **tb = data;
 	int type = mnl_attr_get_type(attr);
@@ -140,69 +140,69 @@ static int nft_gen_parse_attr_cb(const struct nlattr *attr, void *data)
 	return MNL_CB_OK;
 }
 
-int nft_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_gen *gen)
+int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen)
 {
 	struct nlattr *tb[NFTA_GEN_MAX + 1] = {};
 	struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
 
-	if (mnl_attr_parse(nlh, sizeof(*nfg), nft_gen_parse_attr_cb, tb) < 0)
+	if (mnl_attr_parse(nlh, sizeof(*nfg), nftnl_gen_parse_attr_cb, tb) < 0)
 		return -1;
 
 	if (tb[NFTA_GEN_ID]) {
 		gen->id = ntohl(mnl_attr_get_u32(tb[NFTA_GEN_ID]));
-		gen->flags |= (1 << NFT_GEN_ID);
+		gen->flags |= (1 << NFTNL_GEN_ID);
 	}
 	return 0;
 }
 EXPORT_SYMBOL(nftnl_gen_nlmsg_parse, nft_gen_nlmsg_parse);
 
-static int nft_gen_snprintf_default(char *buf, size_t size, struct nft_gen *gen)
+static int nftnl_gen_snprintf_default(char *buf, size_t size, struct nftnl_gen *gen)
 {
 	return snprintf(buf, size, "ruleset generation ID %u", gen->id);
 }
 
-static int nft_gen_cmd_snprintf(char *buf, size_t size, struct nft_gen *gen,
+static int nftnl_gen_cmd_snprintf(char *buf, size_t size, struct nftnl_gen *gen,
 				uint32_t cmd, uint32_t type, uint32_t flags)
 {
 	int ret, len = size, offset = 0;
 
-	ret = nft_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
+	ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
 	switch(type) {
-	case NFT_OUTPUT_DEFAULT:
-		ret = nft_gen_snprintf_default(buf + offset, len, gen);
+	case NFTNL_OUTPUT_DEFAULT:
+		ret = nftnl_gen_snprintf_default(buf + offset, len, gen);
 		break;
 	default:
 		return -1;
 	}
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-	ret = nft_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
+	ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
 	return offset;
 }
 
-int nft_gen_snprintf(char *buf, size_t size, struct nft_gen *gen, uint32_t type,
+int nftnl_gen_snprintf(char *buf, size_t size, struct nftnl_gen *gen, uint32_t type,
 		     uint32_t flags)
 {;
-	return nft_gen_cmd_snprintf(buf, size, gen, nft_flag2cmd(flags), type,
+	return nftnl_gen_cmd_snprintf(buf, size, gen, nftnl_flag2cmd(flags), type,
 				    flags);
 }
 EXPORT_SYMBOL(nftnl_gen_snprintf, nft_gen_snprintf);
 
-static inline int nft_gen_do_snprintf(char *buf, size_t size, void *gen,
+static inline int nftnl_gen_do_snprintf(char *buf, size_t size, void *gen,
 				      uint32_t cmd, uint32_t type,
 				      uint32_t flags)
 {
-	return nft_gen_snprintf(buf, size, gen, type, flags);
+	return nftnl_gen_snprintf(buf, size, gen, type, flags);
 }
 
-int nft_gen_fprintf(FILE *fp, struct nft_gen *gen, uint32_t type,
+int nftnl_gen_fprintf(FILE *fp, struct nftnl_gen *gen, uint32_t type,
 		    uint32_t flags)
 {
-	return nft_fprintf(fp, gen, NFT_CMD_UNSPEC, type, flags,
-			   nft_gen_do_snprintf);
+	return nftnl_fprintf(fp, gen, NFTNL_CMD_UNSPEC, type, flags,
+			   nftnl_gen_do_snprintf);
 }
 EXPORT_SYMBOL(nftnl_gen_fprintf, nft_gen_fprintf);