cirros-testvm/src-cirros/buildroot-2015.05/package/libnftnl/0001-Rename-xfree-to-libnftnl_xfree-to-avoid-symbol-namin.patch

   1 From 85dfe7dcd20c54e6d75d66a400f7ae038a52239b Mon Sep 17 00:00:00 2001
   2 From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
   3 Date: Mon, 29 Dec 2014 15:31:40 +0100
   4 Subject: [PATCH 1/2] Rename xfree() to libnftnl_xfree() to avoid symbol naming
   5  conflict
   6
   7 When ELF binaries and shared libraries are used, the internal
   8 functions of libnftnl such as xfree() are not visible to the outside
   9 world (their visibility is 'hidden'). Therefore, the fact that other
  10 programs (especially nftables) may have symbols with the same name
  11 does not cause any problem.
  12
  13 However, when doing static linking on a non-ELF platform (such as
  14 Blackfin, which uses the FLAT binary format), there is no way of
  15 encoding this visibility. Therefore, the xfree() symbols of libnftnl
  16 becomes visible to the outside world, causing a conflict with the
  17 xfree() symbol defined by nftables.
  18
  19 To solve this, this patch renames the libnftnl xfree() function to
  20 libnftnl_xfree().
  21
  22 Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
  23 [Gustavo: update for version 1.0.3]
  24
  25 Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
  26 ---
  27  src/chain.c          | 18 +++++++++---------
  28  src/common.c         |  2 +-
  29  src/expr.c           |  2 +-
  30  src/expr/data_reg.c  |  2 +-
  31  src/expr/immediate.c |  2 +-
  32  src/expr/log.c       |  6 +++---
  33  src/expr/match.c     |  6 +++---
  34  src/expr/target.c    |  6 +++---
  35  src/gen.c            |  2 +-
  36  src/internal.h       |  2 +-
  37  src/mxml.c           |  2 +-
  38  src/rule.c           | 24 ++++++++++++------------
  39  src/ruleset.c        |  2 +-
  40  src/set.c            | 18 +++++++++---------
  41  src/set_elem.c       | 10 +++++-----
  42  src/table.c          | 12 ++++++------
  43  src/utils.c          |  2 +-
  44  17 files changed, 59 insertions(+), 59 deletions(-)
  45
  46 diff --git a/src/chain.c b/src/chain.c
  47 index b67385e..9ccde54 100644
  48 --- a/src/chain.c
  49 +++ b/src/chain.c
  50 @@ -89,11 +89,11 @@ EXPORT_SYMBOL(nft_chain_alloc);
  51  void nft_chain_free(struct nft_chain *c)
  52  {
  53         if (c->table != NULL)
  54 -               xfree(c->table);
  55 +               nftnl_xfree(c->table);
  56         if (c->type != NULL)
  57 -               xfree(c->type);
  58 +               nftnl_xfree(c->type);
  59
  60 -       xfree(c);
  61 +       nftnl_xfree(c);
  62  }
  63  EXPORT_SYMBOL(nft_chain_free);
  64
  65 @@ -111,7 +111,7 @@ void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr)
  66         switch (attr) {
  67         case NFT_CHAIN_ATTR_TABLE:
  68                 if (c->table) {
  69 -                       xfree(c->table);
  70 +                       nftnl_xfree(c->table);
  71                         c->table = NULL;
  72                 }
  73                 break;
  74 @@ -119,7 +119,7 @@ void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr)
  75                 break;
  76         case NFT_CHAIN_ATTR_TYPE:
  77                 if (c->type) {
  78 -                       xfree(c->type);
  79 +                       nftnl_xfree(c->type);
  80                         c->type = NULL;
  81                 }
  82                 break;
  83 @@ -164,7 +164,7 @@ void nft_chain_attr_set_data(struct nft_chain *c, uint16_t attr,
  84                 break;
  85         case NFT_CHAIN_ATTR_TABLE:
  86                 if (c->table)
  87 -                       xfree(c->table);
  88 +                       nftnl_xfree(c->table);
  89
  90                 c->table = strdup(data);
  91                 break;
  92 @@ -194,7 +194,7 @@ void nft_chain_attr_set_data(struct nft_chain *c, uint16_t attr,
  93                 break;
  94         case NFT_CHAIN_ATTR_TYPE:
  95                 if (c->type)
  96 -                       xfree(c->type);
  97 +                       nftnl_xfree(c->type);
  98
  99                 c->type = strdup(data);
 100                 break;
 101 @@ -915,7 +915,7 @@ void nft_chain_list_free(struct nft_chain_list *list)
 102                 list_del(&r->head);
 103                 nft_chain_free(r);
 104         }
 105 -       xfree(list);
 106 +       nftnl_xfree(list);
 107  }
 108  EXPORT_SYMBOL(nft_chain_list_free);
 109
 110 @@ -994,6 +994,6 @@ EXPORT_SYMBOL(nft_chain_list_iter_next);
 111
 112  void nft_chain_list_iter_destroy(struct nft_chain_list_iter *iter)
 113  {
 114 -       xfree(iter);
 115 +       nftnl_xfree(iter);
 116  }
 117  EXPORT_SYMBOL(nft_chain_list_iter_destroy);
 118 diff --git a/src/common.c b/src/common.c
 119 index a6f2508..735b098 100644
 120 --- a/src/common.c
 121 +++ b/src/common.c
 122 @@ -48,7 +48,7 @@ EXPORT_SYMBOL(nft_parse_err_alloc);
 123
 124  void nft_parse_err_free(struct nft_parse_err *err)
 125  {
 126 -       xfree(err);
 127 +       nftnl_xfree(err);
 128  }
 129  EXPORT_SYMBOL(nft_parse_err_free);
 130
 131 diff --git a/src/expr.c b/src/expr.c
 132 index 55557da..d23af01 100644
 133 --- a/src/expr.c
 134 +++ b/src/expr.c
 135 @@ -52,7 +52,7 @@ void nft_rule_expr_free(struct nft_rule_expr *expr)
 136         if (expr->ops->free)
 137                 expr->ops->free(expr);
 138
 139 -       xfree(expr);
 140 +       nftnl_xfree(expr);
 141  }
 142  EXPORT_SYMBOL(nft_rule_expr_free);
 143
 144 diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c
 145 index 33b3346..a217d77 100644
 146 --- a/src/expr/data_reg.c
 147 +++ b/src/expr/data_reg.c
 148 @@ -130,7 +130,7 @@ static int nft_data_reg_verdict_xml_parse(union nft_data_reg *reg,
 149                                    NFT_XML_OPT, err);
 150         if (chain != NULL) {
 151                 if (reg->chain)
 152 -                       xfree(reg->chain);
 153 +                       nftnl_xfree(reg->chain);
 154
 155                 reg->chain = strdup(chain);
 156         }
 157 diff --git a/src/expr/immediate.c b/src/expr/immediate.c
 158 index 3d4e48c..d48a4e1 100644
 159 --- a/src/expr/immediate.c
 160 +++ b/src/expr/immediate.c
 161 @@ -47,7 +47,7 @@ nft_rule_expr_immediate_set(struct nft_rule_expr *e, uint16_t type,
 162                 break;
 163         case NFT_EXPR_IMM_CHAIN:
 164                 if (imm->data.chain)
 165 -                       xfree(imm->data.chain);
 166 +                       nftnl_xfree(imm->data.chain);
 167
 168                 imm->data.chain = strdup(data);
 169                 break;
 170 diff --git a/src/expr/log.c b/src/expr/log.c
 171 index 0a324c4..0eec1dc 100644
 172 --- a/src/expr/log.c
 173 +++ b/src/expr/log.c
 174 @@ -40,7 +40,7 @@ static int nft_rule_expr_log_set(struct nft_rule_expr *e, uint16_t type,
 175         switch(type) {
 176         case NFT_EXPR_LOG_PREFIX:
 177                 if (log->prefix)
 178 -                       xfree(log->prefix);
 179 +                       nftnl_xfree(log->prefix);
 180
 181                 log->prefix = strdup(data);
 182                 break;
 183 @@ -154,7 +154,7 @@ nft_rule_expr_log_parse(struct nft_rule_expr *e, struct nlattr *attr)
 184
 185         if (tb[NFTA_LOG_PREFIX]) {
 186                 if (log->prefix)
 187 -                       xfree(log->prefix);
 188 +                       nftnl_xfree(log->prefix);
 189
 190                 log->prefix = strdup(mnl_attr_get_str(tb[NFTA_LOG_PREFIX]));
 191                 e->flags |= (1 << NFT_EXPR_LOG_PREFIX);
 192 @@ -331,7 +331,7 @@ static void nft_rule_expr_log_free(struct nft_rule_expr *e)
 193  {
 194         struct nft_expr_log *log = nft_expr_data(e);
 195
 196 -       xfree(log->prefix);
 197 +       nftnl_xfree(log->prefix);
 198  }
 199
 200  struct expr_ops expr_ops_log = {
 201 diff --git a/src/expr/match.c b/src/expr/match.c
 202 index 26a368f..b452d06 100644
 203 --- a/src/expr/match.c
 204 +++ b/src/expr/match.c
 205 @@ -53,7 +53,7 @@ nft_rule_expr_match_set(struct nft_rule_expr *e, uint16_t type,
 206                 break;
 207         case NFT_EXPR_MT_INFO:
 208                 if (mt->data)
 209 -                       xfree(mt->data);
 210 +                       nftnl_xfree(mt->data);
 211
 212                 mt->data = data;
 213                 mt->data_len = data_len;
 214 @@ -150,7 +150,7 @@ static int nft_rule_expr_match_parse(struct nft_rule_expr *e, struct nlattr *att
 215                 void *match_data;
 216
 217                 if (match->data)
 218 -                       xfree(match->data);
 219 +                       nftnl_xfree(match->data);
 220
 221                 match_data = calloc(1, len);
 222                 if (match_data == NULL)
 223 @@ -240,7 +240,7 @@ static void nft_rule_expr_match_free(struct nft_rule_expr *e)
 224  {
 225         struct nft_expr_match *match = nft_expr_data(e);
 226
 227 -       xfree(match->data);
 228 +       nftnl_xfree(match->data);
 229  }
 230
 231  struct expr_ops expr_ops_match = {
 232 diff --git a/src/expr/target.c b/src/expr/target.c
 233 index a79bc9e..bf836b7 100644
 234 --- a/src/expr/target.c
 235 +++ b/src/expr/target.c
 236 @@ -53,7 +53,7 @@ nft_rule_expr_target_set(struct nft_rule_expr *e, uint16_t type,
 237                 break;
 238         case NFT_EXPR_TG_INFO:
 239                 if (tg->data)
 240 -                       xfree(tg->data);
 241 +                       nftnl_xfree(tg->data);
 242
 243                 tg->data = data;
 244                 tg->data_len = data_len;
 245 @@ -150,7 +150,7 @@ static int nft_rule_expr_target_parse(struct nft_rule_expr *e, struct nlattr *at
 246                 void *target_data;
 247
 248                 if (target->data)
 249 -                       xfree(target->data);
 250 +                       nftnl_xfree(target->data);
 251
 252                 target_data = calloc(1, len);
 253                 if (target_data == NULL)
 254 @@ -241,7 +241,7 @@ static void nft_rule_expr_target_free(struct nft_rule_expr *e)
 255  {
 256         struct nft_expr_target *target = nft_expr_data(e);
 257
 258 -       xfree(target->data);
 259 +       nftnl_xfree(target->data);
 260  }
 261
 262  struct expr_ops expr_ops_target = {
 263 diff --git a/src/gen.c b/src/gen.c
 264 index 21d3a49..515abc4 100644
 265 --- a/src/gen.c
 266 +++ b/src/gen.c
 267 @@ -37,7 +37,7 @@ EXPORT_SYMBOL(nft_gen_alloc);
 268
 269  void nft_gen_free(struct nft_gen *gen)
 270  {
 271 -       xfree(gen);
 272 +       nftnl_xfree(gen);
 273  }
 274  EXPORT_SYMBOL(nft_gen_free);
 275
 276 diff --git a/src/internal.h b/src/internal.h
 277 index db9af11..898a7e7 100644
 278 --- a/src/internal.h
 279 +++ b/src/internal.h
 280 @@ -16,7 +16,7 @@
 281  #include <libnftnl/common.h>
 282  #include <linux/netfilter/nf_tables.h>
 283
 284 -#define xfree(ptr)     free((void *)ptr);
 285 +#define nftnl_xfree(ptr)       free((void *)ptr);
 286
 287  #define BASE_DEC 10
 288  #define BASE_HEX 16
 289 diff --git a/src/mxml.c b/src/mxml.c
 290 index a97d380..f4b5a05 100644
 291 --- a/src/mxml.c
 292 +++ b/src/mxml.c
 293 @@ -84,7 +84,7 @@ struct nft_rule_expr *nft_mxml_expr_parse(mxml_node_t *node,
 294                 goto err_expr;
 295
 296         tree = mxmlLoadString(NULL, xml_text, MXML_OPAQUE_CALLBACK);
 297 -       xfree(xml_text);
 298 +       nftnl_xfree(xml_text);
 299
 300         if (tree == NULL)
 301                 goto err_expr;
 302 diff --git a/src/rule.c b/src/rule.c
 303 index c974f8b..56bf6ef 100644
 304 --- a/src/rule.c
 305 +++ b/src/rule.c
 306 @@ -75,11 +75,11 @@ void nft_rule_free(struct nft_rule *r)
 307                 nft_rule_expr_free(e);
 308
 309         if (r->table != NULL)
 310 -               xfree(r->table);
 311 +               nftnl_xfree(r->table);
 312         if (r->chain != NULL)
 313 -               xfree(r->chain);
 314 +               nftnl_xfree(r->chain);
 315
 316 -       xfree(r);
 317 +       nftnl_xfree(r);
 318  }
 319  EXPORT_SYMBOL(nft_rule_free);
 320
 321 @@ -97,13 +97,13 @@ void nft_rule_attr_unset(struct nft_rule *r, uint16_t attr)
 322         switch (attr) {
 323         case NFT_RULE_ATTR_TABLE:
 324                 if (r->table) {
 325 -                       xfree(r->table);
 326 +                       nftnl_xfree(r->table);
 327                         r->table = NULL;
 328                 }
 329                 break;
 330         case NFT_RULE_ATTR_CHAIN:
 331                 if (r->chain) {
 332 -                       xfree(r->chain);
 333 +                       nftnl_xfree(r->chain);
 334                         r->chain = NULL;
 335                 }
 336                 break;
 337 @@ -139,13 +139,13 @@ void nft_rule_attr_set_data(struct nft_rule *r, uint16_t attr,
 338         switch(attr) {
 339         case NFT_RULE_ATTR_TABLE:
 340                 if (r->table)
 341 -                       xfree(r->table);
 342 +                       nftnl_xfree(r->table);
 343
 344                 r->table = strdup(data);
 345                 break;
 346         case NFT_RULE_ATTR_CHAIN:
 347                 if (r->chain)
 348 -                       xfree(r->chain);
 349 +                       nftnl_xfree(r->chain);
 350
 351                 r->chain = strdup(data);
 352                 break;
 353 @@ -395,7 +395,7 @@ static int nft_rule_parse_expr2(struct nlattr *attr, struct nft_rule *r)
 354
 355         if (tb[NFTA_EXPR_DATA]) {
 356                 if (expr->ops->parse(expr, tb[NFTA_EXPR_DATA]) < 0) {
 357 -                       xfree(expr);
 358 +                       nftnl_xfree(expr);
 359                         return -1;
 360                 }
 361         }
 362 @@ -491,7 +491,7 @@ int nft_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_rule *r)
 363                         mnl_attr_get_payload(tb[NFTA_RULE_USERDATA]);
 364
 365                 if (r->user.data)
 366 -                       xfree(r->user.data);
 367 +                       nftnl_xfree(r->user.data);
 368
 369                 r->user.len = mnl_attr_get_payload_len(tb[NFTA_RULE_USERDATA]);
 370
 371 @@ -1064,7 +1064,7 @@ EXPORT_SYMBOL(nft_rule_expr_iter_next);
 372
 373  void nft_rule_expr_iter_destroy(struct nft_rule_expr_iter *iter)
 374  {
 375 -       xfree(iter);
 376 +       nftnl_xfree(iter);
 377  }
 378  EXPORT_SYMBOL(nft_rule_expr_iter_destroy);
 379
 380 @@ -1094,7 +1094,7 @@ void nft_rule_list_free(struct nft_rule_list *list)
 381                 list_del(&r->head);
 382                 nft_rule_free(r);
 383         }
 384 -       xfree(list);
 385 +       nftnl_xfree(list);
 386  }
 387  EXPORT_SYMBOL(nft_rule_list_free);
 388
 389 @@ -1179,6 +1179,6 @@ EXPORT_SYMBOL(nft_rule_list_iter_next);
 390
 391  void nft_rule_list_iter_destroy(struct nft_rule_list_iter *iter)
 392  {
 393 -       xfree(iter);
 394 +       nftnl_xfree(iter);
 395  }
 396  EXPORT_SYMBOL(nft_rule_list_iter_destroy);
 397 diff --git a/src/ruleset.c b/src/ruleset.c
 398 index 6bb7582..e482e18 100644
 399 --- a/src/ruleset.c
 400 +++ b/src/ruleset.c
 401 @@ -48,7 +48,7 @@ void nft_ruleset_free(struct nft_ruleset *r)
 402                 nft_set_list_free(r->set_list);
 403         if (r->flags & (1 << NFT_RULESET_ATTR_RULELIST))
 404                 nft_rule_list_free(r->rule_list);
 405 -       xfree(r);
 406 +       nftnl_xfree(r);
 407  }
 408  EXPORT_SYMBOL(nft_ruleset_free);
 409
 410 diff --git a/src/set.c b/src/set.c
 411 index 2385031..0355f99 100644
 412 --- a/src/set.c
 413 +++ b/src/set.c
 414 @@ -47,15 +47,15 @@ void nft_set_free(struct nft_set *s)
 415         struct nft_set_elem *elem, *tmp;
 416
 417         if (s->table != NULL)
 418 -               xfree(s->table);
 419 +               nftnl_xfree(s->table);
 420         if (s->name != NULL)
 421 -               xfree(s->name);
 422 +               nftnl_xfree(s->name);
 423
 424         list_for_each_entry_safe(elem, tmp, &s->element_list, head) {
 425                 list_del(&elem->head);
 426                 nft_set_elem_free(elem);
 427         }
 428 -       xfree(s);
 429 +       nftnl_xfree(s);
 430  }
 431  EXPORT_SYMBOL(nft_set_free);
 432
 433 @@ -71,14 +71,14 @@ void nft_set_attr_unset(struct nft_set *s, uint16_t attr)
 434         case NFT_SET_ATTR_TABLE:
 435                 if (s->flags & (1 << NFT_SET_ATTR_TABLE))
 436                         if (s->table) {
 437 -                               xfree(s->table);
 438 +                               nftnl_xfree(s->table);
 439                                 s->table = NULL;
 440                         }
 441                 break;
 442         case NFT_SET_ATTR_NAME:
 443                 if (s->flags & (1 << NFT_SET_ATTR_NAME))
 444                         if (s->name) {
 445 -                               xfree(s->name);
 446 +                               nftnl_xfree(s->name);
 447                                 s->name = NULL;
 448                         }
 449                 break;
 450 @@ -122,13 +122,13 @@ void nft_set_attr_set_data(struct nft_set *s, uint16_t attr, const void *data,
 451         switch(attr) {
 452         case NFT_SET_ATTR_TABLE:
 453                 if (s->table)
 454 -                       xfree(s->table);
 455 +                       nftnl_xfree(s->table);
 456
 457                 s->table = strdup(data);
 458                 break;
 459         case NFT_SET_ATTR_NAME:
 460                 if (s->name)
 461 -                       xfree(s->name);
 462 +                       nftnl_xfree(s->name);
 463
 464                 s->name = strdup(data);
 465                 break;
 466 @@ -963,7 +963,7 @@ void nft_set_list_free(struct nft_set_list *list)
 467                 list_del(&s->head);
 468                 nft_set_free(s);
 469         }
 470 -       xfree(list);
 471 +       nftnl_xfree(list);
 472  }
 473  EXPORT_SYMBOL(nft_set_list_free);
 474
 475 @@ -1047,7 +1047,7 @@ EXPORT_SYMBOL(nft_set_list_iter_next);
 476
 477  void nft_set_list_iter_destroy(struct nft_set_list_iter *iter)
 478  {
 479 -       xfree(iter);
 480 +       nftnl_xfree(iter);
 481  }
 482  EXPORT_SYMBOL(nft_set_list_iter_destroy);
 483
 484 diff --git a/src/set_elem.c b/src/set_elem.c
 485 index 95f12bf..12d636e 100644
 486 --- a/src/set_elem.c
 487 +++ b/src/set_elem.c
 488 @@ -44,11 +44,11 @@ void nft_set_elem_free(struct nft_set_elem *s)
 489  {
 490         if (s->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) {
 491                 if (s->data.chain) {
 492 -                       xfree(s->data.chain);
 493 +                       nftnl_xfree(s->data.chain);
 494                         s->data.chain = NULL;
 495                 }
 496         }
 497 -       xfree(s);
 498 +       nftnl_xfree(s);
 499  }
 500  EXPORT_SYMBOL(nft_set_elem_free);
 501
 502 @@ -64,7 +64,7 @@ void nft_set_elem_attr_unset(struct nft_set_elem *s, uint16_t attr)
 503         case NFT_SET_ELEM_ATTR_CHAIN:
 504                 if (s->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) {
 505                         if (s->data.chain) {
 506 -                               xfree(s->data.chain);
 507 +                               nftnl_xfree(s->data.chain);
 508                                 s->data.chain = NULL;
 509                         }
 510                 }
 511 @@ -98,7 +98,7 @@ void nft_set_elem_attr_set(struct nft_set_elem *s, uint16_t attr,
 512                 break;
 513         case NFT_SET_ELEM_ATTR_CHAIN:   /* NFTA_SET_ELEM_DATA */
 514                 if (s->data.chain)
 515 -                       xfree(s->data.chain);
 516 +                       nftnl_xfree(s->data.chain);
 517
 518                 s->data.chain = strdup(data);
 519                 break;
 520 @@ -716,7 +716,7 @@ EXPORT_SYMBOL(nft_set_elems_iter_next);
 521
 522  void nft_set_elems_iter_destroy(struct nft_set_elems_iter *iter)
 523  {
 524 -       xfree(iter);
 525 +       nftnl_xfree(iter);
 526  }
 527  EXPORT_SYMBOL(nft_set_elems_iter_destroy);
 528
 529 diff --git a/src/table.c b/src/table.c
 530 index c93e6fb..c89bca1 100644
 531 --- a/src/table.c
 532 +++ b/src/table.c
 533 @@ -45,9 +45,9 @@ EXPORT_SYMBOL(nft_table_alloc);
 534  void nft_table_free(struct nft_table *t)
 535  {
 536         if (t->flags & (1 << NFT_TABLE_ATTR_NAME))
 537 -               xfree(t->name);
 538 +               nftnl_xfree(t->name);
 539
 540 -       xfree(t);
 541 +       nftnl_xfree(t);
 542  }
 543  EXPORT_SYMBOL(nft_table_free);
 544
 545 @@ -65,7 +65,7 @@ void nft_table_attr_unset(struct nft_table *t, uint16_t attr)
 546         switch (attr) {
 547         case NFT_TABLE_ATTR_NAME:
 548                 if (t->name) {
 549 -                       xfree(t->name);
 550 +                       nftnl_xfree(t->name);
 551                         t->name = NULL;
 552                 }
 553                 break;
 554 @@ -95,7 +95,7 @@ void nft_table_attr_set_data(struct nft_table *t, uint16_t attr,
 555         switch (attr) {
 556         case NFT_TABLE_ATTR_NAME:
 557                 if (t->name)
 558 -                       xfree(t->name);
 559 +                       nftnl_xfree(t->name);
 560
 561                 t->name = strdup(data);
 562                 break;
 563 @@ -486,7 +486,7 @@ void nft_table_list_free(struct nft_table_list *list)
 564                 list_del(&r->head);
 565                 nft_table_free(r);
 566         }
 567 -       xfree(list);
 568 +       nftnl_xfree(list);
 569  }
 570  EXPORT_SYMBOL(nft_table_list_free);
 571
 572 @@ -565,6 +565,6 @@ EXPORT_SYMBOL(nft_table_list_iter_next);
 573
 574  void nft_table_list_iter_destroy(struct nft_table_list_iter *iter)
 575  {
 576 -       xfree(iter);
 577 +       nftnl_xfree(iter);
 578  }
 579  EXPORT_SYMBOL(nft_table_list_iter_destroy);
 580 diff --git a/src/utils.c b/src/utils.c
 581 index 9013b68..7058269 100644
 582 --- a/src/utils.c
 583 +++ b/src/utils.c
 584 @@ -206,7 +206,7 @@ int nft_fprintf(FILE *fp, void *obj, uint32_t type, uint32_t flags,
 585
 586  out:
 587         if (buf != _buf)
 588 -               xfree(buf);
 589 +               nftnl_xfree(buf);
 590
 591         return ret;
 592  }
 593 --
 594 2.1.0
 595