netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* Development of this code funded by Astaro AG (http://www.astaro.com/)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/rbtree.h>
|
|
|
|
#include <linux/netlink.h>
|
|
|
|
#include <linux/netfilter.h>
|
|
|
|
#include <linux/netfilter/nf_tables.h>
|
|
|
|
#include <net/netfilter/nf_tables.h>
|
|
|
|
|
|
|
|
struct nft_rbtree {
|
|
|
|
struct rb_root root;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct nft_rbtree_elem {
|
|
|
|
struct rb_node node;
|
|
|
|
u16 flags;
|
|
|
|
struct nft_data key;
|
|
|
|
struct nft_data data[];
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool nft_rbtree_lookup(const struct nft_set *set,
|
|
|
|
const struct nft_data *key,
|
|
|
|
struct nft_data *data)
|
|
|
|
{
|
|
|
|
const struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
const struct nft_rbtree_elem *rbe, *interval = NULL;
|
|
|
|
const struct rb_node *parent = priv->root.rb_node;
|
|
|
|
int d;
|
|
|
|
|
|
|
|
while (parent != NULL) {
|
|
|
|
rbe = rb_entry(parent, struct nft_rbtree_elem, node);
|
|
|
|
|
|
|
|
d = nft_data_cmp(&rbe->key, key, set->klen);
|
|
|
|
if (d < 0) {
|
|
|
|
parent = parent->rb_left;
|
|
|
|
interval = rbe;
|
|
|
|
} else if (d > 0)
|
|
|
|
parent = parent->rb_right;
|
|
|
|
else {
|
|
|
|
found:
|
|
|
|
if (rbe->flags & NFT_SET_ELEM_INTERVAL_END)
|
|
|
|
goto out;
|
|
|
|
if (set->flags & NFT_SET_MAP)
|
|
|
|
nft_data_copy(data, rbe->data);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (set->flags & NFT_SET_INTERVAL && interval != NULL) {
|
|
|
|
rbe = interval;
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nft_rbtree_elem_destroy(const struct nft_set *set,
|
|
|
|
struct nft_rbtree_elem *rbe)
|
|
|
|
{
|
|
|
|
nft_data_uninit(&rbe->key, NFT_DATA_VALUE);
|
2014-02-06 16:15:39 +01:00
|
|
|
if (set->flags & NFT_SET_MAP &&
|
|
|
|
!(rbe->flags & NFT_SET_ELEM_INTERVAL_END))
|
netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
nft_data_uninit(rbe->data, set->dtype);
|
2014-02-06 16:15:39 +01:00
|
|
|
|
netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
kfree(rbe);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __nft_rbtree_insert(const struct nft_set *set,
|
|
|
|
struct nft_rbtree_elem *new)
|
|
|
|
{
|
|
|
|
struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
struct nft_rbtree_elem *rbe;
|
|
|
|
struct rb_node *parent, **p;
|
|
|
|
int d;
|
|
|
|
|
|
|
|
parent = NULL;
|
|
|
|
p = &priv->root.rb_node;
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
rbe = rb_entry(parent, struct nft_rbtree_elem, node);
|
|
|
|
d = nft_data_cmp(&rbe->key, &new->key, set->klen);
|
|
|
|
if (d < 0)
|
|
|
|
p = &parent->rb_left;
|
|
|
|
else if (d > 0)
|
|
|
|
p = &parent->rb_right;
|
|
|
|
else
|
|
|
|
return -EEXIST;
|
|
|
|
}
|
|
|
|
rb_link_node(&new->node, parent, p);
|
|
|
|
rb_insert_color(&new->node, &priv->root);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nft_rbtree_insert(const struct nft_set *set,
|
|
|
|
const struct nft_set_elem *elem)
|
|
|
|
{
|
|
|
|
struct nft_rbtree_elem *rbe;
|
|
|
|
unsigned int size;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
size = sizeof(*rbe);
|
2014-02-06 16:15:39 +01:00
|
|
|
if (set->flags & NFT_SET_MAP &&
|
|
|
|
!(elem->flags & NFT_SET_ELEM_INTERVAL_END))
|
netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
size += sizeof(rbe->data[0]);
|
|
|
|
|
|
|
|
rbe = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (rbe == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
rbe->flags = elem->flags;
|
|
|
|
nft_data_copy(&rbe->key, &elem->key);
|
2014-02-06 16:15:39 +01:00
|
|
|
if (set->flags & NFT_SET_MAP &&
|
|
|
|
!(rbe->flags & NFT_SET_ELEM_INTERVAL_END))
|
netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
nft_data_copy(rbe->data, &elem->data);
|
|
|
|
|
|
|
|
err = __nft_rbtree_insert(set, rbe);
|
|
|
|
if (err < 0)
|
|
|
|
kfree(rbe);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nft_rbtree_remove(const struct nft_set *set,
|
|
|
|
const struct nft_set_elem *elem)
|
|
|
|
{
|
|
|
|
struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
struct nft_rbtree_elem *rbe = elem->cookie;
|
|
|
|
|
|
|
|
rb_erase(&rbe->node, &priv->root);
|
|
|
|
kfree(rbe);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nft_rbtree_get(const struct nft_set *set, struct nft_set_elem *elem)
|
|
|
|
{
|
|
|
|
const struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
const struct rb_node *parent = priv->root.rb_node;
|
|
|
|
struct nft_rbtree_elem *rbe;
|
|
|
|
int d;
|
|
|
|
|
|
|
|
while (parent != NULL) {
|
|
|
|
rbe = rb_entry(parent, struct nft_rbtree_elem, node);
|
|
|
|
|
|
|
|
d = nft_data_cmp(&rbe->key, &elem->key, set->klen);
|
|
|
|
if (d < 0)
|
|
|
|
parent = parent->rb_left;
|
|
|
|
else if (d > 0)
|
|
|
|
parent = parent->rb_right;
|
|
|
|
else {
|
|
|
|
elem->cookie = rbe;
|
2014-02-06 16:15:39 +01:00
|
|
|
if (set->flags & NFT_SET_MAP &&
|
|
|
|
!(rbe->flags & NFT_SET_ELEM_INTERVAL_END))
|
netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
nft_data_copy(&elem->data, rbe->data);
|
|
|
|
elem->flags = rbe->flags;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nft_rbtree_walk(const struct nft_ctx *ctx,
|
|
|
|
const struct nft_set *set,
|
|
|
|
struct nft_set_iter *iter)
|
|
|
|
{
|
|
|
|
const struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
const struct nft_rbtree_elem *rbe;
|
|
|
|
struct nft_set_elem elem;
|
|
|
|
struct rb_node *node;
|
|
|
|
|
|
|
|
for (node = rb_first(&priv->root); node != NULL; node = rb_next(node)) {
|
|
|
|
if (iter->count < iter->skip)
|
|
|
|
goto cont;
|
|
|
|
|
|
|
|
rbe = rb_entry(node, struct nft_rbtree_elem, node);
|
|
|
|
nft_data_copy(&elem.key, &rbe->key);
|
2014-02-06 16:15:39 +01:00
|
|
|
if (set->flags & NFT_SET_MAP &&
|
|
|
|
!(rbe->flags & NFT_SET_ELEM_INTERVAL_END))
|
netfilter: nf_tables: add netlink set API
This patch adds the new netlink API for maintaining nf_tables sets
independently of the ruleset. The API supports the following operations:
- creation of sets
- deletion of sets
- querying of specific sets
- dumping of all sets
- addition of set elements
- removal of set elements
- dumping of all set elements
Sets are identified by name, each table defines an individual namespace.
The name of a set may be allocated automatically, this is mostly useful
in combination with the NFT_SET_ANONYMOUS flag, which destroys a set
automatically once the last reference has been released.
Sets can be marked constant, meaning they're not allowed to change while
linked to a rule. This allows to perform lockless operation for set
types that would otherwise require locking.
Additionally, if the implementation supports it, sets can (as before) be
used as maps, associating a data value with each key (or range), by
specifying the NFT_SET_MAP flag and can be used for interval queries by
specifying the NFT_SET_INTERVAL flag.
Set elements are added and removed incrementally. All element operations
support batching, reducing netlink message and set lookup overhead.
The old "set" and "hash" expressions are replaced by a generic "lookup"
expression, which binds to the specified set. Userspace is not aware
of the actual set implementation used by the kernel anymore, all
configuration options are generic.
Currently the implementation selection logic is largely missing and the
kernel will simply use the first registered implementation supporting the
requested operation. Eventually, the plan is to have userspace supply a
description of the data characteristics and select the implementation
based on expected performance and memory use.
This patch includes the new 'lookup' expression to look up for element
matching in the set.
This patch includes kernel-doc descriptions for this set API and it
also includes the following fixes.
From Patrick McHardy:
* netfilter: nf_tables: fix set element data type in dumps
* netfilter: nf_tables: fix indentation of struct nft_set_elem comments
* netfilter: nf_tables: fix oops in nft_validate_data_load()
* netfilter: nf_tables: fix oops while listing sets of built-in tables
* netfilter: nf_tables: destroy anonymous sets immediately if binding fails
* netfilter: nf_tables: propagate context to set iter callback
* netfilter: nf_tables: add loop detection
From Pablo Neira Ayuso:
* netfilter: nf_tables: allow to dump all existing sets
* netfilter: nf_tables: fix wrong type for flags variable in newelem
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
2013-10-11 12:06:22 +02:00
|
|
|
nft_data_copy(&elem.data, rbe->data);
|
|
|
|
elem.flags = rbe->flags;
|
|
|
|
|
|
|
|
iter->err = iter->fn(ctx, set, iter, &elem);
|
|
|
|
if (iter->err < 0)
|
|
|
|
return;
|
|
|
|
cont:
|
|
|
|
iter->count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int nft_rbtree_privsize(const struct nlattr * const nla[])
|
|
|
|
{
|
|
|
|
return sizeof(struct nft_rbtree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nft_rbtree_init(const struct nft_set *set,
|
|
|
|
const struct nlattr * const nla[])
|
|
|
|
{
|
|
|
|
struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
|
|
|
|
priv->root = RB_ROOT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nft_rbtree_destroy(const struct nft_set *set)
|
|
|
|
{
|
|
|
|
struct nft_rbtree *priv = nft_set_priv(set);
|
|
|
|
struct nft_rbtree_elem *rbe;
|
|
|
|
struct rb_node *node;
|
|
|
|
|
|
|
|
while ((node = priv->root.rb_node) != NULL) {
|
|
|
|
rb_erase(node, &priv->root);
|
|
|
|
rbe = rb_entry(node, struct nft_rbtree_elem, node);
|
|
|
|
nft_rbtree_elem_destroy(set, rbe);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nft_set_ops nft_rbtree_ops __read_mostly = {
|
|
|
|
.privsize = nft_rbtree_privsize,
|
|
|
|
.init = nft_rbtree_init,
|
|
|
|
.destroy = nft_rbtree_destroy,
|
|
|
|
.insert = nft_rbtree_insert,
|
|
|
|
.remove = nft_rbtree_remove,
|
|
|
|
.get = nft_rbtree_get,
|
|
|
|
.lookup = nft_rbtree_lookup,
|
|
|
|
.walk = nft_rbtree_walk,
|
|
|
|
.features = NFT_SET_INTERVAL | NFT_SET_MAP,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init nft_rbtree_module_init(void)
|
|
|
|
{
|
|
|
|
return nft_register_set(&nft_rbtree_ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit nft_rbtree_module_exit(void)
|
|
|
|
{
|
|
|
|
nft_unregister_set(&nft_rbtree_ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(nft_rbtree_module_init);
|
|
|
|
module_exit(nft_rbtree_module_exit);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
|
|
|
|
MODULE_ALIAS_NFT_SET();
|