From 610d015143e88629eab07067a4ae0c1d7548cfaf Mon Sep 17 00:00:00 2001
From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Date: Thu, 2 Jun 2016 23:03:27 -0300
Subject: [PATCH] Rename xfree() to libnftnl_xfree() to avoid symbol naming
 conflict

When ELF binaries and shared libraries are used, the internal
functions of libnftnl such as xfree() are not visible to the outside
world (their visibility is 'hidden'). Therefore, the fact that other
programs (especially nftables) may have symbols with the same name
does not cause any problem.

However, when doing static linking on a non-ELF platform (such as
Blackfin, which uses the FLAT binary format), there is no way of
encoding this visibility. Therefore, the xfree() symbols of libnftnl
becomes visible to the outside world, causing a conflict with the
xfree() symbol defined by nftables.

To solve this, this patch renames the libnftnl xfree() function to
libnftnl_xfree().

Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
[Gustavo: update for version 1.0.5]

Signed-off-by: Gustavo Zacarias <gustavo@zacarias.com.ar>
---
 include/utils.h      |  2 +-
 src/chain.c          | 28 ++++++++++++++--------------
 src/common.c         |  2 +-
 src/expr.c           |  4 ++--
 src/expr/data_reg.c  |  4 ++--
 src/expr/dynset.c    |  2 +-
 src/expr/immediate.c |  2 +-
 src/expr/log.c       |  6 +++---
 src/expr/lookup.c    |  2 +-
 src/expr/match.c     |  6 +++---
 src/expr/target.c    |  6 +++---
 src/gen.c            |  2 +-
 src/mxml.c           |  2 +-
 src/rule.c           | 30 +++++++++++++++---------------
 src/ruleset.c        |  2 +-
 src/set.c            | 22 +++++++++++-----------
 src/set_elem.c       | 20 ++++++++++----------
 src/table.c          | 14 +++++++-------
 src/trace.c          | 14 +++++++-------
 src/udata.c          |  2 +-
 src/utils.c          |  2 +-
 21 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/include/utils.h b/include/utils.h
index 46ff18a..0320c96 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -19,7 +19,7 @@
 
 #define __noreturn	__attribute__((__noreturn__))
 
-#define xfree(ptr)	free((void *)ptr);
+#define nftnl_xfree(ptr)	free((void *)ptr);
 
 #define div_round_up(n, d)	(((n) + (d) - 1) / (d))
 
diff --git a/src/chain.c b/src/chain.c
index 990c576..b8f1e1f 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -96,13 +96,13 @@ EXPORT_SYMBOL_ALIAS(nftnl_chain_alloc, nft_chain_alloc);
 void nftnl_chain_free(const struct nftnl_chain *c)
 {
 	if (c->table != NULL)
-		xfree(c->table);
+		nftnl_xfree(c->table);
 	if (c->type != NULL)
-		xfree(c->type);
+		nftnl_xfree(c->type);
 	if (c->dev != NULL)
-		xfree(c->dev);
+		nftnl_xfree(c->dev);
 
-	xfree(c);
+	nftnl_xfree(c);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_chain_free, nft_chain_free);
 
@@ -120,7 +120,7 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
 	switch (attr) {
 	case NFTNL_CHAIN_TABLE:
 		if (c->table) {
-			xfree(c->table);
+			nftnl_xfree(c->table);
 			c->table = NULL;
 		}
 		break;
@@ -128,7 +128,7 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
 		break;
 	case NFTNL_CHAIN_TYPE:
 		if (c->type) {
-			xfree(c->type);
+			nftnl_xfree(c->type);
 			c->type = NULL;
 		}
 		break;
@@ -143,7 +143,7 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
 		break;
 	case NFTNL_CHAIN_DEV:
 		if (c->dev) {
-			xfree(c->dev);
+			nftnl_xfree(c->dev);
 			c->dev = NULL;
 		}
 		break;
@@ -179,7 +179,7 @@ void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
 		break;
 	case NFTNL_CHAIN_TABLE:
 		if (c->table)
-			xfree(c->table);
+			nftnl_xfree(c->table);
 
 		c->table = strdup(data);
 		break;
@@ -209,13 +209,13 @@ void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
 		break;
 	case NFTNL_CHAIN_TYPE:
 		if (c->type)
-			xfree(c->type);
+			nftnl_xfree(c->type);
 
 		c->type = strdup(data);
 		break;
 	case NFTNL_CHAIN_DEV:
 		if (c->dev)
-			xfree(c->dev);
+			nftnl_xfree(c->dev);
 
 		c->dev = strdup(data);
 		break;
@@ -535,7 +535,7 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
 		c->flags |= (1 << NFTNL_CHAIN_NAME);
 	}
 	if (tb[NFTA_CHAIN_TABLE]) {
-		xfree(c->table);
+		nftnl_xfree(c->table);
 		c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE]));
 		c->flags |= (1 << NFTNL_CHAIN_TABLE);
 	}
