2006-12-02 23:07:13 -07:00
|
|
|
/* NAT for netfilter; shared with compatibility layer. */
|
|
|
|
|
|
|
|
/* (C) 1999-2001 Paul `Rusty' Russell
|
|
|
|
* (C) 2002-2006 Netfilter Core Team <coreteam@netfilter.org>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/skbuff.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/gfp.h>
|
2006-12-02 23:07:13 -07:00
|
|
|
#include <net/checksum.h>
|
|
|
|
#include <net/icmp.h>
|
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/tcp.h> /* For tcp_prot in getorigdst */
|
|
|
|
#include <linux/icmp.h>
|
|
|
|
#include <linux/udp.h>
|
|
|
|
#include <linux/jhash.h>
|
|
|
|
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
|
|
|
#include <net/netfilter/nf_conntrack.h>
|
|
|
|
#include <net/netfilter/nf_conntrack_core.h>
|
|
|
|
#include <net/netfilter/nf_nat.h>
|
|
|
|
#include <net/netfilter/nf_nat_protocol.h>
|
|
|
|
#include <net/netfilter/nf_nat_core.h>
|
|
|
|
#include <net/netfilter/nf_nat_helper.h>
|
|
|
|
#include <net/netfilter/nf_conntrack_helper.h>
|
|
|
|
#include <net/netfilter/nf_conntrack_l3proto.h>
|
|
|
|
#include <net/netfilter/nf_conntrack_l4proto.h>
|
2010-02-15 10:13:33 -07:00
|
|
|
#include <net/netfilter/nf_conntrack_zones.h>
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2008-01-31 05:43:06 -07:00
|
|
|
static DEFINE_SPINLOCK(nf_nat_lock);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-12-17 23:37:52 -07:00
|
|
|
static struct nf_conntrack_l3proto *l3proto __read_mostly;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
#define MAX_IP_NAT_PROTO 256
|
2010-03-09 12:59:15 -07:00
|
|
|
static const struct nf_nat_protocol __rcu *nf_nat_protos[MAX_IP_NAT_PROTO]
|
2007-12-17 23:37:52 -07:00
|
|
|
__read_mostly;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-12-17 23:37:36 -07:00
|
|
|
static inline const struct nf_nat_protocol *
|
2006-12-02 23:07:13 -07:00
|
|
|
__nf_nat_proto_find(u_int8_t protonum)
|
|
|
|
{
|
2007-02-12 12:12:26 -07:00
|
|
|
return rcu_dereference(nf_nat_protos[protonum]);
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We keep an extra hash for each conntrack, for fast searching. */
|
|
|
|
static inline unsigned int
|
2010-02-15 10:13:33 -07:00
|
|
|
hash_by_src(const struct net *net, u16 zone,
|
|
|
|
const struct nf_conntrack_tuple *tuple)
|
2006-12-02 23:07:13 -07:00
|
|
|
{
|
2007-12-17 23:45:52 -07:00
|
|
|
unsigned int hash;
|
|
|
|
|
2006-12-02 23:07:13 -07:00
|
|
|
/* Original src, to ensure we map it consistently if poss. */
|
2007-12-17 23:45:52 -07:00
|
|
|
hash = jhash_3words((__force u32)tuple->src.u3.ip,
|
2010-02-15 10:13:33 -07:00
|
|
|
(__force u32)tuple->src.u.all ^ zone,
|
2007-12-17 23:45:52 -07:00
|
|
|
tuple->dst.protonum, 0);
|
2010-02-08 12:18:07 -07:00
|
|
|
return ((u64)hash * net->ipv4.nat_htable_size) >> 32;
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Is this tuple already taken? (not by us) */
|
|
|
|
int
|
|
|
|
nf_nat_used_tuple(const struct nf_conntrack_tuple *tuple,
|
|
|
|
const struct nf_conn *ignored_conntrack)
|
|
|
|
{
|
|
|
|
/* Conntrack tracking doesn't keep track of outgoing tuples; only
|
|
|
|
incoming ones. NAT means they don't have a fixed mapping,
|
|
|
|
so we invert the tuple and look for the incoming reply.
|
|
|
|
|
|
|
|
We could keep a separate hash if this proves too slow. */
|
|
|
|
struct nf_conntrack_tuple reply;
|
|
|
|
|
|
|
|
nf_ct_invert_tuplepr(&reply, tuple);
|
|
|
|
return nf_conntrack_tuple_taken(&reply, ignored_conntrack);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(nf_nat_used_tuple);
|
|
|
|
|
|
|
|
/* If we source map this tuple so reply looks like reply_tuple, will
|
|
|
|
* that meet the constraints of range. */
|
|
|
|
static int
|
|
|
|
in_range(const struct nf_conntrack_tuple *tuple,
|
|
|
|
const struct nf_nat_range *range)
|
|
|
|
{
|
2007-12-17 23:37:36 -07:00
|
|
|
const struct nf_nat_protocol *proto;
|
2007-02-12 12:12:26 -07:00
|
|
|
int ret = 0;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* If we are supposed to map IPs, then we must be in the
|
|
|
|
range specified, otherwise let this drag us onto a new src IP. */
|
|
|
|
if (range->flags & IP_NAT_RANGE_MAP_IPS) {
|
|
|
|
if (ntohl(tuple->src.u3.ip) < ntohl(range->min_ip) ||
|
|
|
|
ntohl(tuple->src.u3.ip) > ntohl(range->max_ip))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-12 12:12:26 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
proto = __nf_nat_proto_find(tuple->dst.protonum);
|
2006-12-02 23:07:13 -07:00
|
|
|
if (!(range->flags & IP_NAT_RANGE_PROTO_SPECIFIED) ||
|
|
|
|
proto->in_range(tuple, IP_NAT_MANIP_SRC,
|
|
|
|
&range->min, &range->max))
|
2007-02-12 12:12:26 -07:00
|
|
|
ret = 1;
|
|
|
|
rcu_read_unlock();
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-02-12 12:12:26 -07:00
|
|
|
return ret;
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
same_src(const struct nf_conn *ct,
|
|
|
|
const struct nf_conntrack_tuple *tuple)
|
|
|
|
{
|
|
|
|
const struct nf_conntrack_tuple *t;
|
|
|
|
|
|
|
|
t = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
|
|
|
|
return (t->dst.protonum == tuple->dst.protonum &&
|
|
|
|
t->src.u3.ip == tuple->src.u3.ip &&
|
|
|
|
t->src.u.all == tuple->src.u.all);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only called for SRC manip */
|
|
|
|
static int
|
2010-02-15 10:13:33 -07:00
|
|
|
find_appropriate_src(struct net *net, u16 zone,
|
2008-10-08 03:35:11 -06:00
|
|
|
const struct nf_conntrack_tuple *tuple,
|
2006-12-02 23:07:13 -07:00
|
|
|
struct nf_conntrack_tuple *result,
|
|
|
|
const struct nf_nat_range *range)
|
|
|
|
{
|
2010-02-15 10:13:33 -07:00
|
|
|
unsigned int h = hash_by_src(net, zone, tuple);
|
2008-04-14 03:15:42 -06:00
|
|
|
const struct nf_conn_nat *nat;
|
|
|
|
const struct nf_conn *ct;
|
|
|
|
const struct hlist_node *n;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2008-01-31 05:42:37 -07:00
|
|
|
rcu_read_lock();
|
2008-10-08 03:35:11 -06:00
|
|
|
hlist_for_each_entry_rcu(nat, n, &net->ipv4.nat_bysource[h], bysource) {
|
2007-07-07 23:26:35 -06:00
|
|
|
ct = nat->ct;
|
2010-02-15 10:13:33 -07:00
|
|
|
if (same_src(ct, tuple) && nf_ct_zone(ct) == zone) {
|
2006-12-02 23:07:13 -07:00
|
|
|
/* Copy source part from reply tuple. */
|
|
|
|
nf_ct_invert_tuplepr(result,
|
|
|
|
&ct->tuplehash[IP_CT_DIR_REPLY].tuple);
|
|
|
|
result->dst = tuple->dst;
|
|
|
|
|
|
|
|
if (in_range(result, range)) {
|
2008-01-31 05:42:37 -07:00
|
|
|
rcu_read_unlock();
|
2006-12-02 23:07:13 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-01-31 05:42:37 -07:00
|
|
|
rcu_read_unlock();
|
2006-12-02 23:07:13 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For [FUTURE] fragmentation handling, we want the least-used
|
|
|
|
src-ip/dst-ip/proto triple. Fairness doesn't come into it. Thus
|
|
|
|
if the range specifies 1.2.3.4 ports 10000-10005 and 1.2.3.5 ports
|
|
|
|
1-65535, we don't do pro-rata allocation based on ports; we choose
|
|
|
|
the ip with the lowest src-ip/dst-ip/proto usage.
|
|
|
|
*/
|
|
|
|
static void
|
2010-02-15 10:13:33 -07:00
|
|
|
find_best_ips_proto(u16 zone, struct nf_conntrack_tuple *tuple,
|
2006-12-02 23:07:13 -07:00
|
|
|
const struct nf_nat_range *range,
|
|
|
|
const struct nf_conn *ct,
|
|
|
|
enum nf_nat_manip_type maniptype)
|
|
|
|
{
|
|
|
|
__be32 *var_ipp;
|
|
|
|
/* Host order */
|
|
|
|
u_int32_t minip, maxip, j;
|
|
|
|
|
|
|
|
/* No IP mapping? Do nothing. */
|
|
|
|
if (!(range->flags & IP_NAT_RANGE_MAP_IPS))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (maniptype == IP_NAT_MANIP_SRC)
|
|
|
|
var_ipp = &tuple->src.u3.ip;
|
|
|
|
else
|
|
|
|
var_ipp = &tuple->dst.u3.ip;
|
|
|
|
|
|
|
|
/* Fast path: only one choice. */
|
|
|
|
if (range->min_ip == range->max_ip) {
|
|
|
|
*var_ipp = range->min_ip;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hashing source and destination IPs gives a fairly even
|
|
|
|
* spread in practice (if there are a small number of IPs
|
|
|
|
* involved, there usually aren't that many connections
|
|
|
|
* anyway). The consistency means that servers see the same
|
|
|
|
* client coming from the same IP (some Internet Banking sites
|
|
|
|
* like this), even across reboots. */
|
|
|
|
minip = ntohl(range->min_ip);
|
|
|
|
maxip = ntohl(range->max_ip);
|
|
|
|
j = jhash_2words((__force u32)tuple->src.u3.ip,
|
2009-04-16 10:33:01 -06:00
|
|
|
range->flags & IP_NAT_RANGE_PERSISTENT ?
|
2010-02-15 10:13:33 -07:00
|
|
|
0 : (__force u32)tuple->dst.u3.ip ^ zone, 0);
|
2007-12-17 23:45:52 -07:00
|
|
|
j = ((u64)j * (maxip - minip + 1)) >> 32;
|
|
|
|
*var_ipp = htonl(minip + j);
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
2007-11-19 19:53:30 -07:00
|
|
|
/* Manipulate the tuple into the range given. For NF_INET_POST_ROUTING,
|
|
|
|
* we change the source to map into the range. For NF_INET_PRE_ROUTING
|
|
|
|
* and NF_INET_LOCAL_OUT, we change the destination to map into the
|
2006-12-02 23:07:13 -07:00
|
|
|
* range. It might not be possible to get a unique tuple, but we try.
|
|
|
|
* At worst (or if we race), we will end up with a final duplicate in
|
|
|
|
* __ip_conntrack_confirm and drop the packet. */
|
|
|
|
static void
|
|
|
|
get_unique_tuple(struct nf_conntrack_tuple *tuple,
|
|
|
|
const struct nf_conntrack_tuple *orig_tuple,
|
|
|
|
const struct nf_nat_range *range,
|
|
|
|
struct nf_conn *ct,
|
|
|
|
enum nf_nat_manip_type maniptype)
|
|
|
|
{
|
2008-10-08 03:35:11 -06:00
|
|
|
struct net *net = nf_ct_net(ct);
|
2007-12-17 23:37:36 -07:00
|
|
|
const struct nf_nat_protocol *proto;
|
2010-02-15 10:13:33 -07:00
|
|
|
u16 zone = nf_ct_zone(ct);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* 1) If this srcip/proto/src-proto-part is currently mapped,
|
|
|
|
and that same mapping gives a unique tuple within the given
|
|
|
|
range, use that.
|
|
|
|
|
|
|
|
This is only required for source (ie. NAT/masq) mappings.
|
|
|
|
So far, we don't do local source mappings, so multiple
|
|
|
|
manips not an issue. */
|
2008-07-21 11:00:51 -06:00
|
|
|
if (maniptype == IP_NAT_MANIP_SRC &&
|
|
|
|
!(range->flags & IP_NAT_RANGE_PROTO_RANDOM)) {
|
2011-01-20 07:49:52 -07:00
|
|
|
/* try the original tuple first */
|
|
|
|
if (in_range(orig_tuple, range)) {
|
|
|
|
if (!nf_nat_used_tuple(orig_tuple, ct)) {
|
|
|
|
*tuple = *orig_tuple;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (find_appropriate_src(net, zone, orig_tuple, tuple,
|
|
|
|
range)) {
|
2007-07-07 23:39:38 -06:00
|
|
|
pr_debug("get_unique_tuple: Found current src map\n");
|
2008-07-21 11:00:51 -06:00
|
|
|
if (!nf_nat_used_tuple(tuple, ct))
|
|
|
|
return;
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 2) Select the least-used IP/proto combination in the given
|
|
|
|
range. */
|
|
|
|
*tuple = *orig_tuple;
|
2010-02-15 10:13:33 -07:00
|
|
|
find_best_ips_proto(zone, tuple, range, ct, maniptype);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* 3) The per-protocol part of the manip is made to map into
|
|
|
|
the range to make a unique tuple. */
|
|
|
|
|
2007-02-12 12:12:26 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
proto = __nf_nat_proto_find(orig_tuple->dst.protonum);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* Only bother mapping if it's not already in range and unique */
|
2010-09-16 11:45:19 -06:00
|
|
|
if (!(range->flags & IP_NAT_RANGE_PROTO_RANDOM)) {
|
|
|
|
if (range->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
|
|
|
|
if (proto->in_range(tuple, maniptype, &range->min,
|
|
|
|
&range->max) &&
|
|
|
|
(range->min.all == range->max.all ||
|
|
|
|
!nf_nat_used_tuple(tuple, ct)))
|
|
|
|
goto out;
|
|
|
|
} else if (!nf_nat_used_tuple(tuple, ct)) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* Last change: get protocol to try to obtain unique tuple. */
|
|
|
|
proto->unique_tuple(tuple, range, maniptype, ct);
|
2007-02-12 12:12:26 -07:00
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int
|
|
|
|
nf_nat_setup_info(struct nf_conn *ct,
|
|
|
|
const struct nf_nat_range *range,
|
2007-12-17 23:38:20 -07:00
|
|
|
enum nf_nat_manip_type maniptype)
|
2006-12-02 23:07:13 -07:00
|
|
|
{
|
2008-10-08 03:35:11 -06:00
|
|
|
struct net *net = nf_ct_net(ct);
|
2006-12-02 23:07:13 -07:00
|
|
|
struct nf_conntrack_tuple curr_tuple, new_tuple;
|
2007-07-07 23:24:28 -06:00
|
|
|
struct nf_conn_nat *nat;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-07-07 23:24:28 -06:00
|
|
|
/* nat helper or nfctnetlink also setup binding */
|
|
|
|
nat = nfct_nat(ct);
|
|
|
|
if (!nat) {
|
|
|
|
nat = nf_ct_ext_add(ct, NF_CT_EXT_NAT, GFP_ATOMIC);
|
|
|
|
if (nat == NULL) {
|
2007-07-07 23:39:38 -06:00
|
|
|
pr_debug("failed to add NAT extension\n");
|
2007-07-07 23:24:28 -06:00
|
|
|
return NF_ACCEPT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-17 23:38:20 -07:00
|
|
|
NF_CT_ASSERT(maniptype == IP_NAT_MANIP_SRC ||
|
|
|
|
maniptype == IP_NAT_MANIP_DST);
|
2006-12-02 23:07:13 -07:00
|
|
|
BUG_ON(nf_nat_initialized(ct, maniptype));
|
|
|
|
|
|
|
|
/* What we've got will look like inverse of reply. Normally
|
|
|
|
this is what is in the conntrack, except for prior
|
|
|
|
manipulations (future optimization: if num_manips == 0,
|
|
|
|
orig_tp =
|
|
|
|
conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple) */
|
|
|
|
nf_ct_invert_tuplepr(&curr_tuple,
|
|
|
|
&ct->tuplehash[IP_CT_DIR_REPLY].tuple);
|
|
|
|
|
|
|
|
get_unique_tuple(&new_tuple, &curr_tuple, range, ct, maniptype);
|
|
|
|
|
|
|
|
if (!nf_ct_tuple_equal(&new_tuple, &curr_tuple)) {
|
|
|
|
struct nf_conntrack_tuple reply;
|
|
|
|
|
|
|
|
/* Alter conntrack table so will recognize replies. */
|
|
|
|
nf_ct_invert_tuplepr(&reply, &new_tuple);
|
|
|
|
nf_conntrack_alter_reply(ct, &reply);
|
|
|
|
|
|
|
|
/* Non-atomic: we own this at the moment. */
|
|
|
|
if (maniptype == IP_NAT_MANIP_SRC)
|
|
|
|
ct->status |= IPS_SRC_NAT;
|
|
|
|
else
|
|
|
|
ct->status |= IPS_DST_NAT;
|
|
|
|
}
|
|
|
|
|
2011-01-20 07:49:52 -07:00
|
|
|
if (maniptype == IP_NAT_MANIP_SRC) {
|
2006-12-02 23:07:13 -07:00
|
|
|
unsigned int srchash;
|
|
|
|
|
2010-02-15 10:13:33 -07:00
|
|
|
srchash = hash_by_src(net, nf_ct_zone(ct),
|
|
|
|
&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple);
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_lock_bh(&nf_nat_lock);
|
2007-07-07 23:24:28 -06:00
|
|
|
/* nf_conntrack_alter_reply might re-allocate exntension aera */
|
2007-07-07 23:26:35 -06:00
|
|
|
nat = nfct_nat(ct);
|
|
|
|
nat->ct = ct;
|
2008-10-08 03:35:11 -06:00
|
|
|
hlist_add_head_rcu(&nat->bysource,
|
|
|
|
&net->ipv4.nat_bysource[srchash]);
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_unlock_bh(&nf_nat_lock);
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* It's done. */
|
|
|
|
if (maniptype == IP_NAT_MANIP_DST)
|
2011-01-18 07:02:48 -07:00
|
|
|
ct->status |= IPS_DST_NAT_DONE;
|
2006-12-02 23:07:13 -07:00
|
|
|
else
|
2011-01-18 07:02:48 -07:00
|
|
|
ct->status |= IPS_SRC_NAT_DONE;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
return NF_ACCEPT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(nf_nat_setup_info);
|
|
|
|
|
|
|
|
/* Returns true if succeeded. */
|
2008-04-14 03:15:53 -06:00
|
|
|
static bool
|
2006-12-02 23:07:13 -07:00
|
|
|
manip_pkt(u_int16_t proto,
|
2007-10-15 01:53:15 -06:00
|
|
|
struct sk_buff *skb,
|
2006-12-02 23:07:13 -07:00
|
|
|
unsigned int iphdroff,
|
|
|
|
const struct nf_conntrack_tuple *target,
|
|
|
|
enum nf_nat_manip_type maniptype)
|
|
|
|
{
|
|
|
|
struct iphdr *iph;
|
2007-12-17 23:37:36 -07:00
|
|
|
const struct nf_nat_protocol *p;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-10-15 01:53:15 -06:00
|
|
|
if (!skb_make_writable(skb, iphdroff + sizeof(*iph)))
|
2008-04-14 03:15:53 -06:00
|
|
|
return false;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-10-15 01:53:15 -06:00
|
|
|
iph = (void *)skb->data + iphdroff;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* Manipulate protcol part. */
|
2007-02-12 12:12:26 -07:00
|
|
|
|
|
|
|
/* rcu_read_lock()ed by nf_hook_slow */
|
|
|
|
p = __nf_nat_proto_find(proto);
|
2007-10-15 01:53:15 -06:00
|
|
|
if (!p->manip_pkt(skb, iphdroff, target, maniptype))
|
2008-04-14 03:15:53 -06:00
|
|
|
return false;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-10-15 01:53:15 -06:00
|
|
|
iph = (void *)skb->data + iphdroff;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
if (maniptype == IP_NAT_MANIP_SRC) {
|
2007-11-29 07:17:11 -07:00
|
|
|
csum_replace4(&iph->check, iph->saddr, target->src.u3.ip);
|
2006-12-02 23:07:13 -07:00
|
|
|
iph->saddr = target->src.u3.ip;
|
|
|
|
} else {
|
2007-11-29 07:17:11 -07:00
|
|
|
csum_replace4(&iph->check, iph->daddr, target->dst.u3.ip);
|
2006-12-02 23:07:13 -07:00
|
|
|
iph->daddr = target->dst.u3.ip;
|
|
|
|
}
|
2008-04-14 03:15:53 -06:00
|
|
|
return true;
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Do packet manipulations according to nf_nat_setup_info. */
|
|
|
|
unsigned int nf_nat_packet(struct nf_conn *ct,
|
|
|
|
enum ip_conntrack_info ctinfo,
|
|
|
|
unsigned int hooknum,
|
2007-10-15 01:53:15 -06:00
|
|
|
struct sk_buff *skb)
|
2006-12-02 23:07:13 -07:00
|
|
|
{
|
|
|
|
enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
|
|
|
|
unsigned long statusbit;
|
|
|
|
enum nf_nat_manip_type mtype = HOOK2MANIP(hooknum);
|
|
|
|
|
|
|
|
if (mtype == IP_NAT_MANIP_SRC)
|
|
|
|
statusbit = IPS_SRC_NAT;
|
|
|
|
else
|
|
|
|
statusbit = IPS_DST_NAT;
|
|
|
|
|
|
|
|
/* Invert if this is reply dir. */
|
|
|
|
if (dir == IP_CT_DIR_REPLY)
|
|
|
|
statusbit ^= IPS_NAT_MASK;
|
|
|
|
|
|
|
|
/* Non-atomic: these bits don't change. */
|
|
|
|
if (ct->status & statusbit) {
|
|
|
|
struct nf_conntrack_tuple target;
|
|
|
|
|
|
|
|
/* We are aiming to look like inverse of other direction. */
|
|
|
|
nf_ct_invert_tuplepr(&target, &ct->tuplehash[!dir].tuple);
|
|
|
|
|
2007-10-15 01:53:15 -06:00
|
|
|
if (!manip_pkt(target.dst.protonum, skb, 0, &target, mtype))
|
2006-12-02 23:07:13 -07:00
|
|
|
return NF_DROP;
|
|
|
|
}
|
|
|
|
return NF_ACCEPT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nf_nat_packet);
|
|
|
|
|
|
|
|
/* Dir is direction ICMP is coming from (opposite to packet it contains) */
|
|
|
|
int nf_nat_icmp_reply_translation(struct nf_conn *ct,
|
|
|
|
enum ip_conntrack_info ctinfo,
|
|
|
|
unsigned int hooknum,
|
2007-10-15 01:53:15 -06:00
|
|
|
struct sk_buff *skb)
|
2006-12-02 23:07:13 -07:00
|
|
|
{
|
|
|
|
struct {
|
|
|
|
struct icmphdr icmp;
|
|
|
|
struct iphdr ip;
|
|
|
|
} *inside;
|
2008-04-14 03:15:42 -06:00
|
|
|
const struct nf_conntrack_l4proto *l4proto;
|
2006-12-02 23:07:13 -07:00
|
|
|
struct nf_conntrack_tuple inner, target;
|
2007-10-15 01:53:15 -06:00
|
|
|
int hdrlen = ip_hdrlen(skb);
|
2006-12-02 23:07:13 -07:00
|
|
|
enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
|
|
|
|
unsigned long statusbit;
|
|
|
|
enum nf_nat_manip_type manip = HOOK2MANIP(hooknum);
|
|
|
|
|
2007-10-15 01:53:15 -06:00
|
|
|
if (!skb_make_writable(skb, hdrlen + sizeof(*inside)))
|
2006-12-02 23:07:13 -07:00
|
|
|
return 0;
|
|
|
|
|
2010-08-02 09:15:30 -06:00
|
|
|
inside = (void *)skb->data + hdrlen;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* We're actually going to mangle it beyond trivial checksum
|
|
|
|
adjustment, so make sure the current checksum is correct. */
|
2007-10-15 01:53:15 -06:00
|
|
|
if (nf_ip_checksum(skb, hooknum, hdrlen, 0))
|
2006-12-02 23:07:13 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Must be RELATED */
|
2007-10-15 01:53:15 -06:00
|
|
|
NF_CT_ASSERT(skb->nfctinfo == IP_CT_RELATED ||
|
2011-05-19 07:44:27 -06:00
|
|
|
skb->nfctinfo == IP_CT_RELATED_REPLY);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* Redirects on non-null nats must be dropped, else they'll
|
2007-02-09 07:24:47 -07:00
|
|
|
start talking to each other without our translation, and be
|
|
|
|
confused... --RR */
|
2006-12-02 23:07:13 -07:00
|
|
|
if (inside->icmp.type == ICMP_REDIRECT) {
|
|
|
|
/* If NAT isn't finished, assume it and drop. */
|
|
|
|
if ((ct->status & IPS_NAT_DONE_MASK) != IPS_NAT_DONE_MASK)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (ct->status & IPS_NAT_MASK)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-11 02:23:07 -06:00
|
|
|
if (manip == IP_NAT_MANIP_SRC)
|
|
|
|
statusbit = IPS_SRC_NAT;
|
|
|
|
else
|
|
|
|
statusbit = IPS_DST_NAT;
|
|
|
|
|
|
|
|
/* Invert if this is reply dir. */
|
|
|
|
if (dir == IP_CT_DIR_REPLY)
|
|
|
|
statusbit ^= IPS_NAT_MASK;
|
|
|
|
|
|
|
|
if (!(ct->status & statusbit))
|
|
|
|
return 1;
|
|
|
|
|
2007-07-07 23:39:38 -06:00
|
|
|
pr_debug("icmp_reply_translation: translating error %p manip %u "
|
2007-10-15 01:53:15 -06:00
|
|
|
"dir %s\n", skb, manip,
|
2007-07-07 23:39:38 -06:00
|
|
|
dir == IP_CT_DIR_ORIGINAL ? "ORIG" : "REPLY");
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2007-02-12 12:12:57 -07:00
|
|
|
/* rcu_read_lock()ed by nf_hook_slow */
|
|
|
|
l4proto = __nf_ct_l4proto_find(PF_INET, inside->ip.protocol);
|
|
|
|
|
2010-08-02 09:15:30 -06:00
|
|
|
if (!nf_ct_get_tuple(skb, hdrlen + sizeof(struct icmphdr),
|
|
|
|
(hdrlen +
|
2007-03-12 17:09:15 -06:00
|
|
|
sizeof(struct icmphdr) + inside->ip.ihl * 4),
|
2010-08-02 09:15:30 -06:00
|
|
|
(u_int16_t)AF_INET, inside->ip.protocol,
|
2007-02-12 12:12:57 -07:00
|
|
|
&inner, l3proto, l4proto))
|
2006-12-02 23:07:13 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Change inner back to look like incoming packet. We do the
|
|
|
|
opposite manip on this hook to normal, because it might not
|
|
|
|
pass all hooks (locally-generated ICMP). Consider incoming
|
|
|
|
packet: PREROUTING (DST manip), routing produces ICMP, goes
|
|
|
|
through POSTROUTING (which must correct the DST manip). */
|
2010-08-02 09:15:30 -06:00
|
|
|
if (!manip_pkt(inside->ip.protocol, skb, hdrlen + sizeof(inside->icmp),
|
|
|
|
&ct->tuplehash[!dir].tuple, !manip))
|
2006-12-02 23:07:13 -07:00
|
|
|
return 0;
|
|
|
|
|
2007-10-15 01:53:15 -06:00
|
|
|
if (skb->ip_summed != CHECKSUM_PARTIAL) {
|
2006-12-02 23:07:13 -07:00
|
|
|
/* Reloading "inside" here since manip_pkt inner. */
|
2010-08-02 09:15:30 -06:00
|
|
|
inside = (void *)skb->data + hdrlen;
|
2006-12-02 23:07:13 -07:00
|
|
|
inside->icmp.checksum = 0;
|
|
|
|
inside->icmp.checksum =
|
2007-10-15 01:53:15 -06:00
|
|
|
csum_fold(skb_checksum(skb, hdrlen,
|
|
|
|
skb->len - hdrlen, 0));
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Change outer to look the reply to an incoming packet
|
|
|
|
* (proto 0 means don't invert per-proto part). */
|
2010-10-11 02:23:07 -06:00
|
|
|
nf_ct_invert_tuplepr(&target, &ct->tuplehash[!dir].tuple);
|
|
|
|
if (!manip_pkt(0, skb, 0, &target, manip))
|
|
|
|
return 0;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nf_nat_icmp_reply_translation);
|
|
|
|
|
|
|
|
/* Protocol registration. */
|
2007-12-17 23:37:36 -07:00
|
|
|
int nf_nat_protocol_register(const struct nf_nat_protocol *proto)
|
2006-12-02 23:07:13 -07:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_lock_bh(&nf_nat_lock);
|
2010-11-15 10:43:59 -07:00
|
|
|
if (rcu_dereference_protected(
|
|
|
|
nf_nat_protos[proto->protonum],
|
|
|
|
lockdep_is_held(&nf_nat_lock)
|
|
|
|
) != &nf_nat_unknown_protocol) {
|
2006-12-02 23:07:13 -07:00
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2007-02-12 12:12:26 -07:00
|
|
|
rcu_assign_pointer(nf_nat_protos[proto->protonum], proto);
|
2006-12-02 23:07:13 -07:00
|
|
|
out:
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_unlock_bh(&nf_nat_lock);
|
2006-12-02 23:07:13 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(nf_nat_protocol_register);
|
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* No one stores the protocol anywhere; simply delete it. */
|
2007-12-17 23:37:36 -07:00
|
|
|
void nf_nat_protocol_unregister(const struct nf_nat_protocol *proto)
|
2006-12-02 23:07:13 -07:00
|
|
|
{
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_lock_bh(&nf_nat_lock);
|
2007-02-12 12:12:26 -07:00
|
|
|
rcu_assign_pointer(nf_nat_protos[proto->protonum],
|
|
|
|
&nf_nat_unknown_protocol);
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_unlock_bh(&nf_nat_lock);
|
2007-02-12 12:12:26 -07:00
|
|
|
synchronize_rcu();
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(nf_nat_protocol_unregister);
|
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* No one using conntrack by the time this called. */
|
2007-07-07 23:26:16 -06:00
|
|
|
static void nf_nat_cleanup_conntrack(struct nf_conn *ct)
|
|
|
|
{
|
|
|
|
struct nf_conn_nat *nat = nf_ct_ext_find(ct, NF_CT_EXT_NAT);
|
|
|
|
|
2007-07-07 23:26:35 -06:00
|
|
|
if (nat == NULL || nat->ct == NULL)
|
2007-07-07 23:26:16 -06:00
|
|
|
return;
|
|
|
|
|
2011-01-20 07:49:52 -07:00
|
|
|
NF_CT_ASSERT(nat->ct->status & IPS_SRC_NAT_DONE);
|
2007-07-07 23:26:16 -06:00
|
|
|
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_lock_bh(&nf_nat_lock);
|
2008-01-31 05:42:37 -07:00
|
|
|
hlist_del_rcu(&nat->bysource);
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_unlock_bh(&nf_nat_lock);
|
2007-07-07 23:26:16 -06:00
|
|
|
}
|
|
|
|
|
2008-02-07 18:56:34 -07:00
|
|
|
static void nf_nat_move_storage(void *new, void *old)
|
2007-07-07 23:24:28 -06:00
|
|
|
{
|
2008-02-07 18:56:34 -07:00
|
|
|
struct nf_conn_nat *new_nat = new;
|
|
|
|
struct nf_conn_nat *old_nat = old;
|
2007-07-07 23:26:35 -06:00
|
|
|
struct nf_conn *ct = old_nat->ct;
|
2007-07-07 23:24:28 -06:00
|
|
|
|
2011-01-20 07:49:52 -07:00
|
|
|
if (!ct || !(ct->status & IPS_SRC_NAT_DONE))
|
2007-07-07 23:24:28 -06:00
|
|
|
return;
|
|
|
|
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_lock_bh(&nf_nat_lock);
|
2008-06-17 16:51:47 -06:00
|
|
|
hlist_replace_rcu(&old_nat->bysource, &new_nat->bysource);
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_unlock_bh(&nf_nat_lock);
|
2007-07-07 23:24:28 -06:00
|
|
|
}
|
|
|
|
|
2007-07-07 23:27:06 -06:00
|
|
|
static struct nf_ct_ext_type nat_extend __read_mostly = {
|
2007-07-07 23:26:16 -06:00
|
|
|
.len = sizeof(struct nf_conn_nat),
|
|
|
|
.align = __alignof__(struct nf_conn_nat),
|
|
|
|
.destroy = nf_nat_cleanup_conntrack,
|
|
|
|
.move = nf_nat_move_storage,
|
|
|
|
.id = NF_CT_EXT_NAT,
|
|
|
|
.flags = NF_CT_EXT_F_PREALLOC,
|
2007-07-07 23:24:28 -06:00
|
|
|
};
|
|
|
|
|
2008-10-14 12:58:31 -06:00
|
|
|
#if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
|
|
|
|
|
|
|
|
#include <linux/netfilter/nfnetlink.h>
|
|
|
|
#include <linux/netfilter/nfnetlink_conntrack.h>
|
|
|
|
|
2010-10-29 08:28:07 -06:00
|
|
|
static const struct nf_nat_protocol *
|
|
|
|
nf_nat_proto_find_get(u_int8_t protonum)
|
|
|
|
{
|
|
|
|
const struct nf_nat_protocol *p;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
p = __nf_nat_proto_find(protonum);
|
|
|
|
if (!try_module_get(p->me))
|
|
|
|
p = &nf_nat_unknown_protocol;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
nf_nat_proto_put(const struct nf_nat_protocol *p)
|
|
|
|
{
|
|
|
|
module_put(p->me);
|
|
|
|
}
|
|
|
|
|
2008-10-14 12:58:31 -06:00
|
|
|
static const struct nla_policy protonat_nla_policy[CTA_PROTONAT_MAX+1] = {
|
|
|
|
[CTA_PROTONAT_PORT_MIN] = { .type = NLA_U16 },
|
|
|
|
[CTA_PROTONAT_PORT_MAX] = { .type = NLA_U16 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static int nfnetlink_parse_nat_proto(struct nlattr *attr,
|
|
|
|
const struct nf_conn *ct,
|
|
|
|
struct nf_nat_range *range)
|
|
|
|
{
|
|
|
|
struct nlattr *tb[CTA_PROTONAT_MAX+1];
|
|
|
|
const struct nf_nat_protocol *npt;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = nla_parse_nested(tb, CTA_PROTONAT_MAX, attr, protonat_nla_policy);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
npt = nf_nat_proto_find_get(nf_ct_protonum(ct));
|
|
|
|
if (npt->nlattr_to_range)
|
|
|
|
err = npt->nlattr_to_range(tb, range);
|
|
|
|
nf_nat_proto_put(npt);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nla_policy nat_nla_policy[CTA_NAT_MAX+1] = {
|
|
|
|
[CTA_NAT_MINIP] = { .type = NLA_U32 },
|
|
|
|
[CTA_NAT_MAXIP] = { .type = NLA_U32 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
2009-08-25 08:07:58 -06:00
|
|
|
nfnetlink_parse_nat(const struct nlattr *nat,
|
2008-10-14 12:58:31 -06:00
|
|
|
const struct nf_conn *ct, struct nf_nat_range *range)
|
|
|
|
{
|
|
|
|
struct nlattr *tb[CTA_NAT_MAX+1];
|
|
|
|
int err;
|
|
|
|
|
|
|
|
memset(range, 0, sizeof(*range));
|
|
|
|
|
|
|
|
err = nla_parse_nested(tb, CTA_NAT_MAX, nat, nat_nla_policy);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (tb[CTA_NAT_MINIP])
|
|
|
|
range->min_ip = nla_get_be32(tb[CTA_NAT_MINIP]);
|
|
|
|
|
|
|
|
if (!tb[CTA_NAT_MAXIP])
|
|
|
|
range->max_ip = range->min_ip;
|
|
|
|
else
|
|
|
|
range->max_ip = nla_get_be32(tb[CTA_NAT_MAXIP]);
|
|
|
|
|
|
|
|
if (range->min_ip)
|
|
|
|
range->flags |= IP_NAT_RANGE_MAP_IPS;
|
|
|
|
|
|
|
|
if (!tb[CTA_NAT_PROTO])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = nfnetlink_parse_nat_proto(tb[CTA_NAT_PROTO], ct, range);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nfnetlink_parse_nat_setup(struct nf_conn *ct,
|
|
|
|
enum nf_nat_manip_type manip,
|
2009-08-25 08:07:58 -06:00
|
|
|
const struct nlattr *attr)
|
2008-10-14 12:58:31 -06:00
|
|
|
{
|
|
|
|
struct nf_nat_range range;
|
|
|
|
|
|
|
|
if (nfnetlink_parse_nat(attr, ct, &range) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (nf_nat_initialized(ct, manip))
|
|
|
|
return -EEXIST;
|
|
|
|
|
|
|
|
return nf_nat_setup_info(ct, &range, manip);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static int
|
|
|
|
nfnetlink_parse_nat_setup(struct nf_conn *ct,
|
|
|
|
enum nf_nat_manip_type manip,
|
2009-08-25 08:07:58 -06:00
|
|
|
const struct nlattr *attr)
|
2008-10-14 12:58:31 -06:00
|
|
|
{
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-10-08 03:35:11 -06:00
|
|
|
static int __net_init nf_nat_net_init(struct net *net)
|
|
|
|
{
|
2010-02-08 12:18:07 -07:00
|
|
|
/* Leave them the same for the moment. */
|
|
|
|
net->ipv4.nat_htable_size = net->ct.htable_size;
|
2011-01-14 07:45:56 -07:00
|
|
|
net->ipv4.nat_bysource = nf_ct_alloc_hashtable(&net->ipv4.nat_htable_size, 0);
|
2008-10-08 03:35:11 -06:00
|
|
|
if (!net->ipv4.nat_bysource)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear NAT section of all conntracks, in case we're loaded again. */
|
|
|
|
static int clean_nat(struct nf_conn *i, void *data)
|
|
|
|
{
|
|
|
|
struct nf_conn_nat *nat = nfct_nat(i);
|
|
|
|
|
|
|
|
if (!nat)
|
|
|
|
return 0;
|
|
|
|
memset(nat, 0, sizeof(*nat));
|
|
|
|
i->status &= ~(IPS_NAT_MASK | IPS_NAT_DONE_MASK | IPS_SEQ_ADJUST);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit nf_nat_net_exit(struct net *net)
|
|
|
|
{
|
|
|
|
nf_ct_iterate_cleanup(net, &clean_nat, NULL);
|
|
|
|
synchronize_rcu();
|
2011-01-14 07:45:56 -07:00
|
|
|
nf_ct_free_hashtable(net->ipv4.nat_bysource, net->ipv4.nat_htable_size);
|
2008-10-08 03:35:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations nf_nat_net_ops = {
|
|
|
|
.init = nf_nat_net_init,
|
|
|
|
.exit = nf_nat_net_exit,
|
|
|
|
};
|
|
|
|
|
2006-12-02 23:07:13 -07:00
|
|
|
static int __init nf_nat_init(void)
|
|
|
|
{
|
|
|
|
size_t i;
|
2007-07-07 23:24:28 -06:00
|
|
|
int ret;
|
|
|
|
|
2008-04-09 16:14:58 -06:00
|
|
|
need_ipv4_conntrack();
|
|
|
|
|
2007-07-07 23:24:28 -06:00
|
|
|
ret = nf_ct_extend_register(&nat_extend);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_ERR "nf_nat_core: Unable to register extension\n");
|
|
|
|
return ret;
|
|
|
|
}
|
2006-12-02 23:07:13 -07:00
|
|
|
|
2008-10-08 03:35:11 -06:00
|
|
|
ret = register_pernet_subsys(&nf_nat_net_ops);
|
|
|
|
if (ret < 0)
|
2007-07-07 23:24:28 -06:00
|
|
|
goto cleanup_extend;
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* Sew in builtin protocols. */
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_lock_bh(&nf_nat_lock);
|
2006-12-02 23:07:13 -07:00
|
|
|
for (i = 0; i < MAX_IP_NAT_PROTO; i++)
|
2007-02-12 12:12:26 -07:00
|
|
|
rcu_assign_pointer(nf_nat_protos[i], &nf_nat_unknown_protocol);
|
|
|
|
rcu_assign_pointer(nf_nat_protos[IPPROTO_TCP], &nf_nat_protocol_tcp);
|
|
|
|
rcu_assign_pointer(nf_nat_protos[IPPROTO_UDP], &nf_nat_protocol_udp);
|
|
|
|
rcu_assign_pointer(nf_nat_protos[IPPROTO_ICMP], &nf_nat_protocol_icmp);
|
2008-01-31 05:43:06 -07:00
|
|
|
spin_unlock_bh(&nf_nat_lock);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
/* Initialize fake conntrack so that NAT will skip it */
|
2010-06-08 08:09:52 -06:00
|
|
|
nf_ct_untracked_status_or(IPS_NAT_DONE_MASK);
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
l3proto = nf_ct_l3proto_find_get((u_int16_t)AF_INET);
|
2008-04-14 03:15:52 -06:00
|
|
|
|
|
|
|
BUG_ON(nf_nat_seq_adjust_hook != NULL);
|
|
|
|
rcu_assign_pointer(nf_nat_seq_adjust_hook, nf_nat_seq_adjust);
|
2008-10-14 12:58:31 -06:00
|
|
|
BUG_ON(nfnetlink_parse_nat_setup_hook != NULL);
|
|
|
|
rcu_assign_pointer(nfnetlink_parse_nat_setup_hook,
|
|
|
|
nfnetlink_parse_nat_setup);
|
2009-11-06 01:43:42 -07:00
|
|
|
BUG_ON(nf_ct_nat_offset != NULL);
|
|
|
|
rcu_assign_pointer(nf_ct_nat_offset, nf_nat_get_offset);
|
2006-12-02 23:07:13 -07:00
|
|
|
return 0;
|
2007-07-07 23:24:28 -06:00
|
|
|
|
|
|
|
cleanup_extend:
|
|
|
|
nf_ct_extend_unregister(&nat_extend);
|
|
|
|
return ret;
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit nf_nat_cleanup(void)
|
|
|
|
{
|
2008-10-08 03:35:11 -06:00
|
|
|
unregister_pernet_subsys(&nf_nat_net_ops);
|
2006-12-02 23:07:13 -07:00
|
|
|
nf_ct_l3proto_put(l3proto);
|
2007-07-07 23:24:28 -06:00
|
|
|
nf_ct_extend_unregister(&nat_extend);
|
2008-04-14 03:15:52 -06:00
|
|
|
rcu_assign_pointer(nf_nat_seq_adjust_hook, NULL);
|
2008-10-14 12:58:31 -06:00
|
|
|
rcu_assign_pointer(nfnetlink_parse_nat_setup_hook, NULL);
|
2009-11-06 01:43:42 -07:00
|
|
|
rcu_assign_pointer(nf_ct_nat_offset, NULL);
|
2008-04-14 03:15:52 -06:00
|
|
|
synchronize_net();
|
2006-12-02 23:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-10-14 12:58:31 -06:00
|
|
|
MODULE_ALIAS("nf-nat-ipv4");
|
2006-12-02 23:07:13 -07:00
|
|
|
|
|
|
|
module_init(nf_nat_init);
|
|
|
|
module_exit(nf_nat_cleanup);
|