src: add nft_*_unset functions

These functions unset the given attribute in each object and
release the data if needed.

Signed-off-by: Arturo Borrero Gonzalez <arturo.borrero.glez@gmail.com>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/include/libnftables/chain.h b/include/libnftables/chain.h
index b12474fc0bd93dccb110484a47013ac03c9a973d..f06f743c043953a79940b39829a5ff2ee7fabbe9 100644 (file)
--- a/include/libnftables/chain.h
+++ b/include/libnftables/chain.h
@@ -26,6 +26,7 @@ enum {
        NFT_CHAIN_ATTR_TYPE,
 };
 
+void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr);
 void nft_chain_attr_set(struct nft_chain *t, uint16_t attr, const void *data);
 void nft_chain_attr_set_u32(struct nft_chain *t, uint16_t attr, uint32_t data);
 void nft_chain_attr_set_s32(struct nft_chain *t, uint16_t attr, int32_t data);

diff --git a/include/libnftables/rule.h b/include/libnftables/rule.h
index 9c4ab0db8b59f3a51300ac29133135a18fdd2c44..9989f19b10cb83dbe546f423f8011163292f9b1b 100644 (file)
--- a/include/libnftables/rule.h
+++ b/include/libnftables/rule.h
@@ -23,6 +23,7 @@ enum {
        NFT_RULE_ATTR_COMPAT_FLAGS,
 };
 
+void nft_rule_attr_unset(struct nft_rule *r, uint16_t attr);
 void nft_rule_attr_set(struct nft_rule *r, uint16_t attr, const void *data);
 void nft_rule_attr_set_u32(struct nft_rule *r, uint16_t attr, uint32_t val);
 void nft_rule_attr_set_u64(struct nft_rule *r, uint16_t attr, uint64_t val);

diff --git a/include/libnftables/set.h b/include/libnftables/set.h
index 53c2947204a2b4dde7bc6c1e3e324483c9d9a89b..211c065e3f4ca2d8ce0bdc67872f5f17ee7002a6 100644 (file)
--- a/include/libnftables/set.h
+++ b/include/libnftables/set.h
@@ -16,6 +16,7 @@ struct nft_set;
 struct nft_set *nft_set_alloc(void);
 void nft_set_free(struct nft_set *s);
 
+void nft_set_attr_unset(struct nft_set *s, uint16_t attr);
 void nft_set_attr_set(struct nft_set *s, uint16_t attr, const void *data);
 void nft_set_attr_set_u32(struct nft_set *s, uint16_t attr, uint32_t val);
 void nft_set_attr_set_str(struct nft_set *s, uint16_t attr, const char *str);
@@ -61,6 +62,7 @@ void nft_set_elem_free(struct nft_set_elem *s);
 
 void nft_set_elem_add(struct nft_set *s, struct nft_set_elem *elem);
 
+void nft_set_elem_attr_unset(struct nft_set_elem *s, uint16_t attr);
 void nft_set_elem_attr_set(struct nft_set_elem *s, uint16_t attr, const void *data, size_t data_len);
 void nft_set_elem_attr_set_u32(struct nft_set_elem *s, uint16_t attr, uint32_t val);
 void nft_set_elem_attr_set_str(struct nft_set_elem *s, uint16_t attr, const char *str);

diff --git a/include/libnftables/table.h b/include/libnftables/table.h
index 19f322c42f7c3791d6afbf6148c21b64cc25330f..a999770a85babfeddf9f9cfa61e2137da81e810d 100644 (file)
--- a/include/libnftables/table.h
+++ b/include/libnftables/table.h
@@ -18,6 +18,7 @@ enum {
        NFT_TABLE_ATTR_FLAGS,
 };
 
+void nft_table_attr_unset(struct nft_table *t, uint16_t attr);
 void nft_table_attr_set(struct nft_table *t, uint16_t attr, const void *data);
 const void *nft_table_attr_get(struct nft_table *t, uint16_t attr);
 