@@ -562,7 +562,7 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
 		c->flags |= (1 << NFTNL_CHAIN_HANDLE);
 	}
 	if (tb[NFTA_CHAIN_TYPE]) {
-		xfree(c->type);
+		nftnl_xfree(c->type);
 		c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE]));
 		c->flags |= (1 << NFTNL_CHAIN_TYPE);
 	}
@@ -976,7 +976,7 @@ void nftnl_chain_list_free(struct nftnl_chain_list *list)
 		list_del(&r->head);
 		nftnl_chain_free(r);
 	}
-	xfree(list);
+	nftnl_xfree(list);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_chain_list_free, nft_chain_list_free);
 
@@ -1061,6 +1061,6 @@ EXPORT_SYMBOL_ALIAS(nftnl_chain_list_iter_next, nft_chain_list_iter_next);
 
 void nftnl_chain_list_iter_destroy(struct nftnl_chain_list_iter *iter)
 {
-	xfree(iter);
+	nftnl_xfree(iter);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_chain_list_iter_destroy, nft_chain_list_iter_destroy);
diff --git a/src/common.c b/src/common.c
index bf4176c..98f8012 100644
--- a/src/common.c
+++ b/src/common.c
@@ -58,7 +58,7 @@ EXPORT_SYMBOL_ALIAS(nftnl_parse_err_alloc, nft_parse_err_alloc);
 
 void nftnl_parse_err_free(struct nftnl_parse_err *err)
 {
-	xfree(err);
+	nftnl_xfree(err);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_parse_err_free, nft_parse_err_free);
 
diff --git a/src/expr.c b/src/expr.c
index ed07dc4..6c08bd0 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -50,7 +50,7 @@ void nftnl_expr_free(const struct nftnl_expr *expr)
 	if (expr->ops->free)
 		expr->ops->free(expr);
 
-	xfree(expr);
+	nftnl_xfree(expr);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_expr_free, nft_rule_expr_free);
 
@@ -257,7 +257,7 @@ struct nftnl_expr *nftnl_expr_parse(struct nlattr *attr)
 	return expr;
 
 err2:
-	xfree(expr);
+	nftnl_xfree(expr);
 err1:
 	return NULL;
 }
diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c
index 2a23285..2b1a87e 100644
--- a/src/expr/data_reg.c
+++ b/src/expr/data_reg.c
@@ -123,7 +123,7 @@ static int nftnl_data_reg_verdict_xml_parse(union nftnl_data_reg *reg,
 				   NFTNL_XML_OPT, err);
 	if (chain != NULL) {
 		if (reg->chain)
-			xfree(reg->chain);
+			nftnl_xfree(reg->chain);
 
 		reg->chain = strdup(chain);
 	}
