Implement among match support
Phil Sutter
reviewerv2 cover Implement among match support
Changes since v1:
- Rebased onto my performance improvements patch series.
- Aligned set caching routines with changes in above series.
- Fixed patch ordering so builds are not broken intermittently.
- Replaced magic numbers by defines or offsetof() statements. Note that I did not move any defines into libnftnl; the remaining ones are for values in sets' key_type attribute which neither libnftnl nor kernel care about. Setting that is merely for compatibility with nft tool.
This series ultimately adds among match support to ebtables-nft. The implementation merely shares the user interface with legacy one, internally the code is distinct: libebt_among.c does not make use of the wormhash data structure but a much simpler one for "temporary" storage of data until being converted into an anonymous set and associated lookup expression.
Patches 1 to 5 implement required changes and are rather boring by
themselves: When converting an nftnl rule to iptables command state, cache access is required (to lookup set references).
Patch 6 simplifies things a bit with the above in place.
Patches 7 to 11 implement anonymous set support.
Patch 12 then adds the actual among match implementation for ebtables-nft.
Phil Sutter (12):
nft: family_ops: Pass nft_handle to 'add' callback
nft: family_ops: Pass nft_handle to 'rule_find' callback
nft: family_ops: Pass nft_handle to 'print_rule' callback
nft: family_ops: Pass nft_handle to 'rule_to_cs' callback
nft: Keep nft_handle pointer in nft_xt_ctx
nft: Eliminate pointless calls to nft_family_ops_lookup()
nft: Fetch sets when updating rule cache
nft: Support NFT_COMPAT_SET_ADD
nft: Bore up nft_parse_payload()
nft: Embed rule's table name in nft_xt_ctx
nft: Support parsing lookup expression
nft: bridge: Rudimental among extension support
extensions/libebt_among.c | 278 ++++++++++++++++++++ extensions/libebt_among.t | 16 ++ iptables/ebtables-nft.8 | 66 ++--- iptables/nft-arp.c | 13 +- iptables/nft-bridge.c | 244 +++++++++++++++++- iptables/nft-bridge.h | 21 ++ iptables/nft-ipv4.c | 10 +- iptables/nft-ipv6.c | 10 +- iptables/nft-shared.c | 70 +++--- iptables/nft-shared.h | 26 +- iptables/nft.c | 502 +++++++++++++++++++++++++++++++++---- iptables/nft.h | 14 +- iptables/xtables-eb.c | 1 + iptables/xtables-monitor.c | 17 +- iptables/xtables-save.c | 3 + 15 files changed, 1135 insertions(+), 156 deletions(-) create mode 100644 extensions/libebt_among.c create mode 100644 extensions/libebt_among.t
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 1/12 nft: family_ops: Pass nft_handle to 'add' callback
In order for add_match() to create anonymous sets when converting xtables matches it needs access to nft handle. So pass it along from callers of family ops' add callback.
--- iptables/nft-arp.c | 2 +- iptables/nft-bridge.c | 5 +++-- iptables/nft-ipv4.c | 4 ++-- iptables/nft-ipv6.c | 4 ++-- iptables/nft-shared.h | 4 ++-- iptables/nft.c | 5 +++-- iptables/nft.h | 2 +- 7 files changed, 14 insertions(+), 12 deletions(-)
iptables/nft-arp.c +1 -1
@@ -149,7 +149,7 @@ static bool need_devaddr(struct arpt_devaddr_info *info)return false; } -static int nft_arp_add (struct nftnl_rule *r,void *data) +static int nft_arp_add (struct nft_handle *h,struct nftnl_rule *r,void *data) {struct iptables_command_state *cs = data;struct arpt_entry *fw = &cs->arp;
iptables/nft-bridge.c +3 -2
@@ -126,7 +126,8 @@ static int _add_action(struct nftnl_rule *r, struct iptables_command_state *cs)return add_action (r, cs, false); } -static int nft_bridge_add (struct nftnl_rule *r,void *data) +static int nft_bridge_add (struct nft_handle *h, +struct nftnl_rule *r,void *data) {struct iptables_command_state *cs = data;struct ebt_match *iter;
@@ -182,7 +183,7 @@ static int nft_bridge_add(struct nftnl_rule *r, void *data)for (iter = cs->match_list; iter; iter = iter->next) {if (iter->ismatch) { -if (add_match (r, iter->u.match->m)) +if (add_match (h, r, iter->u.match->m))break ; }else {if (add_target (r, iter->u.watcher->t))
iptables/nft-ipv4.c +2 -2
@@ -26,7 +26,7 @@#include "nft.h" #include "nft-shared.h" -static int nft_ipv4_add (struct nftnl_rule *r,void *data) +static int nft_ipv4_add (struct nft_handle *h,struct nftnl_rule *r,void *data) {struct iptables_command_state *cs = data;struct xtables_rule_match *matchp;
@@ -77,7 +77,7 @@ static int nft_ipv4_add(struct nftnl_rule *r, void *data)add_compat (r, cs->fw.ip.proto, cs->fw.ip.invflags &XT_INV_PROTO );for (matchp = cs->matches; matchp; matchp = matchp->next) { - ret =add_match (r, matchp->match->m); + ret =add_match (h, r, matchp->match->m);if (ret <0 )return ret; }
iptables/nft-ipv6.c +2 -2
@@ -25,7 +25,7 @@#include "nft.h" #include "nft-shared.h" -static int nft_ipv6_add (struct nftnl_rule *r,void *data) +static int nft_ipv6_add (struct nft_handle *h,struct nftnl_rule *r,void *data) {struct iptables_command_state *cs = data;struct xtables_rule_match *matchp;
@@ -66,7 +66,7 @@ static int nft_ipv6_add(struct nftnl_rule *r, void *data)add_compat (r, cs->fw6.ipv6.proto, cs->fw6.ipv6.invflags &XT_INV_PROTO );for (matchp = cs->matches; matchp; matchp = matchp->next) { - ret =add_match (r, matchp->match->m); + ret =add_match (h, r, matchp->match->m);if (ret <0 )return ret; }
iptables/nft-shared.h +2 -2
@@ -35,6 +35,7 @@#define FMT (tab,notab) ((format) & FMT_NOTABLE ? (notab) : (tab))struct xtables_args ; +struct nft_handle ;struct xt_xlate ;enum {
@@ -69,7 +70,7 @@ struct nft_xt_ctx { };struct nft_family_ops { -int (*add)(struct nftnl_rule *r,void *data); +int (*add)(struct nft_handle *h,struct nftnl_rule *r,void *data);bool (*is_same)(const void *data_a,const void *data_b); void (*print_payload)(struct nftnl_expr *e,
@@ -163,7 +164,6 @@ void save_matches_and_target(const struct iptables_command_state *cs,struct nft_family_ops *nft_family_ops_lookup (int family); -struct nft_handle ;void nft_ipv46_parse_target (struct xtables_target *t,void *data);bool nft_ipv46_rule_find (struct nft_family_ops *ops,struct nftnl_rule *r,void *data);
iptables/nft.c +3 -2
@@ -1048,7 +1048,8 @@ static int add_nft_limit(struct nftnl_rule *r, struct xt_entry_match *m)return 0 ; } -int add_match (struct nftnl_rule *r,struct xt_entry_match *m) +int add_match (struct nft_handle *h, +struct nftnl_rule *r,struct xt_entry_match *m) {struct nftnl_expr *expr;int ret;
@@ -1270,7 +1271,7 @@ nft_rule_new(struct nft_handle *h, const char *chain, const char *table,nftnl_rule_set_str (r,NFTNL_RULE_TABLE , table);nftnl_rule_set_str (r,NFTNL_RULE_CHAIN , chain); -if (h->ops->add (r, data) <0 ) +if (h->ops->add (h, r, data) <0 ) goto err;return r;
iptables/nft.h +1 -1
@@ -129,7 +129,7 @@ int nft_rule_zero_counters(struct nft_handle *h, const char *chain, const char **/ int add_counters (struct nftnl_rule *r,uint64_t packets,uint64_t bytes);int add_verdict (struct nftnl_rule *r,int verdict); -int add_match (struct nftnl_rule *r,struct xt_entry_match *m); +int add_match (struct nft_handle *h,struct nftnl_rule *r,struct xt_entry_match *m);int add_target (struct nftnl_rule *r,struct xt_entry_target *t);int add_jumpto (struct nftnl_rule *r,const char *name,int verdict);int add_action (struct nftnl_rule *r,struct iptables_command_state *cs,bool goto_set);
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 2/12 nft: family_ops: Pass nft_handle to 'rule_find' callback
In reply to Phil SutterIn order to prepare for rules containing set references, nft handle has to be passed to nft_rule_to_iptables_command_state() in order to let it access the set in cache.
--- iptables/nft-arp.c | 4 ++-- iptables/nft-bridge.c | 4 ++-- iptables/nft-shared.c | 7 +++---- iptables/nft-shared.h | 4 ++-- iptables/nft.c | 2 +- 5 files changed, 10 insertions(+), 11 deletions(-)
iptables/nft-arp.c +2 -2
@@ -655,7 +655,7 @@ static bool nft_arp_is_same(const void *data_a, (unsigned char *)b->arp.outiface_mask); } -static bool nft_arp_rule_find (struct nft_family_ops *ops,struct nftnl_rule *r, +static bool nft_arp_rule_find (struct nft_handle *h,struct nftnl_rule *r,void *data) {const struct iptables_command_state *cs = data;
@@ -676,7 +676,7 @@ static bool nft_arp_rule_find(struct nft_family_ops *ops, struct nftnl_rule *r, ret = true; out: - ops->clear_cs (&this); + h->ops->clear_cs (&this);return ret; }
iptables/nft-bridge.c +2 -2
@@ -537,7 +537,7 @@ static bool nft_bridge_is_same(const void *data_a, const void *data_b)return strcmp (a->in, b->in) ==0 &&strcmp (a->out, b->out) ==0 ; } -static bool nft_bridge_rule_find (struct nft_family_ops *ops,struct nftnl_rule *r, +static bool nft_bridge_rule_find (struct nft_handle *h,struct nftnl_rule *r,void *data) {struct iptables_command_state *cs = data;
@@ -568,7 +568,7 @@ static bool nft_bridge_rule_find(struct nft_family_ops *ops, struct nftnl_rule * ret = true; out: - ops->clear_cs (&this); + h->ops->clear_cs (&this);return ret; }
iptables/nft-shared.c +3 -4
@@ -982,8 +982,7 @@ void nft_ipv46_parse_target(struct xtables_target *t, void *data) cs->target = t; } -bool nft_ipv46_rule_find (struct nft_family_ops *ops, -struct nftnl_rule *r,void *data) +bool nft_ipv46_rule_find (struct nft_handle *h,struct nftnl_rule *r,void *data) {struct iptables_command_state *cs = data, this = {};bool ret = false;
@@ -994,7 +993,7 @@ bool nft_ipv46_rule_find(struct nft_family_ops *ops,#ifdef DEBUG_DEL nft_rule_print_save (r,NFT_RULE_APPEND ,0 );#endif -if (!ops->is_same (cs, &this)) +if (!h->ops->is_same (cs, &this)) goto out;if (!compare_matches (cs->matches, this.matches)) {
@@ -1014,7 +1013,7 @@ bool nft_ipv46_rule_find(struct nft_family_ops *ops, ret = true; out: - ops->clear_cs (&this); + h->ops->clear_cs (&this);return ret; }
iptables/nft-shared.h +2 -2
@@ -104,7 +104,7 @@ struct nft_family_ops {void (*rule_to_cs)(const struct nftnl_rule *r,struct iptables_command_state *cs);void (*clear_cs)(struct iptables_command_state *cs); -bool (*rule_find)(struct nft_family_ops *ops,struct nftnl_rule *r, +bool (*rule_find)(struct nft_handle *h,struct nftnl_rule *r,void *data);int (*xlate)(const void *data,struct xt_xlate *xl); };
@@ -165,7 +165,7 @@ void save_matches_and_target(const struct iptables_command_state *cs,struct nft_family_ops *nft_family_ops_lookup (int family);void nft_ipv46_parse_target (struct xtables_target *t,void *data); -bool nft_ipv46_rule_find (struct nft_family_ops *ops,struct nftnl_rule *r, +bool nft_ipv46_rule_find (struct nft_handle *h,struct nftnl_rule *r,void *data);bool compare_matches (struct xtables_rule_match *mt1,struct xtables_rule_match *mt2);
iptables/nft.c +1 -1
@@ -2336,7 +2336,7 @@ nft_rule_find(struct nft_handle *h, struct nftnl_chain *c, void *data, int rulen r =nftnl_rule_iter_next (iter);while (r !=NULL ) { - found = h->ops->rule_find (h->ops, r, data); + found = h->ops->rule_find (h, r, data);if (found)break ; r =nftnl_rule_iter_next (iter);
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 3/12 nft: family_ops: Pass nft_handle to 'print_rule' callback
In reply to Phil SutterPrepare for 'rule_to_cs' callback to receive nft_handle pointer so it is able to access cache for set lookups.
--- iptables/nft-arp.c | 3 ++- iptables/nft-bridge.c | 4 ++-- iptables/nft-ipv4.c | 4 ++-- iptables/nft-ipv6.c | 4 ++-- iptables/nft-shared.h | 4 ++-- iptables/nft.c | 19 ++++++++++--------- 6 files changed, 20 insertions(+), 18 deletions(-)
iptables/nft-arp.c +2 -1
@@ -605,7 +605,8 @@ nft_arp_save_rule(const void *data, unsigned int format) }static void -nft_arp_print_rule (struct nftnl_rule *r,unsigned int num,unsigned int format) +nft_arp_print_rule (struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format) {struct iptables_command_state cs = {};
iptables/nft-bridge.c +2 -2
@@ -472,8 +472,8 @@ static void nft_bridge_save_rule(const void *data, unsigned int format)fputc ('\n' , stdout); } -static void nft_bridge_print_rule (struct nftnl_rule *r,unsigned int num, -unsigned int format) +static void nft_bridge_print_rule (struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format) {struct iptables_command_state cs = {};
iptables/nft-ipv4.c +2 -2
@@ -261,8 +261,8 @@ static void print_fragment(unsigned int flags, unsigned int invflags,fputc (' ' , stdout); } -static void nft_ipv4_print_rule (struct nftnl_rule *r,unsigned int num, -unsigned int format) +static void nft_ipv4_print_rule (struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format) {struct iptables_command_state cs = {};
iptables/nft-ipv6.c +2 -2
@@ -187,8 +187,8 @@ static void nft_ipv6_parse_immediate(const char *jumpto, bool nft_goto, cs->fw6.ipv6.flags |=IP6T_F_GOTO ; } -static void nft_ipv6_print_rule (struct nftnl_rule *r,unsigned int num, -unsigned int format) +static void nft_ipv6_print_rule (struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format) {struct iptables_command_state cs = {};
iptables/nft-shared.h +2 -2
@@ -90,8 +90,8 @@ struct nft_family_ops {const char *pol, const struct xt_counters *counters, bool basechain, uint32_t refs, uint32_t entries); -void (*print_rule)(struct nftnl_rule *r,unsigned int num, -unsigned int format); +void (*print_rule)(struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format);void (*save_rule)(const void *data,unsigned int format);void (*save_counters)(const void *data);void (*save_chain)(const struct nftnl_chain *c,const char *policy);
iptables/nft.c +10 -9
@@ -1321,7 +1321,7 @@ nft_rule_append(struct nft_handle *h, const char *chain, const char *table, }if (verbose) - h->ops->print_rule (r,0 ,FMT_PRINT_RULE ); + h->ops->print_rule (h, r,0 ,FMT_PRINT_RULE );if (ref) {nftnl_chain_rule_insert_at (r, ref);
@@ -2364,7 +2364,7 @@ int nft_rule_check(struct nft_handle *h, const char *chain, goto fail_enoent;if (verbose) - h->ops->print_rule (r,0 ,FMT_PRINT_RULE ); + h->ops->print_rule (h, r,0 ,FMT_PRINT_RULE );return 1 ; fail_enoent:
@@ -2393,7 +2393,7 @@ int nft_rule_delete(struct nft_handle *h, const char *chain,if (ret <0 ) errno =ENOMEM ;if (verbose) - h->ops->print_rule (r,0 ,FMT_PRINT_RULE ); + h->ops->print_rule (h, r,0 ,FMT_PRINT_RULE ); }else errno =ENOENT ;
@@ -2434,7 +2434,7 @@ nft_rule_add(struct nft_handle *h, const char *chain, }if (verbose) - h->ops->print_rule (r,0 ,FMT_PRINT_RULE ); + h->ops->print_rule (h, r,0 ,FMT_PRINT_RULE );return r; }
@@ -2543,8 +2543,8 @@ int nft_rule_replace(struct nft_handle *h, const char *chain,static int __nft_rule_list (struct nft_handle *h,struct nftnl_chain *c,int rulenum,unsigned int format, -void (*cb)(struct nftnl_rule *r,unsigned int num, -unsigned int format)) +void (*cb)(struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format)) {struct nftnl_rule_iter *iter;struct nftnl_rule *r;
@@ -2557,7 +2557,7 @@ __nft_rule_list(struct nft_handle *h, struct nftnl_chain *c,* valid chain but invalid rule number */ return 1 ; -cb (r, rulenum, format); +cb (h, r, rulenum, format);return 1 ; }
@@ -2567,7 +2567,7 @@ __nft_rule_list(struct nft_handle *h, struct nftnl_chain *c, r =nftnl_rule_iter_next (iter);while (r !=NULL ) { -cb (r, ++rule_ctr, format); +cb (h, r, ++rule_ctr, format); r =nftnl_rule_iter_next (iter); }
@@ -2671,7 +2671,8 @@ int nft_rule_list(struct nft_handle *h, const char *chain, const char *table, }static void -list_save (struct nftnl_rule *r,unsigned int num,unsigned int format) +list_save (struct nft_handle *h,struct nftnl_rule *r, +unsigned int num,unsigned int format) {nft_rule_print_save (r,NFT_RULE_APPEND , format); }
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 4/12 nft: family_ops: Pass nft_handle to 'rule_to_cs' callback
In reply to Phil SutterThis is the actual callback used to parse nftables rules. Pass nft_handle to it so it can access the cache (and possible sets therein).
Having to pass nft_handle to nft_rule_print_save() allows to simplify it a bit since no family ops lookup has to be done anymore.
--- iptables/nft-arp.c | 4 ++-- iptables/nft-bridge.c | 9 +++++---- iptables/nft-ipv4.c | 2 +- iptables/nft-ipv6.c | 2 +- iptables/nft-shared.c | 5 +++-- iptables/nft-shared.h | 5 +++-- iptables/nft.c | 29 +++++++++++++---------------- iptables/nft.h | 4 ++-- iptables/xtables-monitor.c | 17 +++++++++++++++-- iptables/xtables-save.c | 3 +++ 10 files changed, 48 insertions(+), 32 deletions(-)
iptables/nft-arp.c +2 -2
@@ -613,7 +613,7 @@ nft_arp_print_rule(struct nft_handle *h, struct nftnl_rule *r,if (format &FMT_LINENUMBERS )printf ("%u " , num); -nft_rule_to_iptables_command_state (r, &cs); +nft_rule_to_iptables_command_state (h, r, &cs);nft_arp_print_rule_details (&cs, format);print_matches_and_target (&cs, format);
@@ -664,7 +664,7 @@ static bool nft_arp_rule_find(struct nft_handle *h, struct nftnl_rule *r,bool ret = false;/* Delete by matching rule case */ -nft_rule_to_iptables_command_state (r, &this); +nft_rule_to_iptables_command_state (h, r, &this);if (!nft_arp_is_same (&cs->arp, &this.arp)) goto out;
iptables/nft-bridge.c +5 -4
@@ -333,11 +333,12 @@ static void nft_bridge_parse_target(struct xtables_target *t, void *data) cs->target = t; } -static void nft_rule_to_ebtables_command_state (const struct nftnl_rule *r, +static void nft_rule_to_ebtables_command_state (struct nft_handle *h, +const struct nftnl_rule *r,struct iptables_command_state *cs) { cs->eb.bitmask =EBT_NOPROTO ; -nft_rule_to_iptables_command_state (r, cs); +nft_rule_to_iptables_command_state (h, r, cs); }static void print_iface (const char *option,const char *name,bool invert)
@@ -480,7 +481,7 @@ static void nft_bridge_print_rule(struct nft_handle *h, struct nftnl_rule *r,if (format &FMT_LINENUMBERS )printf ("%d " , num); -nft_rule_to_ebtables_command_state (r, &cs); +nft_rule_to_ebtables_command_state (h, r, &cs);nft_bridge_save_rule (&cs, format);ebt_cs_clean (&cs); }
@@ -544,7 +545,7 @@ static bool nft_bridge_rule_find(struct nft_handle *h, struct nftnl_rule *r,struct iptables_command_state this = {};bool ret = false; -nft_rule_to_ebtables_command_state (r, &this); +nft_rule_to_ebtables_command_state (h, r, &this);DEBUGP ("comparing with... " );
iptables/nft-ipv4.c +1 -1
@@ -266,7 +266,7 @@ static void nft_ipv4_print_rule(struct nft_handle *h, struct nftnl_rule *r, {struct iptables_command_state cs = {}; -nft_rule_to_iptables_command_state (r, &cs); +nft_rule_to_iptables_command_state (h, r, &cs);print_rule_details (&cs, cs.jumpto, cs.fw.ip.flags, cs.fw.ip.invflags, cs.fw.ip.proto, num, format);
iptables/nft-ipv6.c +1 -1
@@ -192,7 +192,7 @@ static void nft_ipv6_print_rule(struct nft_handle *h, struct nftnl_rule *r, {struct iptables_command_state cs = {}; -nft_rule_to_iptables_command_state (r, &cs); +nft_rule_to_iptables_command_state (h, r, &cs); print_rule_details(&cs, cs.jumpto, cs.fw6.ipv6.flags, cs.fw6.ipv6.invflags, cs.fw6.ipv6.proto,
iptables/nft-shared.c +3 -2
@@ -591,7 +591,8 @@ static void nft_parse_limit(struct nft_xt_ctx *ctx, struct nftnl_expr *e) ops->parse_match (match, ctx->cs); } -void nft_rule_to_iptables_command_state (const struct nftnl_rule *r, +void nft_rule_to_iptables_command_state (struct nft_handle *h, +const struct nftnl_rule *r,struct iptables_command_state *cs) {struct nftnl_expr_iter *iter;
@@ -987,7 +988,7 @@ bool nft_ipv46_rule_find(struct nft_handle *h, struct nftnl_rule *r, void *data)struct iptables_command_state *cs = data, this = {};bool ret = false; -nft_rule_to_iptables_command_state (r, &this); +nft_rule_to_iptables_command_state (h, r, &this);DEBUGP ("comparing with... " );#ifdef DEBUG_DEL
iptables/nft-shared.h +3 -2
@@ -101,7 +101,7 @@ struct nft_family_ops { struct xtables_args *args);void (*parse_match)(struct xtables_match *m,void *data);void (*parse_target)(struct xtables_target *t,void *data); -void (*rule_to_cs)(const struct nftnl_rule *r, +void (*rule_to_cs)(struct nft_handle *h,const struct nftnl_rule *r,struct iptables_command_state *cs);void (*clear_cs)(struct iptables_command_state *cs); bool (*rule_find)(struct nft_handle *h, struct nftnl_rule *r,
@@ -138,7 +138,8 @@ int parse_meta(struct nftnl_expr *e, uint8_t key, char *iniface, unsigned char *outiface_mask, uint8_t *invflags);void print_proto (uint16_t proto,int invert);void get_cmp_data (struct nftnl_expr *e,void *data,size_t dlen,bool *inv); -void nft_rule_to_iptables_command_state (const struct nftnl_rule *r, +void nft_rule_to_iptables_command_state (struct nft_handle *h, +const struct nftnl_rule *r,struct iptables_command_state *cs);void nft_clear_iptables_command_state (struct iptables_command_state *cs); void print_header(unsigned int format, const char *chain, const char *pol,
iptables/nft.c +13 -16
@@ -386,7 +386,7 @@ static int mnl_append_error(const struct nft_handle *h, nftnl_rule_get_str(o->rule, NFTNL_RULE_CHAIN));#if 0 { -nft_rule_print_save (o->rule,NFT_RULE_APPEND ,FMT_NOCOUNTS ); +nft_rule_print_save (h, o->rule,NFT_RULE_APPEND ,FMT_NOCOUNTS ); }#endif break ;
@@ -1339,19 +1339,16 @@ nft_rule_append(struct nft_handle *h, const char *chain, const char *table, }void -nft_rule_print_save (const struct nftnl_rule *r,enum nft_rule_print type, -unsigned int format) +nft_rule_print_save (struct nft_handle *h,const struct nftnl_rule *r, +enum nft_rule_print type,unsigned int format) {const char *chain =nftnl_rule_get_str (r,NFTNL_RULE_CHAIN ); -int family =nftnl_rule_get_u32 (r,NFTNL_RULE_FAMILY );struct iptables_command_state cs = {}; -struct nft_family_ops *ops; - ops =nft_family_ops_lookup (family); - ops->rule_to_cs (r, &cs); + h->ops->rule_to_cs (h, r, &cs); -if (!(format & (FMT_NOCOUNTS |FMT_C_COUNTS )) && ops->save_counters) - ops->save_counters (&cs); +if (!(format & (FMT_NOCOUNTS |FMT_C_COUNTS )) && h->ops->save_counters) + h->ops->save_counters (&cs);/* print chain name */ switch (type) {
@@ -1363,11 +1360,11 @@ nft_rule_print_save(const struct nftnl_rule *r, enum nft_rule_print type,break ; } -if (ops->save_rule) - ops->save_rule (&cs, format); +if (h->ops->save_rule) + h->ops->save_rule (&cs, format); -if (ops->clear_cs) - ops->clear_cs (&cs); +if (h->ops->clear_cs) + h->ops->clear_cs (&cs); }struct nftnl_chain_list_cb_data {
@@ -1813,7 +1810,7 @@ static int nft_chain_save_rules(struct nft_handle *h, r =nftnl_rule_iter_next (iter);while (r !=NULL ) { -nft_rule_print_save (r,NFT_RULE_APPEND , format); +nft_rule_print_save (h, r,NFT_RULE_APPEND , format); r =nftnl_rule_iter_next (iter); }
@@ -2674,7 +2671,7 @@ static void list_save(struct nft_handle *h, struct nftnl_rule *r, unsigned int num, unsigned int format) { -nft_rule_print_save (r, NFT_RULE_APPEND, format); +nft_rule_print_save (h, r, NFT_RULE_APPEND, format); }static int __nftnl_rule_list_chain_save (struct nftnl_chain *c,void *data)
@@ -2786,7 +2783,7 @@ int nft_rule_zero_counters(struct nft_handle *h, const char *chain, goto error; } -nft_rule_to_iptables_command_state (r, &cs); +nft_rule_to_iptables_command_state (h, r, &cs); cs.counters.pcnt = cs.counters.bcnt =0 ;
iptables/nft.h +2 -2
@@ -140,8 +140,8 @@ enum nft_rule_print { NFT_RULE_DEL, }; -void nft_rule_print_save (const struct nftnl_rule *r,enum nft_rule_print type, -unsigned int format); +void nft_rule_print_save (struct nft_handle *h,const struct nftnl_rule *r, +enum nft_rule_print type,unsigned int format);uint32_t nft_invflags2cmp (uint32_t invflags,uint32_t flag);
iptables/xtables-monitor.c +15 -2
@@ -11,6 +11,7 @@#define _GNU_SOURCE#include "config.h" +#include <errno.h> #include <stdlib.h> #include <time.h> #include <string.h>
@@ -41,6 +42,7 @@struct cb_arg {uint32_t nfproto;bool is_event; +struct nft_handle *h; };static int table_cb (const struct nlmsghdr *nlh,void *data)
@@ -106,7 +108,7 @@ static int rule_cb(const struct nlmsghdr *nlh, void *data) }printf ("-t %s " ,nftnl_rule_get_str (r,NFTNL_RULE_TABLE )); -nft_rule_print_save (r, type ==NFT_MSG_NEWRULE ?NFT_RULE_APPEND : +nft_rule_print_save (arg->h, r, type ==NFT_MSG_NEWRULE ?NFT_RULE_APPEND :NFT_RULE_DEL , counters ?0 :FMT_NOCOUNTS ); err_free:
@@ -593,7 +595,10 @@ int xtables_monitor_main(int argc, char *argv[])struct mnl_socket *nl;char buf[MNL_SOCKET_BUFFER_SIZE ];uint32_t nfgroup =0 ; -struct cb_arg cb_arg = {}; +struct nft_handle h = {}; +struct cb_arg cb_arg = { + .h = &h, + };int ret, c; xtables_globals.program_name ="xtables-monitor" ;
@@ -610,6 +615,14 @@ int xtables_monitor_main(int argc, char *argv[])init_extensions4 ();#endif +if (nft_init (&h, xtables_ipv4)) { +fprintf (stderr,"%s/%s Failed to initialize nft: %s\n" , + xtables_globals.program_name, + xtables_globals.program_version, +strerror (errno)); +exit (EXIT_FAILURE ); + } + opterr =0 ;while ((c =getopt_long (argc, argv,"ceht46V" , options,NULL )) !=-1 ) {switch (c) {
iptables/xtables-save.c +3 -0
@@ -248,6 +248,9 @@ xtables_save_main(int family, int argc, char *argv[], strerror(errno));exit (EXIT_FAILURE ); } + h.ops =nft_family_ops_lookup (h.family); +if (!h.ops) +xtables_error (PARAMETER_PROBLEM ,"Unknown family" ); ret =do_output (&h, tablename, &d);nft_fini (&h);
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 5/12 nft: Keep nft_handle pointer in nft_xt_ctx
In reply to Phil SutterInstead of carrying the family value, carry the handle (which contains the family value) and relieve expression parsers from having to call nft_family_ops_lookup().
--- iptables/nft-shared.c | 40 ++++++++++++++-------------------------- iptables/nft-shared.h | 2 +- 2 files changed, 15 insertions(+), 27 deletions(-)
iptables/nft-shared.c +14 -26
@@ -310,7 +310,6 @@ static void nft_parse_target(struct nft_xt_ctx *ctx, struct nftnl_expr *e)struct xtables_target *target;struct xt_entry_target *t;size_t size; -struct nft_family_ops *ops;void *data = ctx->cs; target =xtables_find_target (targname,XTF_TRY_LOAD );
@@ -327,8 +326,7 @@ static void nft_parse_target(struct nft_xt_ctx *ctx, struct nftnl_expr *e) target->t = t; - ops =nft_family_ops_lookup (ctx->family); - ops->parse_target (target, data); + ctx->h->ops->parse_target (target, data); }static void nft_parse_match (struct nft_xt_ctx *ctx,struct nftnl_expr *e)
@@ -339,9 +337,8 @@ static void nft_parse_match(struct nft_xt_ctx *ctx, struct nftnl_expr *e)struct xtables_match *match;struct xtables_rule_match **matches;struct xt_entry_match *m; -struct nft_family_ops *ops; -switch (ctx->family) { +switch (ctx->h->family) {case NFPROTO_IPV4 :case NFPROTO_IPV6 :case NFPROTO_BRIDGE :
@@ -349,7 +346,7 @@ static void nft_parse_match(struct nft_xt_ctx *ctx, struct nftnl_expr *e)break ;default :fprintf (stderr,"BUG: nft_parse_match() unknown family %d\n" , - ctx->family); + ctx->h->family);exit (EXIT_FAILURE ); }
@@ -365,9 +362,8 @@ static void nft_parse_match(struct nft_xt_ctx *ctx, struct nftnl_expr *e) match->m = m; - ops =nft_family_ops_lookup (ctx->family); -if (ops->parse_match !=NULL ) - ops->parse_match (match, ctx->cs); +if (ctx->h->ops->parse_match !=NULL ) + ctx->h->ops->parse_match (match, ctx->cs); }void print_proto (uint16_t proto,int invert)
@@ -400,7 +396,6 @@ void get_cmp_data(struct nftnl_expr *e, void *data, size_t dlen, bool *inv)static void nft_meta_set_to_target (struct nft_xt_ctx *ctx) { -const struct nft_family_ops *ops;struct xtables_target *target;struct xt_entry_target *t;unsigned int size;
@@ -429,8 +424,7 @@ static void nft_meta_set_to_target(struct nft_xt_ctx *ctx) target->t = t; - ops =nft_family_ops_lookup (ctx->family); - ops->parse_target (target, ctx->cs); + ctx->h->ops->parse_target (target, ctx->cs); }static void nft_parse_meta (struct nft_xt_ctx *ctx,struct nftnl_expr *e)
@@ -474,7 +468,6 @@ static void nft_parse_bitwise(struct nft_xt_ctx *ctx, struct nftnl_expr *e)static void nft_parse_cmp (struct nft_xt_ctx *ctx,struct nftnl_expr *e) { -struct nft_family_ops *ops =nft_family_ops_lookup (ctx->family);void *data = ctx->cs;uint32_t reg;
@@ -483,12 +476,12 @@ static void nft_parse_cmp(struct nft_xt_ctx *ctx, struct nftnl_expr *e)return ;if (ctx->flags &NFT_XT_CTX_META ) { - ops->parse_meta (ctx, e, data); + ctx->h->ops->parse_meta (ctx, e, data); ctx->flags &= ~NFT_XT_CTX_META ; }/* bitwise context is interpreted from payload */ if (ctx->flags &NFT_XT_CTX_PAYLOAD ) { - ops->parse_payload (ctx, e, data); + ctx->h->ops->parse_payload (ctx, e, data); ctx->flags &= ~NFT_XT_CTX_PAYLOAD ; } }
@@ -502,7 +495,6 @@ static void nft_parse_counter(struct nftnl_expr *e, struct xt_counters *countersstatic void nft_parse_immediate (struct nft_xt_ctx *ctx,struct nftnl_expr *e) {const char *chain =nftnl_expr_get_str (e,NFTNL_EXPR_IMM_CHAIN ); -struct nft_family_ops *ops;const char *jumpto =NULL ;bool nft_goto = false;void *data = ctx->cs;
@@ -544,8 +536,7 @@ static void nft_parse_immediate(struct nft_xt_ctx *ctx, struct nftnl_expr *e)break ; } - ops =nft_family_ops_lookup (ctx->family); - ops->parse_immediate (jumpto, nft_goto, data); + ctx->h->ops->parse_immediate (jumpto, nft_goto, data); }static void nft_parse_limit (struct nft_xt_ctx *ctx,struct nftnl_expr *e)
@@ -555,11 +546,10 @@ static void nft_parse_limit(struct nft_xt_ctx *ctx, struct nftnl_expr *e)__u64 rate =nftnl_expr_get_u64 (e,NFTNL_EXPR_LIMIT_RATE );struct xtables_rule_match **matches;struct xtables_match *match; -struct nft_family_ops *ops;struct xt_rateinfo *rinfo;size_t size; -switch (ctx->family) { +switch (ctx->h->family) {case NFPROTO_IPV4 :case NFPROTO_IPV6 :case NFPROTO_BRIDGE :
@@ -567,7 +557,7 @@ static void nft_parse_limit(struct nft_xt_ctx *ctx, struct nftnl_expr *e)break ;default :fprintf (stderr,"BUG: nft_parse_limit() unknown family %d\n" , - ctx->family); + ctx->h->family);exit (EXIT_FAILURE ); }
@@ -586,9 +576,8 @@ static void nft_parse_limit(struct nft_xt_ctx *ctx, struct nftnl_expr *e) rinfo->avg =XT_LIMIT_SCALE * unit / rate; rinfo->burst = burst; - ops =nft_family_ops_lookup (ctx->family); -if (ops->parse_match !=NULL ) - ops->parse_match (match, ctx->cs); +if (ctx->h->ops->parse_match !=NULL ) + ctx->h->ops->parse_match (match, ctx->cs); } void nft_rule_to_iptables_command_state(struct nft_handle *h,
@@ -597,10 +586,9 @@ void nft_rule_to_iptables_command_state(struct nft_handle *h, {struct nftnl_expr_iter *iter;struct nftnl_expr *expr; -int family =nftnl_rule_get_u32 (r,NFTNL_RULE_FAMILY );struct nft_xt_ctx ctx = { .cs = cs, - .family = family, + .h = h, }; iter =nftnl_expr_iter_create (r);
iptables/nft-shared.h +1 -1
@@ -48,7 +48,7 @@ enum {struct nft_xt_ctx {struct iptables_command_state *cs;struct nftnl_expr_iter *iter; -int family; +struct nft_handle *h;uint32_t flags;uint32_t reg;
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 6/12 nft: Eliminate pointless calls to nft_family_ops_lookup()
In reply to Phil SutterIf nft_handle is available, use its 'ops' field instead of performing a new lookup. For the same reason, there is no need to pass ops pointer to __nft_print_header().
--- iptables/nft.c | 29 +++++++++++------------------ 1 file changed, 11 insertions(+), 18 deletions(-)
iptables/nft.c +11 -18
@@ -1757,11 +1757,8 @@ static const char *policy_name[NF_ACCEPT+1] = {int nft_chain_save (struct nft_handle *h,struct nftnl_chain_list *list) {struct nftnl_chain_list_iter *iter; -struct nft_family_ops *ops;struct nftnl_chain *c; - ops =nft_family_ops_lookup (h->family); - iter =nftnl_chain_list_iter_create (list);if (iter ==NULL )return 0 ;
@@ -1787,8 +1784,8 @@ int nft_chain_save(struct nft_handle *h, struct nftnl_chain_list *list) } } -if (ops->save_chain) - ops->save_chain (c, policy); +if (h->ops->save_chain) + h->ops->save_chain (c, policy); c =nftnl_chain_list_iter_next (iter); }
@@ -2593,7 +2590,6 @@ static int nft_rule_count(struct nft_handle *h, struct nftnl_chain *c) }static void __nft_print_header (struct nft_handle *h, -const struct nft_family_ops *ops,struct nftnl_chain *c,unsigned int format) {const char *chain_name =nftnl_chain_get_str (c,NFTNL_CHAIN_NAME );
@@ -2609,14 +2605,13 @@ static void __nft_print_header(struct nft_handle *h,if (nftnl_chain_is_set (c,NFTNL_CHAIN_POLICY )) pname = policy_name[nftnl_chain_get_u32 (c,NFTNL_CHAIN_POLICY )]; - ops->print_header (format, chain_name, pname, + h->ops->print_header (format, chain_name, pname, &ctrs, basechain, refs - entries, entries); }int nft_rule_list (struct nft_handle *h,const char *chain,const char *table,int rulenum,unsigned int format) { -const struct nft_family_ops *ops;struct nftnl_chain_list *list;struct nftnl_chain_list_iter *iter;struct nftnl_chain *c;
@@ -2625,8 +2620,6 @@ int nft_rule_list(struct nft_handle *h, const char *chain, const char *table,nft_xt_builtin_init (h, table);nft_assert_table_compatible (h, table, chain); - ops =nft_family_ops_lookup (h->family); - list =nft_chain_list_get (h, table, chain);if (!list)return 0 ;
@@ -2637,11 +2630,11 @@ int nft_rule_list(struct nft_handle *h, const char *chain, const char *table,return 0 ;if (!rulenum) { -if (ops->print_table_header) - ops->print_table_header (table); -__nft_print_header (h, ops, c, format); +if (h->ops->print_table_header) + h->ops->print_table_header (table); +__nft_print_header (h, c, format); } -__nft_rule_list (h, c, rulenum, format, ops->print_rule); +__nft_rule_list (h, c, rulenum, format, h->ops->print_rule);return 1 ; }
@@ -2649,16 +2642,16 @@ int nft_rule_list(struct nft_handle *h, const char *chain, const char *table,if (iter ==NULL )return 0 ; -if (ops->print_table_header) - ops->print_table_header (table); +if (h->ops->print_table_header) + h->ops->print_table_header (table); c =nftnl_chain_list_iter_next (iter);while (c !=NULL ) {if (found)printf ("\n" ); -__nft_print_header (h, ops, c, format); -__nft_rule_list (h, c, rulenum, format, ops->print_rule); +__nft_print_header (h, c, format); +__nft_rule_list (h, c, rulenum, format, h->ops->print_rule); found = true; c =nftnl_chain_list_iter_next (iter);
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 7/12 nft: Fetch sets when updating rule cache
In reply to Phil SutterIn order to support anonymous sets, cache them along with their elements.
---
Changes since v1:
- Fix cache flushing: Since set fetching happens only if rules are fetched, too, set list may be NULL so call nftnl_set_list_free() and nftnl_set_list_foreach() conditionally.
- Support fetching only a specific set from kernel. Make sure no duplicate element fetches happen by checking set element count. (If non-zero, don't fetch elements.)
- When fetching rules for a single chain, fetch only that table's sets.
--- iptables/nft.c | 208 +++++++++++++++++++++++++++++++++++++++++++++++-- iptables/nft.h | 8 ++ 2 files changed, 211 insertions(+), 5 deletions(-)
iptables/nft.c +203 -5
@@ -874,6 +874,14 @@ static int __flush_chain_cache(struct nftnl_chain *c, void *data)return 0 ; } +static int __flush_set_cache (struct nftnl_set *s,void *data) +{ +nftnl_set_list_del (s); +nftnl_set_free (s); + +return 0 ; +} +static int flush_cache (struct nft_cache *c,const struct builtin_table *tables,const char *tablename) {
@@ -882,10 +890,14 @@ static int flush_cache(struct nft_cache *c, const struct builtin_table *tables,if (tablename) { table =__nft_table_builtin_find (tables, tablename); -if (!table || !c->table[table->type].chains) +if (!table)return 0 ; -nftnl_chain_list_foreach (c->table[table->type].chains, - __flush_chain_cache,NULL ); +if (c->table[table->type].chains) +nftnl_chain_list_foreach (c->table[table->type].chains, + __flush_chain_cache,NULL ); +if (c->table[table->type].sets) +nftnl_set_list_foreach (c->table[table->type].sets, + __flush_set_cache,NULL );return 0 ; }
@@ -898,6 +910,9 @@ static int flush_cache(struct nft_cache *c, const struct builtin_table *tables,nftnl_chain_list_free (c->table[i].chains); c->table[i].chains =NULL ; +if (c->table[i].sets) +nftnl_set_list_free (c->table[i].sets); + c->table[i].sets =NULL ; }nftnl_table_list_free (c->tables); c->tables =NULL ;
@@ -1457,6 +1472,159 @@ static int fetch_table_cache(struct nft_handle *h)return 1 ; } +struct nftnl_set_list_cb_data { +struct nft_handle *h; +const struct builtin_table *t; +}; + +static int nftnl_set_list_cb (const struct nlmsghdr *nlh,void *data) +{ +struct nftnl_set_list_cb_data *d = data; +const struct builtin_table *t = d->t; +struct nftnl_set_list *list; +struct nft_handle *h = d->h; +const char *tname, *sname; +struct nftnl_set *s; + + s =nftnl_set_alloc (); +if (s ==NULL ) +return MNL_CB_OK ; + +if (nftnl_set_nlmsg_parse (nlh, s) <0 ) + goto out_free; + + tname =nftnl_set_get_str (s,NFTNL_SET_TABLE ); + +if (!t) + t =nft_table_builtin_find (h, tname); +else if (strcmp (t->name, tname)) + goto out_free; + +if (!t) + goto out_free; + + list = h->cache->table[t->type].sets; + sname =nftnl_set_get_str (s,NFTNL_SET_NAME ); + +if (nftnl_set_list_lookup_byname (list, sname)) + goto out_free; + +nftnl_set_list_add_tail (s, list); + +return MNL_CB_OK ; +out_free: +nftnl_set_free (s); +return MNL_CB_OK ; +} + +static int set_elem_cb (const struct nlmsghdr *nlh,void *data) +{ +return nftnl_set_elems_nlmsg_parse (nlh, data) ?-1 :MNL_CB_OK ; +} + +static bool set_has_elements (struct nftnl_set *s) +{ +struct nftnl_set_elems_iter *iter; +bool ret = false; + + iter =nftnl_set_elems_iter_create (s); +if (iter) { + ret = !!nftnl_set_elems_iter_cur (iter); +nftnl_set_elems_iter_destroy (iter); + } +return ret; +} + +static int set_fetch_elem_cb (struct nftnl_set *s,void *data) +{ +char buf[MNL_SOCKET_BUFFER_SIZE ]; +struct nft_handle *h = data; +struct nlmsghdr *nlh; + +if (set_has_elements (s)) +return 0 ; + + nlh =nftnl_nlmsg_build_hdr (buf,NFT_MSG_GETSETELEM , h->family, +NLM_F_DUMP , h->seq); +nftnl_set_elems_nlmsg_build_payload (nlh, s); + +return mnl_talk (h, nlh, set_elem_cb, s); +} + +static int fetch_set_cache (struct nft_handle *h, +const struct builtin_table *t,const char *set) +{ +struct nftnl_set_list_cb_data d = { + .h = h, + .t = t, + }; +struct nlmsghdr *nlh; +char buf[16536 ]; +int i, ret; + +if (!t) { +fetch_table_cache (h); + +for (i =0 ; i <NFT_TABLE_MAX ; i++) { +enum nft_table_type type = h->tables[i].type; + +if (!h->tables[i].name) +continue ; + + h->cache->table[type].sets =nftnl_set_list_alloc (); +if (!h->cache->table[type].sets) +return -1 ; + } + }else if (!h->cache->table[t->type].sets) { + h->cache->table[t->type].sets =nftnl_set_list_alloc (); + } + +if (t && set) { +struct nftnl_set *s =nftnl_set_alloc (); + +if (!s) +return -1 ; + + nlh =nftnl_set_nlmsg_build_hdr (buf,NFT_MSG_GETSET , h->family, +NLM_F_ACK , h->seq); +nftnl_set_set_str (s,NFTNL_SET_TABLE , t->name); +nftnl_set_set_str (s,NFTNL_SET_NAME , set); +nftnl_set_nlmsg_build_payload (nlh, s); +nftnl_set_free (s); + }else { + nlh =nftnl_set_nlmsg_build_hdr (buf,NFT_MSG_GETSET , h->family, +NLM_F_DUMP , h->seq); + } + + ret =mnl_talk (h, nlh, nftnl_set_list_cb, &d); +if (ret <0 && errno ==EINTR ) { +assert (nft_restart (h) >=0 ); +return ret; + } + +if (t && set) { +struct nftnl_set *s; + + s =nftnl_set_list_lookup_byname (h->cache->table[t->type].sets, + set); +set_fetch_elem_cb (s, h); + }else if (t) { +nftnl_set_list_foreach (h->cache->table[t->type].sets, + set_fetch_elem_cb, h); + }else { +for (i =0 ; i <NFT_TABLE_MAX ; i++) { +enum nft_table_type type = h->tables[i].type; + +if (!h->tables[i].name) +continue ; + +nftnl_set_list_foreach (h->cache->table[type].sets, + set_fetch_elem_cb, h); + } + } +return ret; +} +static int fetch_chain_cache (struct nft_handle *h,const struct builtin_table *t,const char *chain) {
@@ -1651,15 +1819,29 @@ static int fetch_rule_cache(struct nft_handle *h, struct nftnl_chain *c)if (h->have_cache)return 0 ; -if (c) -return nft_rule_list_update (c, h); +if (c) { +const struct builtin_table *t; +const char *tname; + + tname =nftnl_chain_get_str (c,NFTNL_CHAIN_TABLE ); + t =nft_table_builtin_find (h, tname); +if (!t) +return -1 ; +if (fetch_set_cache (h, t,NULL )) +return -1 ; + +return nft_rule_list_update (c, h); + }for (i =0 ; i <NFT_TABLE_MAX ; i++) {enum nft_table_type type = h->tables[i].type;if (!h->tables[i].name)continue ; +if (fetch_set_cache (h, &h->tables[i],NULL )) +return -1 ; +if (nftnl_chain_list_foreach (h->cache->table[type].chains, nft_rule_list_update, h))return -1 ;
@@ -1749,6 +1931,22 @@ struct nftnl_chain_list *nft_chain_list_get(struct nft_handle *h,return h->cache->table[t->type].chains; } +struct nftnl_set_list *nft_set_list_get (struct nft_handle *h, +const char *table, +const char *set) +{ +const struct builtin_table *t; + + t =nft_table_builtin_find (h, table); +if (!t) +return NULL ; + +if (!h->have_cache) +fetch_set_cache (h, t, set); + +return h->cache->table[t->type].sets; +} +static const char *policy_name[NF_ACCEPT +1 ] = { [NF_DROP ] ="DROP" , [NF_ACCEPT ] ="ACCEPT" ,
iptables/nft.h +8 -0
@@ -31,6 +31,7 @@ struct nft_cache {struct nftnl_table_list *tables;struct {struct nftnl_chain_list *chains; +struct nftnl_set_list *sets;bool initialized; } table[NFT_TABLE_MAX ]; };
@@ -89,6 +90,13 @@ int nft_table_flush(struct nft_handle *h, const char *table);void nft_table_new (struct nft_handle *h,const char *table);const struct builtin_table *nft_table_builtin_find (struct nft_handle *h,const char *table); +/* +* Operations with sets. +*/ +struct nftnl_set_list *nft_set_list_get (struct nft_handle *h, +const char *table, +const char *set); +/* * Operations with chains. */
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 8/12 nft: Support NFT_COMPAT_SET_ADD
In reply to Phil SutterImplement the required infrastructure to create sets as part of a batch job commit.
--- iptables/nft.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)
iptables/nft.c +58 -0
@@ -306,6 +306,7 @@ enum obj_update_type {NFT_COMPAT_RULE_REPLACE ,NFT_COMPAT_RULE_DELETE ,NFT_COMPAT_RULE_FLUSH , + NFT_COMPAT_SET_ADD, }; enum obj_action {
@@ -323,6 +324,7 @@ struct obj_update {struct nftnl_table *table;struct nftnl_chain *chain;struct nftnl_rule *rule; +struct nftnl_set *set;void *ptr; };struct {
@@ -350,6 +352,7 @@ static int mnl_append_error(const struct nft_handle *h, [NFT_COMPAT_RULE_REPLACE] = "RULE_REPLACE", [NFT_COMPAT_RULE_DELETE] = "RULE_DELETE", [NFT_COMPAT_RULE_FLUSH] = "RULE_FLUSH", + [NFT_COMPAT_SET_ADD] = "SET_ADD", };char errmsg[256 ];char tcr[128 ];
@@ -390,6 +393,10 @@ static int mnl_append_error(const struct nft_handle *h, }#endif break ; +case NFT_COMPAT_SET_ADD : +snprintf (tcr,sizeof (tcr),"set %s" , +nftnl_set_get_str (o->set,NFTNL_SET_NAME )); +break ; }return snprintf (buf, len,"%s: %s" , errmsg, tcr);
@@ -419,6 +426,13 @@ batch_table_add(struct nft_handle *h, enum obj_update_type type,return batch_add (h, type, t); } +static struct obj_update * +batch_set_add (struct nft_handle *h,enum obj_update_type type, +struct nftnl_set *s) +{ +return batch_add (h, type, s); +} +static int batch_chain_add (struct nft_handle *h,enum obj_update_type type,struct nftnl_chain *c) {
@@ -2995,6 +3009,39 @@ static void nft_compat_table_batch_add(struct nft_handle *h, uint16_t type,nftnl_table_nlmsg_build_payload (nlh, table); } +static void nft_compat_set_batch_add (struct nft_handle *h,uint16_t type, +uint16_t flags,uint32_t seq, +struct nftnl_set *set) +{ +struct nlmsghdr *nlh; + + nlh =nftnl_nlmsg_build_hdr (nftnl_batch_buffer (h->batch), + type, h->family, flags, seq); +nftnl_set_nlmsg_build_payload (nlh, set); +} + +static void nft_compat_setelem_batch_add (struct nft_handle *h,uint16_t type, +uint16_t flags,uint32_t *seq, +struct nftnl_set *set) +{ +struct nftnl_set_elems_iter *iter; +struct nlmsghdr *nlh; + + iter =nftnl_set_elems_iter_create (set); +if (!iter) +return ; + +while (nftnl_set_elems_iter_cur (iter)) { + (*seq)++; +mnl_nft_batch_continue (h->batch); + nlh =nftnl_nlmsg_build_hdr (nftnl_batch_buffer (h->batch), + type, h->family, flags, *seq); +if (nftnl_set_elems_nlmsg_build_payload_iter (nlh, iter) <=0 ) +break ; + } +nftnl_set_elems_iter_destroy (iter); +} +static void nft_compat_chain_batch_add (struct nft_handle *h,uint16_t type,uint16_t flags,uint32_t seq,struct nftnl_chain *chain)
@@ -3044,6 +3091,9 @@ static void batch_obj_del(struct nft_handle *h, struct obj_update *o)case NFT_COMPAT_RULE_FLUSH :nftnl_rule_free (o->rule);break ; +case NFT_COMPAT_SET_ADD : +nftnl_set_free (o->set); +break ; } h->obj_list_num--;list_del (&o->head);
@@ -3110,6 +3160,7 @@ static void nft_refresh_transaction(struct nft_handle *h)case NFT_COMPAT_RULE_REPLACE :case NFT_COMPAT_RULE_DELETE :case NFT_COMPAT_RULE_FLUSH : +case NFT_COMPAT_SET_ADD :break ; } }
@@ -3200,6 +3251,13 @@ retry:nft_compat_rule_batch_add (h,NFT_MSG_DELRULE ,0 , n->seq, n->rule);break ; +case NFT_COMPAT_SET_ADD : +nft_compat_set_batch_add (h,NFT_MSG_NEWSET , +NLM_F_CREATE , n->seq, n->set); +nft_compat_setelem_batch_add (h,NFT_MSG_NEWSETELEM , +NLM_F_CREATE , &n->seq, n->set); + seq = n->seq; +break ; }mnl_nft_batch_continue (h->batch);
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 9/12 nft: Bore up nft_parse_payload()
In reply to Phil SutterAllow for closer inspection by storing payload expression's base and length values. Also facilitate for two consecutive payload expressions as LHS of a (cmp/lookup) statement as used with concatenations.
--- iptables/nft-shared.c | 8 ++++++++ iptables/nft-shared.h | 4 +++- 2 files changed, 11 insertions(+), 1 deletion(-)
iptables/nft-shared.c +8 -0
@@ -445,8 +445,16 @@ static void nft_parse_meta(struct nft_xt_ctx *ctx, struct nftnl_expr *e)static void nft_parse_payload (struct nft_xt_ctx *ctx,struct nftnl_expr *e) { +if (ctx->flags &NFT_XT_CTX_PAYLOAD ) { +memcpy (&ctx->prev_payload, &ctx->payload, +sizeof (ctx->prev_payload)); + ctx->flags |=NFT_XT_CTX_PREV_PAYLOAD ; + } + ctx->reg =nftnl_expr_get_u32 (e,NFTNL_EXPR_META_DREG ); + ctx->payload.base =nftnl_expr_get_u32 (e,NFTNL_EXPR_PAYLOAD_BASE ); ctx->payload.offset =nftnl_expr_get_u32 (e,NFTNL_EXPR_PAYLOAD_OFFSET ); + ctx->payload.len =nftnl_expr_get_u32 (e,NFTNL_EXPR_PAYLOAD_LEN ); ctx->flags |=NFT_XT_CTX_PAYLOAD ; }
iptables/nft-shared.h +3 -1
@@ -43,6 +43,7 @@ enum {NFT_XT_CTX_META = (1 <<1 ),NFT_XT_CTX_BITWISE = (1 <<2 ),NFT_XT_CTX_IMMEDIATE = (1 <<3 ), + NFT_XT_CTX_PREV_PAYLOAD = (1 << 4), }; struct nft_xt_ctx {
@@ -53,9 +54,10 @@ struct nft_xt_ctx {uint32_t reg;struct { +uint32_t base;uint32_t offset;uint32_t len; - } payload; + } payload, prev_payload;struct {uint32_t key; } meta;
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 10/12 nft: Embed rule's table name in nft_xt_ctx
In reply to Phil SutterDown to the point where expression parsing happens, the rule's table is not known anymore but relevant if set lookups are required.
--- iptables/nft-shared.c | 1 + iptables/nft-shared.h | 1 + 2 files changed, 2 insertions(+)
iptables/nft-shared.c +1 -0
@@ -597,6 +597,7 @@ void nft_rule_to_iptables_command_state(struct nft_handle *h,struct nft_xt_ctx ctx = { .cs = cs, .h = h, + .table =nftnl_rule_get_str (r,NFTNL_RULE_TABLE ), }; iter =nftnl_expr_iter_create (r);
iptables/nft-shared.h +1 -0
@@ -51,6 +51,7 @@ struct nft_xt_ctx {struct nftnl_expr_iter *iter;struct nft_handle *h;uint32_t flags; +const char *table;uint32_t reg;struct {
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 11/12 nft: Support parsing lookup expression
In reply to Phil SutterAdd required glue code to support family specific lookup expression parsers implemented as family_ops callback.
--- iptables/nft-shared.c | 9 +++++++++ iptables/nft-shared.h | 2 ++ iptables/nft.c | 5 ++++- 3 files changed, 15 insertions(+), 1 deletion(-)
iptables/nft-shared.c +9 -0
@@ -588,6 +588,13 @@ static void nft_parse_limit(struct nft_xt_ctx *ctx, struct nftnl_expr *e) ctx->h->ops->parse_match (match, ctx->cs); } +static void nft_parse_lookup (struct nft_xt_ctx *ctx,struct nft_handle *h, +struct nftnl_expr *e) +{ +if (ctx->h->ops->parse_lookup) + ctx->h->ops->parse_lookup (ctx, e,NULL ); +} +void nft_rule_to_iptables_command_state (struct nft_handle *h,const struct nftnl_rule *r,struct iptables_command_state *cs)
@@ -628,6 +635,8 @@ void nft_rule_to_iptables_command_state(struct nft_handle *h,nft_parse_target (&ctx, expr); else if (strcmp(name, "limit") == 0) nft_parse_limit(&ctx, expr); + else if (strcmp(name, "lookup") == 0) + nft_parse_lookup(&ctx, h, expr); expr = nftnl_expr_iter_next(iter); }
iptables/nft-shared.h +2 -0
@@ -86,6 +86,8 @@ struct nft_family_ops { void *data);void (*parse_cmp)(struct nft_xt_ctx *ctx,struct nftnl_expr *e,void *data); +void (*parse_lookup)(struct nft_xt_ctx *ctx,struct nftnl_expr *e, +void *data);void (*parse_immediate)(const char *jumpto,bool nft_goto,void *data);void (*print_table_header)(const char *tablename);
iptables/nft.c +4 -1
@@ -1085,6 +1085,8 @@ int add_match(struct nft_handle *h,if (!strcmp (m->u.user.name,"limit" ))return add_nft_limit (r, m); +else if (!strcmp (m->u.user.name,"among" )) +return add_nft_among (h, r, m); expr =nftnl_expr_alloc ("match" );if (expr ==NULL )
@@ -3697,7 +3699,8 @@ static const char *supported_exprs[] = {"cmp" ,"bitwise" ,"counter" , - "immediate" +"immediate" , + "lookup" };
Signature · 1 line
2.23.0
Phil Sutter
reviewerPATCH v2 12/12 nft: bridge: Rudimental among extension support
In reply to Phil SutterSupport among match as far as possible given the limitations of nftables sets, namely limited to homogeneous MAC address only or MAC and IP address only matches.
---
Changes since v1:
- Fix for overlong lines.
- Use nftnl_set_list_lookup_byname() from libnftnl.
--- extensions/libebt_among.c | 278 ++++++++++++++++++++++++++++++++++++++ extensions/libebt_among.t | 16 +++ iptables/ebtables-nft.8 | 66 ++++----- iptables/nft-bridge.c | 222 ++++++++++++++++++++++++++++++ iptables/nft-bridge.h | 21 +++ iptables/nft.c | 147 ++++++++++++++++++++ iptables/xtables-eb.c | 1 + 7 files changed, 720 insertions(+), 31 deletions(-) create mode 100644 extensions/libebt_among.c create mode 100644 extensions/libebt_among.t
extensions/libebt_among.c new file +278 -0
@@ -0,0 +1,278 @@ +/* ebt_among +* +* Authors: +* Grzegorz Borowiak <[email protected]> +* +* August, 2003 +*/ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <getopt.h> +#include <ctype.h> +#include <unistd.h> +#include <netinet/ether.h> +#include <linux/if_ether.h> +#include <linux/netfilter_bridge/ebt_among.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <xtables.h> +#include "iptables/nft.h" +#include "iptables/nft-bridge.h" + +#define AMONG_DST '1' +#define AMONG_SRC '2' +#define AMONG_DST_F '3' +#define AMONG_SRC_F '4' + +static const struct option bramong_opts[] = { + {"among-dst" , required_argument,0 ,AMONG_DST }, + {"among-src" , required_argument,0 ,AMONG_SRC }, + {"among-dst-file" , required_argument,0 ,AMONG_DST_F }, + {"among-src-file" , required_argument,0 ,AMONG_SRC_F }, + {0 } +}; + +static void bramong_print_help (void ) +{ +printf ( +"`among' options:\n" +"--among-dst [!] list : matches if ether dst is in list\n" +"--among-src [!] list : matches if ether src is in list\n" +"--among-dst-file [!] file : obtain dst list from file\n" +"--among-src-file [!] file : obtain src list from file\n" +"list has form:\n" +" xx:xx:xx:xx:xx:xx[=ip.ip.ip.ip],yy:yy:yy:yy:yy:yy[=ip.ip.ip.ip]" +",...,zz:zz:zz:zz:zz:zz[=ip.ip.ip.ip][,]\n" +"Things in brackets are optional.\n" +"If you want to allow two (or more) IP addresses to one MAC address, you\n" +"can specify two (or more) pairs with the same MAC, e.g.\n" +" 00:00:00:fa:eb:fe=153.19.120.250,00:00:00:fa:eb:fe=192.168.0.1\n" + ); +} + +static int +parse_nft_among_pairs (char *buf,struct nft_among_pair **pairsp, +int *cntp,bool *ipp) +{ +struct nft_among_pair *pairs; +int cnt =0 , i, idx =0 ; +bool ip = false; +char *p; + +if (*buf) + cnt++; +for (p = buf; *p; p++) { +if (*p ==',' ) + cnt++; + } +if (!cnt) +return -1 ; + + pairs =xtables_calloc (cnt,sizeof (*pairs)); + p =strtok (buf,"," ); +while (p) { +struct nft_among_pair tmpair = {}; +unsigned int tmp[ETH_ALEN ] = {}; +char *sep =index (p,'=' ); + +if (sep) { +if (idx >0 && !ip) +xtables_error (PARAMETER_PROBLEM , +"among: Mixed MAC and MAC=IP not allowed." ); + ip = true; + *sep ='\0' ; +if (sscanf (sep +1 ,"%d.%d.%d.%d" , + &tmp[0 ], &tmp[1 ], &tmp[2 ], &tmp[3 ]) !=4 ) +xtables_error (PARAMETER_PROBLEM , +"Invalid IP address '%s'\n" , + sep +1 ); +for (i =0 ; i <4 ; i++) { +if (tmp[i] >255 ) +xtables_error (PARAMETER_PROBLEM , +"Invalid IP address '%s'\n" , + sep +1 ); + tmpair.ip[i] = tmp[i]; + } + }else if (idx >0 && ip) { +xtables_error (PARAMETER_PROBLEM , +"among: Mixed MAC and MAC=IP not allowed." ); + } +if (sscanf (p,"%x:%x:%x:%x:%x:%x" , + &tmp[0 ], &tmp[1 ], &tmp[2 ], + &tmp[3 ], &tmp[4 ], &tmp[5 ]) !=6 ) +xtables_error (PARAMETER_PROBLEM , +"Invalid MAC address '%s'\n" , p); +for (i =0 ; i <ETH_ALEN ; i++) { +if (tmp[i] >255 ) +xtables_error (PARAMETER_PROBLEM , +"Invalid MAC address '%s'\n" , p); + tmpair.mac[i] = tmp[i]; + } +for (i =0 ; i < idx; i++) { +if (memcmp (tmpair.buf, pairs[i].buf, +sizeof (tmpair.buf)) <0 ) +break ; + } +memmove (pairs + i +1 , pairs + i,sizeof (*pairs) * (idx - i)); +memcpy (pairs + i, &tmpair,sizeof (tmpair)); + idx++; + p =strtok (NULL ,"," ); + } + +if (pairsp) + *pairsp = pairs; +if (cntp) + *cntp = cnt; +if (ipp) + *ipp = ip; +return 0 ; +} + +static int bramong_parse (int c,char **argv,int invert, +unsigned int *flags,const void *entry, +struct xt_entry_match **match) +{ +struct nft_among_data *data = (struct nft_among_data *)(*match)->data; +struct xt_entry_match *new_match; +struct nft_among_pair *pairs; +struct stat stats; +bool dst = false; +int fd =-1 , cnt; +size_t new_size; +long flen =0 ; +int poff; +bool ip; +int ret; + +switch (c) { +case AMONG_DST_F : + dst = true; +/* fall through */ +case AMONG_SRC_F : +if ((fd =open (optarg,O_RDONLY )) ==-1 ) +xtables_error (PARAMETER_PROBLEM , +"Couldn't open file '%s'" , optarg); +fstat (fd, &stats); + flen = stats.st_size; +/* use mmap because the file will probably be big */ + optarg =mmap (0 , flen,PROT_READ |PROT_WRITE , +MAP_PRIVATE , fd,0 ); +if (optarg ==MAP_FAILED ) +xtables_error (PARAMETER_PROBLEM , +"Couldn't map file to memory" ); +if (optarg[flen-1 ] !='\n' ) +xtables_error (PARAMETER_PROBLEM , +"File should end with a newline" ); +if (strchr (optarg,'\n' ) != optarg+flen-1 ) +xtables_error (PARAMETER_PROBLEM , +"File should only contain one line" ); + optarg[flen-1 ] ='\0' ; +/* fall through */ +case AMONG_DST : +if (c ==AMONG_DST ) + dst = true; +/* fall through */ +case AMONG_SRC : +break ; +default : +return 0 ; + } + + ret =parse_nft_among_pairs (optarg, &pairs, &cnt, &ip); +if (ret) +return 0 ; + new_size = data->src.cnt + data->dst.cnt + cnt; + new_size *=sizeof (struct nft_among_pair ); + new_size +=XT_ALIGN (sizeof (struct xt_entry_match )) + +sizeof (struct nft_among_data ); + new_match =xtables_calloc (1 , new_size); +memcpy (new_match, *match, (*match)->u.match_size); + new_match->u.match_size = new_size; + + data = (struct nft_among_data *)new_match->data; +if (dst) { + data->dst.cnt = cnt; + data->dst.inv = invert; + data->dst.ip = ip; + poff = data->src.cnt; + }else { + data->src.cnt = cnt; + data->src.inv = invert; + data->src.ip = ip; + poff =0 ; +memmove (data->pairs + cnt, data->pairs, + data->dst.cnt *sizeof (struct nft_among_pair )); + } +memcpy (data->pairs + poff, pairs, cnt *sizeof (struct nft_among_pair )); +free (pairs); +free (*match); + *match = new_match; + +if (c ==AMONG_DST_F || c ==AMONG_SRC_F ) { +munmap (argv, flen); +close (fd); + } +return 1 ; +} + +static void __bramong_print (struct nft_among_pair *pairs, +int cnt,bool inv,bool ip) +{ +const char *isep ="" , *sep; +int i, j; + +if (inv) +printf ("! " ); + +for (i =0 ; i < cnt; i++) { +printf ("%s" , isep); + isep ="," ; + +for (sep ="" , j =0 ; j <ETH_ALEN ; sep =":" , j++) +printf ("%s%02x" , sep, pairs[i].mac[j]); + +if (!ip) +continue ; +for (sep ="=" , j =0 ; j <4 ; sep ="." , j++) +printf ("%s%u" , sep, pairs[i].ip[j]); + } +printf (" " ); +} + +static void bramong_print (const void *ip,const struct xt_entry_match *match, +int numeric) +{ +struct nft_among_data *data = (struct nft_among_data *)match->data; + +if (data->src.cnt) { +printf ("--among-src " ); +__bramong_print (data->pairs, + data->src.cnt, data->src.inv, data->src.ip); + } +if (data->dst.cnt) { +printf ("--among-dst " ); +__bramong_print (data->pairs + data->src.cnt, + data->dst.cnt, data->dst.inv, data->dst.ip); + } +} + +static struct xtables_match bramong_match = { + .name ="among" , + .revision =0 , + .version =XTABLES_VERSION , + .family =NFPROTO_BRIDGE , + .size =XT_ALIGN (sizeof (struct nft_among_data )), + .userspacesize =XT_ALIGN (sizeof (struct nft_among_data )), + .help = bramong_print_help, + .parse = bramong_parse, + .print = bramong_print, + .extra_opts = bramong_opts, +}; + +void _init (void ) +{ +xtables_register_match (&bramong_match); +}
extensions/libebt_among.t new file +16 -0
@@ -0,0 +1,16 @@ +:INPUT,FORWARD,OUTPUT +--among-dst de:ad:00:be:ee:ff,c0:ff:ee:00:ba:be;--among-dst c0:ff:ee:00:ba:be,de:ad:00:be:ee:ff;OK +--among-dst ! c0:ff:ee:00:ba:be,de:ad:00:be:ee:ff;=;OK +--among-src be:ef:00:c0:ff:ee,c0:ff:ee:00:ba:be,de:ad:00:be:ee:ff;=;OK +--among-src de:ad:00:be:ee:ff=10.0.0.1,c0:ff:ee:00:ba:be=192.168.1.1;--among-src c0:ff:ee:00:ba:be=192.168.1.1,de:ad:00:be:ee:ff=10.0.0.1;OK +--among-src ! c0:ff:ee:00:ba:be=192.168.1.1,de:ad:00:be:ee:ff=10.0.0.1;=;OK +--among-src de:ad:00:be:ee:ff --among-dst c0:ff:ee:00:ba:be;=;OK +--among-src de:ad:00:be:ee:ff=10.0.0.1 --among-dst c0:ff:ee:00:ba:be=192.168.1.1;=;OK +--among-src ! de:ad:00:be:ee:ff --among-dst c0:ff:ee:00:ba:be;=;OK +--among-src de:ad:00:be:ee:ff=10.0.0.1 --among-dst ! c0:ff:ee:00:ba:be=192.168.1.1;=;OK +--among-src ! de:ad:00:be:ee:ff --among-dst c0:ff:ee:00:ba:be=192.168.1.1;=;OK +--among-src de:ad:00:be:ee:ff=10.0.0.1 --among-dst ! c0:ff:ee:00:ba:be=192.168.1.1;=;OK +--among-src;=;FAIL +--among-src 00:11=10.0.0.1;=;FAIL +--among-src de:ad:00:be:ee:ff=10.256.0.1;=;FAIL +--among-src de:ad:00:be:ee:ff,c0:ff:ee:00:ba:be=192.168.1.1;=;FAIL
iptables/ebtables-nft.8 +35 -31
78 lines not on this page · raw message
iptables/nft-bridge.c +222 -0
240 lines not on this page · raw message
iptables/nft-bridge.h +21 -0
@@ -122,4 +122,25 @@ void ebt_add_watcher(struct xtables_target *watcher, struct iptables_command_state *cs);int ebt_command_default (struct iptables_command_state *cs); +struct nft_among_pair { +union { +struct { +unsigned char mac[ETH_ALEN ]; +unsigned char pad[2 ]; +unsigned char ip[4 ]; + }; +unsigned char buf[ETH_ALEN +2 +4 ]; + } __attribute__((packed)); +}; + +struct nft_among_data { +struct { +int cnt; +bool inv; +bool ip; + } src, dst; +/* first source, then dest pairs */ +struct nft_among_pair pairs[0 ]; +}; +#endif
iptables/nft.c +147 -0
153 lines not on this page · raw message
iptables/xtables-eb.c +1 -0
@@ -594,6 +594,7 @@ void ebt_load_match_extensions(void)ebt_load_match ("pkttype" );ebt_load_match ("vlan" );ebt_load_match ("stp" ); +ebt_load_match ("among" );ebt_load_watcher ("log" );ebt_load_watcher ("nflog" );
Signature · 1 line
2.23.0