ebtables-compat: fix ACCEPT printing by simplifying logic
PATCH 1/1 ebtables-compat: fix ACCEPT printing by simplifying logic
The commit bc543af ("ebtables-compat: fix segfault in rules w/o target") doesn't handle all possible cases of target printing, and ACCEPT is left behind.
BTW, the logic of target (-j XXX) printing is a bit weird. This patch simplifies it.
I assume:
* cs->jumpto is only filled by nft_immediate.
* cs->target is only filled by nft_target.
So we end with these cases:
* nft_immediate contains a 'standard' target (ACCEPT, DROP, CONTINUE, RETURN, chain) Then cs->jumpto contains the target already. We have the rule.
* No standard target. If nft_target contains a target, try to load it.
* Neither nft_target nor nft_immediate exist. Then, assume CONTINUE.
The printing path is then straight forward: either cs.jumpto or cs.target contains the target.
As there isn't support for target extensions yet, there is no way to test the nft_target (cs.target) path.
--- iptables/nft-bridge.c | 27 +++++++++++---------------- 1 file changed, 11 insertions(+), 16 deletions(-)
iptables/nft-bridge.c +11 -16
@@ -337,12 +337,13 @@ void nft_rule_to_ebtables_command_state(struct nft_rule *r,nft_rule_expr_iter_destroy (iter); -if (cs->target !=NULL ) - cs->jumpto = cs->target->name; -else if (cs->jumpto !=NULL ) - cs->target =xtables_find_target (cs->jumpto,XTF_TRY_LOAD ); +if (cs->jumpto !=NULL ) +return ; + +if (cs->target !=NULL && cs->target->name !=NULL ) + cs->target =xtables_find_target (cs->target->name,XTF_TRY_LOAD );else - cs->jumpto ="" ; + cs->jumpto ="CONTINUE" ; }static void print_iface (const char *iface)
@@ -455,17 +456,11 @@ static void nft_bridge_print_firewall(struct nft_rule *r, unsigned int num, }printf ("-j " ); -if (cs.target !=NULL ) { -if (cs.target->print !=NULL ) { - cs.target->FMT_NUMERIC ); - } - }else { -if (strcmp (cs.jumpto,"" ) ==0 ) -printf ("CONTINUE" ); -else -printf ("%s" , cs.jumpto); - } + +if (cs.jumpto !=NULL ) +printf ("%s" , cs.jumpto); +else if (cs.target !=NULL && cs.target->print !=NULL ) + cs.target->FMT_NUMERIC );if (!(format &FMT_NOCOUNTS )) printf(" , pcnt = %"PRIu64" -- bcnt = %"PRIu64"",
Pablo Neira Ayuso
maintainerQuoted 17 lines · Arturo Borrero Gonzalez
The commit bc543af ("ebtables-compat: fix segfault in rules w/o target") doesn't handle all possible cases of target printing, and ACCEPT is left behind.
BTW, the logic of target (-j XXX) printing is a bit weird. This patch simplifies it.
I assume:
*cs->jumptois only filled bynft_immediate.
*cs->targetis only filled bynft_target.So we end with these cases:
*nft_immediatecontains a 'standard' target (ACCEPT, DROP, CONTINUE, RETURN, chain) Thencs->jumptocontains the target already. We have the rule.
* No standard target. Ifnft_targetcontains a target, try to load it.
* Neithernft_targetnornft_immediateexist. Then, assume CONTINUE.
Quoted 5 lines
The printing path is then straight forward: either cs.jumpto or cs.target contains the target.
As there isn't support for target extensions yet, there is no way to test the
nft_target(cs.target) path.
Not telling this is wrong, but I guess the resulting code to print the target has to converge to what we have in iptables-compat (see iptables/nft-ipv4.c). I mean, the handling should look similar. Could you revisit that and make sure that this and the existing code converge to the point? Thanks.
Quoted 21 lines · Pablo Neira Ayuso
Quoted 20 lines · Arturo Borrero Gonzalez
The commit bc543af ("ebtables-compat: fix segfault in rules w/o target") doesn't handle all possible cases of target printing, and ACCEPT is left behind.
BTW, the logic of target (-j XXX) printing is a bit weird. This patch simplifies it.
I assume:
*cs->jumptois only filled bynft_immediate.
*cs->targetis only filled bynft_target.So we end with these cases:
*nft_immediatecontains a 'standard' target (ACCEPT, DROP, CONTINUE, RETURN, chain) Thencs->jumptocontains the target already. We have the rule.
* No standard target. Ifnft_targetcontains a target, try to load it.
* Neithernft_targetnornft_immediateexist. Then, assume CONTINUE.The printing path is then straight forward: either cs.jumpto or cs.target contains the target.
Quoted 8 lines
Quoted 2 lines
As there isn't support for target extensions yet, there is no way to test the
nft_target(cs.target) path.Not telling this is wrong, but I guess the resulting code to print the target has to converge to what we have in iptables-compat (see
iptables/nft-ipv4.c). I mean, the handling should look similar. Could you revisit that and make sure that this and the existing code converge to the point? Thanks.
I could try to factorize code to a common function, something like:
void nft_shared_rule_translate_target(char **jumpto, struct xtables_target **target)
void nft_shared_print_target(const char *jumpto, const struct xtables_target *target)
Do you like the idea?
Signature · 5 lines
Arturo Borrero González -- To unsubscribe from this list: send the line "unsubscribe netfilter-devel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Pablo Neira Ayuso
maintainerQuoted 31 lines · Arturo Borrero Gonzalez
Quoted 21 lines · Pablo Neira Ayuso
Quoted 20 lines · Arturo Borrero Gonzalez
The commit bc543af ("ebtables-compat: fix segfault in rules w/o target") doesn't handle all possible cases of target printing, and ACCEPT is left behind.
BTW, the logic of target (-j XXX) printing is a bit weird. This patch simplifies it.
I assume:
*cs->jumptois only filled bynft_immediate.
*cs->targetis only filled bynft_target.So we end with these cases:
*nft_immediatecontains a 'standard' target (ACCEPT, DROP, CONTINUE, RETURN, chain) Thencs->jumptocontains the target already. We have the rule.
* No standard target. Ifnft_targetcontains a target, try to load it.
* Neithernft_targetnornft_immediateexist. Then, assume CONTINUE.The printing path is then straight forward: either cs.jumpto or cs.target contains the target.
Quoted 8 lines
Quoted 2 lines
As there isn't support for target extensions yet, there is no way to test the
nft_target(cs.target) path.Not telling this is wrong, but I guess the resulting code to print the target has to converge to what we have in iptables-compat (see
iptables/nft-ipv4.c). I mean, the handling should look similar. Could you revisit that and make sure that this and the existing code converge to the point? Thanks.
Quoted 7 lines
I could try to factorize code to a common function, something like:
voidnft_shared_rule_translate_target(char **jumpto, struct xtables_target **target)
voidnft_shared_print_target(const char *jumpto, const struct xtables_target *target)Do you like the idea?
Yes, the more we consolidate the less redundancy. Please, for the function names, I'd suggest a bit shorter ones: nft_set_target() and nft_print_target() I'd say.
Quoted 38 lines · Pablo Neira Ayuso
Quoted 37 lines · Arturo Borrero Gonzalez
Quoted 21 lines · Pablo Neira Ayuso
Quoted 20 lines · Arturo Borrero Gonzalez
The commit bc543af ("ebtables-compat: fix segfault in rules w/o target") doesn't handle all possible cases of target printing, and ACCEPT is left behind.
BTW, the logic of target (-j XXX) printing is a bit weird. This patch simplifies it.
I assume:
*cs->jumptois only filled bynft_immediate.
*cs->targetis only filled bynft_target.So we end with these cases:
*nft_immediatecontains a 'standard' target (ACCEPT, DROP, CONTINUE, RETURN, chain) Thencs->jumptocontains the target already. We have the rule.
* No standard target. Ifnft_targetcontains a target, try to load it.
* Neithernft_targetnornft_immediateexist. Then, assume CONTINUE.The printing path is then straight forward: either cs.jumpto or cs.target contains the target.
Quoted 8 lines
Quoted 2 lines
As there isn't support for target extensions yet, there is no way to test the
nft_target(cs.target) path.Not telling this is wrong, but I guess the resulting code to print the target has to converge to what we have in iptables-compat (see
iptables/nft-ipv4.c). I mean, the handling should look similar. Could you revisit that and make sure that this and the existing code converge to the point? Thanks.I could try to factorize code to a common function, something like:
voidnft_shared_rule_translate_target(char **jumpto, struct xtables_target **target)
voidnft_shared_print_target(const char *jumpto, const struct xtables_target *target)
Quoted 5 lines
Quoted 1 line
Do you like the idea?
Yes, the more we consolidate the less redundancy. Please, for the function names, I'd suggest a bit shorter ones:
nft_set_target()andnft_print_target()I'd say.
Hi Pablo,
reading the code again, I believe code paths we mentioned for iptables-compat and ebtables-compat are different enough for the code factorization to not worth it.
However, I think that nft_rule_to_*tables_command_state() is more suitable for the factorization, but it is a different issue.
let me know.
Signature · 5 lines
Arturo Borrero González -- To unsubscribe from this list: send the line "unsubscribe netfilter-devel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html