@@ -511,7 +511,7 @@ void nftnl_free_verdict(const union nftnl_data_reg *data)
 	switch(data->verdict) {
 	case NFT_JUMP:
 	case NFT_GOTO:
-		xfree(data->chain);
+		nftnl_xfree(data->chain);
 		break;
 	default:
 		break;
diff --git a/src/expr/dynset.c b/src/expr/dynset.c
index c8d97a5..604600a 100644
--- a/src/expr/dynset.c
+++ b/src/expr/dynset.c
@@ -361,7 +361,7 @@ static void nftnl_expr_dynset_free(const struct nftnl_expr *e)
 {
 	struct nftnl_expr_dynset *dynset = nftnl_expr_data(e);
 
-	xfree(dynset->set_name);
+	nftnl_xfree(dynset->set_name);
 }
 
 struct expr_ops expr_ops_dynset = {
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index eb2ca0f..237f944 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -44,7 +44,7 @@ nftnl_expr_immediate_set(struct nftnl_expr *e, uint16_t type,
 		break;
 	case NFTNL_EXPR_IMM_CHAIN:
 		if (imm->data.chain)
-			xfree(imm->data.chain);
+			nftnl_xfree(imm->data.chain);
 
 		imm->data.chain = strdup(data);
 		break;
diff --git a/src/expr/log.c b/src/expr/log.c
index c3dc0a6..ab24686 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -38,7 +38,7 @@ static int nftnl_expr_log_set(struct nftnl_expr *e, uint16_t type,
 	switch(type) {
 	case NFTNL_EXPR_LOG_PREFIX:
 		if (log->prefix)
-			xfree(log->prefix);
+			nftnl_xfree(log->prefix);
 
 		log->prefix = strdup(data);
 		break;
@@ -152,7 +152,7 @@ nftnl_expr_log_parse(struct nftnl_expr *e, struct nlattr *attr)
 
 	if (tb[NFTA_LOG_PREFIX]) {
 		if (log->prefix)
-			xfree(log->prefix);
+			nftnl_xfree(log->prefix);
 
 		log->prefix = strdup(mnl_attr_get_str(tb[NFTA_LOG_PREFIX]));
 		e->flags |= (1 << NFTNL_EXPR_LOG_PREFIX);
@@ -329,7 +329,7 @@ static void nftnl_expr_log_free(const struct nftnl_expr *e)
 {
 	struct nftnl_expr_log *log = nftnl_expr_data(e);
 
-	xfree(log->prefix);
+	nftnl_xfree(log->prefix);
 }
 
 struct expr_ops expr_ops_log = {
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
index ed32ba6..6e9b0e6 100644
--- a/src/expr/lookup.c
+++ b/src/expr/lookup.c
@@ -258,7 +258,7 @@ static void nftnl_expr_lookup_free(const struct nftnl_expr *e)
 {
 	struct nftnl_expr_lookup *lookup = nftnl_expr_data(e);
 
-	xfree(lookup->set_name);
+	nftnl_xfree(lookup->set_name);
 }
 
 struct expr_ops expr_ops_lookup = {
diff --git a/src/expr/match.c b/src/expr/match.c
index 2929b43..ec46394 100644
--- a/src/expr/match.c
+++ b/src/expr/match.c
@@ -50,7 +50,7 @@ nftnl_expr_match_set(struct nftnl_expr *e, uint16_t type,
 		break;
 	case NFTNL_EXPR_MT_INFO:
 		if (mt->data)
-			xfree(mt->data);
+			nftnl_xfree(mt->data);
 
 		mt->data = data;
 		mt->data_len = data_len;
@@ -147,7 +147,7 @@ static int nftnl_expr_match_parse(struct nftnl_expr *e, struct nlattr *attr)
 		void *match_data;
 
 		if (match->data)
-			xfree(match->data);
+			nftnl_xfree(match->data);
 
 		match_data = calloc(1, len);
 		if (match_data == NULL)
@@ -237,7 +237,7 @@ static void nftnl_expr_match_free(const struct nftnl_expr *e)
 {
 	struct nftnl_expr_match *match = nftnl_expr_data(e);
 
-	xfree(match->data);
+	nftnl_xfree(match->data);
 }
 
 struct expr_ops expr_ops_match = {
diff --git a/src/expr/target.c b/src/expr/target.c
index 68a7d8a..05f9e5a 100644
--- a/src/expr/target.c
+++ b/src/expr/target.c
@@ -50,7 +50,7 @@ nftnl_expr_target_set(struct nftnl_expr *e, uint16_t type,
 		break;
 	case NFTNL_EXPR_TG_INFO:
 		if (tg->data)
-			xfree(tg->data);
+			nftnl_xfree(tg->data);
 
 		tg->data = data;
 		tg->data_len = data_len;
@@ -147,7 +147,7 @@ static int nftnl_expr_target_parse(struct nftnl_expr *e, struct nlattr *attr)
 		void *target_data;
 
 		if (target->data)
-			xfree(target->data);
+			nftnl_xfree(target->data);
 
 		target_data = calloc(1, len);
 		if (target_data == NULL)
@@ -238,7 +238,7 @@ static void nftnl_expr_target_free(const struct nftnl_expr *e)
 {
 	struct nftnl_expr_target *target = nftnl_expr_data(e);
 
-	xfree(target->data);
+	nftnl_xfree(target->data);
 }
 
 struct expr_ops expr_ops_target = {
diff --git a/src/gen.c b/src/gen.c
index 115a105..576771a 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -37,7 +37,7 @@ EXPORT_SYMBOL_ALIAS(nftnl_gen_alloc, nft_gen_alloc);
 
 void nftnl_gen_free(const struct nftnl_gen *gen)
 {
-	xfree(gen);
+	nftnl_xfree(gen);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_gen_free, nft_gen_free);
 
diff --git a/src/mxml.c b/src/mxml.c
index 51dbf1b..5b2aa57 100644
--- a/src/mxml.c
+++ b/src/mxml.c
@@ -85,7 +85,7 @@ struct nftnl_expr *nftnl_mxml_expr_parse(mxml_node_t *node,
 		goto err_expr;
 
 	tree = mxmlLoadString(NULL, xml_text, MXML_OPAQUE_CALLBACK);
-	xfree(xml_text);
+	nftnl_xfree(xml_text);
 
 	if (tree == NULL)
 		goto err_expr;
diff --git a/src/rule.c b/src/rule.c
index 8ee8648..8158c26 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -72,13 +72,13 @@ void nftnl_rule_free(const struct nftnl_rule *r)
 		nftnl_expr_free(e);
 
 	if (r->table != NULL)
-		xfree(r->table);
+		nftnl_xfree(r->table);
 	if (r->chain != NULL)
-		xfree(r->chain);
+		nftnl_xfree(r->chain);
 	if (r->user.data != NULL)
-		xfree(r->user.data);
+		nftnl_xfree(r->user.data);
 
-	xfree(r);
+	nftnl_xfree(r);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_rule_free, nft_rule_free);
 
@@ -96,13 +96,13 @@ void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
 	switch (attr) {
 	case NFTNL_RULE_TABLE:
 		if (r->table) {
-			xfree(r->table);
+			nftnl_xfree(r->table);
 			r->table = NULL;
 		}
 		break;
 	case NFTNL_RULE_CHAIN:
 		if (r->chain) {
-			xfree(r->chain);
+			nftnl_xfree(r->chain);
 			r->chain = NULL;
 		}
 		break;
@@ -138,13 +138,13 @@ void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
 	switch(attr) {
 	case NFTNL_RULE_TABLE:
 		if (r->table)
-			xfree(r->table);
+			nftnl_xfree(r->table);
 
 		r->table = strdup(data);
 		break;
 	case NFTNL_RULE_CHAIN:
 		if (r->chain)
-			xfree(r->chain);
+			nftnl_xfree(r->chain);
 
 		r->chain = strdup(data);
 		break;
@@ -165,7 +165,7 @@ void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
 		break;
 	case NFTNL_RULE_USERDATA:
 		if (r->user.data != NULL)
-			xfree(r->user.data);
+			nftnl_xfree(r->user.data);
 
 		r->user.data = malloc(data_len);
 		if (!r->user.data)
@@ -434,12 +434,12 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
 		return -1;
 
 	if (tb[NFTA_RULE_TABLE]) {
-		xfree(r->table);
+		nftnl_xfree(r->table);
 		r->table = strdup(mnl_attr_get_str(tb[NFTA_RULE_TABLE]));
 		r->flags |= (1 << NFTNL_RULE_TABLE);
 	}
 	if (tb[NFTA_RULE_CHAIN]) {
-		xfree(r->chain);
+		nftnl_xfree(r->chain);
 		r->chain = strdup(mnl_attr_get_str(tb[NFTA_RULE_CHAIN]));
 		r->flags |= (1 << NFTNL_RULE_CHAIN);
 	}
@@ -460,7 +460,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
 			mnl_attr_get_payload(tb[NFTA_RULE_USERDATA]);
 
 		if (r->user.data)
-			xfree(r->user.data);
+			nftnl_xfree(r->user.data);
 
 		r->user.len = mnl_attr_get_payload_len(tb[NFTA_RULE_USERDATA]);
 
@@ -1054,7 +1054,7 @@ EXPORT_SYMBOL_ALIAS(nftnl_expr_iter_next, nft_rule_expr_iter_next);
 
 void nftnl_expr_iter_destroy(struct nftnl_expr_iter *iter)
 {
-	xfree(iter);
+	nftnl_xfree(iter);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_expr_iter_destroy, nft_rule_expr_iter_destroy);
 
@@ -1084,7 +1084,7 @@ void nftnl_rule_list_free(struct nftnl_rule_list *list)
 		list_del(&r->head);
 		nftnl_rule_free(r);
 	}
-	xfree(list);
+	nftnl_xfree(list);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_rule_list_free, nft_rule_list_free);
 
@@ -1175,6 +1175,6 @@ EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_next, nft_rule_list_iter_next);
 
 void nftnl_rule_list_iter_destroy(const struct nftnl_rule_list_iter *iter)
 {
-	xfree(iter);
+	nftnl_xfree(iter);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_destroy, nft_rule_list_iter_destroy);
diff --git a/src/ruleset.c b/src/ruleset.c
index 414b7c4..6ec38c6 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -74,7 +74,7 @@ void nftnl_ruleset_free(const struct nftnl_ruleset *r)
 		nftnl_set_list_free(r->set_list);
 	if (r->flags & (1 << NFTNL_RULESET_RULELIST))
 		nftnl_rule_list_free(r->rule_list);
-	xfree(r);
+	nftnl_xfree(r);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_ruleset_free, nft_ruleset_free);
 
diff --git a/src/set.c b/src/set.c
index dbea93b..025d50c 100644
--- a/src/set.c
+++ b/src/set.c
@@ -45,15 +45,15 @@ void nftnl_set_free(const struct nftnl_set *s)
 	struct nftnl_set_elem *elem, *tmp;
 
 	if (s->table != NULL)
-		xfree(s->table);
+		nftnl_xfree(s->table);
 	if (s->name != NULL)
-		xfree(s->name);
+		nftnl_xfree(s->name);
 
 	list_for_each_entry_safe(elem, tmp, &s->element_list, head) {
 		list_del(&elem->head);
 		nftnl_set_elem_free(elem);
 	}
-	xfree(s);
+	nftnl_xfree(s);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_set_free, nft_set_free);
 
@@ -69,14 +69,14 @@ void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
 	case NFTNL_SET_TABLE:
 		if (s->flags & (1 << NFTNL_SET_TABLE))
 			if (s->table) {
-				xfree(s->table);
+				nftnl_xfree(s->table);
 				s->table = NULL;
 			}
 		break;
 	case NFTNL_SET_NAME:
 		if (s->flags & (1 << NFTNL_SET_NAME))
 			if (s->name) {
-				xfree(s->name);
+				nftnl_xfree(s->name);
 				s->name = NULL;
 			}
 		break;
@@ -124,13 +124,13 @@ void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
 	switch(attr) {
 	case NFTNL_SET_TABLE:
 		if (s->table)
-			xfree(s->table);
+			nftnl_xfree(s->table);
 
 		s->table = strdup(data);
 		break;
 	case NFTNL_SET_NAME:
 		if (s->name)
-			xfree(s->name);
+			nftnl_xfree(s->name);
 
 		s->name = strdup(data);
 		break;
@@ -435,12 +435,12 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
 		return -1;
 
 	if (tb[NFTA_SET_TABLE]) {
-		xfree(s->table);
+		nftnl_xfree(s->table);
 		s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE]));
 		s->flags |= (1 << NFTNL_SET_TABLE);
 	}
 	if (tb[NFTA_SET_NAME]) {
-		xfree(s->name);
+		nftnl_xfree(s->name);
 		s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME]));
 		s->flags |= (1 << NFTNL_SET_NAME);
 	}
@@ -1087,7 +1087,7 @@ void nftnl_set_list_free(struct nftnl_set_list *list)
 		list_del(&s->head);
 		nftnl_set_free(s);
 	}
-	xfree(list);
+	nftnl_xfree(list);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_set_list_free, nft_set_list_free);
 
@@ -1177,7 +1177,7 @@ EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_next, nft_set_list_iter_next);
 
 void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter)
 {
-	xfree(iter);
+	nftnl_xfree(iter);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_destroy, nft_set_list_iter_destroy);
 
