2008-01-15 08:40:53 +01:00
|
|
|
/*
|
|
|
|
* xt_conntrack - Netfilter module to match connection tracking
|
|
|
|
* information. (Superset of Rusty's minimalistic state match.)
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2008-01-15 08:40:53 +01:00
|
|
|
* (C) 2001 Marc Boucher (marc@mbsi.ca).
|
|
|
|
* Copyright © CC Computer Consultants GmbH, 2007 - 2008
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2008-01-15 08:40:53 +01:00
|
|
|
* 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.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/skbuff.h>
|
2008-01-15 08:40:53 +01:00
|
|
|
#include <net/ipv6.h>
|
[NETFILTER] x_tables: Abstraction layer for {ip,ip6,arp}_tables
This monster-patch tries to do the best job for unifying the data
structures and backend interfaces for the three evil clones ip_tables,
ip6_tables and arp_tables. In an ideal world we would never have
allowed this kind of copy+paste programming... but well, our world
isn't (yet?) ideal.
o introduce a new x_tables module
o {ip,arp,ip6}_tables depend on this x_tables module
o registration functions for tables, matches and targets are only
wrappers around x_tables provided functions
o all matches/targets that are used from ip_tables and ip6_tables
are now implemented as xt_FOOBAR.c files and provide module aliases
to ipt_FOOBAR and ip6t_FOOBAR
o header files for xt_matches are in include/linux/netfilter/,
include/linux/netfilter_{ipv4,ipv6} contains compatibility wrappers
around the xt_FOOBAR.h headers
Based on this patchset we're going to further unify the code,
gradually getting rid of all the layer 3 specific assumptions.
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-01-12 22:30:04 +01:00
|
|
|
#include <linux/netfilter/x_tables.h>
|
|
|
|
#include <linux/netfilter/xt_conntrack.h>
|
2007-03-15 00:37:25 +01:00
|
|
|
#include <net/netfilter/nf_conntrack.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("Marc Boucher <marc@mbsi.ca>");
|
2008-01-31 12:58:24 +01:00
|
|
|
MODULE_AUTHOR("Jan Engelhardt <jengelh@computergmbh.de>");
|
2008-01-15 08:42:28 +01:00
|
|
|
MODULE_DESCRIPTION("Xtables: connection tracking state match");
|
[NETFILTER] x_tables: Abstraction layer for {ip,ip6,arp}_tables
This monster-patch tries to do the best job for unifying the data
structures and backend interfaces for the three evil clones ip_tables,
ip6_tables and arp_tables. In an ideal world we would never have
allowed this kind of copy+paste programming... but well, our world
isn't (yet?) ideal.
o introduce a new x_tables module
o {ip,arp,ip6}_tables depend on this x_tables module
o registration functions for tables, matches and targets are only
wrappers around x_tables provided functions
o all matches/targets that are used from ip_tables and ip6_tables
are now implemented as xt_FOOBAR.c files and provide module aliases
to ipt_FOOBAR and ip6t_FOOBAR
o header files for xt_matches are in include/linux/netfilter/,
include/linux/netfilter_{ipv4,ipv6} contains compatibility wrappers
around the xt_FOOBAR.h headers
Based on this patchset we're going to further unify the code,
gradually getting rid of all the layer 3 specific assumptions.
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-01-12 22:30:04 +01:00
|
|
|
MODULE_ALIAS("ipt_conntrack");
|
2008-01-15 08:40:53 +01:00
|
|
|
MODULE_ALIAS("ip6t_conntrack");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-08 07:15:35 +02:00
|
|
|
static bool
|
2008-01-15 08:40:53 +01:00
|
|
|
conntrack_mt_v0(const struct sk_buff *skb, const struct net_device *in,
|
|
|
|
const struct net_device *out, const struct xt_match *match,
|
|
|
|
const void *matchinfo, int offset, unsigned int protoff,
|
|
|
|
bool *hotdrop)
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
{
|
[NETFILTER] x_tables: Abstraction layer for {ip,ip6,arp}_tables
This monster-patch tries to do the best job for unifying the data
structures and backend interfaces for the three evil clones ip_tables,
ip6_tables and arp_tables. In an ideal world we would never have
allowed this kind of copy+paste programming... but well, our world
isn't (yet?) ideal.
o introduce a new x_tables module
o {ip,arp,ip6}_tables depend on this x_tables module
o registration functions for tables, matches and targets are only
wrappers around x_tables provided functions
o all matches/targets that are used from ip_tables and ip6_tables
are now implemented as xt_FOOBAR.c files and provide module aliases
to ipt_FOOBAR and ip6t_FOOBAR
o header files for xt_matches are in include/linux/netfilter/,
include/linux/netfilter_{ipv4,ipv6} contains compatibility wrappers
around the xt_FOOBAR.h headers
Based on this patchset we're going to further unify the code,
gradually getting rid of all the layer 3 specific assumptions.
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-01-12 22:30:04 +01:00
|
|
|
const struct xt_conntrack_info *sinfo = matchinfo;
|
2007-07-08 07:16:55 +02:00
|
|
|
const struct nf_conn *ct;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
enum ip_conntrack_info ctinfo;
|
|
|
|
unsigned int statebit;
|
|
|
|
|
2007-07-08 07:16:55 +02:00
|
|
|
ct = nf_ct_get(skb, &ctinfo);
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2007-12-18 07:44:06 +01:00
|
|
|
#define FWINV(bool, invflg) ((bool) ^ !!(sinfo->invflags & (invflg)))
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
|
|
|
if (ct == &nf_conntrack_untracked)
|
[NETFILTER] x_tables: Abstraction layer for {ip,ip6,arp}_tables
This monster-patch tries to do the best job for unifying the data
structures and backend interfaces for the three evil clones ip_tables,
ip6_tables and arp_tables. In an ideal world we would never have
allowed this kind of copy+paste programming... but well, our world
isn't (yet?) ideal.
o introduce a new x_tables module
o {ip,arp,ip6}_tables depend on this x_tables module
o registration functions for tables, matches and targets are only
wrappers around x_tables provided functions
o all matches/targets that are used from ip_tables and ip6_tables
are now implemented as xt_FOOBAR.c files and provide module aliases
to ipt_FOOBAR and ip6t_FOOBAR
o header files for xt_matches are in include/linux/netfilter/,
include/linux/netfilter_{ipv4,ipv6} contains compatibility wrappers
around the xt_FOOBAR.h headers
Based on this patchset we're going to further unify the code,
gradually getting rid of all the layer 3 specific assumptions.
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-01-12 22:30:04 +01:00
|
|
|
statebit = XT_CONNTRACK_STATE_UNTRACKED;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
else if (ct)
|
2007-02-12 20:15:49 +01:00
|
|
|
statebit = XT_CONNTRACK_STATE_BIT(ctinfo);
|
|
|
|
else
|
|
|
|
statebit = XT_CONNTRACK_STATE_INVALID;
|
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (sinfo->flags & XT_CONNTRACK_STATE) {
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
if (ct) {
|
2006-09-20 20:58:17 +02:00
|
|
|
if (test_bit(IPS_SRC_NAT_BIT, &ct->status))
|
[NETFILTER] x_tables: Abstraction layer for {ip,ip6,arp}_tables
This monster-patch tries to do the best job for unifying the data
structures and backend interfaces for the three evil clones ip_tables,
ip6_tables and arp_tables. In an ideal world we would never have
allowed this kind of copy+paste programming... but well, our world
isn't (yet?) ideal.
o introduce a new x_tables module
o {ip,arp,ip6}_tables depend on this x_tables module
o registration functions for tables, matches and targets are only
wrappers around x_tables provided functions
o all matches/targets that are used from ip_tables and ip6_tables
are now implemented as xt_FOOBAR.c files and provide module aliases
to ipt_FOOBAR and ip6t_FOOBAR
o header files for xt_matches are in include/linux/netfilter/,
include/linux/netfilter_{ipv4,ipv6} contains compatibility wrappers
around the xt_FOOBAR.h headers
Based on this patchset we're going to further unify the code,
gradually getting rid of all the layer 3 specific assumptions.
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-01-12 22:30:04 +01:00
|
|
|
statebit |= XT_CONNTRACK_STATE_SNAT;
|
2006-09-20 20:58:17 +02:00
|
|
|
if (test_bit(IPS_DST_NAT_BIT, &ct->status))
|
[NETFILTER] x_tables: Abstraction layer for {ip,ip6,arp}_tables
This monster-patch tries to do the best job for unifying the data
structures and backend interfaces for the three evil clones ip_tables,
ip6_tables and arp_tables. In an ideal world we would never have
allowed this kind of copy+paste programming... but well, our world
isn't (yet?) ideal.
o introduce a new x_tables module
o {ip,arp,ip6}_tables depend on this x_tables module
o registration functions for tables, matches and targets are only
wrappers around x_tables provided functions
o all matches/targets that are used from ip_tables and ip6_tables
are now implemented as xt_FOOBAR.c files and provide module aliases
to ipt_FOOBAR and ip6t_FOOBAR
o header files for xt_matches are in include/linux/netfilter/,
include/linux/netfilter_{ipv4,ipv6} contains compatibility wrappers
around the xt_FOOBAR.h headers
Based on this patchset we're going to further unify the code,
gradually getting rid of all the layer 3 specific assumptions.
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-01-12 22:30:04 +01:00
|
|
|
statebit |= XT_CONNTRACK_STATE_DNAT;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
}
|
2006-09-20 20:58:17 +02:00
|
|
|
if (FWINV((statebit & sinfo->statemask) == 0,
|
|
|
|
XT_CONNTRACK_STATE))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
}
|
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (ct == NULL) {
|
|
|
|
if (sinfo->flags & ~XT_CONNTRACK_STATE)
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
|
|
|
return true;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
}
|
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (sinfo->flags & XT_CONNTRACK_PROTO &&
|
2008-04-14 11:15:52 +02:00
|
|
|
FWINV(nf_ct_protonum(ct) !=
|
2007-02-12 20:15:49 +01:00
|
|
|
sinfo->tuple[IP_CT_DIR_ORIGINAL].dst.protonum,
|
2006-09-20 20:58:17 +02:00
|
|
|
XT_CONNTRACK_PROTO))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
2006-09-20 20:58:17 +02:00
|
|
|
|
|
|
|
if (sinfo->flags & XT_CONNTRACK_ORIGSRC &&
|
|
|
|
FWINV((ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip &
|
2007-02-12 20:15:49 +01:00
|
|
|
sinfo->sipmsk[IP_CT_DIR_ORIGINAL].s_addr) !=
|
2006-09-20 20:58:17 +02:00
|
|
|
sinfo->tuple[IP_CT_DIR_ORIGINAL].src.ip,
|
|
|
|
XT_CONNTRACK_ORIGSRC))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (sinfo->flags & XT_CONNTRACK_ORIGDST &&
|
|
|
|
FWINV((ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.ip &
|
2007-02-12 20:15:49 +01:00
|
|
|
sinfo->dipmsk[IP_CT_DIR_ORIGINAL].s_addr) !=
|
2006-09-20 20:58:17 +02:00
|
|
|
sinfo->tuple[IP_CT_DIR_ORIGINAL].dst.ip,
|
|
|
|
XT_CONNTRACK_ORIGDST))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (sinfo->flags & XT_CONNTRACK_REPLSRC &&
|
|
|
|
FWINV((ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3.ip &
|
2007-02-12 20:15:49 +01:00
|
|
|
sinfo->sipmsk[IP_CT_DIR_REPLY].s_addr) !=
|
2006-09-20 20:58:17 +02:00
|
|
|
sinfo->tuple[IP_CT_DIR_REPLY].src.ip,
|
|
|
|
XT_CONNTRACK_REPLSRC))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (sinfo->flags & XT_CONNTRACK_REPLDST &&
|
|
|
|
FWINV((ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip &
|
2007-02-12 20:15:49 +01:00
|
|
|
sinfo->dipmsk[IP_CT_DIR_REPLY].s_addr) !=
|
2006-09-20 20:58:17 +02:00
|
|
|
sinfo->tuple[IP_CT_DIR_REPLY].dst.ip,
|
|
|
|
XT_CONNTRACK_REPLDST))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (sinfo->flags & XT_CONNTRACK_STATUS &&
|
|
|
|
FWINV((ct->status & sinfo->statusmask) == 0,
|
2007-02-12 20:15:49 +01:00
|
|
|
XT_CONNTRACK_STATUS))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if(sinfo->flags & XT_CONNTRACK_EXPIRES) {
|
|
|
|
unsigned long expires = timer_pending(&ct->timeout) ?
|
|
|
|
(ct->timeout.expires - jiffies)/HZ : 0;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
|
2006-09-20 20:58:17 +02:00
|
|
|
if (FWINV(!(expires >= sinfo->expires_min &&
|
|
|
|
expires <= sinfo->expires_max),
|
|
|
|
XT_CONNTRACK_EXPIRES))
|
2007-07-08 07:15:35 +02:00
|
|
|
return false;
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
}
|
2007-07-08 07:15:35 +02:00
|
|
|
return true;
|
2007-12-18 07:44:06 +01:00
|
|
|
#undef FWINV
|
[NETFILTER]: Add nf_conntrack subsystem.
The existing connection tracking subsystem in netfilter can only
handle ipv4. There were basically two choices present to add
connection tracking support for ipv6. We could either duplicate all
of the ipv4 connection tracking code into an ipv6 counterpart, or (the
choice taken by these patches) we could design a generic layer that
could handle both ipv4 and ipv6 and thus requiring only one sub-protocol
(TCP, UDP, etc.) connection tracking helper module to be written.
In fact nf_conntrack is capable of working with any layer 3
protocol.
The existing ipv4 specific conntrack code could also not deal
with the pecularities of doing connection tracking on ipv6,
which is also cured here. For example, these issues include:
1) ICMPv6 handling, which is used for neighbour discovery in
ipv6 thus some messages such as these should not participate
in connection tracking since effectively they are like ARP
messages
2) fragmentation must be handled differently in ipv6, because
the simplistic "defrag, connection track and NAT, refrag"
(which the existing ipv4 connection tracking does) approach simply
isn't feasible in ipv6
3) ipv6 extension header parsing must occur at the correct spots
before and after connection tracking decisions, and there were
no provisions for this in the existing connection tracking
design
4) ipv6 has no need for stateful NAT
The ipv4 specific conntrack layer is kept around, until all of
the ipv4 specific conntrack helpers are ported over to nf_conntrack
and it is feature complete. Once that occurs, the old conntrack
stuff will get placed into the feature-removal-schedule and we will
fully kill it off 6 months later.
Signed-off-by: Yasuyuki Kozakai <yasuyuki.kozakai@toshiba.co.jp>
Signed-off-by: Harald Welte <laforge@netfilter.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
2005-11-10 01:38:16 +01:00
|
|
|
}
|
|
|
|
|
2008-01-15 08:40:53 +01:00
|
|
|
static bool
|
|
|
|
conntrack_addrcmp(const union nf_inet_addr *kaddr,
|
|
|
|
const union nf_inet_addr *uaddr,
|
|
|
|
const union nf_inet_addr *umask, unsigned int l3proto)
|
|
|
|
{
|
|
|
|
if (l3proto == AF_INET)
|
2008-02-27 21:20:41 +01:00
|
|
|
return ((kaddr->ip ^ uaddr->ip) & umask->ip) == 0;
|
2008-01-15 08:40:53 +01:00
|
|
|
else if (l3proto == AF_INET6)
|
|
|
|
return ipv6_masked_addr_cmp(&kaddr->in6, &umask->in6,
|
|
|
|
&uaddr->in6) == 0;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
conntrack_mt_origsrc(const struct nf_conn *ct,
|
|
|
|
const struct xt_conntrack_mtinfo1 *info,
|
|
|
|
unsigned int family)
|
|
|
|
{
|
|
|
|
return conntrack_addrcmp(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3,
|
|
|
|
&info->origsrc_addr, &info->origsrc_mask, family);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
conntrack_mt_origdst(const struct nf_conn *ct,
|
|
|
|
const struct xt_conntrack_mtinfo1 *info,
|
|
|
|
unsigned int family)
|
|
|
|
{
|
|
|
|
return conntrack_addrcmp(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3,
|
|
|
|
&info->origdst_addr, &info->origdst_mask, family);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
conntrack_mt_replsrc(const struct nf_conn *ct,
|
|
|
|
const struct xt_conntrack_mtinfo1 *info,
|
|
|
|
unsigned int family)
|
|
|
|
{
|
|
|
|
return conntrack_addrcmp(&ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3,
|
|
|
|
&info->replsrc_addr, &info->replsrc_mask, family);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
conntrack_mt_repldst(const struct nf_conn *ct,
|
|
|
|
const struct xt_conntrack_mtinfo1 *info,
|
|
|
|
unsigned int family)
|
|
|
|
{
|
|
|
|
return conntrack_addrcmp(&ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3,
|
|
|
|
&info->repldst_addr, &info->repldst_mask, family);
|
|
|
|
}
|
|
|
|
|
2008-01-31 12:58:24 +01:00
|
|
|
static inline bool
|
|
|
|
ct_proto_port_check(const struct xt_conntrack_mtinfo1 *info,
|
|
|
|
const struct nf_conn *ct)
|
|
|
|
{
|
|
|
|
const struct nf_conntrack_tuple *tuple;
|
|
|
|
|
|
|
|
tuple = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
|
|
|
|
if ((info->match_flags & XT_CONNTRACK_PROTO) &&
|
2008-04-14 11:15:52 +02:00
|
|
|
(nf_ct_protonum(ct) == info->l4proto) ^
|
2008-01-31 12:58:24 +01:00
|
|
|
!(info->invert_flags & XT_CONNTRACK_PROTO))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Shortcut to match all recognized protocols by using ->src.all. */
|
|
|
|
if ((info->match_flags & XT_CONNTRACK_ORIGSRC_PORT) &&
|
|
|
|
(tuple->src.u.all == info->origsrc_port) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_ORIGSRC_PORT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((info->match_flags & XT_CONNTRACK_ORIGDST_PORT) &&
|
|
|
|
(tuple->dst.u.all == info->origdst_port) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_ORIGDST_PORT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
tuple = &ct->tuplehash[IP_CT_DIR_REPLY].tuple;
|
|
|
|
|
|
|
|
if ((info->match_flags & XT_CONNTRACK_REPLSRC_PORT) &&
|
|
|
|
(tuple->src.u.all == info->replsrc_port) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_REPLSRC_PORT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((info->match_flags & XT_CONNTRACK_REPLDST_PORT) &&
|
|
|
|
(tuple->dst.u.all == info->repldst_port) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_REPLDST_PORT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-01-15 08:40:53 +01:00
|
|
|
static bool
|
|
|
|
conntrack_mt(const struct sk_buff *skb, const struct net_device *in,
|
|
|
|
const struct net_device *out, const struct xt_match *match,
|
|
|
|
const void *matchinfo, int offset, unsigned int protoff,
|
|
|
|
bool *hotdrop)
|
|
|
|
{
|
|
|
|
const struct xt_conntrack_mtinfo1 *info = matchinfo;
|
|
|
|
enum ip_conntrack_info ctinfo;
|
|
|
|
const struct nf_conn *ct;
|
|
|
|
unsigned int statebit;
|
|
|
|
|
|
|
|
ct = nf_ct_get(skb, &ctinfo);
|
|
|
|
|
|
|
|
if (ct == &nf_conntrack_untracked)
|
|
|
|
statebit = XT_CONNTRACK_STATE_UNTRACKED;
|
|
|
|
else if (ct != NULL)
|
|
|
|
statebit = XT_CONNTRACK_STATE_BIT(ctinfo);
|
|
|
|
else
|
|
|
|
statebit = XT_CONNTRACK_STATE_INVALID;
|
|
|
|
|
|
|
|
if (info->match_flags & XT_CONNTRACK_STATE) {
|
|
|
|
if (ct != NULL) {
|
|
|
|
if (test_bit(IPS_SRC_NAT_BIT, &ct->status))
|
|
|
|
statebit |= XT_CONNTRACK_STATE_SNAT;
|
|
|
|
if (test_bit(IPS_DST_NAT_BIT, &ct->status))
|
|
|
|
statebit |= XT_CONNTRACK_STATE_DNAT;
|
|
|
|
}
|
2008-02-27 21:09:05 +01:00
|
|
|
if (!!(info->state_mask & statebit) ^
|
2008-01-15 08:40:53 +01:00
|
|
|
!(info->invert_flags & XT_CONNTRACK_STATE))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ct == NULL)
|
|
|
|
return info->match_flags & XT_CONNTRACK_STATE;
|
2008-01-31 12:58:24 +01:00
|
|
|
if ((info->match_flags & XT_CONNTRACK_DIRECTION) &&
|
|
|
|
(CTINFO2DIR(ctinfo) == IP_CT_DIR_ORIGINAL) ^
|
|
|
|
!!(info->invert_flags & XT_CONNTRACK_DIRECTION))
|
2008-01-15 08:40:53 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (info->match_flags & XT_CONNTRACK_ORIGSRC)
|
|
|
|
if (conntrack_mt_origsrc(ct, info, match->family) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_ORIGSRC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (info->match_flags & XT_CONNTRACK_ORIGDST)
|
|
|
|
if (conntrack_mt_origdst(ct, info, match->family) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_ORIGDST))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (info->match_flags & XT_CONNTRACK_REPLSRC)
|
|
|
|
if (conntrack_mt_replsrc(ct, info, match->family) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_REPLSRC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (info->match_flags & XT_CONNTRACK_REPLDST)
|
|
|
|
if (conntrack_mt_repldst(ct, info, match->family) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_REPLDST))
|
|
|
|
return false;
|
|
|
|
|
2008-01-31 12:58:24 +01:00
|
|
|
if (!ct_proto_port_check(info, ct))
|
|
|
|
return false;
|
|
|
|
|
2008-01-15 08:40:53 +01:00
|
|
|
if ((info->match_flags & XT_CONNTRACK_STATUS) &&
|
|
|
|
(!!(info->status_mask & ct->status) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_STATUS)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (info->match_flags & XT_CONNTRACK_EXPIRES) {
|
|
|
|
unsigned long expires = 0;
|
|
|
|
|
|
|
|
if (timer_pending(&ct->timeout))
|
|
|
|
expires = (ct->timeout.expires - jiffies) / HZ;
|
|
|
|
if ((expires >= info->expires_min &&
|
|
|
|
expires <= info->expires_max) ^
|
|
|
|
!(info->invert_flags & XT_CONNTRACK_EXPIRES))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-07-08 07:16:00 +02:00
|
|
|
static bool
|
2007-12-05 08:24:03 +01:00
|
|
|
conntrack_mt_check(const char *tablename, const void *ip,
|
|
|
|
const struct xt_match *match, void *matchinfo,
|
|
|
|
unsigned int hook_mask)
|
2006-03-22 22:56:08 +01:00
|
|
|
{
|
|
|
|
if (nf_ct_l3proto_try_module_get(match->family) < 0) {
|
2006-12-12 09:28:40 +01:00
|
|
|
printk(KERN_WARNING "can't load conntrack support for "
|
2007-12-18 07:43:15 +01:00
|
|
|
"proto=%u\n", match->family);
|
2007-07-08 07:16:00 +02:00
|
|
|
return false;
|
2006-03-22 22:56:08 +01:00
|
|
|
}
|
2007-07-08 07:16:00 +02:00
|
|
|
return true;
|
2006-03-22 22:56:08 +01:00
|
|
|
}
|
|
|
|
|
2007-12-05 08:24:03 +01:00
|
|
|
static void
|
|
|
|
conntrack_mt_destroy(const struct xt_match *match, void *matchinfo)
|
2006-03-22 22:56:08 +01:00
|
|
|
{
|
|
|
|
nf_ct_l3proto_module_put(match->family);
|
|
|
|
}
|
|
|
|
|
2007-05-10 23:17:58 +02:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
struct compat_xt_conntrack_info
|
|
|
|
{
|
|
|
|
compat_uint_t statemask;
|
|
|
|
compat_uint_t statusmask;
|
|
|
|
struct ip_conntrack_old_tuple tuple[IP_CT_DIR_MAX];
|
|
|
|
struct in_addr sipmsk[IP_CT_DIR_MAX];
|
|
|
|
struct in_addr dipmsk[IP_CT_DIR_MAX];
|
|
|
|
compat_ulong_t expires_min;
|
|
|
|
compat_ulong_t expires_max;
|
|
|
|
u_int8_t flags;
|
|
|
|
u_int8_t invflags;
|
|
|
|
};
|
|
|
|
|
2008-01-15 08:40:53 +01:00
|
|
|
static void conntrack_mt_compat_from_user_v0(void *dst, void *src)
|
2007-05-10 23:17:58 +02:00
|
|
|
{
|
2007-07-08 07:16:55 +02:00
|
|
|
const struct compat_xt_conntrack_info *cm = src;
|
2007-05-10 23:17:58 +02:00
|
|
|
struct xt_conntrack_info m = {
|
|
|
|
.statemask = cm->statemask,
|
|
|
|
.statusmask = cm->statusmask,
|
|
|
|
.expires_min = cm->expires_min,
|
|
|
|
.expires_max = cm->expires_max,
|
|
|
|
.flags = cm->flags,
|
|
|
|
.invflags = cm->invflags,
|
|
|
|
};
|
|
|
|
memcpy(m.tuple, cm->tuple, sizeof(m.tuple));
|
|
|
|
memcpy(m.sipmsk, cm->sipmsk, sizeof(m.sipmsk));
|
|
|
|
memcpy(m.dipmsk, cm->dipmsk, sizeof(m.dipmsk));
|
|
|
|
memcpy(dst, &m, sizeof(m));
|
|
|
|
}
|
|
|
|
|
2008-01-15 08:40:53 +01:00
|
|
|
static int conntrack_mt_compat_to_user_v0(void __user *dst, void *src)
|
2007-05-10 23:17:58 +02:00
|
|
|
{
|
2007-07-08 07:16:55 +02:00
|
|
|
const struct xt_conntrack_info *m = src;
|
2007-05-10 23:17:58 +02:00
|
|
|
struct compat_xt_conntrack_info cm = {
|
|
|
|
.statemask = m->statemask,
|
|
|
|
.statusmask = m->statusmask,
|
|
|
|
.expires_min = m->expires_min,
|
|
|
|
.expires_max = m->expires_max,
|
|
|
|
.flags = m->flags,
|
|
|
|
.invflags = m->invflags,
|
|
|
|
};
|
|
|
|
memcpy(cm.tuple, m->tuple, sizeof(cm.tuple));
|
|
|
|
memcpy(cm.sipmsk, m->sipmsk, sizeof(cm.sipmsk));
|
|
|
|
memcpy(cm.dipmsk, m->dipmsk, sizeof(cm.dipmsk));
|
|
|
|
return copy_to_user(dst, &cm, sizeof(cm)) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-01-15 08:40:53 +01:00
|
|
|
static struct xt_match conntrack_mt_reg[] __read_mostly = {
|
|
|
|
{
|
|
|
|
.name = "conntrack",
|
|
|
|
.revision = 0,
|
|
|
|
.family = AF_INET,
|
|
|
|
.match = conntrack_mt_v0,
|
|
|
|
.checkentry = conntrack_mt_check,
|
|
|
|
.destroy = conntrack_mt_destroy,
|
|
|
|
.matchsize = sizeof(struct xt_conntrack_info),
|
|
|
|
.me = THIS_MODULE,
|
2007-05-10 23:17:58 +02:00
|
|
|
#ifdef CONFIG_COMPAT
|
2008-01-15 08:40:53 +01:00
|
|
|
.compatsize = sizeof(struct compat_xt_conntrack_info),
|
|
|
|
.compat_from_user = conntrack_mt_compat_from_user_v0,
|
|
|
|
.compat_to_user = conntrack_mt_compat_to_user_v0,
|
2007-05-10 23:17:58 +02:00
|
|
|
#endif
|
2008-01-15 08:40:53 +01:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "conntrack",
|
|
|
|
.revision = 1,
|
|
|
|
.family = AF_INET,
|
|
|
|
.matchsize = sizeof(struct xt_conntrack_mtinfo1),
|
|
|
|
.match = conntrack_mt,
|
|
|
|
.checkentry = conntrack_mt_check,
|
|
|
|
.destroy = conntrack_mt_destroy,
|
|
|
|
.me = THIS_MODULE,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "conntrack",
|
|
|
|
.revision = 1,
|
|
|
|
.family = AF_INET6,
|
|
|
|
.matchsize = sizeof(struct xt_conntrack_mtinfo1),
|
|
|
|
.match = conntrack_mt,
|
|
|
|
.checkentry = conntrack_mt_check,
|
|
|
|
.destroy = conntrack_mt_destroy,
|
|
|
|
.me = THIS_MODULE,
|
|
|
|
},
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2007-12-05 08:24:03 +01:00
|
|
|
static int __init conntrack_mt_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-01-15 08:40:53 +01:00
|
|
|
return xt_register_matches(conntrack_mt_reg,
|
|
|
|
ARRAY_SIZE(conntrack_mt_reg));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-12-05 08:24:03 +01:00
|
|
|
static void __exit conntrack_mt_exit(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-01-15 08:40:53 +01:00
|
|
|
xt_unregister_matches(conntrack_mt_reg, ARRAY_SIZE(conntrack_mt_reg));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-12-05 08:24:03 +01:00
|
|
|
module_init(conntrack_mt_init);
|
|
|
|
module_exit(conntrack_mt_exit);
|