diff --git a/src/chain.c b/src/chain.c
index 093e3eae1915a933fa371abfde3ed53e5fc67d38..530e045cc9ad922578b6eeb2b346246cb5e58849 100644 (file)
--- a/src/chain.c
+++ b/src/chain.c
@@ -59,6 +59,34 @@ void nft_chain_free(struct nft_chain *c)
 }
 EXPORT_SYMBOL(nft_chain_free);
 
+void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr)
+{
+       switch (attr) {
+       case NFT_CHAIN_ATTR_TABLE:
+               if (c->flags & (1 << NFT_CHAIN_ATTR_TABLE))
+                       if (c->table) {
+                               free(c->table);
+                               c->table = NULL;
+                       }
+               break;
+       case NFT_CHAIN_ATTR_USE:
+               /* cannot be unset?, ignore it */
+               return;
+       case NFT_CHAIN_ATTR_TYPE:
+               if (c->flags & (1 << NFT_CHAIN_ATTR_TYPE))
+                       if (c->type) {
+                               free(c->type);
+                               c->type = NULL;
+                       }
+               break;
+       default:
+               return;
+       }
+
+       c->flags &= ~(1 << attr);
+}
+EXPORT_SYMBOL(nft_chain_attr_unset);
+
 void nft_chain_attr_set(struct nft_chain *c, uint16_t attr, const void *data)
 {
        switch(attr) {

diff --git a/src/libnftables.map b/src/libnftables.map
index 8bae60cfbcb5e1a2da67eb7edd32a34f87ea1b7a..2b31d5515389bf7eb1ec152e32d2fc637f48523d 100644 (file)
--- a/src/libnftables.map
+++ b/src/libnftables.map
@@ -2,6 +2,7 @@ LIBNFTABLES_1.0 {
 global:
   nft_table_alloc;
   nft_table_free;
+  nft_table_attr_unset;
   nft_table_attr_set;
   nft_table_attr_get;
   nft_table_attr_set_u32;
@@ -22,6 +23,7 @@ global:
 
   nft_chain_alloc;
   nft_chain_free;
+  nft_chain_attr_unset;
   nft_chain_attr_set;
   nft_chain_attr_set_u32;
   nft_chain_attr_set_s32;
@@ -47,6 +49,7 @@ global:
 
   nft_rule_alloc;
   nft_rule_free;
+  nft_rule_attr_unset;
   nft_rule_attr_set;
   nft_rule_attr_set_u32;
   nft_rule_attr_set_u64;
@@ -91,6 +94,7 @@ global:
 
   nft_set_alloc;
   nft_set_free;
+  nft_set_attr_unset;
   nft_set_attr_set;
   nft_set_attr_set_u32;
   nft_set_attr_set_str;
@@ -114,6 +118,7 @@ global:
   nft_set_elem_alloc;
   nft_set_elem_free;
   nft_set_elem_add;
+  nft_set_elem_attr_unset;
   nft_set_elem_attr_set;
   nft_set_elem_attr_set_u32;
   nft_set_elem_attr_set_str;

diff --git a/src/rule.c b/src/rule.c
index 698bf89bd7d4c338f5f2ae7ecb2250cdcac727d9..b3e21d8c17b5e671b3459ce286d145b8270bff0d 100644 (file)
--- a/src/rule.c
+++ b/src/rule.c
@@ -71,6 +71,31 @@ void nft_rule_free(struct nft_rule *r)
 }
 EXPORT_SYMBOL(nft_rule_free);
 
+void nft_rule_attr_unset(struct nft_rule *r, uint16_t attr)
+{
+       switch (attr) {
+       case NFT_RULE_ATTR_TABLE:
+               if (r->flags & (1 << NFT_RULE_ATTR_TABLE))
+                       if (r->table) {
+                               free(r->table);
+                               r->table = NULL;
+                       }
+               break;
+       case NFT_RULE_ATTR_CHAIN:
+               if (r->flags & (1 << NFT_RULE_ATTR_CHAIN))
+                       if (r->chain) {
+                               free(r->chain);
+                               r->chain = NULL;
+                       }
+               break;
+       default:
+               return;
+       }
+
+       r->flags &= ~(1 << attr);
+}
+EXPORT_SYMBOL(nft_rule_attr_unset);
+
 void nft_rule_attr_set(struct nft_rule *r, uint16_t attr, const void *data)
 {
        switch(attr) {

diff --git a/src/set.c b/src/set.c
index ef2d11d841a22120297f68aef8c75e59307939e0..029e2f27d96c96f20ede18bf0bbd5af553884e45 100644 (file)
--- a/src/set.c
+++ b/src/set.c
@@ -56,6 +56,31 @@ void nft_set_free(struct nft_set *s)
 }
 EXPORT_SYMBOL(nft_set_free);
 
+void nft_set_attr_unset(struct nft_set *s, uint16_t attr)
+{
+       switch (attr) {
+       case NFT_SET_ATTR_TABLE:
+               if (s->flags & (1 << NFT_SET_ATTR_TABLE))
+                       if (s->table) {
+                               free(s->table);
+                               s->table = NULL;
+                       }
+               break;
+       case NFT_SET_ATTR_NAME:
+               if (s->flags & (1 << NFT_SET_ATTR_NAME))
+                       if (s->name) {
+                               free(s->name);
+                               s->name = NULL;
+                       }
+               break;
+       default:
+               return;
+       }
+
+       s->flags &= ~(1 << attr);
+}
+EXPORT_SYMBOL(nft_set_attr_unset);
+
 void nft_set_attr_set(struct nft_set *s, uint16_t attr, const void *data)
 {
        switch(attr) {

diff --git a/src/set_elem.c b/src/set_elem.c
index a2669ad7f79d9aaf2ac249c0097ef762d25c262c..13047ae468bb24603ee37d9893d0a4d198f42311 100644 (file)
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -44,6 +44,25 @@ void nft_set_elem_free(struct nft_set_elem *s)
 }
 EXPORT_SYMBOL(nft_set_elem_free);
 
+void nft_set_elem_attr_unset(struct nft_set_elem *s, uint16_t attr)
+{
+       switch (attr) {
+       case NFT_SET_ELEM_ATTR_CHAIN:
+               if (s->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) {
+                       if (s->data.chain) {
+                               free(s->data.chain);
+                               s->data.chain = NULL;
+                       }
+               }
+               break;
+       default:
+               return;
+       }
+
+       s->flags &= ~(1 << attr);
+}
+EXPORT_SYMBOL(nft_set_elem_attr_unset);
+
 void nft_set_elem_attr_set(struct nft_set_elem *s, uint16_t attr,
                           const void *data, size_t data_len)
 {

diff --git a/src/table.c b/src/table.c
index de106bbdf3fce54c3aa6542118cf1cb6adf31c74..937f9b5dc7bbb11624fc2e7981985e688562ca0a 100644 (file)
--- a/src/table.c
+++ b/src/table.c
@@ -49,9 +49,27 @@ void nft_table_free(struct nft_table *t)
 }
 EXPORT_SYMBOL(nft_table_free);
 
+void nft_table_attr_unset(struct nft_table *t, uint16_t attr)
+{
+       switch (attr) {
+       case NFT_TABLE_ATTR_NAME:
+               if (t->flags & (1 << NFT_TABLE_ATTR_NAME)) {
+                       if (t->name) {
+                               free(t->name);
+                               t->name = NULL;
+                       }
+               }
+               break;
+       default:
+               return;
+       }
+       t->flags &= ~(1 << attr);
+}
+EXPORT_SYMBOL(nft_table_attr_unset);
+
 void nft_table_attr_set(struct nft_table *t, uint16_t attr, const void *data)
 {
-       switch(attr) {
+       switch (attr) {
        case NFT_TABLE_ATTR_NAME:
                if (t->name)
                        free(t->name);