diff --git a/src/set_elem.c b/src/set_elem.c
index b9c7e1e..c8ffeae 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -43,7 +43,7 @@ void nftnl_set_elem_free(struct nftnl_set_elem *s)
 {
 	if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
 		if (s->data.chain) {
-			xfree(s->data.chain);
+			nftnl_xfree(s->data.chain);
 			s->data.chain = NULL;
 		}
 	}
@@ -52,9 +52,9 @@ void nftnl_set_elem_free(struct nftnl_set_elem *s)
 		nftnl_expr_free(s->expr);
 
 	if (s->flags & (1 << NFTNL_SET_ELEM_USERDATA))
-		xfree(s->user.data);
+		nftnl_xfree(s->user.data);
 
-	xfree(s);
+	nftnl_xfree(s);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_set_elem_free, nft_set_elem_free);
 
@@ -70,7 +70,7 @@ void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
 	case NFTNL_SET_ELEM_CHAIN:
 		if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
 			if (s->data.chain) {
-				xfree(s->data.chain);
+				nftnl_xfree(s->data.chain);
 				s->data.chain = NULL;
 			}
 		}
@@ -113,7 +113,7 @@ void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
 		break;
 	case NFTNL_SET_ELEM_CHAIN:	/* NFTA_SET_ELEM_DATA */
 		if (s->data.chain)
