![Johannes Berg](/assets/img/avatar_default.png)
We currently have two levels of strict validation: 1) liberal (default) - undefined (type >= max) & NLA_UNSPEC attributes accepted - attribute length >= expected accepted - garbage at end of message accepted 2) strict (opt-in) - NLA_UNSPEC attributes accepted - attribute length >= expected accepted Split out parsing strictness into four different options: * TRAILING - check that there's no trailing data after parsing attributes (in message or nested) * MAXTYPE - reject attrs > max known type * UNSPEC - reject attributes with NLA_UNSPEC policy entries * STRICT_ATTRS - strictly validate attribute size The default for future things should be *everything*. The current *_strict() is a combination of TRAILING and MAXTYPE, and is renamed to _deprecated_strict(). The current regular parsing has none of this, and is renamed to *_parse_deprecated(). Additionally it allows us to selectively set one of the new flags even on old policies. Notably, the UNSPEC flag could be useful in this case, since it can be arranged (by filling in the policy) to not be an incompatible userspace ABI change, but would then going forward prevent forgetting attribute entries. Similar can apply to the POLICY flag. We end up with the following renames: * nla_parse -> nla_parse_deprecated * nla_parse_strict -> nla_parse_deprecated_strict * nlmsg_parse -> nlmsg_parse_deprecated * nlmsg_parse_strict -> nlmsg_parse_deprecated_strict * nla_parse_nested -> nla_parse_nested_deprecated * nla_validate_nested -> nla_validate_nested_deprecated Using spatch, of course: @@ expression TB, MAX, HEAD, LEN, POL, EXT; @@ -nla_parse(TB, MAX, HEAD, LEN, POL, EXT) +nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT) @@ expression NLH, HDRLEN, TB, MAX, POL, EXT; @@ -nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT) +nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT) @@ expression NLH, HDRLEN, TB, MAX, POL, EXT; @@ -nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT) +nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT) @@ expression TB, MAX, NLA, POL, EXT; @@ -nla_parse_nested(TB, MAX, NLA, POL, EXT) +nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT) @@ expression START, MAX, POL, EXT; @@ -nla_validate_nested(START, MAX, POL, EXT) +nla_validate_nested_deprecated(START, MAX, POL, EXT) @@ expression NLH, HDRLEN, MAX, POL, EXT; @@ -nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT) +nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT) For this patch, don't actually add the strict, non-renamed versions yet so that it breaks compile if I get it wrong. Also, while at it, make nla_validate and nla_parse go down to a common __nla_validate_parse() function to avoid code duplication. Ultimately, this allows us to have very strict validation for every new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the next patch, while existing things will continue to work as is. In effect then, this adds fully strict validation for any new command. Signed-off-by: Johannes Berg <johannes.berg@intel.com> Signed-off-by: David S. Miller <davem@davemloft.net>
640 lines
15 KiB
C
640 lines
15 KiB
C
/* Netfilter messages via netlink socket. Allows for user space
|
|
* protocol helpers and general trouble making from userspace.
|
|
*
|
|
* (C) 2001 by Jay Schulist <jschlst@samba.org>,
|
|
* (C) 2002-2005 by Harald Welte <laforge@gnumonks.org>
|
|
* (C) 2005-2017 by Pablo Neira Ayuso <pablo@netfilter.org>
|
|
*
|
|
* Initial netfilter messages via netlink development funded and
|
|
* generally made possible by Network Robots, Inc. (www.networkrobots.com)
|
|
*
|
|
* Further development of this code funded by Astaro AG (http://www.astaro.com)
|
|
*
|
|
* This software may be used and distributed according to the terms
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/socket.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/sockios.h>
|
|
#include <linux/net.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/uaccess.h>
|
|
#include <net/sock.h>
|
|
#include <linux/init.h>
|
|
#include <linux/sched/signal.h>
|
|
|
|
#include <net/netlink.h>
|
|
#include <linux/netfilter/nfnetlink.h>
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
|
|
MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_NETFILTER);
|
|
|
|
#define nfnl_dereference_protected(id) \
|
|
rcu_dereference_protected(table[(id)].subsys, \
|
|
lockdep_nfnl_is_held((id)))
|
|
|
|
#define NFNL_MAX_ATTR_COUNT 32
|
|
|
|
static struct {
|
|
struct mutex mutex;
|
|
const struct nfnetlink_subsystem __rcu *subsys;
|
|
} table[NFNL_SUBSYS_COUNT];
|
|
|
|
static const int nfnl_group2type[NFNLGRP_MAX+1] = {
|
|
[NFNLGRP_CONNTRACK_NEW] = NFNL_SUBSYS_CTNETLINK,
|
|
[NFNLGRP_CONNTRACK_UPDATE] = NFNL_SUBSYS_CTNETLINK,
|
|
[NFNLGRP_CONNTRACK_DESTROY] = NFNL_SUBSYS_CTNETLINK,
|
|
[NFNLGRP_CONNTRACK_EXP_NEW] = NFNL_SUBSYS_CTNETLINK_EXP,
|
|
[NFNLGRP_CONNTRACK_EXP_UPDATE] = NFNL_SUBSYS_CTNETLINK_EXP,
|
|
[NFNLGRP_CONNTRACK_EXP_DESTROY] = NFNL_SUBSYS_CTNETLINK_EXP,
|
|
[NFNLGRP_NFTABLES] = NFNL_SUBSYS_NFTABLES,
|
|
[NFNLGRP_ACCT_QUOTA] = NFNL_SUBSYS_ACCT,
|
|
[NFNLGRP_NFTRACE] = NFNL_SUBSYS_NFTABLES,
|
|
};
|
|
|
|
void nfnl_lock(__u8 subsys_id)
|
|
{
|
|
mutex_lock(&table[subsys_id].mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnl_lock);
|
|
|
|
void nfnl_unlock(__u8 subsys_id)
|
|
{
|
|
mutex_unlock(&table[subsys_id].mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnl_unlock);
|
|
|
|
#ifdef CONFIG_PROVE_LOCKING
|
|
bool lockdep_nfnl_is_held(u8 subsys_id)
|
|
{
|
|
return lockdep_is_held(&table[subsys_id].mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(lockdep_nfnl_is_held);
|
|
#endif
|
|
|
|
int nfnetlink_subsys_register(const struct nfnetlink_subsystem *n)
|
|
{
|
|
u8 cb_id;
|
|
|
|
/* Sanity-check attr_count size to avoid stack buffer overflow. */
|
|
for (cb_id = 0; cb_id < n->cb_count; cb_id++)
|
|
if (WARN_ON(n->cb[cb_id].attr_count > NFNL_MAX_ATTR_COUNT))
|
|
return -EINVAL;
|
|
|
|
nfnl_lock(n->subsys_id);
|
|
if (table[n->subsys_id].subsys) {
|
|
nfnl_unlock(n->subsys_id);
|
|
return -EBUSY;
|
|
}
|
|
rcu_assign_pointer(table[n->subsys_id].subsys, n);
|
|
nfnl_unlock(n->subsys_id);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnetlink_subsys_register);
|
|
|
|
int nfnetlink_subsys_unregister(const struct nfnetlink_subsystem *n)
|
|
{
|
|
nfnl_lock(n->subsys_id);
|
|
table[n->subsys_id].subsys = NULL;
|
|
nfnl_unlock(n->subsys_id);
|
|
synchronize_rcu();
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnetlink_subsys_unregister);
|
|
|
|
static inline const struct nfnetlink_subsystem *nfnetlink_get_subsys(u16 type)
|
|
{
|
|
u8 subsys_id = NFNL_SUBSYS_ID(type);
|
|
|
|
if (subsys_id >= NFNL_SUBSYS_COUNT)
|
|
return NULL;
|
|
|
|
return rcu_dereference(table[subsys_id].subsys);
|
|
}
|
|
|
|
static inline const struct nfnl_callback *
|
|
nfnetlink_find_client(u16 type, const struct nfnetlink_subsystem *ss)
|
|
{
|
|
u8 cb_id = NFNL_MSG_TYPE(type);
|
|
|
|
if (cb_id >= ss->cb_count)
|
|
return NULL;
|
|
|
|
return &ss->cb[cb_id];
|
|
}
|
|
|
|
int nfnetlink_has_listeners(struct net *net, unsigned int group)
|
|
{
|
|
return netlink_has_listeners(net->nfnl, group);
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnetlink_has_listeners);
|
|
|
|
int nfnetlink_send(struct sk_buff *skb, struct net *net, u32 portid,
|
|
unsigned int group, int echo, gfp_t flags)
|
|
{
|
|
return nlmsg_notify(net->nfnl, skb, portid, group, echo, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnetlink_send);
|
|
|
|
int nfnetlink_set_err(struct net *net, u32 portid, u32 group, int error)
|
|
{
|
|
return netlink_set_err(net->nfnl, portid, group, error);
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnetlink_set_err);
|
|
|
|
int nfnetlink_unicast(struct sk_buff *skb, struct net *net, u32 portid,
|
|
int flags)
|
|
{
|
|
return netlink_unicast(net->nfnl, skb, portid, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfnetlink_unicast);
|
|
|
|
/* Process one complete nfnetlink message. */
|
|
static int nfnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
struct net *net = sock_net(skb->sk);
|
|
const struct nfnl_callback *nc;
|
|
const struct nfnetlink_subsystem *ss;
|
|
int type, err;
|
|
|
|
/* All the messages must at least contain nfgenmsg */
|
|
if (nlmsg_len(nlh) < sizeof(struct nfgenmsg))
|
|
return 0;
|
|
|
|
type = nlh->nlmsg_type;
|
|
replay:
|
|
rcu_read_lock();
|
|
ss = nfnetlink_get_subsys(type);
|
|
if (!ss) {
|
|
#ifdef CONFIG_MODULES
|
|
rcu_read_unlock();
|
|
request_module("nfnetlink-subsys-%d", NFNL_SUBSYS_ID(type));
|
|
rcu_read_lock();
|
|
ss = nfnetlink_get_subsys(type);
|
|
if (!ss)
|
|
#endif
|
|
{
|
|
rcu_read_unlock();
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
nc = nfnetlink_find_client(type, ss);
|
|
if (!nc) {
|
|
rcu_read_unlock();
|
|
return -EINVAL;
|
|
}
|
|
|
|
{
|
|
int min_len = nlmsg_total_size(sizeof(struct nfgenmsg));
|
|
u8 cb_id = NFNL_MSG_TYPE(nlh->nlmsg_type);
|
|
struct nlattr *cda[NFNL_MAX_ATTR_COUNT + 1];
|
|
struct nlattr *attr = (void *)nlh + min_len;
|
|
int attrlen = nlh->nlmsg_len - min_len;
|
|
__u8 subsys_id = NFNL_SUBSYS_ID(type);
|
|
|
|
/* Sanity-check NFNL_MAX_ATTR_COUNT */
|
|
if (ss->cb[cb_id].attr_count > NFNL_MAX_ATTR_COUNT) {
|
|
rcu_read_unlock();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
err = nla_parse_deprecated(cda, ss->cb[cb_id].attr_count,
|
|
attr, attrlen,
|
|
ss->cb[cb_id].policy, extack);
|
|
if (err < 0) {
|
|
rcu_read_unlock();
|
|
return err;
|
|
}
|
|
|
|
if (nc->call_rcu) {
|
|
err = nc->call_rcu(net, net->nfnl, skb, nlh,
|
|
(const struct nlattr **)cda,
|
|
extack);
|
|
rcu_read_unlock();
|
|
} else {
|
|
rcu_read_unlock();
|
|
nfnl_lock(subsys_id);
|
|
if (nfnl_dereference_protected(subsys_id) != ss ||
|
|
nfnetlink_find_client(type, ss) != nc)
|
|
err = -EAGAIN;
|
|
else if (nc->call)
|
|
err = nc->call(net, net->nfnl, skb, nlh,
|
|
(const struct nlattr **)cda,
|
|
extack);
|
|
else
|
|
err = -EINVAL;
|
|
nfnl_unlock(subsys_id);
|
|
}
|
|
if (err == -EAGAIN)
|
|
goto replay;
|
|
return err;
|
|
}
|
|
}
|
|
|
|
struct nfnl_err {
|
|
struct list_head head;
|
|
struct nlmsghdr *nlh;
|
|
int err;
|
|
struct netlink_ext_ack extack;
|
|
};
|
|
|
|
static int nfnl_err_add(struct list_head *list, struct nlmsghdr *nlh, int err,
|
|
const struct netlink_ext_ack *extack)
|
|
{
|
|
struct nfnl_err *nfnl_err;
|
|
|
|
nfnl_err = kmalloc(sizeof(struct nfnl_err), GFP_KERNEL);
|
|
if (nfnl_err == NULL)
|
|
return -ENOMEM;
|
|
|
|
nfnl_err->nlh = nlh;
|
|
nfnl_err->err = err;
|
|
nfnl_err->extack = *extack;
|
|
list_add_tail(&nfnl_err->head, list);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void nfnl_err_del(struct nfnl_err *nfnl_err)
|
|
{
|
|
list_del(&nfnl_err->head);
|
|
kfree(nfnl_err);
|
|
}
|
|
|
|
static void nfnl_err_reset(struct list_head *err_list)
|
|
{
|
|
struct nfnl_err *nfnl_err, *next;
|
|
|
|
list_for_each_entry_safe(nfnl_err, next, err_list, head)
|
|
nfnl_err_del(nfnl_err);
|
|
}
|
|
|
|
static void nfnl_err_deliver(struct list_head *err_list, struct sk_buff *skb)
|
|
{
|
|
struct nfnl_err *nfnl_err, *next;
|
|
|
|
list_for_each_entry_safe(nfnl_err, next, err_list, head) {
|
|
netlink_ack(skb, nfnl_err->nlh, nfnl_err->err,
|
|
&nfnl_err->extack);
|
|
nfnl_err_del(nfnl_err);
|
|
}
|
|
}
|
|
|
|
enum {
|
|
NFNL_BATCH_FAILURE = (1 << 0),
|
|
NFNL_BATCH_DONE = (1 << 1),
|
|
NFNL_BATCH_REPLAY = (1 << 2),
|
|
};
|
|
|
|
static void nfnetlink_rcv_batch(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
u16 subsys_id, u32 genid)
|
|
{
|
|
struct sk_buff *oskb = skb;
|
|
struct net *net = sock_net(skb->sk);
|
|
const struct nfnetlink_subsystem *ss;
|
|
const struct nfnl_callback *nc;
|
|
struct netlink_ext_ack extack;
|
|
LIST_HEAD(err_list);
|
|
u32 status;
|
|
int err;
|
|
|
|
if (subsys_id >= NFNL_SUBSYS_COUNT)
|
|
return netlink_ack(skb, nlh, -EINVAL, NULL);
|
|
replay:
|
|
status = 0;
|
|
|
|
skb = netlink_skb_clone(oskb, GFP_KERNEL);
|
|
if (!skb)
|
|
return netlink_ack(oskb, nlh, -ENOMEM, NULL);
|
|
|
|
nfnl_lock(subsys_id);
|
|
ss = nfnl_dereference_protected(subsys_id);
|
|
if (!ss) {
|
|
#ifdef CONFIG_MODULES
|
|
nfnl_unlock(subsys_id);
|
|
request_module("nfnetlink-subsys-%d", subsys_id);
|
|
nfnl_lock(subsys_id);
|
|
ss = nfnl_dereference_protected(subsys_id);
|
|
if (!ss)
|
|
#endif
|
|
{
|
|
nfnl_unlock(subsys_id);
|
|
netlink_ack(oskb, nlh, -EOPNOTSUPP, NULL);
|
|
return kfree_skb(skb);
|
|
}
|
|
}
|
|
|
|
if (!ss->valid_genid || !ss->commit || !ss->abort) {
|
|
nfnl_unlock(subsys_id);
|
|
netlink_ack(oskb, nlh, -EOPNOTSUPP, NULL);
|
|
return kfree_skb(skb);
|
|
}
|
|
|
|
if (!try_module_get(ss->owner)) {
|
|
nfnl_unlock(subsys_id);
|
|
netlink_ack(oskb, nlh, -EOPNOTSUPP, NULL);
|
|
return kfree_skb(skb);
|
|
}
|
|
|
|
if (!ss->valid_genid(net, genid)) {
|
|
module_put(ss->owner);
|
|
nfnl_unlock(subsys_id);
|
|
netlink_ack(oskb, nlh, -ERESTART, NULL);
|
|
return kfree_skb(skb);
|
|
}
|
|
|
|
nfnl_unlock(subsys_id);
|
|
|
|
while (skb->len >= nlmsg_total_size(0)) {
|
|
int msglen, type;
|
|
|
|
if (fatal_signal_pending(current)) {
|
|
nfnl_err_reset(&err_list);
|
|
err = -EINTR;
|
|
status = NFNL_BATCH_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
memset(&extack, 0, sizeof(extack));
|
|
nlh = nlmsg_hdr(skb);
|
|
err = 0;
|
|
|
|
if (nlh->nlmsg_len < NLMSG_HDRLEN ||
|
|
skb->len < nlh->nlmsg_len ||
|
|
nlmsg_len(nlh) < sizeof(struct nfgenmsg)) {
|
|
nfnl_err_reset(&err_list);
|
|
status |= NFNL_BATCH_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Only requests are handled by the kernel */
|
|
if (!(nlh->nlmsg_flags & NLM_F_REQUEST)) {
|
|
err = -EINVAL;
|
|
goto ack;
|
|
}
|
|
|
|
type = nlh->nlmsg_type;
|
|
if (type == NFNL_MSG_BATCH_BEGIN) {
|
|
/* Malformed: Batch begin twice */
|
|
nfnl_err_reset(&err_list);
|
|
status |= NFNL_BATCH_FAILURE;
|
|
goto done;
|
|
} else if (type == NFNL_MSG_BATCH_END) {
|
|
status |= NFNL_BATCH_DONE;
|
|
goto done;
|
|
} else if (type < NLMSG_MIN_TYPE) {
|
|
err = -EINVAL;
|
|
goto ack;
|
|
}
|
|
|
|
/* We only accept a batch with messages for the same
|
|
* subsystem.
|
|
*/
|
|
if (NFNL_SUBSYS_ID(type) != subsys_id) {
|
|
err = -EINVAL;
|
|
goto ack;
|
|
}
|
|
|
|
nc = nfnetlink_find_client(type, ss);
|
|
if (!nc) {
|
|
err = -EINVAL;
|
|
goto ack;
|
|
}
|
|
|
|
{
|
|
int min_len = nlmsg_total_size(sizeof(struct nfgenmsg));
|
|
u8 cb_id = NFNL_MSG_TYPE(nlh->nlmsg_type);
|
|
struct nlattr *cda[NFNL_MAX_ATTR_COUNT + 1];
|
|
struct nlattr *attr = (void *)nlh + min_len;
|
|
int attrlen = nlh->nlmsg_len - min_len;
|
|
|
|
/* Sanity-check NFTA_MAX_ATTR */
|
|
if (ss->cb[cb_id].attr_count > NFNL_MAX_ATTR_COUNT) {
|
|
err = -ENOMEM;
|
|
goto ack;
|
|
}
|
|
|
|
err = nla_parse_deprecated(cda,
|
|
ss->cb[cb_id].attr_count,
|
|
attr, attrlen,
|
|
ss->cb[cb_id].policy, NULL);
|
|
if (err < 0)
|
|
goto ack;
|
|
|
|
if (nc->call_batch) {
|
|
err = nc->call_batch(net, net->nfnl, skb, nlh,
|
|
(const struct nlattr **)cda,
|
|
&extack);
|
|
}
|
|
|
|
/* The lock was released to autoload some module, we
|
|
* have to abort and start from scratch using the
|
|
* original skb.
|
|
*/
|
|
if (err == -EAGAIN) {
|
|
status |= NFNL_BATCH_REPLAY;
|
|
goto done;
|
|
}
|
|
}
|
|
ack:
|
|
if (nlh->nlmsg_flags & NLM_F_ACK || err) {
|
|
/* Errors are delivered once the full batch has been
|
|
* processed, this avoids that the same error is
|
|
* reported several times when replaying the batch.
|
|
*/
|
|
if (nfnl_err_add(&err_list, nlh, err, &extack) < 0) {
|
|
/* We failed to enqueue an error, reset the
|
|
* list of errors and send OOM to userspace
|
|
* pointing to the batch header.
|
|
*/
|
|
nfnl_err_reset(&err_list);
|
|
netlink_ack(oskb, nlmsg_hdr(oskb), -ENOMEM,
|
|
NULL);
|
|
status |= NFNL_BATCH_FAILURE;
|
|
goto done;
|
|
}
|
|
/* We don't stop processing the batch on errors, thus,
|
|
* userspace gets all the errors that the batch
|
|
* triggers.
|
|
*/
|
|
if (err)
|
|
status |= NFNL_BATCH_FAILURE;
|
|
}
|
|
|
|
msglen = NLMSG_ALIGN(nlh->nlmsg_len);
|
|
if (msglen > skb->len)
|
|
msglen = skb->len;
|
|
skb_pull(skb, msglen);
|
|
}
|
|
done:
|
|
if (status & NFNL_BATCH_REPLAY) {
|
|
ss->abort(net, oskb);
|
|
nfnl_err_reset(&err_list);
|
|
kfree_skb(skb);
|
|
module_put(ss->owner);
|
|
goto replay;
|
|
} else if (status == NFNL_BATCH_DONE) {
|
|
err = ss->commit(net, oskb);
|
|
if (err == -EAGAIN) {
|
|
status |= NFNL_BATCH_REPLAY;
|
|
goto done;
|
|
} else if (err) {
|
|
ss->abort(net, oskb);
|
|
netlink_ack(oskb, nlmsg_hdr(oskb), err, NULL);
|
|
}
|
|
} else {
|
|
ss->abort(net, oskb);
|
|
}
|
|
if (ss->cleanup)
|
|
ss->cleanup(net);
|
|
|
|
nfnl_err_deliver(&err_list, oskb);
|
|
kfree_skb(skb);
|
|
module_put(ss->owner);
|
|
}
|
|
|
|
static const struct nla_policy nfnl_batch_policy[NFNL_BATCH_MAX + 1] = {
|
|
[NFNL_BATCH_GENID] = { .type = NLA_U32 },
|
|
};
|
|
|
|
static void nfnetlink_rcv_skb_batch(struct sk_buff *skb, struct nlmsghdr *nlh)
|
|
{
|
|
int min_len = nlmsg_total_size(sizeof(struct nfgenmsg));
|
|
struct nlattr *attr = (void *)nlh + min_len;
|
|
struct nlattr *cda[NFNL_BATCH_MAX + 1];
|
|
int attrlen = nlh->nlmsg_len - min_len;
|
|
struct nfgenmsg *nfgenmsg;
|
|
int msglen, err;
|
|
u32 gen_id = 0;
|
|
u16 res_id;
|
|
|
|
msglen = NLMSG_ALIGN(nlh->nlmsg_len);
|
|
if (msglen > skb->len)
|
|
msglen = skb->len;
|
|
|
|
if (skb->len < NLMSG_HDRLEN + sizeof(struct nfgenmsg))
|
|
return;
|
|
|
|
err = nla_parse_deprecated(cda, NFNL_BATCH_MAX, attr, attrlen,
|
|
nfnl_batch_policy, NULL);
|
|
if (err < 0) {
|
|
netlink_ack(skb, nlh, err, NULL);
|
|
return;
|
|
}
|
|
if (cda[NFNL_BATCH_GENID])
|
|
gen_id = ntohl(nla_get_be32(cda[NFNL_BATCH_GENID]));
|
|
|
|
nfgenmsg = nlmsg_data(nlh);
|
|
skb_pull(skb, msglen);
|
|
/* Work around old nft using host byte order */
|
|
if (nfgenmsg->res_id == NFNL_SUBSYS_NFTABLES)
|
|
res_id = NFNL_SUBSYS_NFTABLES;
|
|
else
|
|
res_id = ntohs(nfgenmsg->res_id);
|
|
|
|
nfnetlink_rcv_batch(skb, nlh, res_id, gen_id);
|
|
}
|
|
|
|
static void nfnetlink_rcv(struct sk_buff *skb)
|
|
{
|
|
struct nlmsghdr *nlh = nlmsg_hdr(skb);
|
|
|
|
if (skb->len < NLMSG_HDRLEN ||
|
|
nlh->nlmsg_len < NLMSG_HDRLEN ||
|
|
skb->len < nlh->nlmsg_len)
|
|
return;
|
|
|
|
if (!netlink_net_capable(skb, CAP_NET_ADMIN)) {
|
|
netlink_ack(skb, nlh, -EPERM, NULL);
|
|
return;
|
|
}
|
|
|
|
if (nlh->nlmsg_type == NFNL_MSG_BATCH_BEGIN)
|
|
nfnetlink_rcv_skb_batch(skb, nlh);
|
|
else
|
|
netlink_rcv_skb(skb, nfnetlink_rcv_msg);
|
|
}
|
|
|
|
#ifdef CONFIG_MODULES
|
|
static int nfnetlink_bind(struct net *net, int group)
|
|
{
|
|
const struct nfnetlink_subsystem *ss;
|
|
int type;
|
|
|
|
if (group <= NFNLGRP_NONE || group > NFNLGRP_MAX)
|
|
return 0;
|
|
|
|
type = nfnl_group2type[group];
|
|
|
|
rcu_read_lock();
|
|
ss = nfnetlink_get_subsys(type << 8);
|
|
rcu_read_unlock();
|
|
if (!ss)
|
|
request_module("nfnetlink-subsys-%d", type);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int __net_init nfnetlink_net_init(struct net *net)
|
|
{
|
|
struct sock *nfnl;
|
|
struct netlink_kernel_cfg cfg = {
|
|
.groups = NFNLGRP_MAX,
|
|
.input = nfnetlink_rcv,
|
|
#ifdef CONFIG_MODULES
|
|
.bind = nfnetlink_bind,
|
|
#endif
|
|
};
|
|
|
|
nfnl = netlink_kernel_create(net, NETLINK_NETFILTER, &cfg);
|
|
if (!nfnl)
|
|
return -ENOMEM;
|
|
net->nfnl_stash = nfnl;
|
|
rcu_assign_pointer(net->nfnl, nfnl);
|
|
return 0;
|
|
}
|
|
|
|
static void __net_exit nfnetlink_net_exit_batch(struct list_head *net_exit_list)
|
|
{
|
|
struct net *net;
|
|
|
|
list_for_each_entry(net, net_exit_list, exit_list)
|
|
RCU_INIT_POINTER(net->nfnl, NULL);
|
|
synchronize_net();
|
|
list_for_each_entry(net, net_exit_list, exit_list)
|
|
netlink_kernel_release(net->nfnl_stash);
|
|
}
|
|
|
|
static struct pernet_operations nfnetlink_net_ops = {
|
|
.init = nfnetlink_net_init,
|
|
.exit_batch = nfnetlink_net_exit_batch,
|
|
};
|
|
|
|
static int __init nfnetlink_init(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = NFNLGRP_NONE + 1; i <= NFNLGRP_MAX; i++)
|
|
BUG_ON(nfnl_group2type[i] == NFNL_SUBSYS_NONE);
|
|
|
|
for (i=0; i<NFNL_SUBSYS_COUNT; i++)
|
|
mutex_init(&table[i].mutex);
|
|
|
|
return register_pernet_subsys(&nfnetlink_net_ops);
|
|
}
|
|
|
|
static void __exit nfnetlink_exit(void)
|
|
{
|
|
unregister_pernet_subsys(&nfnetlink_net_ops);
|
|
}
|
|
module_init(nfnetlink_init);
|
|
module_exit(nfnetlink_exit);
|