![Baruch Siach](/assets/img/avatar_default.png)
Add SHA256 hash, and a license hash. Drop mxml dependency since XML support has been removed upstream. Refresh the patch. Cc: Yegor Yefremov <yegorslists@googlemail.com> Signed-off-by: Baruch Siach <baruch@tkos.co.il> Signed-off-by: Peter Korsgaard <peter@korsgaard.com>
912 lines
26 KiB
Diff
912 lines
26 KiB
Diff
From a51cdce6fd271a5cc393c5e56996846d9c453d6a 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.7]
|
|
Signed-off-by: Gustavo Zacarias <gustavo@zacarias.com.ar>
|
|
[baruch: update for version 1.0.9]
|
|
Signed-off-by: Baruch Siach <baruch@tkos.co.il>
|
|
---
|
|
include/utils.h | 2 +-
|
|
src/chain.c | 36 ++++++++++++++++++------------------
|
|
src/common.c | 2 +-
|
|
src/expr.c | 4 ++--
|
|
src/expr/data_reg.c | 2 +-
|
|
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/object.c | 14 +++++++-------
|
|
src/rule.c | 32 ++++++++++++++++----------------
|
|
src/ruleset.c | 2 +-
|
|
src/set.c | 28 ++++++++++++++--------------
|
|
src/set_elem.c | 28 ++++++++++++++--------------
|
|
src/table.c | 14 +++++++-------
|
|
src/trace.c | 14 +++++++-------
|
|
src/udata.c | 2 +-
|
|
src/utils.c | 2 +-
|
|
21 files changed, 104 insertions(+), 104 deletions(-)
|
|
|
|
diff --git a/include/utils.h b/include/utils.h
|
|
index 3cc659652fe2..820556715013 100644
|
|
--- a/include/utils.h
|
|
+++ b/include/utils.h
|
|
@@ -17,7 +17,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 eff518680873..03033bbcb93b 100644
|
|
--- a/src/chain.c
|
|
+++ b/src/chain.c
|
|
@@ -97,14 +97,14 @@ EXPORT_SYMBOL(nftnl_chain_free);
|
|
void nftnl_chain_free(const struct nftnl_chain *c)
|
|
{
|
|
if (c->flags & (1 << NFTNL_CHAIN_NAME))
|
|
- xfree(c->name);
|
|
+ nftnl_xfree(c->name);
|
|
if (c->flags & (1 << NFTNL_CHAIN_TABLE))
|
|
- xfree(c->table);
|
|
+ nftnl_xfree(c->table);
|
|
if (c->flags & (1 << NFTNL_CHAIN_TYPE))
|
|
- xfree(c->type);
|
|
+ nftnl_xfree(c->type);
|
|
if (c->flags & (1 << NFTNL_CHAIN_DEV))
|
|
- xfree(c->dev);
|
|
- xfree(c);
|
|
+ nftnl_xfree(c->dev);
|
|
+ nftnl_xfree(c);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_chain_is_set);
|
|
@@ -121,15 +121,15 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
|
|
|
|
switch (attr) {
|
|
case NFTNL_CHAIN_NAME:
|
|
- xfree(c->name);
|
|
+ nftnl_xfree(c->name);
|
|
break;
|
|
case NFTNL_CHAIN_TABLE:
|
|
- xfree(c->table);
|
|
+ nftnl_xfree(c->table);
|
|
break;
|
|
case NFTNL_CHAIN_USE:
|
|
break;
|
|
case NFTNL_CHAIN_TYPE:
|
|
- xfree(c->type);
|
|
+ nftnl_xfree(c->type);
|
|
break;
|
|
case NFTNL_CHAIN_HOOKNUM:
|
|
case NFTNL_CHAIN_PRIO:
|
|
@@ -140,7 +140,7 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
|
|
case NFTNL_CHAIN_FAMILY:
|
|
break;
|
|
case NFTNL_CHAIN_DEV:
|
|
- xfree(c->dev);
|
|
+ nftnl_xfree(c->dev);
|
|
break;
|
|
default:
|
|
return;
|
|
@@ -169,7 +169,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
|
|
switch(attr) {
|
|
case NFTNL_CHAIN_NAME:
|
|
if (c->flags & (1 << NFTNL_CHAIN_NAME))
|
|
- xfree(c->name);
|
|
+ nftnl_xfree(c->name);
|
|
|
|
c->name = strdup(data);
|
|
if (!c->name)
|
|
@@ -177,7 +177,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
|
|
break;
|
|
case NFTNL_CHAIN_TABLE:
|
|
if (c->flags & (1 << NFTNL_CHAIN_TABLE))
|
|
- xfree(c->table);
|
|
+ nftnl_xfree(c->table);
|
|
|
|
c->table = strdup(data);
|
|
if (!c->table)
|
|
@@ -209,7 +209,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
|
|
break;
|
|
case NFTNL_CHAIN_TYPE:
|
|
if (c->flags & (1 << NFTNL_CHAIN_TYPE))
|
|
- xfree(c->type);
|
|
+ nftnl_xfree(c->type);
|
|
|
|
c->type = strdup(data);
|
|
if (!c->type)
|
|
@@ -217,7 +217,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
|
|
break;
|
|
case NFTNL_CHAIN_DEV:
|
|
if (c->flags & (1 << NFTNL_CHAIN_DEV))
|
|
- xfree(c->dev);
|
|
+ nftnl_xfree(c->dev);
|
|
|
|
c->dev = strdup(data);
|
|
if (!c->dev)
|
|
@@ -541,7 +541,7 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
|
|
|
|
if (tb[NFTA_CHAIN_NAME]) {
|
|
if (c->flags & (1 << NFTNL_CHAIN_NAME))
|
|
- xfree(c->name);
|
|
+ nftnl_xfree(c->name);
|
|
c->name = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_NAME]));
|
|
if (!c->name)
|
|
return -1;
|
|
@@ -549,7 +549,7 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
|
|
}
|
|
if (tb[NFTA_CHAIN_TABLE]) {
|
|
if (c->flags & (1 << NFTNL_CHAIN_TABLE))
|
|
- xfree(c->table);
|
|
+ nftnl_xfree(c->table);
|
|
c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE]));
|
|
if (!c->table)
|
|
return -1;
|
|
@@ -579,7 +579,7 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
|
|
}
|
|
if (tb[NFTA_CHAIN_TYPE]) {
|
|
if (c->flags & (1 << NFTNL_CHAIN_TYPE))
|
|
- xfree(c->type);
|
|
+ nftnl_xfree(c->type);
|
|
c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE]));
|
|
if (!c->type)
|
|
return -1;
|
|
@@ -902,7 +902,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(nftnl_chain_list_is_empty);
|
|
@@ -988,5 +988,5 @@ struct nftnl_chain *nftnl_chain_list_iter_next(struct nftnl_chain_list_iter *ite
|
|
EXPORT_SYMBOL(nftnl_chain_list_iter_destroy);
|
|
void nftnl_chain_list_iter_destroy(struct nftnl_chain_list_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
diff --git a/src/common.c b/src/common.c
|
|
index 561c95439114..d0124134ea29 100644
|
|
--- a/src/common.c
|
|
+++ b/src/common.c
|
|
@@ -68,7 +68,7 @@ struct nftnl_parse_err *nftnl_parse_err_alloc(void)
|
|
EXPORT_SYMBOL(nftnl_parse_err_free);
|
|
void nftnl_parse_err_free(struct nftnl_parse_err *err)
|
|
{
|
|
- xfree(err);
|
|
+ nftnl_xfree(err);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_parse_perror);
|
|
diff --git a/src/expr.c b/src/expr.c
|
|
index 62565e046996..97f16275f44f 100644
|
|
--- a/src/expr.c
|
|
+++ b/src/expr.c
|
|
@@ -51,7 +51,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(nftnl_expr_is_set);
|
|
@@ -270,7 +270,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 1b28b291617b..8c7abdb91d21 100644
|
|
--- a/src/expr/data_reg.c
|
|
+++ b/src/expr/data_reg.c
|
|
@@ -379,7 +379,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 160d0e15c151..614124d841c7 100644
|
|
--- a/src/expr/dynset.c
|
|
+++ b/src/expr/dynset.c
|
|
@@ -330,7 +330,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);
|
|
}
|
|
|
|
static bool nftnl_expr_dynset_cmp(const struct nftnl_expr *e1,
|
|
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
|
|
index b0570bd539a4..6a0732c38ebd 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 (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN))
|
|
- xfree(imm->data.chain);
|
|
+ nftnl_xfree(imm->data.chain);
|
|
|
|
imm->data.chain = strdup(data);
|
|
if (!imm->data.chain)
|
|
diff --git a/src/expr/log.c b/src/expr/log.c
|
|
index 86d965136cd4..0624a7712237 100644
|
|
--- a/src/expr/log.c
|
|
+++ b/src/expr/log.c
|
|
@@ -39,7 +39,7 @@ static int nftnl_expr_log_set(struct nftnl_expr *e, uint16_t type,
|
|
switch(type) {
|
|
case NFTNL_EXPR_LOG_PREFIX:
|
|
if (log->flags & (1 << NFTNL_EXPR_LOG_PREFIX))
|
|
- xfree(log->prefix);
|
|
+ nftnl_xfree(log->prefix);
|
|
|
|
log->prefix = strdup(data);
|
|
if (!log->prefix)
|
|
@@ -155,7 +155,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]));
|
|
if (!log->prefix)
|
|
@@ -317,7 +317,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);
|
|
}
|
|
|
|
static bool nftnl_expr_log_cmp(const struct nftnl_expr *e1,
|
|
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
|
|
index 5fcb81f3a7a2..45f5dfefd33f 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);
|
|
}
|
|
|
|
static bool nftnl_expr_lookup_cmp(const struct nftnl_expr *e1,
|
|
diff --git a/src/expr/match.c b/src/expr/match.c
|
|
index dd09e1e85192..09e35c528aca 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 (e->flags & (1 << NFTNL_EXPR_MT_INFO))
|
|
- 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 (e->flags & (1 << NFTNL_EXPR_MT_INFO))
|
|
- xfree(match->data);
|
|
+ nftnl_xfree(match->data);
|
|
|
|
match_data = calloc(1, len);
|
|
if (match_data == NULL)
|
|
@@ -217,7 +217,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);
|
|
}
|
|
|
|
static bool nftnl_expr_match_cmp(const struct nftnl_expr *e1,
|
|
diff --git a/src/expr/target.c b/src/expr/target.c
|
|
index ed4bf7df6328..5e28925debeb 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 (e->flags & (1 << NFTNL_EXPR_TG_INFO))
|
|
- 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)
|
|
@@ -217,7 +217,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);
|
|
}
|
|
|
|
static bool nftnl_expr_target_cmp(const struct nftnl_expr *e1,
|
|
diff --git a/src/gen.c b/src/gen.c
|
|
index f92180c7baf6..4fe078d3832c 100644
|
|
--- a/src/gen.c
|
|
+++ b/src/gen.c
|
|
@@ -38,7 +38,7 @@ struct nftnl_gen *nftnl_gen_alloc(void)
|
|
EXPORT_SYMBOL(nftnl_gen_free);
|
|
void nftnl_gen_free(const struct nftnl_gen *gen)
|
|
{
|
|
- xfree(gen);
|
|
+ nftnl_xfree(gen);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_gen_is_set);
|
|
diff --git a/src/object.c b/src/object.c
|
|
index 30000f748da4..1b5965d7abdc 100644
|
|
--- a/src/object.c
|
|
+++ b/src/object.c
|
|
@@ -50,11 +50,11 @@ EXPORT_SYMBOL(nftnl_obj_free);
|
|
void nftnl_obj_free(const struct nftnl_obj *obj)
|
|
{
|
|
if (obj->flags & (1 << NFTNL_OBJ_TABLE))
|
|
- xfree(obj->table);
|
|
+ nftnl_xfree(obj->table);
|
|
if (obj->flags & (1 << NFTNL_OBJ_NAME))
|
|
- xfree(obj->name);
|
|
+ nftnl_xfree(obj->name);
|
|
|
|
- xfree(obj);
|
|
+ nftnl_xfree(obj);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_obj_is_set);
|
|
@@ -77,11 +77,11 @@ void nftnl_obj_set_data(struct nftnl_obj *obj, uint16_t attr,
|
|
|
|
switch (attr) {
|
|
case NFTNL_OBJ_TABLE:
|
|
- xfree(obj->table);
|
|
+ nftnl_xfree(obj->table);
|
|
obj->table = strdup(data);
|
|
break;
|
|
case NFTNL_OBJ_NAME:
|
|
- xfree(obj->name);
|
|
+ nftnl_xfree(obj->name);
|
|
obj->name = strdup(data);
|
|
break;
|
|
case NFTNL_OBJ_TYPE:
|
|
@@ -523,7 +523,7 @@ void nftnl_obj_list_free(struct nftnl_obj_list *list)
|
|
list_del(&r->head);
|
|
nftnl_obj_free(r);
|
|
}
|
|
- xfree(list);
|
|
+ nftnl_xfree(list);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_obj_list_is_empty);
|
|
@@ -610,5 +610,5 @@ struct nftnl_obj *nftnl_obj_list_iter_next(struct nftnl_obj_list_iter *iter)
|
|
EXPORT_SYMBOL(nftnl_obj_list_iter_destroy);
|
|
void nftnl_obj_list_iter_destroy(struct nftnl_obj_list_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
diff --git a/src/rule.c b/src/rule.c
|
|
index e4cba1f7a352..911f327a6f9f 100644
|
|
--- a/src/rule.c
|
|
+++ b/src/rule.c
|
|
@@ -75,13 +75,13 @@ void nftnl_rule_free(const struct nftnl_rule *r)
|
|
nftnl_expr_free(e);
|
|
|
|
if (r->flags & (1 << (NFTNL_RULE_TABLE)))
|
|
- xfree(r->table);
|
|
+ nftnl_xfree(r->table);
|
|
if (r->flags & (1 << (NFTNL_RULE_CHAIN)))
|
|
- xfree(r->chain);
|
|
+ nftnl_xfree(r->chain);
|
|
if (r->flags & (1 << (NFTNL_RULE_USERDATA)))
|
|
- xfree(r->user.data);
|
|
+ nftnl_xfree(r->user.data);
|
|
|
|
- xfree(r);
|
|
+ nftnl_xfree(r);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_rule_is_set);
|
|
@@ -98,10 +98,10 @@ void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
|
|
|
|
switch (attr) {
|
|
case NFTNL_RULE_TABLE:
|
|
- xfree(r->table);
|
|
+ nftnl_xfree(r->table);
|
|
break;
|
|
case NFTNL_RULE_CHAIN:
|
|
- xfree(r->chain);
|
|
+ nftnl_xfree(r->chain);
|
|
break;
|
|
case NFTNL_RULE_HANDLE:
|
|
case NFTNL_RULE_COMPAT_PROTO:
|
|
@@ -111,7 +111,7 @@ void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
|
|
case NFTNL_RULE_ID:
|
|
break;
|
|
case NFTNL_RULE_USERDATA:
|
|
- xfree(r->user.data);
|
|
+ nftnl_xfree(r->user.data);
|
|
break;
|
|
}
|
|
|
|
@@ -137,7 +137,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
|
|
switch(attr) {
|
|
case NFTNL_RULE_TABLE:
|
|
if (r->flags & (1 << NFTNL_RULE_TABLE))
|
|
- xfree(r->table);
|
|
+ nftnl_xfree(r->table);
|
|
|
|
r->table = strdup(data);
|
|
if (!r->table)
|
|
@@ -145,7 +145,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
|
|
break;
|
|
case NFTNL_RULE_CHAIN:
|
|
if (r->flags & (1 << NFTNL_RULE_CHAIN))
|
|
- xfree(r->chain);
|
|
+ nftnl_xfree(r->chain);
|
|
|
|
r->chain = strdup(data);
|
|
if (!r->chain)
|
|
@@ -168,7 +168,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
|
|
break;
|
|
case NFTNL_RULE_USERDATA:
|
|
if (r->flags & (1 << NFTNL_RULE_USERDATA))
|
|
- xfree(r->user.data);
|
|
+ nftnl_xfree(r->user.data);
|
|
|
|
r->user.data = malloc(data_len);
|
|
if (!r->user.data)
|
|
@@ -453,7 +453,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
|
|
|
|
if (tb[NFTA_RULE_TABLE]) {
|
|
if (r->flags & (1 << NFTNL_RULE_TABLE))
|
|
- xfree(r->table);
|
|
+ nftnl_xfree(r->table);
|
|
r->table = strdup(mnl_attr_get_str(tb[NFTA_RULE_TABLE]));
|
|
if (!r->table)
|
|
return -1;
|
|
@@ -461,7 +461,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
|
|
}
|
|
if (tb[NFTA_RULE_CHAIN]) {
|
|
if (r->flags & (1 << NFTNL_RULE_CHAIN))
|
|
- xfree(r->chain);
|
|
+ nftnl_xfree(r->chain);
|
|
r->chain = strdup(mnl_attr_get_str(tb[NFTA_RULE_CHAIN]));
|
|
if (!r->chain)
|
|
return -1;
|
|
@@ -490,7 +490,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
|
|
mnl_attr_get_payload(tb[NFTA_RULE_USERDATA]);
|
|
|
|
if (r->flags & (1 << NFTNL_RULE_USERDATA))
|
|
- xfree(r->user.data);
|
|
+ nftnl_xfree(r->user.data);
|
|
|
|
r->user.len = mnl_attr_get_payload_len(tb[NFTA_RULE_USERDATA]);
|
|
|
|
@@ -910,7 +910,7 @@ struct nftnl_expr *nftnl_expr_iter_next(struct nftnl_expr_iter *iter)
|
|
EXPORT_SYMBOL(nftnl_expr_iter_destroy);
|
|
void nftnl_expr_iter_destroy(struct nftnl_expr_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_rule_cmp);
|
|
@@ -971,7 +971,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(nftnl_rule_list_is_empty);
|
|
@@ -1063,5 +1063,5 @@ struct nftnl_rule *nftnl_rule_list_iter_next(struct nftnl_rule_list_iter *iter)
|
|
EXPORT_SYMBOL(nftnl_rule_list_iter_destroy);
|
|
void nftnl_rule_list_iter_destroy(const struct nftnl_rule_list_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
diff --git a/src/ruleset.c b/src/ruleset.c
|
|
index eb49fde582c2..1639cae68c61 100644
|
|
--- a/src/ruleset.c
|
|
+++ b/src/ruleset.c
|
|
@@ -72,7 +72,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(nftnl_ruleset_is_set);
|
|
diff --git a/src/set.c b/src/set.c
|
|
index ac24eae6bb16..2b758c4ec89a 100644
|
|
--- a/src/set.c
|
|
+++ b/src/set.c
|
|
@@ -46,17 +46,17 @@ void nftnl_set_free(const struct nftnl_set *s)
|
|
struct nftnl_set_elem *elem, *tmp;
|
|
|
|
if (s->flags & (1 << NFTNL_SET_TABLE))
|
|
- xfree(s->table);
|
|
+ nftnl_xfree(s->table);
|
|
if (s->flags & (1 << NFTNL_SET_NAME))
|
|
- xfree(s->name);
|
|
+ nftnl_xfree(s->name);
|
|
if (s->flags & (1 << NFTNL_SET_USERDATA))
|
|
- xfree(s->user.data);
|
|
+ nftnl_xfree(s->user.data);
|
|
|
|
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(nftnl_set_is_set);
|
|
@@ -73,10 +73,10 @@ void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
|
|
|
|
switch (attr) {
|
|
case NFTNL_SET_TABLE:
|
|
- xfree(s->table);
|
|
+ nftnl_xfree(s->table);
|
|
break;
|
|
case NFTNL_SET_NAME:
|
|
- xfree(s->name);
|
|
+ nftnl_xfree(s->name);
|
|
break;
|
|
case NFTNL_SET_FLAGS:
|
|
case NFTNL_SET_KEY_TYPE:
|
|
@@ -92,7 +92,7 @@ void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
|
|
case NFTNL_SET_GC_INTERVAL:
|
|
break;
|
|
case NFTNL_SET_USERDATA:
|
|
- xfree(s->user.data);
|
|
+ nftnl_xfree(s->user.data);
|
|
break;
|
|
default:
|
|
return;
|
|
@@ -125,7 +125,7 @@ int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
|
|
switch(attr) {
|
|
case NFTNL_SET_TABLE:
|
|
if (s->flags & (1 << NFTNL_SET_TABLE))
|
|
- xfree(s->table);
|
|
+ nftnl_xfree(s->table);
|
|
|
|
s->table = strdup(data);
|
|
if (!s->table)
|
|
@@ -133,7 +133,7 @@ int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
|
|
break;
|
|
case NFTNL_SET_NAME:
|
|
if (s->flags & (1 << NFTNL_SET_NAME))
|
|
- xfree(s->name);
|
|
+ nftnl_xfree(s->name);
|
|
|
|
s->name = strdup(data);
|
|
if (!s->name)
|
|
@@ -177,7 +177,7 @@ int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
|
|
break;
|
|
case NFTNL_SET_USERDATA:
|
|
if (s->flags & (1 << NFTNL_SET_USERDATA))
|
|
- xfree(s->user.data);
|
|
+ nftnl_xfree(s->user.data);
|
|
|
|
s->user.data = malloc(data_len);
|
|
if (!s->user.data)
|
|
@@ -478,7 +478,7 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
|
|
|
|
if (tb[NFTA_SET_TABLE]) {
|
|
if (s->flags & (1 << NFTNL_SET_TABLE))
|
|
- xfree(s->table);
|
|
+ nftnl_xfree(s->table);
|
|
s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE]));
|
|
if (!s->table)
|
|
return -1;
|
|
@@ -486,7 +486,7 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
|
|
}
|
|
if (tb[NFTA_SET_NAME]) {
|
|
if (s->flags & (1 << NFTNL_SET_NAME))
|
|
- xfree(s->name);
|
|
+ nftnl_xfree(s->name);
|
|
s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME]));
|
|
if (!s->name)
|
|
return -1;
|
|
@@ -982,7 +982,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(nftnl_set_list_is_empty);
|
|
@@ -1074,7 +1074,7 @@ struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter)
|
|
EXPORT_SYMBOL(nftnl_set_list_iter_destroy);
|
|
void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
|
|
static struct nftnl_set *nftnl_set_lookup(const char *this_set_name,
|
|
diff --git a/src/set_elem.c b/src/set_elem.c
|
|
index e02a38791c9a..100ccda699c6 100644
|
|
--- a/src/set_elem.c
|
|
+++ b/src/set_elem.c
|
|
@@ -43,18 +43,18 @@ EXPORT_SYMBOL(nftnl_set_elem_free);
|
|
void nftnl_set_elem_free(struct nftnl_set_elem *s)
|
|
{
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN))
|
|
- xfree(s->data.chain);
|
|
+ nftnl_xfree(s->data.chain);
|
|
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_EXPR))
|
|
nftnl_expr_free(s->expr);
|
|
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_USERDATA))
|
|
- xfree(s->user.data);
|
|
+ nftnl_xfree(s->user.data);
|
|
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_OBJREF))
|
|
- xfree(s->objref);
|
|
+ nftnl_xfree(s->objref);
|
|
|
|
- xfree(s);
|
|
+ nftnl_xfree(s);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_set_elem_is_set);
|
|
@@ -71,7 +71,7 @@ void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
|
|
|
|
switch (attr) {
|
|
case NFTNL_SET_ELEM_CHAIN:
|
|
- xfree(s->data.chain);
|
|
+ nftnl_xfree(s->data.chain);
|
|
break;
|
|
case NFTNL_SET_ELEM_FLAGS:
|
|
case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */
|
|
@@ -81,13 +81,13 @@ void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
|
|
case NFTNL_SET_ELEM_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */
|
|
break;
|
|
case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
|
|
- xfree(s->user.data);
|
|
+ nftnl_xfree(s->user.data);
|
|
break;
|
|
case NFTNL_SET_ELEM_EXPR:
|
|
nftnl_expr_free(s->expr);
|
|
break;
|
|
case NFTNL_SET_ELEM_OBJREF:
|
|
- xfree(s->objref);
|
|
+ nftnl_xfree(s->objref);
|
|
break;
|
|
default:
|
|
return;
|
|
@@ -113,7 +113,7 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
|
|
break;
|
|
case NFTNL_SET_ELEM_CHAIN: /* NFTA_SET_ELEM_DATA */
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN))
|
|
- xfree(s->data.chain);
|
|
+ nftnl_xfree(s->data.chain);
|
|
|
|
s->data.chain = strdup(data);
|
|
if (!s->data.chain)
|
|
@@ -128,7 +128,7 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
|
|
break;
|
|
case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_USERDATA))
|
|
- xfree(s->user.data);
|
|
+ nftnl_xfree(s->user.data);
|
|
|
|
s->user.data = malloc(data_len);
|
|
if (!s->user.data)
|
|
@@ -138,7 +138,7 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
|
|
break;
|
|
case NFTNL_SET_ELEM_OBJREF:
|
|
if (s->flags & (1 << NFTNL_SET_ELEM_OBJREF))
|
|
- xfree(s->objref);
|
|
+ nftnl_xfree(s->objref);
|
|
|
|
s->objref = strdup(data);
|
|
if (!s->objref)
|
|
@@ -431,7 +431,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->flags & (1 << NFTNL_RULE_USERDATA))
|
|
- 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);
|
|
@@ -516,7 +516,7 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
|
|
|
|
if (tb[NFTA_SET_ELEM_LIST_TABLE]) {
|
|
if (s->flags & (1 << NFTNL_SET_TABLE))
|
|
- xfree(s->table);
|
|
+ nftnl_xfree(s->table);
|
|
s->table =
|
|
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE]));
|
|
if (!s->table)
|
|
@@ -525,7 +525,7 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
|
|
}
|
|
if (tb[NFTA_SET_ELEM_LIST_SET]) {
|
|
if (s->flags & (1 << NFTNL_SET_NAME))
|
|
- xfree(s->name);
|
|
+ nftnl_xfree(s->name);
|
|
s->name =
|
|
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET]));
|
|
if (!s->name)
|
|
@@ -816,7 +816,7 @@ struct nftnl_set_elem *nftnl_set_elems_iter_next(struct nftnl_set_elems_iter *it
|
|
EXPORT_SYMBOL(nftnl_set_elems_iter_destroy);
|
|
void nftnl_set_elems_iter_destroy(struct nftnl_set_elems_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
|
|
static bool nftnl_attr_nest_overflow(struct nlmsghdr *nlh,
|
|
diff --git a/src/table.c b/src/table.c
|
|
index 7f97ca4e5807..7ac57c33021b 100644
|
|
--- a/src/table.c
|
|
+++ b/src/table.c
|
|
@@ -46,9 +46,9 @@ EXPORT_SYMBOL(nftnl_table_free);
|
|
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(nftnl_table_is_set);
|
|
@@ -65,7 +65,7 @@ void nftnl_table_unset(struct nftnl_table *t, uint16_t attr)
|
|
|
|
switch (attr) {
|
|
case NFTNL_TABLE_NAME:
|
|
- xfree(t->name);
|
|
+ nftnl_xfree(t->name);
|
|
break;
|
|
case NFTNL_TABLE_FLAGS:
|
|
case NFTNL_TABLE_FAMILY:
|
|
@@ -91,7 +91,7 @@ int nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
|
|
switch (attr) {
|
|
case NFTNL_TABLE_NAME:
|
|
if (t->flags & (1 << NFTNL_TABLE_NAME))
|
|
- xfree(t->name);
|
|
+ nftnl_xfree(t->name);
|
|
|
|
t->name = strdup(data);
|
|
if (!t->name)
|
|
@@ -230,7 +230,7 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
|
|
|
|
if (tb[NFTA_TABLE_NAME]) {
|
|
if (t->flags & (1 << NFTNL_TABLE_NAME))
|
|
- xfree(t->name);
|
|
+ nftnl_xfree(t->name);
|
|
t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
|
|
if (!t->name)
|
|
return -1;
|
|
@@ -452,7 +452,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(nftnl_table_list_is_empty);
|
|
@@ -538,5 +538,5 @@ struct nftnl_table *nftnl_table_list_iter_next(struct nftnl_table_list_iter *ite
|
|
EXPORT_SYMBOL(nftnl_table_list_iter_destroy);
|
|
void nftnl_table_list_iter_destroy(const struct nftnl_table_list_iter *iter)
|
|
{
|
|
- xfree(iter);
|
|
+ nftnl_xfree(iter);
|
|
}
|
|
diff --git a/src/trace.c b/src/trace.c
|
|
index f4264377508e..8a18391d83d1 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 6bd965161c43..049819304ef5 100644
|
|
--- a/src/udata.c
|
|
+++ b/src/udata.c
|
|
@@ -33,7 +33,7 @@ struct nftnl_udata_buf *nftnl_udata_buf_alloc(uint32_t data_size)
|
|
EXPORT_SYMBOL(nftnl_udata_buf_free);
|
|
void nftnl_udata_buf_free(const struct nftnl_udata_buf *buf)
|
|
{
|
|
- xfree(buf);
|
|
+ nftnl_xfree(buf);
|
|
}
|
|
|
|
EXPORT_SYMBOL(nftnl_udata_buf_len);
|
|
diff --git a/src/utils.c b/src/utils.c
|
|
index 3e449609395e..08f668f56a95 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.15.1
|
|
|