-			xfree(s->data.chain);
+			nftnl_xfree(s->data.chain);
 
 		s->data.chain = strdup(data);
 		break;
@@ -126,7 +126,7 @@ void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
 		break;
 	case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
 		if (s->user.data != NULL)
-			xfree(s->user.data);
+			nftnl_xfree(s->user.data);
 
 		s->user.data = malloc(data_len);
 		if (!s->user.data)
@@ -399,7 +399,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
 			mnl_attr_get_payload(tb[NFTA_SET_ELEM_USERDATA]);
 
 		if (e->user.data)
-			xfree(e->user.data);
+			nftnl_xfree(e->user.data);
 
 		e->user.len  = mnl_attr_get_payload_len(tb[NFTA_SET_ELEM_USERDATA]);
 		e->user.data = malloc(e->user.len);
@@ -471,13 +471,13 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
 		return -1;
 
 	if (tb[NFTA_SET_ELEM_LIST_TABLE]) {
-		xfree(s->table);
+		nftnl_xfree(s->table);
 		s->table =
 			strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE]));
 		s->flags |= (1 << NFTNL_SET_TABLE);
 	}
 	if (tb[NFTA_SET_ELEM_LIST_SET]) {
-		xfree(s->name);
+		nftnl_xfree(s->name);
 		s->name =
 			strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET]));
 		s->flags |= (1 << NFTNL_SET_NAME);
