Netfilter/IPVS fixes for net
Subsystems (5)
Pablo Neira Ayuso
maintainercover Netfilter/IPVS fixes for net
Hi David,
The following patchset contains Netfilter/IPVS fixes for your net tree:
1) The nftnl mutex is now per-netns, therefore use reference counter for matches and targets to deal with concurrent updates from netns. Moreover, place extensions in a pernet list. Patches from Florian Westphal.
2) Bail out with EINVAL in case of negative timeouts via setsockopt() through ip_vs_set_timeout(), from ZhangXiaoxu.
3) Spurious EINVAL on ebtables 32bit binary with 64bit kernel, also from Florian.
4) Reset TCP option header parser in case of fingerprint mismatch, otherwise follow up overlapping fingerprint definitions including TCP options do not work, from Fernando Fernandez Mancera.
5) Compilation warning in ipt_CLUSTER with CONFIG_PROC_FS unset. From Anders Roxell.
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
Thanks!
----------------------------------------------------------------
The following changes since commit 88a8121dc1d3d0dbddd411b79ed236b6b6ea415c:
af_packet: fix raw sockets over 6in4 tunnel (2019-01-17 15:54:45 -0800)
are available in the git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git HEAD
for you to fetch changes up to 206b8cc514d7ff2b79dd2d5ad939adc7c493f07a:
netfilter: ipt_CLUSTERIP: fix warning unused variable cn (2019-01-28 11:09:12 +0100)
----------------------------------------------------------------
Anders Roxell (1):
netfilter: ipt_CLUSTERIP: fix warning unused variable cn
Fernando Fernandez Mancera (1):
netfilter: nfnetlink_osf: add missing fmatch check
Florian Westphal (4):
netfilter: nft_compat: use refcnt_t type for nft_xt reference count
netfilter: nft_compat: make lists per netns
netfilter: nft_compat: destroy function must not have side effects
netfilter: ebtables: compat: un-break 32bit setsockopt when no rules are present
ZhangXiaoxu (1):
ipvs: Fix signed integer overflow when setsockopt timeout
net/bridge/netfilter/ebtables.c | 9 +- net/ipv4/netfilter/ipt_CLUSTERIP.c | 2 +- net/netfilter/ipvs/ip_vs_ctl.c | 12 +++ net/netfilter/nfnetlink_osf.c | 4 + net/netfilter/nft_compat.c | 189 ++++++++++++++++++++++++++++--------- 5 files changed, 165 insertions(+), 51 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/7 netfilter: nft_compat: use refcnt_t type for nft_xt reference count
From: Florian Westphal <[email protected]>
Using standard integer type was fine while all operations on it were guarded by the nftnl subsys mutex.
This isn't true anymore:
1. transactions are guarded only by a pernet mutex, so concurrent rule manipulation in different netns is racy
2. the ->destroy hook runs from a work queue after the transaction mutex has been released already.
cpu0 cpu1 (net 1) cpu2 (net 2)
kworker
nft_compat->destroy nft_compat->init nft_compat->init
if (--nft_xt->ref == 0) nft_xt->ref++ nft_xt->ref++Switch to refcount_t. Doing this however only fixes a minor aspect, nft_compat also performs linked-list operations in an unsafe way.
This is addressed in the next two patches.
--- net/netfilter/nft_compat.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
net/netfilter/nft_compat.c +8 -8
@@ -26,7 +26,7 @@struct nft_xt {struct list_head head;struct nft_expr_ops ops; -unsigned int refcnt; +refcount_t refcnt;/* Unlike other expressions, ops doesn't have static storage duration. * nft core assumes they do. We use kfree_rcu so that nft core can
@@ -45,7 +45,7 @@ struct nft_xt_match_priv {static bool nft_xt_put (struct nft_xt *xt) { -if (--xt->refcnt ==0 ) { +if (refcount_dec_and_test (&xt->refcnt)) {list_del (&xt->head);kfree_rcu (xt, rcu_head);return true;
@@ -273,7 +273,7 @@ nft_target_init(const struct nft_ctx *ctx, const struct nft_expr *expr,return -EINVAL ; nft_xt = container_of(expr->ops, struct nft_xt, ops); - nft_xt->refcnt++; +refcount_inc (&nft_xt->refcnt);return 0 ; }
@@ -486,7 +486,7 @@ __nft_match_init(const struct nft_ctx *ctx, const struct nft_expr *expr,return ret; nft_xt = container_of(expr->ops, struct nft_xt, ops); - nft_xt->refcnt++; +refcount_inc (&nft_xt->refcnt);return 0 ; }
@@ -789,7 +789,7 @@ nft_match_select_ops(const struct nft_ctx *ctx, goto err; } - nft_match->refcnt =0 ; +refcount_set (&nft_match->refcnt,0 ); nft_match->ops.type = &nft_match_type; nft_match->ops.eval = nft_match_eval; nft_match->ops.init = nft_match_init;
@@ -893,7 +893,7 @@ nft_target_select_ops(const struct nft_ctx *ctx, goto err; } - nft_target->refcnt =0 ; +refcount_set (&nft_target->refcnt,0 ); nft_target->ops.type = &nft_target_type; nft_target->ops.size =NFT_EXPR_SIZE (XT_ALIGN (target->targetsize)); nft_target->ops.init = nft_target_init;
@@ -964,7 +964,7 @@ static void __exit nft_compat_module_exit(void)list_for_each_entry_safe (xt, next, &nft_target_list, head) {struct xt_target *target = xt->ops.data; -if (WARN_ON_ONCE (xt->refcnt)) +if (WARN_ON_ONCE (refcount_read (&xt->refcnt)))continue ;module_put (target->me);kfree (xt);
@@ -973,7 +973,7 @@ static void __exit nft_compat_module_exit(void)list_for_each_entry_safe (xt, next, &nft_match_list, head) {struct xt_match *match = xt->ops.data; -if (WARN_ON_ONCE (xt->refcnt)) +if (WARN_ON_ONCE (refcount_read (&xt->refcnt)))continue ;module_put (match->me);kfree (xt);
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 2/7 netfilter: nft_compat: make lists per netns
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
There are two problems with nft_compat since the netlink config plane uses a per-netns mutex:
1. Concurrent add/del accesses to the same list
2. accesses to a list element after it has been free'd already.
This patch fixes the first problem.
Freeing occurs from a work queue, after transaction mutexes have been released, i.e., it still possible for a new transaction (even from same net ns) to find the to-be-deleted expression in the list.
The ->destroy functions are not allowed to have any such side effects, i.e. the list_del() in the destroy function is not allowed.
This part of the problem is solved in the next patch. I tried to make this work by serializing list access via mutex and by moving list_del() to a deactivate callback, but Taehee spotted following race on this approach:
NET #0 NET #1
Quoted 1 line
select_ops()
->init()
->select_ops()
->deactivate()
->destroy()
nft_xt_put()
kfree_rcu(xt, rcu_head);
->init() <-- use-after-free occurred.Unfortunately, we can't increment reference count in select_ops(), because we can't undo the refcount increase in case a different expression fails in the same batch.
(The destroy hook will only be called in case the expression
was initialized successfully).
--- net/netfilter/nft_compat.c | 129 +++++++++++++++++++++++++++++++-------------- 1 file changed, 89 insertions(+), 40 deletions(-)
net/netfilter/nft_compat.c +89 -40
@@ -22,6 +22,7 @@#include <linux/netfilter_bridge/ebtables.h> #include <linux/netfilter_arp/arp_tables.h> #include <net/netfilter/nf_tables.h> +#include <net/netns/generic.h> struct nft_xt {struct list_head head;
@@ -43,6 +44,20 @@ struct nft_xt_match_priv {void *info; }; +struct nft_compat_net { +struct list_head nft_target_list; +struct list_head nft_match_list; +}; + +static unsigned int nft_compat_net_id__read_mostly ; +static struct nft_expr_type nft_match_type; +static struct nft_expr_type nft_target_type; + +static struct nft_compat_net *nft_compat_pernet (struct net *net) +{ +return net_generic (net, nft_compat_net_id); +} +static bool nft_xt_put (struct nft_xt *xt) {if (refcount_dec_and_test (&xt->refcnt)) {
@@ -734,10 +749,6 @@ static const struct nfnetlink_subsystem nfnl_compat_subsys = { .cb = nfnl_nft_compat_cb, }; -static LIST_HEAD (nft_match_list); - -static struct nft_expr_type nft_match_type; -static bool nft_match_cmp (const struct xt_match *match,const char *name,u32 rev,u32 family) {
@@ -749,6 +760,7 @@ static const struct nft_expr_ops * nft_match_select_ops(const struct nft_ctx *ctx, const struct nlattr * const tb[]) { + struct nft_compat_net *cn;struct nft_xt *nft_match;struct xt_match *match;unsigned int matchsize;
@@ -765,8 +777,10 @@ nft_match_select_ops(const struct nft_ctx *ctx, rev =ntohl (nla_get_be32 (tb[NFTA_MATCH_REV ])); family = ctx->family; + cn =nft_compat_pernet (ctx->net); +/* Re-use the existing match if it's already loaded. */ -list_for_each_entry (nft_match, &nft_match_list, head) { +list_for_each_entry (nft_match, &cn->nft_match_list, head) {struct xt_match *match = nft_match->ops.data;if (nft_match_cmp (match, mt_name, rev, family))
@@ -810,7 +824,7 @@ nft_match_select_ops(const struct nft_ctx *ctx, nft_match->ops.size = matchsize; -list_add (&nft_match->head, &nft_match_list); +list_add (&nft_match->head, &cn->nft_match_list);return &nft_match->ops; err:
@@ -826,10 +840,6 @@ static struct nft_expr_type nft_match_type __read_mostly = { .owner = THIS_MODULE, }; -static LIST_HEAD (nft_target_list); - -static struct nft_expr_type nft_target_type; -static bool nft_target_cmp (const struct xt_target *tg,const char *name,u32 rev,u32 family) {
@@ -841,6 +851,7 @@ static const struct nft_expr_ops * nft_target_select_ops(const struct nft_ctx *ctx, const struct nlattr * const tb[]) { + struct nft_compat_net *cn;struct nft_xt *nft_target;struct xt_target *target;char *tg_name;
@@ -861,8 +872,9 @@ nft_target_select_ops(const struct nft_ctx *ctx, strcmp(tg_name, "standard") == 0)return ERR_PTR (-EINVAL ); + cn =nft_compat_pernet (ctx->net);/* Re-use the existing target if it's already loaded. */ -list_for_each_entry (nft_target, &nft_target_list, head) { +list_for_each_entry (nft_target, &cn->nft_target_list, head) {struct xt_target *target = nft_target->ops.data;if (!target->target)
@@ -907,7 +919,7 @@ nft_target_select_ops(const struct nft_ctx *ctx,else nft_target->ops.eval = nft_target_eval_xt; -list_add (&nft_target->head, &nft_target_list); +list_add (&nft_target->head, &cn->nft_target_list);return &nft_target->ops; err:
@@ -923,13 +935,74 @@ static struct nft_expr_type nft_target_type __read_mostly = { .owner = THIS_MODULE, }; +static int __net_init nft_compat_init_net (struct net *net) +{ +struct nft_compat_net *cn =nft_compat_pernet (net); + +INIT_LIST_HEAD (&cn->nft_target_list); +INIT_LIST_HEAD (&cn->nft_match_list); + +return 0 ; +} + +static void __net_exit nft_compat_exit_net(struct net *net) +{ +struct nft_compat_net *cn =nft_compat_pernet (net); +struct nft_xt *xt, *next; + +if (list_empty (&cn->nft_match_list) && +list_empty (&cn->nft_target_list)) +return ; + +/* If there was an error that caused nft_xt expr to not be initialized +* fully and noone else requested the same expression later, the lists +* contain 0-refcount entries that still hold module reference. +* +* Clean them here. +*/ +mutex_lock (&net->nft.commit_mutex); +list_for_each_entry_safe (xt, next, &cn->nft_target_list, head) { +struct xt_target *target = xt->ops.data; + +list_del_init (&xt->head); + +if (refcount_read (&xt->refcnt)) +continue ; +module_put (target->me); +kfree (xt); + } + +list_for_each_entry_safe (xt, next, &cn->nft_match_list, head) { +struct xt_match *match = xt->ops.data; + +list_del_init (&xt->head); + +if (refcount_read (&xt->refcnt)) +continue ; +module_put (match->me); +kfree (xt); + } +mutex_unlock (&net->nft.commit_mutex); +} + +static struct pernet_operations nft_compat_net_ops = { + .init = nft_compat_init_net, + .exit = nft_compat_exit_net, + .id = &nft_compat_net_id, + .size =sizeof (struct nft_compat_net ), +}; +static int __init nft_compat_module_init (void ) {int ret; + ret =register_pernet_subsys (&nft_compat_net_ops); +if (ret <0 ) + goto err_target; + ret =nft_register_expr (&nft_match_type);if (ret <0 ) -return ret; + goto err_pernet; ret =nft_register_expr (&nft_target_type);if (ret <0 )
@@ -942,45 +1015,21 @@ static int __init nft_compat_module_init(void) }return ret; - err_target:nft_unregister_expr (&nft_target_type); err_match:nft_unregister_expr (&nft_match_type); +err_pernet: +unregister_pernet_subsys (&nft_compat_net_ops);return ret; } static void __exit nft_compat_module_exit(void) { -struct nft_xt *xt, *next; - -/* list should be empty here, it can be non-empty only in case there -* was an error that caused nft_xt expr to not be initialized fully -* and noone else requested the same expression later. -* -* In this case, the lists contain 0-refcount entries that still -* hold module reference. -*/ -list_for_each_entry_safe (xt, next, &nft_target_list, head) { -struct xt_target *target = xt->ops.data; - -if (WARN_ON_ONCE (refcount_read (&xt->refcnt))) -continue ; -module_put (target->me); -kfree (xt); - } - -list_for_each_entry_safe (xt, next, &nft_match_list, head) { -struct xt_match *match = xt->ops.data; - -if (WARN_ON_ONCE (refcount_read (&xt->refcnt))) -continue ; -module_put (match->me); -kfree (xt); - }nfnetlink_subsys_unregister (&nfnl_compat_subsys);nft_unregister_expr (&nft_target_type);nft_unregister_expr (&nft_match_type); +unregister_pernet_subsys (&nft_compat_net_ops); }MODULE_ALIAS_NFNL_SUBSYS (NFNL_SUBSYS_NFT_COMPAT );
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 3/7 netfilter: nft_compat: destroy function must not have side effects
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
The nft_compat destroy function deletes the nft_xt object from a list. This isn't allowed anymore. Destroy functions are called asynchronously, i.e. next batch can find the object that has a pending ->destroy() invocation:
cpu0 cpu1
worker
->destroy for_each_entry()
if (x == ...
return x->ops;
list_del(x)
kfree_rcu(x)
expr->ops->... // ops was free'dTo resolve this, the list_del needs to occur before the transaction mutex gets released. nf_tables has a 'deactivate' hook for this purpose, so use that to unlink the object from the list.
--- net/netfilter/nft_compat.c | 48 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 47 insertions(+), 1 deletion(-)
net/netfilter/nft_compat.c +47 -1
@@ -29,6 +29,9 @@ struct nft_xt {struct nft_expr_ops ops;refcount_t refcnt; +/* used only when transaction mutex is locked */ +unsigned int listcnt; +/* Unlike other expressions, ops doesn't have static storage duration. * nft core assumes they do. We use kfree_rcu so that nft core can * can check expr->ops->size even after nft_compat->destroy() frees
@@ -61,7 +64,7 @@ static struct nft_compat_net *nft_compat_pernet(struct net *net)static bool nft_xt_put (struct nft_xt *xt) {if (refcount_dec_and_test (&xt->refcnt)) { -list_del (&xt->head); +WARN_ON_ONCE (!list_empty (&xt->head));kfree_rcu (xt, rcu_head);return true; }
@@ -555,6 +558,43 @@ nft_match_destroy(const struct nft_ctx *ctx, const struct nft_expr *expr)__nft_match_destroy (ctx, expr,nft_expr_priv (expr)); } +static void nft_compat_activate (const struct nft_ctx *ctx, +const struct nft_expr *expr, +struct list_head *h) +{ + struct nft_xt *xt = container_of(expr->ops, struct nft_xt, ops); + +if (xt->listcnt ==0 ) +list_add (&xt->head, h); + + xt->listcnt++; +} + +static void nft_compat_activate_mt (const struct nft_ctx *ctx, +const struct nft_expr *expr) +{ +struct nft_compat_net *cn =nft_compat_pernet (ctx->net); + +nft_compat_activate (ctx, expr, &cn->nft_match_list); +} + +static void nft_compat_activate_tg (const struct nft_ctx *ctx, +const struct nft_expr *expr) +{ +struct nft_compat_net *cn =nft_compat_pernet (ctx->net); + +nft_compat_activate (ctx, expr, &cn->nft_target_list); +} + +static void nft_compat_deactivate (const struct nft_ctx *ctx, +const struct nft_expr *expr) +{ + struct nft_xt *xt = container_of(expr->ops, struct nft_xt, ops); + +if (--xt->listcnt ==0 ) +list_del_init (&xt->head); +} +static void nft_match_large_destroy (const struct nft_ctx *ctx,const struct nft_expr *expr) {
@@ -808,6 +848,8 @@ nft_match_select_ops(const struct nft_ctx *ctx, nft_match->ops.eval = nft_match_eval; nft_match->ops.init = nft_match_init; nft_match->ops.destroy = nft_match_destroy; + nft_match->ops.activate = nft_compat_activate_mt; + nft_match->ops.deactivate = nft_compat_deactivate; nft_match->ops.dump = nft_match_dump; nft_match->ops.validate = nft_match_validate; nft_match->ops.data = match;
@@ -824,6 +866,7 @@ nft_match_select_ops(const struct nft_ctx *ctx, nft_match->ops.size = matchsize; + nft_match->listcnt =1 ;list_add (&nft_match->head, &cn->nft_match_list);return &nft_match->ops;
@@ -910,6 +953,8 @@ nft_target_select_ops(const struct nft_ctx *ctx, nft_target->ops.size =NFT_EXPR_SIZE (XT_ALIGN (target->targetsize)); nft_target->ops.init = nft_target_init; nft_target->ops.destroy = nft_target_destroy; + nft_target->ops.activate = nft_compat_activate_tg; + nft_target->ops.deactivate = nft_compat_deactivate; nft_target->ops.dump = nft_target_dump; nft_target->ops.validate = nft_target_validate; nft_target->ops.data = target;
@@ -919,6 +964,7 @@ nft_target_select_ops(const struct nft_ctx *ctx,else nft_target->ops.eval = nft_target_eval_xt; + nft_target->listcnt =1 ;list_add (&nft_target->head, &cn->nft_target_list);return &nft_target->ops;
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 4/7 ipvs: Fix signed integer overflow when setsockopt timeout
In reply to Pablo Neira AyusoFrom: ZhangXiaoxu <[email protected]>
There is a UBSAN bug report as below:
UBSAN: Undefined behaviour in net/netfilter/ipvs/ip_vs_ctl.c:2227:21
signed integer overflow:
-2147483647 * 1000 cannot be represented in type 'int'
Reproduce program:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#define IPPROTO_IP 0
#define IPPROTO_RAW 255
#define IP_VS_BASE_CTL (64+1024+64)
#define IP_VS_SO_SET_TIMEOUT (IP_VS_BASE_CTL+10)
/* The argument to IP_VS_SO_GET_TIMEOUT */
struct ipvs_timeout_t {
int tcp_timeout;
int tcp_fin_timeout;
int udp_timeout;
};
int main() {
int ret = -1;
int sockfd = -1;
struct ipvs_timeout_t to;
sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
if (sockfd == -1) {
printf("socket init error\n");
return -1;
}
to.tcp_timeout = -2147483647;
to.tcp_fin_timeout = -2147483647;
to.udp_timeout = -2147483647;
ret = setsockopt(sockfd,
IPPROTO_IP,
IP_VS_SO_SET_TIMEOUT,
(char *)(&to),
sizeof(to));
printf("setsockopt return %d\n", ret);
return ret;
}Return -EINVAL if the timeout value is negative or max than 'INT_MAX / HZ'.
--- net/netfilter/ipvs/ip_vs_ctl.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
net/netfilter/ipvs/ip_vs_ctl.c +12 -0
@@ -2221,6 +2221,18 @@ static int ip_vs_set_timeout(struct netns_ipvs *ipvs, struct ip_vs_timeout_user u->udp_timeout);#ifdef CONFIG_IP_VS_PROTO_TCP +if (u->tcp_timeout <0 || u->tcp_timeout > (INT_MAX /HZ ) || + u->tcp_fin_timeout <0 || u->tcp_fin_timeout > (INT_MAX /HZ )) { +return -EINVAL ; + } +#endif + +#ifdef CONFIG_IP_VS_PROTO_UDP +if (u->udp_timeout <0 || u->udp_timeout > (INT_MAX /HZ )) +return -EINVAL ; +#endif + +#ifdef CONFIG_IP_VS_PROTO_TCP if (u->tcp_timeout) { pd =ip_vs_proto_data_get (ipvs,IPPROTO_TCP ); pd->timeout_table[IP_VS_TCP_S_ESTABLISHED ]
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 5/7 netfilter: ebtables: compat: un-break 32bit setsockopt when no rules are present
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
Unlike ip(6)tables ebtables only counts user-defined chains.
The effect is that a 32bit ebtables binary on a 64bit kernel can do 'ebtables -N FOO' only after adding at least one rule, else the request fails with -EINVAL.
This is a similar fix as done in3f1e53abff84 ("netfilter: ebtables: don't attempt to allocate 0-sized compat array").
--- net/bridge/netfilter/ebtables.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
net/bridge/netfilter/ebtables.c +6 -3
@@ -2293,9 +2293,12 @@ static int compat_do_replace(struct net *net, void __user *user,xt_compat_lock (NFPROTO_BRIDGE ); - ret =xt_compat_init_offsets (NFPROTO_BRIDGE , tmp.nentries); -if (ret <0 ) - goto out_unlock; +if (tmp.nentries) { + ret =xt_compat_init_offsets (NFPROTO_BRIDGE , tmp.nentries); +if (ret <0 ) + goto out_unlock; + } + ret =compat_copy_entries (entries_tmp, tmp.entries_size, &state);if (ret <0 ) goto out_unlock;
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 6/7 netfilter: nfnetlink_osf: add missing fmatch check
In reply to Pablo Neira AyusoFrom: Fernando Fernandez Mancera <[email protected]>
When we check the tcp options of a packet and it doesn't match the current fingerprint, the tcp packet option pointer must be restored to its initial value in order to do the proper tcp options check for the next fingerprint.
Here we can see an example.
Assumming the following fingerprint base with two lines:
S10:64:1:60:M*,S,T,N,W6: Linux:3.0::Linux 3.0
S20:64:1:60:M*,S,T,N,W7: Linux:4.19:arch:Linux 4.1
Where TCP options are the last field in the OS signature, all of them overlap except by the last one, ie. 'W6' versus 'W7'.
In case a packet for Linux 4.19 kicks in, the osf finds no matching because the TCP options pointer is updated after checking for the TCP options in the first line.
Therefore, reset pointer back to where it should be.
--- net/netfilter/nfnetlink_osf.c | 4 ++++ 1 file changed, 4 insertions(+)
net/netfilter/nfnetlink_osf.c +4 -0
@@ -66,6 +66,7 @@ static bool nf_osf_match_one(const struct sk_buff *skb,int ttl_check, struct nf_osf_hdr_ctx *ctx) { + const __u8 *optpinit = ctx->optp;unsigned int check_WSS =0 ;int fmatch =FMATCH_WRONG ;int foptsize, optnum;
@@ -155,6 +156,9 @@ static bool nf_osf_match_one(const struct sk_buff *skb, } } +if (fmatch !=FMATCH_OK ) + ctx->optp = optpinit; +return fmatch ==FMATCH_OK ; }
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH 7/7 netfilter: ipt_CLUSTERIP: fix warning unused variable cn
In reply to Pablo Neira AyusoFrom: Anders Roxell <[email protected]>
When CONFIG_PROC_FS isn't set the variable cn isn't used.
net/ipv4/netfilter/ipt_CLUSTERIP.c: In function ‘clusterip_net_exit’:net/ipv4/netfilter/ipt_CLUSTERIP.c:849:24: warning: unused variable ‘cn’ [-Wunused-variable]
struct clusterip_net *cn = clusterip_pernet(net);
^~Rework so the variable 'cn' is declared inside "#ifdef CONFIG_PROC_FS".
--- net/ipv4/netfilter/ipt_CLUSTERIP.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/ipv4/netfilter/ipt_CLUSTERIP.c +1 -1
@@ -846,9 +846,9 @@ static int clusterip_net_init(struct net *net)static void clusterip_net_exit (struct net *net) { +#ifdef CONFIG_PROC_FS struct clusterip_net *cn =clusterip_pernet (net); -#ifdef CONFIG_PROC_FS mutex_lock (&cn->mutex);proc_remove (cn->procdir); cn->procdir =NULL ;
Signature · 1 line
2.11.0
David Miller
maintainerFrom: Pablo Neira Ayuso <[email protected]>
Date: Mon, 28 Jan 2019 15:03:58 +0100
Quoted 16 lines
The following patchset contains Netfilter/IPVS fixes for your net tree:
1) The nftnl mutex is now per-netns, therefore use reference counter for matches and targets to deal with concurrent updates from netns. Moreover, place extensions in a pernet list. Patches from Florian Westphal.
2) Bail out with EINVAL in case of negative timeouts via
setsockopt()throughip_vs_set_timeout(), from ZhangXiaoxu.3) Spurious EINVAL on ebtables 32bit binary with 64bit kernel, also from Florian.
4) Reset TCP option header parser in case of fingerprint mismatch, otherwise follow up overlapping fingerprint definitions including TCP options do not work, from Fernando Fernandez Mancera.
Quoted 6 lines
5) Compilation warning in
ipt_CLUSTERwithCONFIG_PROC_FSunset. From Anders Roxell.You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
Pulled, thanks Pablo.