2005-04-16 22:20:36 +00:00
|
|
|
#ifndef __LINUX_NETFILTER_H
|
|
|
|
#define __LINUX_NETFILTER_H
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/net.h>
|
|
|
|
#include <linux/if.h>
|
2008-01-15 07:40:34 +00:00
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/in6.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#endif
|
2008-05-21 21:08:38 +00:00
|
|
|
#include <linux/types.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/compiler.h>
|
2011-05-26 20:40:37 +00:00
|
|
|
#include <linux/sysctl.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Responses from hook functions. */
|
|
|
|
#define NF_DROP 0
|
|
|
|
#define NF_ACCEPT 1
|
|
|
|
#define NF_STOLEN 2
|
|
|
|
#define NF_QUEUE 3
|
|
|
|
#define NF_REPEAT 4
|
|
|
|
#define NF_STOP 5
|
|
|
|
#define NF_MAX_VERDICT NF_STOP
|
|
|
|
|
2005-08-10 02:43:44 +00:00
|
|
|
/* we overload the higher bits for encoding auxiliary data such as the queue
|
2011-01-18 14:52:14 +00:00
|
|
|
* number or errno values. Not nice, but better than additional function
|
|
|
|
* arguments. */
|
|
|
|
#define NF_VERDICT_MASK 0x000000ff
|
|
|
|
|
|
|
|
/* extra verdict flags have mask 0x0000ff00 */
|
2011-01-18 15:08:30 +00:00
|
|
|
#define NF_VERDICT_FLAG_QUEUE_BYPASS 0x00008000
|
2005-08-10 02:43:44 +00:00
|
|
|
|
2011-01-18 14:52:14 +00:00
|
|
|
/* queue number (NF_QUEUE) or errno (NF_DROP) */
|
2005-08-10 02:43:44 +00:00
|
|
|
#define NF_VERDICT_QMASK 0xffff0000
|
|
|
|
#define NF_VERDICT_QBITS 16
|
|
|
|
|
2011-01-18 14:52:14 +00:00
|
|
|
#define NF_QUEUE_NR(x) ((((x) << 16) & NF_VERDICT_QMASK) | NF_QUEUE)
|
2005-08-10 02:43:44 +00:00
|
|
|
|
2011-01-18 14:52:14 +00:00
|
|
|
#define NF_DROP_ERR(x) (((-x) << 16) | NF_DROP)
|
2010-11-16 11:52:38 +00:00
|
|
|
|
2005-08-10 02:24:19 +00:00
|
|
|
/* only for userspace compatibility */
|
|
|
|
#ifndef __KERNEL__
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Generic cache responses from hook functions.
|
|
|
|
<= 0x2000 is used for protocol-flags. */
|
|
|
|
#define NFC_UNKNOWN 0x4000
|
|
|
|
#define NFC_ALTERED 0x8000
|
2011-01-18 14:52:14 +00:00
|
|
|
|
|
|
|
/* NF_VERDICT_BITS should be 8 now, but userspace might break if this changes */
|
|
|
|
#define NF_VERDICT_BITS 16
|
2005-08-10 02:24:19 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-20 02:53:30 +00:00
|
|
|
enum nf_inet_hooks {
|
|
|
|
NF_INET_PRE_ROUTING,
|
|
|
|
NF_INET_LOCAL_IN,
|
|
|
|
NF_INET_FORWARD,
|
|
|
|
NF_INET_LOCAL_OUT,
|
|
|
|
NF_INET_POST_ROUTING,
|
|
|
|
NF_INET_NUMHOOKS
|
|
|
|
};
|
|
|
|
|
2008-10-08 09:35:00 +00:00
|
|
|
enum {
|
|
|
|
NFPROTO_UNSPEC = 0,
|
|
|
|
NFPROTO_IPV4 = 2,
|
|
|
|
NFPROTO_ARP = 3,
|
|
|
|
NFPROTO_BRIDGE = 7,
|
|
|
|
NFPROTO_IPV6 = 10,
|
|
|
|
NFPROTO_DECNET = 12,
|
|
|
|
NFPROTO_NUMPROTO,
|
|
|
|
};
|
|
|
|
|
2007-12-18 06:43:50 +00:00
|
|
|
union nf_inet_addr {
|
2008-02-20 01:20:33 +00:00
|
|
|
__u32 all[4];
|
2007-12-18 06:43:50 +00:00
|
|
|
__be32 ip;
|
|
|
|
__be32 ip6[4];
|
2008-01-15 07:40:34 +00:00
|
|
|
struct in_addr in;
|
|
|
|
struct in6_addr in6;
|
2007-12-18 06:43:50 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef __KERNEL__
|
|
|
|
#ifdef CONFIG_NETFILTER
|
2011-01-18 14:52:14 +00:00
|
|
|
static inline int NF_DROP_GETERR(int verdict)
|
|
|
|
{
|
|
|
|
return -(verdict >> NF_VERDICT_QBITS);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-26 03:09:33 +00:00
|
|
|
static inline int nf_inet_addr_cmp(const union nf_inet_addr *a1,
|
|
|
|
const union nf_inet_addr *a2)
|
|
|
|
{
|
|
|
|
return a1->all[0] == a2->all[0] &&
|
|
|
|
a1->all[1] == a2->all[1] &&
|
|
|
|
a1->all[2] == a2->all[2] &&
|
|
|
|
a1->all[3] == a2->all[3];
|
|
|
|
}
|
|
|
|
|
2012-05-17 20:08:57 +00:00
|
|
|
static inline void nf_inet_addr_mask(const union nf_inet_addr *a1,
|
|
|
|
union nf_inet_addr *result,
|
|
|
|
const union nf_inet_addr *mask)
|
|
|
|
{
|
|
|
|
result->all[0] = a1->all[0] & mask->all[0];
|
|
|
|
result->all[1] = a1->all[1] & mask->all[1];
|
|
|
|
result->all[2] = a1->all[2] & mask->all[2];
|
|
|
|
result->all[3] = a1->all[3] & mask->all[3];
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void netfilter_init(void);
|
|
|
|
|
|
|
|
/* Largest hook number + 1 */
|
|
|
|
#define NF_MAX_HOOKS 8
|
|
|
|
|
|
|
|
struct sk_buff;
|
|
|
|
|
|
|
|
typedef unsigned int nf_hookfn(unsigned int hooknum,
|
2007-10-15 07:53:15 +00:00
|
|
|
struct sk_buff *skb,
|
2005-04-16 22:20:36 +00:00
|
|
|
const struct net_device *in,
|
|
|
|
const struct net_device *out,
|
|
|
|
int (*okfn)(struct sk_buff *));
|
|
|
|
|
2009-11-04 17:50:58 +00:00
|
|
|
struct nf_hook_ops {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
/* User fills in from here down. */
|
|
|
|
nf_hookfn *hook;
|
|
|
|
struct module *owner;
|
2008-10-08 09:35:00 +00:00
|
|
|
u_int8_t pf;
|
|
|
|
unsigned int hooknum;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Hooks are ordered in ascending priority. */
|
|
|
|
int priority;
|
|
|
|
};
|
|
|
|
|
2009-11-04 17:50:58 +00:00
|
|
|
struct nf_sockopt_ops {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct list_head list;
|
|
|
|
|
2008-10-08 09:35:00 +00:00
|
|
|
u_int8_t pf;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Non-inclusive ranges: use 0/0/NULL to never get called. */
|
|
|
|
int set_optmin;
|
|
|
|
int set_optmax;
|
|
|
|
int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
|
2010-02-02 14:03:24 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-21 06:45:21 +00:00
|
|
|
int (*compat_set)(struct sock *sk, int optval,
|
|
|
|
void __user *user, unsigned int len);
|
2010-02-02 14:03:24 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
int get_optmin;
|
|
|
|
int get_optmax;
|
|
|
|
int (*get)(struct sock *sk, int optval, void __user *user, int *len);
|
2010-02-02 14:03:24 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-21 06:45:21 +00:00
|
|
|
int (*compat_get)(struct sock *sk, int optval,
|
|
|
|
void __user *user, int *len);
|
2010-02-02 14:03:24 +00:00
|
|
|
#endif
|
[NETFILTER]: Fix/improve deadlock condition on module removal netfilter
So I've had a deadlock reported to me. I've found that the sequence of
events goes like this:
1) process A (modprobe) runs to remove ip_tables.ko
2) process B (iptables-restore) runs and calls setsockopt on a netfilter socket,
increasing the ip_tables socket_ops use count
3) process A acquires a file lock on the file ip_tables.ko, calls remove_module
in the kernel, which in turn executes the ip_tables module cleanup routine,
which calls nf_unregister_sockopt
4) nf_unregister_sockopt, seeing that the use count is non-zero, puts the
calling process into uninterruptible sleep, expecting the process using the
socket option code to wake it up when it exits the kernel
4) the user of the socket option code (process B) in do_ipt_get_ctl, calls
ipt_find_table_lock, which in this case calls request_module to load
ip_tables_nat.ko
5) request_module forks a copy of modprobe (process C) to load the module and
blocks until modprobe exits.
6) Process C. forked by request_module process the dependencies of
ip_tables_nat.ko, of which ip_tables.ko is one.
7) Process C attempts to lock the request module and all its dependencies, it
blocks when it attempts to lock ip_tables.ko (which was previously locked in
step 3)
Theres not really any great permanent solution to this that I can see, but I've
developed a two part solution that corrects the problem
Part 1) Modifies the nf_sockopt registration code so that, instead of using a
use counter internal to the nf_sockopt_ops structure, we instead use a pointer
to the registering modules owner to do module reference counting when nf_sockopt
calls a modules set/get routine. This prevents the deadlock by preventing set 4
from happening.
Part 2) Enhances the modprobe utilty so that by default it preforms non-blocking
remove operations (the same way rmmod does), and add an option to explicity
request blocking operation. So if you select blocking operation in modprobe you
can still cause the above deadlock, but only if you explicity try (and since
root can do any old stupid thing it would like.... :) ).
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-09-11 09:28:26 +00:00
|
|
|
/* Use the module struct to lock set/get code in place */
|
|
|
|
struct module *owner;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Function to register/unregister hook points. */
|
|
|
|
int nf_register_hook(struct nf_hook_ops *reg);
|
|
|
|
void nf_unregister_hook(struct nf_hook_ops *reg);
|
2006-04-06 21:09:12 +00:00
|
|
|
int nf_register_hooks(struct nf_hook_ops *reg, unsigned int n);
|
|
|
|
void nf_unregister_hooks(struct nf_hook_ops *reg, unsigned int n);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Functions to register get/setsockopt ranges (non-inclusive). You
|
|
|
|
need to check permissions yourself! */
|
|
|
|
int nf_register_sockopt(struct nf_sockopt_ops *reg);
|
|
|
|
void nf_unregister_sockopt(struct nf_sockopt_ops *reg);
|
|
|
|
|
2008-10-08 09:35:00 +00:00
|
|
|
extern struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-11-18 17:32:46 +00:00
|
|
|
#if defined(CONFIG_JUMP_LABEL)
|
2012-02-24 07:31:31 +00:00
|
|
|
#include <linux/static_key.h>
|
|
|
|
extern struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
|
2011-11-18 17:32:46 +00:00
|
|
|
static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
|
|
|
|
{
|
|
|
|
if (__builtin_constant_p(pf) &&
|
|
|
|
__builtin_constant_p(hook))
|
2012-02-24 07:31:31 +00:00
|
|
|
return static_key_false(&nf_hooks_needed[pf][hook]);
|
2011-11-18 17:32:46 +00:00
|
|
|
|
|
|
|
return !list_empty(&nf_hooks[pf][hook]);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
|
|
|
|
{
|
|
|
|
return !list_empty(&nf_hooks[pf][hook]);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-10-08 09:35:00 +00:00
|
|
|
int nf_hook_slow(u_int8_t pf, unsigned int hook, struct sk_buff *skb,
|
2006-01-07 07:01:48 +00:00
|
|
|
struct net_device *indev, struct net_device *outdev,
|
|
|
|
int (*okfn)(struct sk_buff *), int thresh);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nf_hook_thresh - call a netfilter hook
|
|
|
|
*
|
|
|
|
* Returns 1 if the hook has allowed the packet to pass. The function
|
|
|
|
* okfn must be invoked by the caller in this case. Any other return
|
|
|
|
* value indicates the packet has been consumed by the hook.
|
|
|
|
*/
|
2008-10-08 09:35:00 +00:00
|
|
|
static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
|
2007-10-15 07:53:15 +00:00
|
|
|
struct sk_buff *skb,
|
2006-01-07 07:01:48 +00:00
|
|
|
struct net_device *indev,
|
|
|
|
struct net_device *outdev,
|
2009-06-05 15:31:46 +00:00
|
|
|
int (*okfn)(struct sk_buff *), int thresh)
|
2006-01-07 07:01:48 +00:00
|
|
|
{
|
2011-11-18 17:32:46 +00:00
|
|
|
if (nf_hooks_active(pf, hook))
|
|
|
|
return nf_hook_slow(pf, hook, skb, indev, outdev, okfn, thresh);
|
|
|
|
return 1;
|
2006-01-07 07:01:48 +00:00
|
|
|
}
|
|
|
|
|
2008-10-08 09:35:00 +00:00
|
|
|
static inline int nf_hook(u_int8_t pf, unsigned int hook, struct sk_buff *skb,
|
2006-01-07 07:01:48 +00:00
|
|
|
struct net_device *indev, struct net_device *outdev,
|
|
|
|
int (*okfn)(struct sk_buff *))
|
|
|
|
{
|
2009-06-05 15:31:46 +00:00
|
|
|
return nf_hook_thresh(pf, hook, skb, indev, outdev, okfn, INT_MIN);
|
2006-01-07 07:01:48 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Activate hook; either okfn or kfree_skb called, unless a hook
|
|
|
|
returns NF_STOLEN (in which case, it's up to the hook to deal with
|
|
|
|
the consequences).
|
|
|
|
|
|
|
|
Returns -ERRNO if packet dropped. Zero means queued, stolen or
|
|
|
|
accepted.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* RR:
|
|
|
|
> I don't want nf_hook to return anything because people might forget
|
|
|
|
> about async and trust the return value to mean "packet was ok".
|
|
|
|
|
|
|
|
AK:
|
|
|
|
Just document it clearly, then you can expect some sense from kernel
|
|
|
|
coders :)
|
|
|
|
*/
|
|
|
|
|
2009-06-13 02:13:26 +00:00
|
|
|
static inline int
|
|
|
|
NF_HOOK_THRESH(uint8_t pf, unsigned int hook, struct sk_buff *skb,
|
|
|
|
struct net_device *in, struct net_device *out,
|
|
|
|
int (*okfn)(struct sk_buff *), int thresh)
|
|
|
|
{
|
|
|
|
int ret = nf_hook_thresh(pf, hook, skb, in, out, okfn, thresh);
|
|
|
|
if (ret == 1)
|
|
|
|
ret = okfn(skb);
|
|
|
|
return ret;
|
|
|
|
}
|
2006-02-15 23:10:22 +00:00
|
|
|
|
2009-06-13 02:13:26 +00:00
|
|
|
static inline int
|
|
|
|
NF_HOOK_COND(uint8_t pf, unsigned int hook, struct sk_buff *skb,
|
|
|
|
struct net_device *in, struct net_device *out,
|
|
|
|
int (*okfn)(struct sk_buff *), bool cond)
|
|
|
|
{
|
2010-02-19 07:03:28 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!cond ||
|
2010-11-12 07:26:06 +00:00
|
|
|
((ret = nf_hook_thresh(pf, hook, skb, in, out, okfn, INT_MIN)) == 1))
|
2009-06-13 02:13:26 +00:00
|
|
|
ret = okfn(skb);
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-13 02:13:26 +00:00
|
|
|
static inline int
|
|
|
|
NF_HOOK(uint8_t pf, unsigned int hook, struct sk_buff *skb,
|
|
|
|
struct net_device *in, struct net_device *out,
|
|
|
|
int (*okfn)(struct sk_buff *))
|
|
|
|
{
|
|
|
|
return NF_HOOK_THRESH(pf, hook, skb, in, out, okfn, INT_MIN);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Call setsockopt() */
|
2008-10-08 09:35:00 +00:00
|
|
|
int nf_setsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
|
2009-09-30 23:12:20 +00:00
|
|
|
unsigned int len);
|
2008-10-08 09:35:00 +00:00
|
|
|
int nf_getsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
|
2005-04-16 22:20:36 +00:00
|
|
|
int *len);
|
2010-02-02 14:03:24 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
2008-10-08 09:35:00 +00:00
|
|
|
int compat_nf_setsockopt(struct sock *sk, u_int8_t pf, int optval,
|
2009-09-30 23:12:20 +00:00
|
|
|
char __user *opt, unsigned int len);
|
2008-10-08 09:35:00 +00:00
|
|
|
int compat_nf_getsockopt(struct sock *sk, u_int8_t pf, int optval,
|
2006-03-21 06:45:21 +00:00
|
|
|
char __user *opt, int *len);
|
2010-02-02 14:03:24 +00:00
|
|
|
#endif
|
2006-03-21 06:45:21 +00:00
|
|
|
|
2005-08-10 02:37:23 +00:00
|
|
|
/* Call this before modifying an existing packet: ensures it is
|
|
|
|
modifiable and linear to the point you care about (writable_len).
|
|
|
|
Returns true or false. */
|
2007-10-14 07:39:18 +00:00
|
|
|
extern int skb_make_writable(struct sk_buff *skb, unsigned int writable_len);
|
2005-08-10 02:37:23 +00:00
|
|
|
|
2007-12-05 09:22:05 +00:00
|
|
|
struct flowi;
|
2007-12-05 09:26:33 +00:00
|
|
|
struct nf_queue_entry;
|
2007-12-05 09:24:48 +00:00
|
|
|
|
2006-04-06 21:18:09 +00:00
|
|
|
struct nf_afinfo {
|
|
|
|
unsigned short family;
|
2006-11-15 05:40:42 +00:00
|
|
|
__sum16 (*checksum)(struct sk_buff *skb, unsigned int hook,
|
2006-04-06 21:18:43 +00:00
|
|
|
unsigned int dataoff, u_int8_t protocol);
|
2008-03-20 14:15:53 +00:00
|
|
|
__sum16 (*checksum_partial)(struct sk_buff *skb,
|
|
|
|
unsigned int hook,
|
|
|
|
unsigned int dataoff,
|
|
|
|
unsigned int len,
|
|
|
|
u_int8_t protocol);
|
2011-04-04 14:56:29 +00:00
|
|
|
int (*route)(struct net *net, struct dst_entry **dst,
|
2011-04-04 15:00:54 +00:00
|
|
|
struct flowi *fl, bool strict);
|
2006-04-06 21:18:09 +00:00
|
|
|
void (*saveroute)(const struct sk_buff *skb,
|
2007-12-05 09:26:33 +00:00
|
|
|
struct nf_queue_entry *entry);
|
2007-10-15 07:53:15 +00:00
|
|
|
int (*reroute)(struct sk_buff *skb,
|
2007-12-05 09:26:33 +00:00
|
|
|
const struct nf_queue_entry *entry);
|
2006-04-06 21:18:09 +00:00
|
|
|
int route_key_size;
|
2005-08-10 02:42:34 +00:00
|
|
|
};
|
|
|
|
|
2010-11-15 17:17:21 +00:00
|
|
|
extern const struct nf_afinfo __rcu *nf_afinfo[NFPROTO_NUMPROTO];
|
2007-12-18 06:42:27 +00:00
|
|
|
static inline const struct nf_afinfo *nf_get_afinfo(unsigned short family)
|
2006-04-06 21:18:09 +00:00
|
|
|
{
|
|
|
|
return rcu_dereference(nf_afinfo[family]);
|
|
|
|
}
|
2005-08-10 02:42:34 +00:00
|
|
|
|
2006-11-15 05:40:42 +00:00
|
|
|
static inline __sum16
|
2006-04-06 21:18:43 +00:00
|
|
|
nf_checksum(struct sk_buff *skb, unsigned int hook, unsigned int dataoff,
|
|
|
|
u_int8_t protocol, unsigned short family)
|
|
|
|
{
|
2007-12-18 06:42:27 +00:00
|
|
|
const struct nf_afinfo *afinfo;
|
2006-11-15 05:40:42 +00:00
|
|
|
__sum16 csum = 0;
|
2006-04-06 21:18:43 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
afinfo = nf_get_afinfo(family);
|
|
|
|
if (afinfo)
|
|
|
|
csum = afinfo->checksum(skb, hook, dataoff, protocol);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return csum;
|
|
|
|
}
|
|
|
|
|
2008-03-20 14:15:53 +00:00
|
|
|
static inline __sum16
|
|
|
|
nf_checksum_partial(struct sk_buff *skb, unsigned int hook,
|
|
|
|
unsigned int dataoff, unsigned int len,
|
|
|
|
u_int8_t protocol, unsigned short family)
|
|
|
|
{
|
|
|
|
const struct nf_afinfo *afinfo;
|
|
|
|
__sum16 csum = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
afinfo = nf_get_afinfo(family);
|
|
|
|
if (afinfo)
|
|
|
|
csum = afinfo->checksum_partial(skb, hook, dataoff, len,
|
|
|
|
protocol);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return csum;
|
|
|
|
}
|
|
|
|
|
2007-12-18 06:42:27 +00:00
|
|
|
extern int nf_register_afinfo(const struct nf_afinfo *afinfo);
|
|
|
|
extern void nf_unregister_afinfo(const struct nf_afinfo *afinfo);
|
2006-04-06 21:18:09 +00:00
|
|
|
|
2006-01-07 07:06:30 +00:00
|
|
|
#include <net/flow.h>
|
|
|
|
extern void (*ip_nat_decode_session)(struct sk_buff *, struct flowi *);
|
|
|
|
|
|
|
|
static inline void
|
2008-10-08 09:35:00 +00:00
|
|
|
nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
|
2006-01-07 07:06:30 +00:00
|
|
|
{
|
2007-12-18 06:42:51 +00:00
|
|
|
#ifdef CONFIG_NF_NAT_NEEDED
|
2006-01-07 07:06:30 +00:00
|
|
|
void (*decodefn)(struct sk_buff *, struct flowi *);
|
|
|
|
|
2007-12-18 06:42:51 +00:00
|
|
|
if (family == AF_INET) {
|
|
|
|
rcu_read_lock();
|
|
|
|
decodefn = rcu_dereference(ip_nat_decode_session);
|
|
|
|
if (decodefn)
|
|
|
|
decodefn(skb, fl);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2006-01-07 07:06:30 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-08-10 02:58:27 +00:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
extern struct proc_dir_entry *proc_net_netfilter;
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#else /* !CONFIG_NETFILTER */
|
|
|
|
#define NF_HOOK(pf, hook, skb, indev, outdev, okfn) (okfn)(skb)
|
2006-02-15 23:10:22 +00:00
|
|
|
#define NF_HOOK_COND(pf, hook, skb, indev, outdev, okfn, cond) (okfn)(skb)
|
2008-10-08 09:35:00 +00:00
|
|
|
static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
|
2007-10-15 07:53:15 +00:00
|
|
|
struct sk_buff *skb,
|
2006-01-07 20:50:27 +00:00
|
|
|
struct net_device *indev,
|
|
|
|
struct net_device *outdev,
|
2009-06-05 15:31:46 +00:00
|
|
|
int (*okfn)(struct sk_buff *), int thresh)
|
2006-01-07 20:50:27 +00:00
|
|
|
{
|
2007-10-15 07:53:15 +00:00
|
|
|
return okfn(skb);
|
2006-01-07 20:50:27 +00:00
|
|
|
}
|
2008-10-08 09:35:00 +00:00
|
|
|
static inline int nf_hook(u_int8_t pf, unsigned int hook, struct sk_buff *skb,
|
2006-01-07 20:50:27 +00:00
|
|
|
struct net_device *indev, struct net_device *outdev,
|
|
|
|
int (*okfn)(struct sk_buff *))
|
|
|
|
{
|
2006-02-15 23:18:19 +00:00
|
|
|
return 1;
|
2006-01-07 20:50:27 +00:00
|
|
|
}
|
|
|
|
struct flowi;
|
2006-01-07 07:06:30 +00:00
|
|
|
static inline void
|
2008-10-08 09:35:00 +00:00
|
|
|
nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
|
|
|
|
{
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /*CONFIG_NETFILTER*/
|
|
|
|
|
2007-03-23 18:17:07 +00:00
|
|
|
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
|
2010-11-15 17:17:21 +00:00
|
|
|
extern void (*ip_ct_attach)(struct sk_buff *, struct sk_buff *) __rcu;
|
2007-03-23 18:17:07 +00:00
|
|
|
extern void nf_ct_attach(struct sk_buff *, struct sk_buff *);
|
2010-11-15 17:17:21 +00:00
|
|
|
extern void (*nf_ct_destroy)(struct nf_conntrack *) __rcu;
|
2012-06-07 10:13:39 +00:00
|
|
|
|
|
|
|
struct nf_conn;
|
|
|
|
struct nlattr;
|
|
|
|
|
|
|
|
struct nfq_ct_hook {
|
|
|
|
size_t (*build_size)(const struct nf_conn *ct);
|
|
|
|
int (*build)(struct sk_buff *skb, struct nf_conn *ct);
|
|
|
|
int (*parse)(const struct nlattr *attr, struct nf_conn *ct);
|
2012-06-07 11:31:25 +00:00
|
|
|
void (*seq_adjust)(struct sk_buff *skb, struct nf_conn *ct,
|
|
|
|
u32 ctinfo, int off);
|
2012-06-07 10:13:39 +00:00
|
|
|
};
|
|
|
|
extern struct nfq_ct_hook *nfq_ct_hook;
|
2007-03-23 18:17:07 +00:00
|
|
|
#else
|
|
|
|
static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /*__KERNEL__*/
|
|
|
|
#endif /*__LINUX_NETFILTER_H*/
|