@@ -866,7 +866,7 @@ EXPORT_SYMBOL_ALIAS(nftnl_set_elems_iter_next, nft_set_elems_iter_next);
 
 void nftnl_set_elems_iter_destroy(struct nftnl_set_elems_iter *iter)
 {
-	xfree(iter);
+	nftnl_xfree(iter);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_set_elems_iter_destroy, nft_set_elems_iter_destroy);
 
diff --git a/src/table.c b/src/table.c
index 42fe49f..7363853 100644
--- a/src/table.c
+++ b/src/table.c
@@ -45,9 +45,9 @@ EXPORT_SYMBOL_ALIAS(nftnl_table_alloc, nft_table_alloc);
 void nftnl_table_free(const struct nftnl_table *t)
 {
 	if (t->flags & (1 << NFTNL_TABLE_NAME))
-		xfree(t->name);
+		nftnl_xfree(t->name);
 
-	xfree(t);
+	nftnl_xfree(t);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_table_free, nft_table_free);
 
@@ -65,7 +65,7 @@ void nftnl_table_unset(struct nftnl_table *t, uint16_t attr)
 	switch (attr) {
 	case NFTNL_TABLE_NAME:
 		if (t->name) {
-			xfree(t->name);
+			nftnl_xfree(t->name);
 			t->name = NULL;
 		}
 		break;
@@ -95,7 +95,7 @@ void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
 	switch (attr) {
 	case NFTNL_TABLE_NAME:
 		if (t->name)
-			xfree(t->name);
+			nftnl_xfree(t->name);
 
 		t->name = strdup(data);
 		break;
@@ -229,7 +229,7 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
 		return -1;
 
 	if (tb[NFTA_TABLE_NAME]) {
-		xfree(t->name);
+		nftnl_xfree(t->name);
 		t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
 		t->flags |= (1 << NFTNL_TABLE_NAME);
 	}
@@ -497,7 +497,7 @@ void nftnl_table_list_free(struct nftnl_table_list *list)
 		list_del(&r->head);
 		nftnl_table_free(r);
 	}
-	xfree(list);
+	nftnl_xfree(list);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_table_list_free, nft_table_list_free);
 
