netfilter: ebtables: CONFIG_COMPAT support
Subsystems (3)
Florian Westphal
maintainerv2 cover netfilter: ebtables: CONFIG_COMPAT support
Hello everyone,
this is version 2 of the ebtables CONFIG_COMPAT patch set.
First patches are minor bug fixes/preparation patches. Patch 7 is the main CONFIG_COMPAT hunk, 8 handles those ebtables binaries specifically built for 64 bit kernel (i.e. pad in userspace).
Last two patches add CONFIG_COMPAT support to the targets/matches that need special handling (maybe I missed some, though).
Tested on x86_64 with x86 userland by comparing output of 32 and 64 bit ebtables binaries.
Changes since v1:
- also move handling of ebt counter set/getsockopt handling to helper functions to avoid copy & pasting the same code in the COMPAT handlers.
- add missing length check to compat_do_ebt_get_ctl().
- add a patch to handle "userspace-side-padding" in some ebtables 32bit userspace binaries.
- add "const *" qualifiers to the compat_from/to user functions.
At the moment this tree adds a few compiler warnings due to the presence of "const" qualifiers; those warnings should all go away once Jan Engelhardts patch that adds the qualifier to the declarations ("netfilter: xtables: constify args in compat copying functions") is merged.
The following changes since commit a8c28d05150f758625c5da38199b247887735e65:
Patrick McHardy (1):
Merge branch 'master' of git://dev.medozas.de/linux
are available in the git repository at:
git://chamillionaire.breakpoint.cc/fw/nf-next-2.6.git ebt_config_compat
Florian Westphal (10):
netfilter: ebtables: abort if next_offset is too small
netfilter: ebtables: avoid explicit XT_ALIGN() in match/targets
netfilter: CONFIG_COMPAT: allow delta to exceed 32767
netfilter: ebtables: split do_replace into two functions
netfilter: ebtables: split copy_everything_to_user into two functions
netfilter: ebtables: split update_counters into two functions
netfilter: ebtables: add CONFIG_COMPAT support
netfilter: ebtables: try native set/getsockopt handlers, too
netfilter: ebt_limit: add CONFIG_COMPAT support
netfilter: ebtables: mark: add CONFIG_COMPAT support
include/linux/netfilter/x_tables.h | 2 +- net/bridge/netfilter/ebt_802_3.c | 2 +- net/bridge/netfilter/ebt_arp.c | 2 +- net/bridge/netfilter/ebt_arpreply.c | 2 +- net/bridge/netfilter/ebt_dnat.c | 2 +- net/bridge/netfilter/ebt_ip.c | 2 +- net/bridge/netfilter/ebt_ip6.c | 2 +- net/bridge/netfilter/ebt_limit.c | 18 +- net/bridge/netfilter/ebt_log.c | 2 +- net/bridge/netfilter/ebt_mark.c | 33 +- net/bridge/netfilter/ebt_mark_m.c | 39 ++- net/bridge/netfilter/ebt_nflog.c | 2 +- net/bridge/netfilter/ebt_pkttype.c | 2 +- net/bridge/netfilter/ebt_redirect.c | 2 +- net/bridge/netfilter/ebt_snat.c | 2 +- net/bridge/netfilter/ebt_stp.c | 2 +- net/bridge/netfilter/ebt_ulog.c | 2 +- net/bridge/netfilter/ebt_vlan.c | 2 +- net/bridge/netfilter/ebtables.c | 1110 +++++++++++++++++++++++++++++++---- net/netfilter/x_tables.c | 6 +- 20 files changed, 1103 insertions(+), 133 deletions(-)
Florian Westphal
maintainerPATCH v2 1/10 netfilter: ebtables: abort if next_offset is too small
next_offset must be > 0, otherwise this loops forever. The offset also contains the size of the ebt_entry structure itself, so anything smaller is invalid.
--- net/bridge/netfilter/ebtables.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
net/bridge/netfilter/ebtables.c +2 -0
@@ -442,6 +442,8 @@ static int ebt_verify_pointers(struct ebt_replace *repl,break ;if (left < e->next_offset)break ; +if (e->next_offset <sizeof (struct ebt_entry )) +return -EINVAL ; offset += e->next_offset; } }
Signature · 1 line
1.6.3.3
Patrick McHardy
AppliedRe: [PATCH 01/10] netfilter: ebtables: abort if next_offset is too small
Quoted 3 lines · Florian Westphal
next_offsetmust be > 0, otherwise this loops forever. The offset also contains the size of theebt_entrystructure itself, so anything smaller is invalid.
Applied, thanks.
Florian Westphal
maintainerPATCH v2 2/10 netfilter: ebtables: avoid explicit XT_ALIGN() in match/targets
In reply to Florian WestphalFrom: Florian Westphal <[email protected]>
This will cause trouble once CONFIG_COMPAT support is added to ebtables.
xt_compat_*_offset() calculate the kernel/userland structure size delta using:
XT_ALIGN(size) - COMPAT_XT_ALIGN(size)
If the match/target sizes are aligned at registration time, delta is always zero.
Should have zero effect for existing systems: xtables uses XT_ALIGN() whenever it deals with match/target sizes.
---
no changes since v1.
net/bridge/netfilter/ebt_802_3.c | 2 +- net/bridge/netfilter/ebt_arp.c | 2 +- net/bridge/netfilter/ebt_arpreply.c | 2 +- net/bridge/netfilter/ebt_dnat.c | 2 +- net/bridge/netfilter/ebt_ip.c | 2 +- net/bridge/netfilter/ebt_ip6.c | 2 +- net/bridge/netfilter/ebt_limit.c | 2 +- net/bridge/netfilter/ebt_log.c | 2 +- net/bridge/netfilter/ebt_mark.c | 2 +- net/bridge/netfilter/ebt_mark_m.c | 2 +- net/bridge/netfilter/ebt_nflog.c | 2 +- net/bridge/netfilter/ebt_pkttype.c | 2 +- net/bridge/netfilter/ebt_redirect.c | 2 +- net/bridge/netfilter/ebt_snat.c | 2 +- net/bridge/netfilter/ebt_stp.c | 2 +- net/bridge/netfilter/ebt_ulog.c | 2 +- net/bridge/netfilter/ebt_vlan.c | 2 +- 17 files changed, 17 insertions(+), 17 deletions(-)
net/bridge/netfilter/ebt_802_3.c +1 -1
@@ -52,7 +52,7 @@ static struct xt_match ebt_802_3_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_802_3_mt, .checkentry = ebt_802_3_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_802_3_info)), + .matchsize = sizeof(struct ebt_802_3_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_arp.c +1 -1
@@ -120,7 +120,7 @@ static struct xt_match ebt_arp_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_arp_mt, .checkentry = ebt_arp_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_arp_info)), + .matchsize = sizeof(struct ebt_arp_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_arpreply.c +1 -1
@@ -78,7 +78,7 @@ static struct xt_target ebt_arpreply_tg_reg __read_mostly = { .hooks = (1 << NF_BR_NUMHOOKS) | (1 << NF_BR_PRE_ROUTING), .target = ebt_arpreply_tg, .checkentry = ebt_arpreply_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_arpreply_info)), + .targetsize = sizeof(struct ebt_arpreply_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_dnat.c +1 -1
@@ -54,7 +54,7 @@ static struct xt_target ebt_dnat_tg_reg __read_mostly = { (1 << NF_BR_LOCAL_OUT) | (1 << NF_BR_BROUTING), .target = ebt_dnat_tg, .checkentry = ebt_dnat_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_nat_info)), + .targetsize = sizeof(struct ebt_nat_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_ip.c +1 -1
@@ -110,7 +110,7 @@ static struct xt_match ebt_ip_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_ip_mt, .checkentry = ebt_ip_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_ip_info)), + .matchsize = sizeof(struct ebt_ip_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_ip6.c +1 -1
@@ -122,7 +122,7 @@ static struct xt_match ebt_ip6_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_ip6_mt, .checkentry = ebt_ip6_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_ip6_info)), + .matchsize = sizeof(struct ebt_ip6_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_limit.c +1 -1
@@ -90,7 +90,7 @@ static struct xt_match ebt_limit_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_limit_mt, .checkentry = ebt_limit_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_limit_info)), + .matchsize = sizeof(struct ebt_limit_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_log.c +1 -1
@@ -195,7 +195,7 @@ static struct xt_target ebt_log_tg_reg __read_mostly = { .family = NFPROTO_BRIDGE, .target = ebt_log_tg, .checkentry = ebt_log_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_log_info)), + .targetsize = sizeof(struct ebt_log_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_mark.c +1 -1
@@ -59,7 +59,7 @@ static struct xt_target ebt_mark_tg_reg __read_mostly = { .family = NFPROTO_BRIDGE, .target = ebt_mark_tg, .checkentry = ebt_mark_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_mark_t_info)), + .targetsize = sizeof(struct ebt_mark_t_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_mark_m.c +1 -1
@@ -41,7 +41,7 @@ static struct xt_match ebt_mark_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_mark_mt, .checkentry = ebt_mark_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_mark_m_info)), + .matchsize = sizeof(struct ebt_mark_m_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_nflog.c +1 -1
@@ -51,7 +51,7 @@ static struct xt_target ebt_nflog_tg_reg __read_mostly = { .family = NFPROTO_BRIDGE, .target = ebt_nflog_tg, .checkentry = ebt_nflog_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_nflog_info)), + .targetsize = sizeof(struct ebt_nflog_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_pkttype.c +1 -1
@@ -36,7 +36,7 @@ static struct xt_match ebt_pkttype_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_pkttype_mt, .checkentry = ebt_pkttype_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_pkttype_info)), + .matchsize = sizeof(struct ebt_pkttype_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_redirect.c +1 -1
@@ -59,7 +59,7 @@ static struct xt_target ebt_redirect_tg_reg __read_mostly = { (1 << NF_BR_BROUTING), .target = ebt_redirect_tg, .checkentry = ebt_redirect_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_redirect_info)), + .targetsize = sizeof(struct ebt_redirect_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_snat.c +1 -1
@@ -67,7 +67,7 @@ static struct xt_target ebt_snat_tg_reg __read_mostly = { .hooks = (1 << NF_BR_NUMHOOKS) | (1 << NF_BR_POST_ROUTING), .target = ebt_snat_tg, .checkentry = ebt_snat_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_nat_info)), + .targetsize = sizeof(struct ebt_nat_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_stp.c +1 -1
@@ -177,7 +177,7 @@ static struct xt_match ebt_stp_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_stp_mt, .checkentry = ebt_stp_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_stp_info)), + .matchsize = sizeof(struct ebt_stp_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_ulog.c +1 -1
@@ -275,7 +275,7 @@ static struct xt_target ebt_ulog_tg_reg __read_mostly = { .family = NFPROTO_BRIDGE, .target = ebt_ulog_tg, .checkentry = ebt_ulog_tg_check, - .targetsize = XT_ALIGN(sizeof(struct ebt_ulog_info)), + .targetsize = sizeof(struct ebt_ulog_info), .me = THIS_MODULE, };
net/bridge/netfilter/ebt_vlan.c +1 -1
@@ -163,7 +163,7 @@ static struct xt_match ebt_vlan_mt_reg __read_mostly = { .family = NFPROTO_BRIDGE, .match = ebt_vlan_mt, .checkentry = ebt_vlan_mt_check, - .matchsize = XT_ALIGN(sizeof(struct ebt_vlan_info)), + .matchsize = sizeof(struct ebt_vlan_info), .me = THIS_MODULE, };
Signature · 1 line
1.6.3.3
Patrick McHardy
AppliedRe: [PATCH 02/10] netfilter: ebtables: avoid explicit XT_ALIGN() in match/targets
Quoted 7 lines · Florian Westphal
From: Florian Westphal <[email protected]>
This will cause trouble once
CONFIG_COMPATsupport is added to ebtables.
xt_compat_*_offset() calculate the kernel/userland structure size delta using:
Quoted 7 lines
XT_ALIGN(size)-COMPAT_XT_ALIGN(size)If the match/target sizes are aligned at registration time, delta is always zero.
Should have zero effect for existing systems: xtables uses
XT_ALIGN()whenever it deals with match/target sizes.
Applied, thanks.
Florian Westphal
maintainerPATCH v2 3/10 netfilter: CONFIG_COMPAT: allow delta to exceed 32767
In reply to Florian Westphalwith 32 bit userland and 64 bit kernels, it is unlikely but possible that insertion of new rules fails even tough there are only about 2000 iptables rules.
This happens because the compat delta is using a short int. Easily reproducible via "iptables -m limit" ; after about 2050 rules inserting new ones fails with -ELOOP.
Note that compat_delta included 2 bytes of padding on x86_64, so structure size remains the same.
---
no changes since v1.
include/linux/netfilter/x_tables.h | 2 +- net/netfilter/x_tables.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-)
include/linux/netfilter/x_tables.h +1 -1
@@ -588,7 +588,7 @@ extern void xt_compat_unlock(u_int8_t af);extern int xt_compat_add_offset (u_int8_t af,unsigned int offset,short delta);extern void xt_compat_flush_offsets (u_int8_t af); -extern short xt_compat_calc_jump (u_int8_t af,unsigned int offset); +extern int xt_compat_calc_jump (u_int8_t af,unsigned int offset);extern int xt_compat_match_offset (const struct xt_match *match); extern int xt_compat_match_from_user(struct xt_entry_match *m,
net/netfilter/x_tables.c +3 -3
@@ -39,7 +39,7 @@ MODULE_DESCRIPTION("{ip,ip6,arp,eb}_tables backend module");struct compat_delta {struct compat_delta *next;unsigned int offset; -short delta; +int delta; };struct xt_af {
@@ -437,10 +437,10 @@ void xt_compat_flush_offsets(u_int8_t af) }EXPORT_SYMBOL_GPL (xt_compat_flush_offsets); -short xt_compat_calc_jump (u_int8_t af,unsigned int offset) +int xt_compat_calc_jump (u_int8_t af,unsigned int offset) {struct compat_delta *tmp; -short delta; +int delta;for (tmp = xt[af].compat_offsets, delta =0 ; tmp; tmp = tmp->next)if (tmp->offset < offset)
Signature · 1 line
1.6.3.3
Re: [PATCH 03/10] netfilter: CONFIG_COMPAT: allow delta to exceed 32767
Quoted 10 lines · Florian Westphal
with 32 bit userland and 64 bit kernels, it is unlikely but possible that insertion of new rules fails even tough there are only about 2000 iptables rules.
This happens because the compat delta is using a short int. Easily reproducible via "iptables -m limit" ; after about 2050 rules inserting new ones fails with
-ELOOP.Note that
compat_deltaincluded 2 bytes of padding onx86_64, so structure size remains the same.
The first three patches already look fine, I'll apply those after a bit of testing. The remaining ones should get submitted very soon in order to still make the 2.6.34 merge window.
Florian Westphal
maintainerRe: [PATCH 03/10] netfilter: CONFIG_COMPAT: allow delta to exceed 32767
Quoted 10 lines · Patrick McHardy
Quoted 6 lines
This happens because the compat delta is using a short int. Easily reproducible via "iptables -m limit" ; after about 2050 rules inserting new ones fails with
-ELOOP.Note that
compat_deltaincluded 2 bytes of padding onx86_64, so structure size remains the same.The first three patches already look fine, I'll apply those after a bit of testing. The remaining ones should get submitted very soon in order to still make the 2.6.34 merge window.
Thanks, I'll send out v3 of the patches (only changes are the ones suggested by Bart) once those three appear in nf-next-2.6.
Thanks, Florian
Re: [PATCH 03/10] netfilter: CONFIG_COMPAT: allow delta to exceed 32767
Quoted 5 lines · Florian Westphal
Quoted 4 lines · Patrick McHardy
Quoted 4 lines
This happens because the compat delta is using a short int. Easily reproducible via "iptables -m limit" ; after about 2050 rules inserting new ones fails with
-ELOOP.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Note that
compat_deltaincluded 2 bytes of padding onx86_64, so structure size remains the same.The first three patches already look fine, I'll apply those after a bit of testing. The remaining ones should get submitted very soon in order to still make the 2.6.34 merge window.
Thanks, I'll send out v3 of the patches (only changes are the ones suggested by Bart) once those three appear in nf-next-2.6.
Great, thanks. They should be in the tree within the next two or three hours.
Re: [PATCH 03/10] netfilter: CONFIG_COMPAT: allow delta to exceed 32767
In reply to Florian WestphalQuoted 10 lines · Florian Westphal
with 32 bit userland and 64 bit kernels, it is unlikely but possible that insertion of new rules fails even tough there are only about 2000 iptables rules.
This happens because the compat delta is using a short int. Easily reproducible via "iptables -m limit" ; after about 2050 rules inserting new ones fails with
-ELOOP.Note that
compat_deltaincluded 2 bytes of padding onx86_64, so structure size remains the same.
Also applied, thanks Florian.
Florian Westphal
maintainerPATCH v2 4/10 netfilter: ebtables: split do_replace into two functions
In reply to Florian Westphalonce CONFIG_COMPAT support is merged this allows
to call do_replace_finish() after doing the CONFIG_COMPAT conversion instead of copy & pasting this.
---
no changes since v1.
net/bridge/netfilter/ebtables.c | 133 ++++++++++++++++++++------------------- 1 files changed, 69 insertions(+), 64 deletions(-)
net/bridge/netfilter/ebtables.c +69 -64
@@ -958,90 +958,44 @@ static void get_counters(struct ebt_counter *oldcounters, } } -/* replace the table */ -static int do_replace (struct net *net,void __user *user,unsigned int len) +static int do_replace_finish (struct net *net,struct ebt_replace *repl, +struct ebt_table_info *newinfo) { -int ret, i, countersize; -struct ebt_table_info *newinfo; -struct ebt_replace tmp; -struct ebt_table *t; +int ret, i;struct ebt_counter *counterstmp =NULL ;/* used to be able to unlock earlier */ struct ebt_table_info *table; - -if (copy_from_user (&tmp, user,sizeof (tmp)) !=0 ) -return -EFAULT ; - -if (len !=sizeof (tmp) + tmp.entries_size) { -BUGPRINT ("Wrong len argument\n" ); -return -EINVAL ; - } - -if (tmp.entries_size ==0 ) { -BUGPRINT ("Entries_size never zero\n" ); -return -EINVAL ; - } -/* overflow check */ -if (tmp.nentries >= ((INT_MAX -sizeof (struct ebt_table_info )) /NR_CPUS - -SMP_CACHE_BYTES ) /sizeof (struct ebt_counter )) -return -ENOMEM ; -if (tmp.num_counters >=INT_MAX /sizeof (struct ebt_counter )) -return -ENOMEM ; - - countersize =COUNTER_OFFSET (tmp.nentries) * nr_cpu_ids; - newinfo =vmalloc (sizeof (*newinfo) + countersize); -if (!newinfo) -return -ENOMEM ; - -if (countersize) -memset (newinfo->counters,0 , countersize); - - newinfo->entries =vmalloc (tmp.entries_size); -if (!newinfo->entries) { - ret = -ENOMEM ; - goto free_newinfo; - } -if (copy_from_user ( - newinfo->entries, tmp.entries, tmp.entries_size) !=0 ) { -BUGPRINT ("Couldn't copy entries from userspace\n" ); - ret = -EFAULT ; - goto free_entries; - } +struct ebt_table *t;/* the user wants counters back the check on the size is done later, when we have the lock */ -if (tmp.num_counters) { - counterstmp =vmalloc (tmp.num_counters *sizeof (*counterstmp)); -if (!counterstmp) { - ret = -ENOMEM ; - goto free_entries; - } +if (repl->num_counters) { + counterstmp =vmalloc (repl->num_counters *sizeof (*counterstmp)); +if (!counterstmp) +return -ENOMEM ; } -else - counterstmp =NULL ; -/* this can get initialized by translate_table() */ newinfo->chainstack =NULL ; - ret =ebt_verify_pointers (&tmp, newinfo); + ret =ebt_verify_pointers (repl, newinfo);if (ret !=0 ) goto free_counterstmp; - ret =translate_table (net, tmp.name, newinfo); + ret =translate_table (net, repl->name, newinfo);if (ret !=0 ) goto free_counterstmp; - t =find_table_lock (net, tmp.name, &ret, &ebt_mutex); + t =find_table_lock (net, repl->name, &ret, &ebt_mutex);if (!t) { ret = -ENOENT ; goto free_iterate; }/* the table doesn't like it */ -if (t->check && (ret = t->check (newinfo, tmp.valid_hooks))) +if (t->check && (ret = t->check (newinfo, repl->valid_hooks))) goto free_unlock; -if (tmp.num_counters && tmp.num_counters != t->private->nentries) { +if (repl->num_counters && repl->num_counters != t->private->nentries) {BUGPRINT ("Wrong nr. of counters requested\n" ); ret = -EINVAL ; goto free_unlock;
@@ -1057,7 +1011,7 @@ static int do_replace(struct net *net, void __user *user, unsigned int len)module_put (t->me);/* we need an atomic snapshot of the counters */ write_lock_bh (&t->lock); -if (tmp.num_counters) +if (repl->num_counters)get_counters (t->private->counters, counterstmp, t->private->nentries);
@@ -1068,10 +1022,9 @@ static int do_replace(struct net *net, void __user *user, unsigned int len)allocation. Only reason why this is done is because this way the lock is held only once, while this doesn't bring the kernel into a dangerous state. */ -if (tmp.num_counters && -copy_to_user (tmp.counters, counterstmp, - tmp.num_counters *sizeof (struct ebt_counter ))) { -BUGPRINT ("Couldn't copy counters to userspace\n" ); +if (repl->num_counters && +copy_to_user (repl->counters, counterstmp, + repl->num_counters *sizeof (struct ebt_counter ))) { ret = -EFAULT ; }else
@@ -1105,6 +1058,58 @@ free_counterstmp:vfree (newinfo->chainstack[i]);vfree (newinfo->chainstack); } +return ret; +} + +/* replace the table */ +static int do_replace (struct net *net,void __user *user,unsigned int len) +{ +int ret, countersize; +struct ebt_table_info *newinfo; +struct ebt_replace tmp; + +if (copy_from_user (&tmp, user,sizeof (tmp)) !=0 ) +return -EFAULT ; + +if (len !=sizeof (tmp) + tmp.entries_size) { +BUGPRINT ("Wrong len argument\n" ); +return -EINVAL ; + } + +if (tmp.entries_size ==0 ) { +BUGPRINT ("Entries_size never zero\n" ); +return -EINVAL ; + } +/* overflow check */ +if (tmp.nentries >= ((INT_MAX -sizeof (struct ebt_table_info )) /NR_CPUS - +SMP_CACHE_BYTES ) /sizeof (struct ebt_counter )) +return -ENOMEM ; +if (tmp.num_counters >=INT_MAX /sizeof (struct ebt_counter )) +return -ENOMEM ; + + countersize =COUNTER_OFFSET (tmp.nentries) * nr_cpu_ids; + newinfo =vmalloc (sizeof (*newinfo) + countersize); +if (!newinfo) +return -ENOMEM ; + +if (countersize) +memset (newinfo->counters,0 , countersize); + + newinfo->entries =vmalloc (tmp.entries_size); +if (!newinfo->entries) { + ret = -ENOMEM ; + goto free_newinfo; + } +if (copy_from_user ( + newinfo->entries, tmp.entries, tmp.entries_size) !=0 ) { +BUGPRINT ("Couldn't copy entries from userspace\n" ); + ret = -EFAULT ; + goto free_entries; + } + + ret =do_replace_finish (net, &tmp, newinfo); +if (ret ==0 ) +return ret; free_entries:vfree (newinfo->entries); free_newinfo:
Signature · 1 line
1.6.3.3
Florian Westphal
maintainerPATCH v2 5/10 netfilter: ebtables: split copy_everything_to_user into two functions
In reply to Florian Westphalonce CONFIG_COMPAT support is added to ebtables, the new copy_counters_to_user function can be called instead of duplicating code.
---
patch was not present in v1 patch series.
net/bridge/netfilter/ebtables.c | 62 ++++++++++++++++++++++++--------------- 1 files changed, 38 insertions(+), 24 deletions(-)
net/bridge/netfilter/ebtables.c +38 -24
@@ -1340,14 +1340,47 @@ static inline int ebt_make_names(struct ebt_entry *e, char *base, char __user *ureturn 0 ; } +static int copy_counters_to_user (struct ebt_table *t,struct ebt_counter *oldcounters, +void __user *user,unsigned int num_counters, +unsigned int nentries) +{ +struct ebt_counter *counterstmp; +int ret =0 ; + +/* userspace might not need the counters */ +if (num_counters ==0 ) +return 0 ; + +if (num_counters != nentries) { +BUGPRINT ("Num_counters wrong\n" ); +return -EINVAL ; + } + + counterstmp =vmalloc (nentries *sizeof (*counterstmp)); +if (!counterstmp) { +MEMPRINT ("Couldn't copy counters, out of memory\n" ); +return -ENOMEM ; + } +write_lock_bh (&t->lock); +get_counters (oldcounters, counterstmp, nentries); +write_unlock_bh (&t->lock); + +if (copy_to_user (user, counterstmp, + nentries *sizeof (struct ebt_counter ))) + ret = -EFAULT ; +vfree (counterstmp); +return ret; +} +/* called with ebt_mutex locked */ static int copy_everything_to_user (struct ebt_table *t,void __user *user,int *len,int cmd) {struct ebt_replace tmp; -struct ebt_counter *counterstmp, *oldcounters; +struct ebt_counter *oldcounters;unsigned int entries_size, nentries;char *entries; +int ret;if (cmd ==EBT_SO_GET_ENTRIES ) { entries_size = t->private->entries_size;
@@ -1382,29 +1415,10 @@ static int copy_everything_to_user(struct ebt_table *t, void __user *user,return -EINVAL ; } -/* userspace might not need the counters */ -if (tmp.num_counters) { -if (tmp.num_counters != nentries) { -BUGPRINT ("Num_counters wrong\n" ); -return -EINVAL ; - } - counterstmp =vmalloc (nentries *sizeof (*counterstmp)); -if (!counterstmp) { -MEMPRINT ("Couldn't copy counters, out of memory\n" ); -return -ENOMEM ; - } -write_lock_bh (&t->lock); -get_counters (oldcounters, counterstmp, nentries); -write_unlock_bh (&t->lock); - -if (copy_to_user (tmp.counters, counterstmp, - nentries *sizeof (struct ebt_counter ))) { -BUGPRINT ("Couldn't copy counters to userspace\n" ); -vfree (counterstmp); -return -EFAULT ; - } -vfree (counterstmp); - } + ret =copy_counters_to_user (t, oldcounters, tmp.counters, + tmp.num_counters, nentries); +if (ret) +return ret;if (copy_to_user (tmp.entries, entries, entries_size)) {BUGPRINT ("Couldn't copy entries to userspace\n" );
Signature · 1 line
1.6.3.3
Florian Westphal
maintainerPATCH v2 6/10 netfilter: ebtables: split update_counters into two functions
In reply to Florian Westphalallows to call do_update_counters() from upcoming CONFIG_COMPAT code instead of copy&pasting the same code.
---
patch was not present in v1 patch series.
net/bridge/netfilter/ebtables.c | 40 ++++++++++++++++++++++---------------- 1 files changed, 23 insertions(+), 17 deletions(-)
net/bridge/netfilter/ebtables.c +23 -17
@@ -1244,39 +1244,31 @@ void ebt_unregister_table(struct net *net, struct ebt_table *table) }/* userspace just supplied us with counters */ -static int update_counters (struct net *net,void __user *user,unsigned int len) +static int do_update_counters (struct net *net,const char *name, +struct ebt_counter __user *counters,unsigned int num_counters, +void __user *user,unsigned int len) {int i, ret;struct ebt_counter *tmp; -struct ebt_replace hlp;struct ebt_table *t; -if (copy_from_user (&hlp, user,sizeof (hlp))) -return -EFAULT ; - -if (len !=sizeof (hlp) + hlp.num_counters *sizeof (struct ebt_counter )) -return -EINVAL ; -if (hlp.num_counters ==0 ) +if (num_counters ==0 )return -EINVAL ; -if (!(tmp =vmalloc (hlp.num_counters *sizeof (*tmp)))) { -MEMPRINT ("Update_counters && nomemory\n" ); +if (!(tmp =vmalloc (num_counters *sizeof (*tmp))))return -ENOMEM ; - } - t =find_table_lock (net, hlp.name, &ret, &ebt_mutex); + t =find_table_lock (net, name, &ret, &ebt_mutex);if (!t) goto free_tmp; -if (hlp.num_counters != t->private->nentries) { +if (num_counters != t->private->nentries) {BUGPRINT ("Wrong nr of counters\n" ); ret = -EINVAL ; goto unlock_mutex; } -if (copy_from_user (tmp, hlp.counters, - hlp.num_counters *sizeof (struct ebt_counter )) ) { -BUGPRINT ("Updata_counters && !cfu\n" ); +if (copy_from_user (tmp, counters, num_counters *sizeof (*counters))) { ret = -EFAULT ; goto unlock_mutex; }
@@ -1285,7 +1277,7 @@ static int update_counters(struct net *net, void __user *user, unsigned int len)write_lock_bh (&t->lock);/* we add to the counters of the first cpu */ -for (i =0 ; i < hlp.num_counters; i++) { +for (i =0 ; i < num_counters; i++) { t->private->counters[i].pcnt += tmp[i].pcnt; t->private->counters[i].bcnt += tmp[i].bcnt; }
@@ -1299,6 +1291,20 @@ free_tmp:return ret; } +static int update_counters (struct net *net,void __user *user,unsigned int len) +{ +struct ebt_replace hlp; + +if (copy_from_user (&hlp, user,sizeof (hlp))) +return -EFAULT ; + +if (len !=sizeof (hlp) + hlp.num_counters *sizeof (struct ebt_counter )) +return -EINVAL ; + +return do_update_counters (net, hlp.name, hlp.counters, + hlp.num_counters, user, len); +} +static inline int ebt_make_matchname (struct ebt_entry_match *m,char *base,char __user *ubase) {
Signature · 1 line
1.6.3.3
Florian Westphal
maintainerPATCH v2 7/10 netfilter: ebtables: add CONFIG_COMPAT support
In reply to Florian WestphalFrom: Florian Westphal <[email protected]>
Main code to run unmodified 32bit userland ebtables binary with 64bit kernel.
Tested on x86_64 kernel only, using 64bit ebtables binary for output comparision.
At least ebt_mark, m_mark and ebt_limit need CONFIG_COMPAT hooks, too.
remaining problem:
The ebtables userland makefile has:
ifeq ($(shell uname -m),sparc64)
CFLAGS+=-DEBT_MIN_ALIGN=8 -DKERNEL_64_USERSPACE_32
endif
struct ebt_replace, ebt_entry_match etc. then contain userland-side padding -- this means, that even if we are called from a 32 bit userland, the structures may already be in the right format.
This problem is addressed in a follow-up patch.
---
changes since v1:
- removed a couple of pointless/uneeded BUG_ON()s
- reduced code duplication when handling ebt counters in the compat code
- add missing length check to compat_do_ebt_get_ctl
- add "const" qualifiers to compat_from_user/compat_to_user functions. This change adds compiler warnings because Jans patch that adds those qualifiers ("netfilter: xtables: constify args in compat copying functions") is not yet in nf-next-2.6.
net/bridge/netfilter/ebtables.c | 853 ++++++++++++++++++++++++++++++++++++++- 1 files changed, 852 insertions(+), 1 deletions(-)
net/bridge/netfilter/ebtables.c +852 -1
@@ -56,11 +56,37 @@static DEFINE_MUTEX (ebt_mutex); +#ifdef CONFIG_COMPAT +static void ebt_standard_compat_from_user (void *dst,const void *src) +{ +int v = *(compat_int_t *)src; + +if (v >=0 ) + v +=xt_compat_calc_jump (NFPROTO_BRIDGE , v); +memcpy (dst, &v,sizeof (v)); +} + +static int ebt_standard_compat_to_user (void __user *dst,const void *src) +{ +compat_int_t cv = *(int *)src; + +if (cv >=0 ) + cv -=xt_compat_calc_jump (NFPROTO_BRIDGE , cv); +return copy_to_user (dst, &cv,sizeof (cv)) ? -EFAULT :0 ; +} +#endif + +static struct xt_target ebt_standard_target = { .name ="standard" , .revision =0 , .family =NFPROTO_BRIDGE , .targetsize =sizeof (int ), +#ifdef CONFIG_COMPAT + .compatsize =sizeof (compat_int_t), + .compat_from_user = ebt_standard_compat_from_user, + .compat_to_user = ebt_standard_compat_to_user, +#endif }; static inline int
@@ -1452,7 +1478,7 @@ static int do_ebt_set_ctl(struct sock *sk,break ;default : ret = -EINVAL ; - } + }return ret; }
@@ -1512,15 +1538,840 @@ static int do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)return ret; } +#ifdef CONFIG_COMPAT +/* 32 bit-userspace compatibility definitions. */ +struct compat_ebt_replace { +char name[EBT_TABLE_MAXNAMELEN ]; +compat_uint_t valid_hooks; +compat_uint_t nentries; +compat_uint_t entries_size; +/* start of the chains */ +compat_uptr_t hook_entry[NF_BR_NUMHOOKS ]; +/* nr of counters userspace expects back */ +compat_uint_t num_counters; +/* where the kernel will put the old counters. */ +compat_uptr_t counters; +compat_uptr_t entries; +}; + +/* struct ebt_entry_match, _target and _watcher have same layout */ +struct compat_ebt_entry_mwt { +union { +char name[EBT_FUNCTION_MAXNAMELEN ]; +compat_uptr_t ptr; + } u; +compat_uint_t match_size; +compat_uint_t data[0 ]; +}; + +/* account for possible padding between match_size and ->data */ +static int ebt_compat_entry_padsize (void ) +{ +BUILD_BUG_ON (XT_ALIGN (sizeof (struct ebt_entry_match )) <COMPAT_XT_ALIGN (sizeof (struct compat_ebt_entry_mwt ))); +return (int )XT_ALIGN (sizeof (struct ebt_entry_match )) -COMPAT_XT_ALIGN (sizeof (struct compat_ebt_entry_mwt )); +} + +static int ebt_compat_match_offset (const struct xt_match *match,unsigned int userlen) +{ +/* +* ebt_among needs special handling. The kernel .matchsize is set to -1 at +* registration time; at runtime an EBT_ALIGN()ed value is expected. +* Example: userspace sends 4500, ebt_among.c wants 4504. +*/ +if (unlikely (match->matchsize ==-1 )) +return XT_ALIGN (userlen) -COMPAT_XT_ALIGN (userlen); +return xt_compat_match_offset (match); +} + +static int compat_match_to_user (struct ebt_entry_match *m,void __user **dstptr, +unsigned int *size) +{ +const struct xt_match *match = m->u.match; +struct compat_ebt_entry_mwt __user *cm = *dstptr; +int off =ebt_compat_match_offset (match, m->match_size); +compat_uint_t msize = m->match_size - off; + +BUG_ON (off >= m->match_size); + +if (copy_to_user (cm->u.name, match->name, +strlen (match->name) +1 ) ||put_user (msize, &cm->match_size)) +return -EFAULT ; + +if (match->compat_to_user) { +if (match->compat_to_user (cm->data, m->data)) +return -EFAULT ; + }else if (copy_to_user (cm->data, m->data, msize)) +return -EFAULT ; + + *size -=ebt_compat_entry_padsize () + off; + *dstptr = cm->data; + *dstptr += msize; +return 0 ; +} + +static int compat_target_to_user (struct ebt_entry_target *t,void __user **dstptr, +unsigned int *size) +{ +const struct xt_target *target = t->u.target; +struct compat_ebt_entry_mwt __user *cm = *dstptr; +int off =xt_compat_target_offset (target); +compat_uint_t tsize = t->target_size - off; + +BUG_ON (off >= t->target_size); + +if (copy_to_user (cm->u.name, target->name, +strlen (target->name) +1 ) ||put_user (tsize, &cm->match_size)) +return -EFAULT ; + +if (target->compat_to_user) { +if (target->compat_to_user (cm->data, t->data)) +return -EFAULT ; + }else if (copy_to_user (cm->data, t->data, tsize)) +return -EFAULT ; + + *size -=ebt_compat_entry_padsize () + off; + *dstptr = cm->data; + *dstptr +=tsize; +return 0 ; +} + +static int compat_watcher_to_user (struct ebt_entry_watcher *w,void __user **dstptr, +unsigned int *size) +{ +return compat_target_to_user ((struct ebt_entry_target *)w, dstptr, size); +} + +static int compat_copy_entry_to_user (struct ebt_entry *e,void __user **dstptr, +unsigned int *size) +{ +struct ebt_entry_target *t; +struct ebt_entry __user *ce; +u32 watchers_offset, target_offset, next_offset; +compat_uint_t origsize; +int ret; + +if (e->bitmask ==0 ) { +if (*size <sizeof (struct ebt_entries )) +return -EINVAL ; +if (copy_to_user (*dstptr, e,sizeof (struct ebt_entries ))) +return -EFAULT ; + + *dstptr +=sizeof (struct ebt_entries ); + *size -=sizeof (struct ebt_entries ); +return 0 ; + } + +if (*size <sizeof (*ce)) +return -EINVAL ; + + ce = (struct ebt_entry __user *)*dstptr; +if (copy_to_user (ce, e,sizeof (*ce))) +return -EFAULT ; + + origsize = *size; + *dstptr +=sizeof (*ce); + + ret =EBT_MATCH_ITERATE (e, compat_match_to_user, dstptr, size); +if (ret) +return ret; + watchers_offset = e->watchers_offset - (origsize - *size); + + ret =EBT_WATCHER_ITERATE (e, compat_watcher_to_user, dstptr, size); +if (ret) +return ret; + target_offset = e->target_offset - (origsize - *size); + + t = (struct ebt_entry_target *) ((char *) e + e->target_offset); + + ret =compat_target_to_user (t, dstptr, size); +if (ret) +return ret; + next_offset = e->next_offset - (origsize - *size); + +if (put_user (watchers_offset, &ce->watchers_offset) || +put_user (target_offset, &ce->target_offset) || +put_user (next_offset, &ce->next_offset)) +return -EFAULT ; + + *size -=sizeof (*ce); +return 0 ; +} + +static int compat_calc_match (struct ebt_entry_match *m,int *off) +{ + *off +=ebt_compat_match_offset (m->u.match, m->match_size); + *off +=ebt_compat_entry_padsize (); +return 0 ; +} + +static int compat_calc_watcher (struct ebt_entry_watcher *w,int *off) +{ + *off +=xt_compat_target_offset (w->u.watcher); + *off +=ebt_compat_entry_padsize (); +return 0 ; +} + +static int compat_calc_entry (const struct ebt_entry *e, +const struct ebt_table_info *info, +const void *base,struct compat_ebt_replace *newinfo) +{ +const struct ebt_entry_target *t; +unsigned int entry_offset; +int off, ret, i; + +if (e->bitmask ==0 ) +return 0 ; + + off =0 ; + entry_offset = (void *)e - base; + +EBT_MATCH_ITERATE (e, compat_calc_match, &off); +EBT_WATCHER_ITERATE (e, compat_calc_watcher, &off); + + t = (const struct ebt_entry_target *) ((char *) e + e->target_offset); + + off +=xt_compat_target_offset (t->u.target) +ebt_compat_entry_padsize (); + + newinfo->entries_size -= off; + + ret =xt_compat_add_offset (NFPROTO_BRIDGE , entry_offset, off); +if (ret) +return ret; + +for (i =0 ; i <NF_BR_NUMHOOKS ; i++) { +if (info->hook_entry[i] && + (e < (struct ebt_entry *)(base - (void *) info->hook_entry[i]))) { + newinfo->hook_entry[i] -= off; +pr_debug ("0x%08X -> 0x%08X\n" ,newinfo->hook_entry[i] + off, newinfo->hook_entry[i]); + } + } + +return 0 ; +} + + +static int compat_table_info (const struct ebt_table_info *info,struct compat_ebt_replace *newinfo) +{ +unsigned int size = info->entries_size; +const void *entries = info->entries; + + newinfo->entries_size = size; + +return EBT_ENTRY_ITERATE (entries, size, compat_calc_entry, info, entries, newinfo); +} + +static int compat_copy_everything_to_user (struct ebt_table *t,void __user *user, +int *len,int cmd) +{ +struct compat_ebt_replace repl, tmp; +struct ebt_counter *oldcounters; +struct ebt_table_info tinfo; +int ret; +void __user *pos; + +memset (&tinfo,0 ,sizeof (tinfo)); + +if (cmd ==EBT_SO_GET_ENTRIES ) { + tinfo.entries_size = t->private->entries_size; + tinfo.nentries = t->private->nentries; + tinfo.entries = t->private->entries; + oldcounters = t->private->counters; + }else { + tinfo.entries_size = t->table->entries_size; + tinfo.nentries = t->table->nentries; + tinfo.entries = t->table->entries; + oldcounters = t->table->counters; + } + +if (copy_from_user (&tmp, user,sizeof (tmp))) +return -EFAULT ; + +if (tmp.nentries != tinfo.nentries || + (tmp.num_counters && tmp.num_counters != tinfo.nentries)) +return -EINVAL ; + +memcpy (&repl, &tmp,sizeof (repl)); +if (cmd ==EBT_SO_GET_ENTRIES ) + ret =compat_table_info (t->private, &repl); +else + ret =compat_table_info (&tinfo, &repl); +if (ret) +return ret; + +if (*len !=sizeof (tmp) + repl.entries_size + + (tmp.num_counters? tinfo.nentries *sizeof (struct ebt_counter ):0 )) { +pr_err ("size mismatch: *len %d, entries_size %u, delta %d xe %d\n" , + *len, tinfo.entries_size,xt_compat_calc_jump (NFPROTO_BRIDGE , tinfo.entries_size), repl.entries_size); +return -EINVAL ; + } + +/* userspace might not need the counters */ + ret =copy_counters_to_user (t, oldcounters,compat_ptr (tmp.counters), + tmp.num_counters, tinfo.nentries); +if (ret) +return ret; + + pos =compat_ptr (tmp.entries); +return EBT_ENTRY_ITERATE (tinfo.entries, tinfo.entries_size, compat_copy_entry_to_user, + &pos, &tmp.entries_size); +} + +struct ebt_entries_buf_state { +char *buf_kern_start;/* kernel buffer to copy (translated) data to */ +u32 buf_kern_len;/* total size of kernel buffer */ +u32 buf_kern_offset;/* amount of data copied so far */ +u32 buf_user_offset;/* read position in userspace buffer */ +}; + +static int ebt_buf_count (struct ebt_entries_buf_state *state,unsigned int sz) +{ + state->buf_kern_offset += sz; +return state->buf_kern_offset >= sz ?0 : -EINVAL ; +} + +/* same as above, but use data from a kernel buffer instead of reading user data */ +static int ebt_buf_add (struct ebt_entries_buf_state *state, +void *data,unsigned int sz) +{ +if (state->buf_kern_start ==NULL ) + goto count_only; + +BUG_ON (state->buf_kern_offset + sz > state->buf_kern_len); + +memcpy (state->buf_kern_start + state->buf_kern_offset, data, sz); + + count_only: + state->buf_user_offset += sz; +return ebt_buf_count (state, sz); +} + +static int ebt_buf_add_pad (struct ebt_entries_buf_state *state,unsigned int sz) +{ +char *b = state->buf_kern_start; + +BUG_ON (b && state->buf_kern_offset > state->buf_kern_len); + +if (b !=NULL && sz >0 ) +memset (b + state->buf_kern_offset,0 , sz); +/* do not adjust ->buf_user_offset here, we added kernel-side padding */ +return ebt_buf_count (state, sz); +} + +enum compat_mwt { +EBT_COMPAT_MATCH , +EBT_COMPAT_WATCHER , +EBT_COMPAT_TARGET , +}; + +static int compat_mtw_from_user (struct compat_ebt_entry_mwt *mwt,enum compat_mwt compat_mwt, +struct ebt_entries_buf_state *state,const unsigned char *base) +{ +char name[EBT_FUNCTION_MAXNAMELEN ]; +struct xt_match *match; +struct xt_target *wt; +void *dst =NULL ; +int off, pad =0 , ret =0 ; +unsigned int size_kern, entry_offset, match_size = mwt->match_size; + +strlcpy (name, mwt->u.name,sizeof (name)); + +if (state->buf_kern_start) + dst = state->buf_kern_start + state->buf_kern_offset; + + entry_offset = (unsigned char *) mwt - base; +switch (compat_mwt) { +case EBT_COMPAT_MATCH : + match =try_then_request_module (xt_find_match (NFPROTO_BRIDGE , name,0 ),"ebt_%s" , name); +if (match ==NULL ) +return -ENOENT ; +if (IS_ERR (match)) +return PTR_ERR (match); + + off =ebt_compat_match_offset (match, match_size); +if (dst) { +if (match->compat_from_user) + match->compat_from_user (dst, mwt->data); +else +memcpy (dst, mwt->data, match_size); + } + + size_kern = match->matchsize; +if (unlikely (size_kern ==-1 )) + size_kern = match_size; +module_put (match->me); +break ; +case EBT_COMPAT_WATCHER :/* fallthrough */ +case EBT_COMPAT_TARGET : + wt =try_then_request_module (xt_find_target (NFPROTO_BRIDGE , name,0 ),"ebt_%s" , name); +if (wt ==NULL ) +return -ENOENT ; +if (IS_ERR (wt)) +return PTR_ERR (wt); + off =xt_compat_target_offset (wt); + +if (dst) { +if (wt->compat_from_user) + wt->compat_from_user (dst, mwt->data); +else +memcpy (dst, mwt->data, match_size); + } + + size_kern = wt->targetsize; +module_put (wt->me); +break ; + } + +if (!dst) { + ret =xt_compat_add_offset (NFPROTO_BRIDGE , entry_offset, off +ebt_compat_entry_padsize ()); +if (ret <0 ) +return ret; + } + + state->buf_kern_offset += match_size + off; + state->buf_user_offset += match_size; + pad =XT_ALIGN (size_kern) - size_kern; + +if (pad >0 && dst) { +BUG_ON (state->buf_kern_len <= pad); +BUG_ON (state->buf_kern_offset - (match_size + off) + size_kern > state->buf_kern_len - pad); +memset (dst + size_kern,0 , pad); + } +return off + match_size; +} + +/* return size of all matches, watchers or target, including necessary alignment padding */ +static int ebt_size_mwt (struct compat_ebt_entry_mwt *match32,unsigned int size_user,enum compat_mwt type, +struct ebt_entries_buf_state *state,const void *base) +{ +int growth =0 ; +unsigned int size_left = size_user; +char *buf; + +if (size_user ==0 ) +return 0 ; + + buf = (char *) match32; + +while (size_left >=sizeof (*match32)) { +struct ebt_entry_match *match_kern = (struct ebt_entry_match *) state->buf_kern_start; +int ret; + +if (match_kern) + match_kern = (struct ebt_entry_match *) (state->buf_kern_start + state->buf_kern_offset); + + ret =ebt_buf_add (state, buf,sizeof (*match32)); +if (ret <0 ) +return ret; + size_left -=sizeof (*match32); + +/* match_size may be changed later, also add padding before -> data */ + ret =ebt_buf_add_pad (state,ebt_compat_entry_padsize ()); +if (ret <0 ) +return ret; + +if (match32->match_size > size_left) +return -EINVAL ; + + size_left -= match32->match_size; + + ret =compat_mtw_from_user (match32, type, state, base); +if (ret <0 ) +return ret; + +BUG_ON (ret < match32->match_size); + growth += ret - match32->match_size; + growth +=ebt_compat_entry_padsize (); + + buf +=sizeof (*match32); + buf += match32->match_size; + +if (match_kern) + match_kern->match_size = ret; + +pr_debug ("%s: parsed entry, match_size was %u, size_user %u, size_left %u, type %d ret %d, growth %d\n" , + __func__, match32->match_size, size_user, size_left, type, ret, growth); +WARN_ON (type ==EBT_COMPAT_TARGET && size_left); + match32 = (struct compat_ebt_entry_mwt *) buf; + } + +return growth; +} + +#define EBT_COMPAT_WATCHER_ITERATE(e, fn, args...) \ +({ \ + unsigned int __i; \ + int __ret = 0; \ + struct compat_ebt_entry_mwt *__watcher; \ + \ + for (__i = e->watchers_offset; \ + __i < (e)->target_offset; \ + __i += __watcher->watcher_size + \ + sizeof(struct compat_ebt_entry_mwt)) { \ + __watcher = (void *)(e) + __i; \ + \ + __ret = fn(__watcher , ## args); \ + if (__ret != 0) \ + break; \ + } \ + if (__ret == 0) { \ + if (__i != (e)->target_offset) \ + __ret = -EINVAL; \ + } \ + __ret; \ +}) + +#define EBT_COMPAT_MATCH_ITERATE(e, fn, args...) \ +({ \ + unsigned int __i; \ + int __ret = 0; \ + struct compat_ebt_entry_mwt *__match; \ + \ + for (__i = sizeof(struct ebt_entry); \ + __i < (e)->watchers_offset; \ + __i += __match->match_size + \ + sizeof(struct compat_ebt_entry_mwt)) { \ + __match = (void *)(e) + __i; \ + \ + __ret = fn(__match , ## args); \ + if (__ret != 0) \ + break; \ + } \ + if (__ret == 0) { \ + if (__i != (e)->watchers_offset) \ + __ret = -EINVAL; \ + } \ + __ret; \ +}) + +/* called for all ebt_entry structures. */ +static int size_entry_match_watchers_target (struct ebt_entry *entry,const unsigned char *base,unsigned int *total, +struct ebt_entries_buf_state *state) +{ +unsigned int i, j, size_user, startoff, new_offset =0 ; +unsigned int offsets[4 ];/* match, watchers, targets and offset of the next struct ebt_entry */ +unsigned int *offsets_update =NULL ; +int ret; +char *buf_start = (char *) entry; + + size_user = *total; + +if (size_user <sizeof (struct ebt_entries )) +return -EINVAL ; + +if (!entry->bitmask) { + *total -=sizeof (struct ebt_entries ); +return ebt_buf_add (state, entry,sizeof (struct ebt_entries )); + } +if (size_user <sizeof (*entry) || entry->next_offset <sizeof (*entry)) +return -EINVAL ; + + startoff = state->buf_user_offset; +/* pull in the most part of ebt_entry, it does not need to be changed. */ + ret =ebt_buf_add (state, entry, offsetof(struct ebt_entry , watchers_offset)); +if (ret <0 ) +return ret; + + offsets[0 ] =sizeof (struct ebt_entry );/* matches come first */ +memcpy (&offsets[1 ], &entry->watchers_offset, +sizeof (offsets) -sizeof (offsets[0 ])); + +if (state->buf_kern_start) + offsets_update = (unsigned int *) (state->buf_kern_start + state->buf_kern_offset); + ret =ebt_buf_add (state, &offsets[1 ],sizeof (offsets) -sizeof (offsets[0 ])); +if (ret <0 ) +return ret; +/* +* 0: matches offset, always follows ebt_entry. +* 1: watchers offset, from ebt_entry structure +* 2: target offset, from ebt_entry structure +* 3: next ebt_entry offset, from ebt_entry structure +* +* offsets are relative to beginning of struct ebt_entry (i.e., 0). +*/ +for (i =0 , j =1 ; j <4 ; j++, i++) { +char *buf = buf_start; + + buf = buf_start + offsets[i]; +if (offsets[i] > offsets[j]) +return -EINVAL ; + + ret =ebt_size_mwt ((void *) buf, offsets[j] - offsets[i], i, state, base); +if (ret <0 ) +return ret; + new_offset += ret; +if (offsets_update && new_offset) { +pr_debug ("ebtables: change offset %d to %d\n" , + offsets_update[i], offsets[j] + new_offset); + offsets_update[i] = offsets[j] + new_offset; + } + } + + startoff = state->buf_user_offset - startoff; + +BUG_ON (*total < startoff); + *total -= startoff; +return 0 ; +} + +/* +* repl->entries_size is the size of the ebt_entry blob in userspace. +* It might need more memory when copied to a 64 bit kernel in case +* userspace is 32-bit. So, first task: find out how much memory is needed. +* +* Called before validation is performed. +*/ +static int compat_copy_entries (unsigned char *data,unsigned int size_user,struct ebt_entries_buf_state *state) +{ +unsigned int size_remaining = size_user; +int ret; + + ret =EBT_ENTRY_ITERATE (data, size_user, size_entry_match_watchers_target, data, &size_remaining, state); +if (ret <0 ) +return ret; + +WARN_ON (size_remaining); +return state->buf_kern_offset; +} + + +static int compat_copy_ebt_replace_from_user (struct ebt_replace *repl,void __user *user,unsigned int len) +{ +struct compat_ebt_replace tmp; +int i; + +if (len <sizeof (tmp)) +return -EINVAL ; + +if (copy_from_user (&tmp, user,sizeof (tmp))) +return -EFAULT ; + +if (len !=sizeof (tmp) + tmp.entries_size) +return -EINVAL ; + +if (tmp.entries_size ==0 ) +return -EINVAL ; + +if (tmp.nentries >= ((INT_MAX -sizeof (struct ebt_table_info )) /NR_CPUS - +SMP_CACHE_BYTES ) /sizeof (struct ebt_counter )) +return -ENOMEM ; +if (tmp.num_counters >=INT_MAX /sizeof (struct ebt_counter )) +return -ENOMEM ; + +memcpy (repl, &tmp, offsetof(struct ebt_replace , hook_entry)); + +/* starting with hook_entry, 32 vs. 64 bit structures are different */ +for (i =0 ; i <NF_BR_NUMHOOKS ; i++) + repl->hook_entry[i] =compat_ptr (tmp.hook_entry[i]); + + repl->num_counters = tmp.num_counters; + repl->counters =compat_ptr (tmp.counters); + repl->entries =compat_ptr (tmp.entries); +return 0 ; +} + +static int compat_do_replace (struct net *net,void __user *user,unsigned int len) +{ +int ret, i, countersize, size64; +struct ebt_table_info *newinfo; +struct ebt_replace tmp; +struct ebt_entries_buf_state state; +void *entries_tmp; + + ret =compat_copy_ebt_replace_from_user (&tmp, user, len); +if (ret) +return ret; + + countersize =COUNTER_OFFSET (tmp.nentries) * nr_cpu_ids; + newinfo =vmalloc (sizeof (*newinfo) + countersize); +if (!newinfo) +return -ENOMEM ; + +if (countersize) +memset (newinfo->counters,0 , countersize); + +memset (&state,0 ,sizeof (state)); + + newinfo->entries =vmalloc (tmp.entries_size); +if (!newinfo->entries) { + ret = -ENOMEM ; + goto free_newinfo; + } +if (copy_from_user ( + newinfo->entries, tmp.entries, tmp.entries_size) !=0 ) { + ret = -EFAULT ; + goto free_entries; + } + + entries_tmp = newinfo->entries; + +xt_compat_lock (NFPROTO_BRIDGE ); + + ret =compat_copy_entries (entries_tmp, tmp.entries_size, &state); +if (ret <0 ) + goto out_unlock; + +pr_debug ("tmp.entries_size %d, kern offset %d, user offset %d delta %d\n" , + tmp.entries_size, state.buf_kern_offset, state.buf_user_offset, +xt_compat_calc_jump (NFPROTO_BRIDGE , tmp.entries_size)); + + size64 = ret; + newinfo->entries =vmalloc (size64); +if (!newinfo->entries) { +vfree (entries_tmp); + ret = -ENOMEM ; + goto out_unlock; + } + +memset (&state,0 ,sizeof (state)); + state.buf_kern_start = newinfo->entries; + state.buf_kern_len = size64; + + ret =compat_copy_entries (entries_tmp, tmp.entries_size, &state); +BUG_ON (ret <0 );/* parses same data again */ + +vfree (entries_tmp); + tmp.entries_size = size64; + +for (i =0 ; i <NF_BR_NUMHOOKS ; i++) { +char __user *usrptr; +if (tmp.hook_entry[i]) { +unsigned int delta = (char __user *) tmp.hook_entry[i] - tmp.entries; +pr_debug ("hook_entry %d: (%p) delta %d\n" , + i, tmp.hook_entry[i],xt_compat_calc_jump (NFPROTO_BRIDGE , delta)); + usrptr = (char __user *) tmp.hook_entry[i]; + usrptr +=xt_compat_calc_jump (NFPROTO_BRIDGE , delta); + tmp.hook_entry[i] = (struct ebt_entries __user *) usrptr; + } + } + +xt_compat_flush_offsets (NFPROTO_BRIDGE ); +xt_compat_unlock (NFPROTO_BRIDGE ); + + ret =do_replace_finish (net, &tmp, newinfo); +if (ret ==0 ) +return ret; +free_entries: +vfree (newinfo->entries); +free_newinfo: +vfree (newinfo); +return ret; +out_unlock: +xt_compat_flush_offsets (NFPROTO_BRIDGE ); +xt_compat_unlock (NFPROTO_BRIDGE ); + goto free_entries; +} + +static int compat_update_counters (struct net *net,void __user *user,unsigned int len) +{ +struct compat_ebt_replace hlp; + +if (copy_from_user (&hlp, user,sizeof (hlp))) +return -EFAULT ; + +if (len !=sizeof (hlp) + hlp.num_counters *sizeof (struct ebt_counter )) +return -EINVAL ; + +return do_update_counters (net, hlp.name,compat_ptr (hlp.counters), + hlp.num_counters, user, len); +} + +static int compat_do_ebt_set_ctl (struct sock *sk, +int cmd,void __user *user,unsigned int len) +{ +int ret; + +if (!capable (CAP_NET_ADMIN )) +return -EPERM ; + +switch (cmd) { +case EBT_SO_SET_ENTRIES : + ret =compat_do_replace (sock_net (sk), user, len); +break ; +case EBT_SO_SET_COUNTERS : + ret =compat_update_counters (sock_net (sk), user, len); +break ; +default : + ret = -EINVAL ; + } +return ret; +} + +static int compat_do_ebt_get_ctl (struct sock *sk,int cmd,void __user *user,int *len) +{ +int ret; +struct compat_ebt_replace tmp; +struct ebt_table *t; + +if (!capable (CAP_NET_ADMIN )) +return -EPERM ; + +if ((cmd ==EBT_SO_GET_INFO || + cmd ==EBT_SO_GET_INIT_INFO ) && *len !=sizeof (tmp)) +return -EINVAL ; + +if (copy_from_user (&tmp, user,sizeof (tmp))) +return -EFAULT ; + + t =find_table_lock (sock_net (sk), tmp.name, &ret, &ebt_mutex); +if (!t) +return ret; + +xt_compat_lock (NFPROTO_BRIDGE ); +switch (cmd) { +case EBT_SO_GET_INFO : + tmp.nentries = t->private->nentries; + ret =compat_table_info (t->private, &tmp); +if (ret) + goto out; + tmp.valid_hooks = t->valid_hooks; + +if (copy_to_user (user, &tmp, *len) !=0 ) { + ret = -EFAULT ; +break ; + } + ret =0 ; +break ; +case EBT_SO_GET_INIT_INFO : + tmp.nentries = t->table->nentries; + tmp.entries_size = t->table->entries_size; + tmp.valid_hooks = t->table->valid_hooks; + +if (copy_to_user (user, &tmp, *len) !=0 ) { + ret = -EFAULT ; +break ; + } + ret =0 ; +break ; +case EBT_SO_GET_ENTRIES : +case EBT_SO_GET_INIT_ENTRIES : + ret =compat_copy_everything_to_user (t, user, len, cmd); +break ; +default : + ret = -EINVAL ; + } + out: +xt_compat_flush_offsets (NFPROTO_BRIDGE ); +xt_compat_unlock (NFPROTO_BRIDGE ); +mutex_unlock (&ebt_mutex); +return ret; +} +#endif +static struct nf_sockopt_ops ebt_sockopts = { .pf =PF_INET , .set_optmin =EBT_BASE_CTL , .set_optmax =EBT_SO_SET_MAX +1 , .set = do_ebt_set_ctl, +#ifdef CONFIG_COMPAT + .compat_set = compat_do_ebt_set_ctl, +#endif .get_optmin =EBT_BASE_CTL , .get_optmax =EBT_SO_GET_MAX +1 , .get = do_ebt_get_ctl, +#ifdef CONFIG_COMPAT + .compat_get = compat_do_ebt_get_ctl, +#endif .owner =THIS_MODULE , };
Signature · 1 line
1.6.3.3
Florian Westphal
maintainerPATCH v2 8/10 netfilter: ebtables: try native set/getsockopt handlers, too
In reply to Florian Westphalebtables can be compiled to perform userspace-side padding of structures. In that case, all the structures are already in the 'native' format expected by the kernel.
This tries to determine what format the userspace program is using.
For most set/getsockopts, this can be done by re-trying the native handler once the compat_ version returns an error.
In case of EBT_SO_GET_ENTRIES, the native handler is tried first, it should error out very early when checking the *len argument (the compat version has to defer this check until after
iterating over the kernel data set once, to adjust for all the structure size differences).
The (useful) error printk is suppressed in this case, as we will try again in compat mode.
--- net/bridge/netfilter/ebtables.c | 28 ++++++++++++++++++---------- 1 files changed, 18 insertions(+), 10 deletions(-)
net/bridge/netfilter/ebtables.c +18 -10
@@ -1406,7 +1406,7 @@ static int copy_counters_to_user(struct ebt_table *t, struct ebt_counter *oldcou/* called with ebt_mutex locked */ static int copy_everything_to_user (struct ebt_table *t,void __user *user, -int *len,int cmd) +int *len,int cmd,bool compat) {struct ebt_replace tmp;struct ebt_counter *oldcounters;
@@ -1426,14 +1426,13 @@ static int copy_everything_to_user(struct ebt_table *t, void __user *user, oldcounters = t->table->counters; } -if (copy_from_user (&tmp, user,sizeof (tmp))) { -BUGPRINT ("Cfu didn't work\n" ); +if (copy_from_user (&tmp, user,sizeof (tmp)))return -EFAULT ; - }if (*len !=sizeof (struct ebt_replace ) + entries_size + (tmp.num_counters? nentries *sizeof (struct ebt_counter ):0 )) { -BUGPRINT ("Wrong size\n" ); +if (!compat) +BUGPRINT ("Wrong size\n" );return -EINVAL ; }
@@ -1526,7 +1525,7 @@ static int do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)case EBT_SO_GET_ENTRIES :case EBT_SO_GET_INIT_ENTRIES : - ret =copy_everything_to_user (t, user, len, cmd); + ret =copy_everything_to_user (t, user, len, cmd, false);mutex_unlock (&ebt_mutex);break ;
@@ -2178,8 +2177,12 @@ static int compat_do_replace(struct net *net, void __user *user, unsigned int levoid *entries_tmp; ret =compat_copy_ebt_replace_from_user (&tmp, user, len); -if (ret) +if (ret) { +/* try real handler in case userland supplied needed padding */ +if (do_replace (net, user, len) ==0 ) + ret =0 ;return ret; + } countersize =COUNTER_OFFSET (tmp.nentries) * nr_cpu_ids; newinfo =vmalloc (sizeof (*newinfo) + countersize);
@@ -2268,8 +2271,9 @@ static int compat_update_counters(struct net *net, void __user *user, unsigned iif (copy_from_user (&hlp, user,sizeof (hlp)))return -EFAULT ; +/* try real handler in case userland supplied needed padding */ if (len !=sizeof (hlp) + hlp.num_counters *sizeof (struct ebt_counter )) -return -EINVAL ; +return update_counters (net, user, len);return do_update_counters (net, hlp.name,compat_ptr (hlp.counters), hlp.num_counters, user, len);
@@ -2305,9 +2309,10 @@ static int compat_do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, inif (!capable (CAP_NET_ADMIN ))return -EPERM ; +/* try real handler in case userland supplied needed padding */ if ((cmd ==EBT_SO_GET_INFO || cmd ==EBT_SO_GET_INIT_INFO ) && *len !=sizeof (tmp)) -return -EINVAL ; +return do_ebt_get_ctl (sk, cmd, user, len);if (copy_from_user (&tmp, user,sizeof (tmp)))return -EFAULT ;
@@ -2344,7 +2349,10 @@ static int compat_do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, inbreak ;case EBT_SO_GET_ENTRIES :case EBT_SO_GET_INIT_ENTRIES : - ret =compat_copy_everything_to_user (t, user, len, cmd); +if (copy_everything_to_user (t, user, len, cmd, true) ==0 ) + ret =0 ; +else + ret =compat_copy_everything_to_user (t, user, len, cmd);break ;default : ret = -EINVAL ;
Signature · 1 line
1.6.3.3
Re: [PATCH 08/10] netfilter: ebtables: try native set/getsockopt handlers, too
Quoted 7 lines · Florian Westphal
ebtables can be compiled to perform userspace-side padding of structures. In that case, all the structures are already in the 'native' format expected by the kernel.
This tries to determine what format the userspace program is using.
Quoted 8 lines
For most set/getsockopts, this can be done by re-trying the native handler once the
compat_version returns an error.In case of
EBT_SO_GET_ENTRIES, the native handler is tried first, it should error out very early when checking the *len argument (the compat version has to defer this check until after
iterating over the kernel data set once, to adjust for all the structure size differences).
Can't we place an explicit check somewhere instead of "probing" for compatibility? Checking the size of struct ebt_replace for compat tasks should be suitable.
Alternatively we could declare the userspace attempts to fix up the ruleset broken and ignore this case. This is what we did for iptables.
Florian Westphal
maintainerRe: [PATCH 08/10] netfilter: ebtables: try native set/getsockopt handlers, too
Quoted 16 lines · Patrick McHardy
Quoted 7 lines
ebtables can be compiled to perform userspace-side padding of structures. In that case, all the structures are already in the 'native' format expected by the kernel.
This tries to determine what format the userspace program is using.
Quoted 8 lines
For most set/getsockopts, this can be done by re-trying the native handler once the
compat_version returns an error.In case of
EBT_SO_GET_ENTRIES, the native handler is tried first, it should error out very early when checking the *len argument (the compat version has to defer this check until after
iterating over the kernel data set once, to adjust for all the structure size differences).
Quoted 3 lines
Can't we place an explicit check somewhere instead of "probing" for compatibility? Checking the size of struct
ebt_replacefor compat tasks should be suitable.
Yes, thats what is being done where possible.
Here is a list of the set/getsockopts and the current "detect" strategy:
EBT_SO_SET_COUNTERS:
in compat handler, copy struct ebt_replace from user, check that
len == sizeof(struct compat_ebt_replace) + repl.num_counters * sizeof(struct ebt_counter)
if yes: continue, else try non-compat handler
EBT_SO_SET_ENTRIES:
in compat handler, copy struct ebt_replace from user, check that len == sizeof(struct compat_ebt_replace) + repl.entries_size
if yes, continue, else try non-compat handler.
Actually, one could move the call to the non-compat handler around so that the non-compat handler is only called when this particular error occurs and not on other errors, like e.g. EFAULT.
I can do this in the next version of the patch series.
EBT_SO_GET_INFO, EBT_SO_GET_INIT_INFO:
trivial: *len must be sizeof(struct compat_ebt_replace), else try non-compat handler
EBT_SO_GET_ENTRIES, EBT_SO_GET_INIT_ENTRIES:
In the non-compat case, this check is easy:
len must be "sizeof(struct ebt_replace) + entries_size_in_kernel" (and size of all counters, but this is irrelevant because the counters
do not need compat fixups).
Thus in case of EBT_SO_GET_ENTRIES and EBT_SO_GET_INIT_ENTRIES the native handler gets called first (compat_ translates the kernel table first to determine how large the data set would be in user space, so the check cannot be done right after copying struct compat_ebt_replace from userspace).
Florian Westphal
maintainerPATCH v2 9/10 netfilter: ebt_limit: add CONFIG_COMPAT support
In reply to Florian Westphalebt_limit structure is larger on 64 bit systems due to "long" type used in the (kernel-only) data section.
Setting .compatsize is enough in this case, these values have no meaning in userspace.
---
no changes since v1.
net/bridge/netfilter/ebt_limit.c | 16 ++++++++++++++++ 1 files changed, 16 insertions(+), 0 deletions(-)
net/bridge/netfilter/ebt_limit.c +16 -0
@@ -84,6 +84,19 @@ static bool ebt_limit_mt_check(const struct xt_mtchk_param *par)return true; } + +#ifdef CONFIG_COMPAT +/* +* no conversion function needed -- +* only avg/burst have meaningful values in userspace. +*/ +struct ebt_compat_limit_info { +compat_uint_t avg, burst; +compat_ulong_t prev; +compat_uint_t credit, credit_cap, cost; +}; +#endif +static struct xt_match ebt_limit_mt_reg__read_mostly = { .name ="limit" , .revision =0 ,
@@ -91,6 +104,9 @@ static struct xt_match ebt_limit_mt_reg __read_mostly = { .match = ebt_limit_mt, .checkentry = ebt_limit_mt_check, .matchsize = sizeof(struct ebt_limit_info), +#ifdef CONFIG_COMPAT + .compatsize = sizeof(struct ebt_compat_limit_info), +#endif .me = THIS_MODULE, };
Signature · 1 line
1.6.3.3
Florian Westphal schreef:
Quoted 4 lines
Hello everyone,
this is version 2 of the ebtables
CONFIG_COMPATpatch set.
Quoted 8 lines
First patches are minor bug fixes/preparation patches. Patch 7 is the main
CONFIG_COMPAThunk, 8 handles those ebtables binaries specifically built for 64 bit kernel (i.e. pad in userspace).Last two patches add
CONFIG_COMPATsupport to the targets/matches that need special handling (maybe I missed some, though).Tested on
x86_64with x86 userland by comparing output of 32 and 64 bit ebtables binaries.
One little cleanup that could be done is remove the last use of MEMPRINT and the corresponding macro in patch 5/10.
For patch 8/10, I'd just remove the BUGPRINT line instead of adding the compat argument to copy_counters_to_user().
But apart from that, the patches look ok to me (patch 10 was missing I think).
cheers,
Bart
Signature · 2 lines
Bart De Schuymer www.artinalgorithms.be
Florian Westphal
maintainerQuoted 11 lines · Bart De Schuymer
Quoted 8 lines
First patches are minor bug fixes/preparation patches. Patch 7 is the main
CONFIG_COMPAThunk, 8 handles those ebtables binaries specifically built for 64 bit kernel (i.e. pad in userspace).Last two patches add
CONFIG_COMPATsupport to the targets/matches that need special handling (maybe I missed some, though).Tested on
x86_64with x86 userland by comparing output of 32 and 64 bit ebtables binaries.One little cleanup that could be done is remove the last use of MEMPRINT and the corresponding macro in patch 5/10.
Okay, I'll do that then in the next iteration.
Quoted 2 lines
For patch 8/10, I'd just remove the BUGPRINT line instead of adding the compat argument to
copy_counters_to_user().
Perfect, I was a bit concerned if removing it would be acceptable; thats the sole reason I added this ugly "bool compat" argument...
I'll just remove it, thanks Bart.
Quoted 2 lines
But apart from that, the patches look ok to me (patch 10 was missing I think).
Whoops. Proabably because I ran send-email 000* .
It was unchanged from v1, though (except added const qualifiers).
Thanks a lot for taking the time to review this.
Regards, Florian