@@ -582,6 +582,6 @@ EXPORT_SYMBOL_ALIAS(nftnl_table_list_iter_next, nft_table_list_iter_next);
 
 void nftnl_table_list_iter_destroy(const struct nftnl_table_list_iter *iter)
 {
-	xfree(iter);
+	nftnl_xfree(iter);
 }
 EXPORT_SYMBOL_ALIAS(nftnl_table_list_iter_destroy, nft_table_list_iter_destroy);
diff --git a/src/trace.c b/src/trace.c
index 921fa21..1933bb8 100644
--- a/src/trace.c
+++ b/src/trace.c
@@ -61,13 +61,13 @@ struct nftnl_trace *nftnl_trace_alloc(void)
 EXPORT_SYMBOL(nftnl_trace_free);
 void nftnl_trace_free(const struct nftnl_trace *t)
 {
-	xfree(t->chain);
-	xfree(t->table);
-	xfree(t->jump_target);
-	xfree(t->ll.data);
-	xfree(t->nh.data);
-	xfree(t->th.data);
-	xfree(t);
+	nftnl_xfree(t->chain);
+	nftnl_xfree(t->table);
+	nftnl_xfree(t->jump_target);
+	nftnl_xfree(t->ll.data);
+	nftnl_xfree(t->nh.data);
+	nftnl_xfree(t->th.data);
+	nftnl_xfree(t);
 }
 
 EXPORT_SYMBOL(nftnl_trace_is_set);
diff --git a/src/udata.c b/src/udata.c
index 60c2f34..ec1f7dc 100644
--- a/src/udata.c
+++ b/src/udata.c
@@ -32,7 +32,7 @@ EXPORT_SYMBOL(nftnl_udata_buf_alloc);
 
 void nftnl_udata_buf_free(const struct nftnl_udata_buf *buf)
 {
-	xfree(buf);
+	nftnl_xfree(buf);
 }
 EXPORT_SYMBOL(nftnl_udata_buf_free);
 
diff --git a/src/utils.c b/src/utils.c
index 22710b9..f29416e 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -264,7 +264,7 @@ int nftnl_fprintf(FILE *fp, const void *obj, uint32_t cmd, uint32_t type,
 
 out:
 	if (buf != _buf)
-		xfree(buf);
+		nftnl_xfree(buf);
 
 	return ret;
 }
-- 
2.7.3

