connection tracking support for bridge
Subsystems (5)
Pablo Neira Ayuso
maintainerv3 cover connection tracking support for bridge
Hi,
This patchset adds native connection tracking support for the bridge.
Patch #1 and #2 extract code from IPv4/IPv6 fragmentation core and introduce the fraglist splitter. That splits a skbuff fraglist into independent fragments.
Patch #3 and #4 also extract code from IPv4/IPv6 fragmentation core and introduce the skbuff into fragments transformer. This can be used by linearized skbuffs (eg. coming from nfqueue and ct helpers) as well as cloned skbuffs (that are either seen either with taps or with bridge port flooding).
Patch #5 moves the specific IPCB() code from these new fragment splitter/transformer APIs into the IPv4 stack. The bridge has a different control buffer layout and it starts using this new APIs in this patchset.
Patch #6 adds basic infrastructure that allows to register bridge conntrack support.
Patch #7 adds bridge conntrack support (only for IPv4 in this patch).
Patch #8 adds IPv6 support for the bridge conntrack support.
Patch #9 registers the IPv4/IPv6 conntrack hooks in case the bridge conntrack is used to deal with local traffic, ie. prerouting -> input bridge hook path. This cover the bridge interface has a IP address scenario.
Before this patchset, only chance for people to do stateful filtering is to use the br_netfilter emulation layer, that turns bridge frame into IPv4/IPv6 packets and inject them into the IPv4/IPv6 hooks. Apparently, this module allows users to use iptables and all of its feature-set from the bridge, including stateful filtering. However, this approach is flawed in many aspects that have been discussed many times. This is a step forward to deprecate `br_netfilter'.
v2: Fix English typo in commit message.
v3: Fix another English typo in commit message.
Please, apply. Thanks.
Pablo Neira Ayuso (9):
net: ipv4: add skbuff fraglist splitter
net: ipv6: add skbuff fraglist splitter
net: ipv4: split skbuff into fragments transformer
net: ipv6: split skbuff into fragments transformer
net: ipv4: place control buffer handling away from fragmentation iterators
netfilter: nf_conntrack: allow to register bridge support
netfilter: bridge: add connection tracking system
netfilter: nf_conntrack_bridge: add support for IPv6
netfilter: nf_conntrack_bridge: register inet conntrack for bridge
include/linux/netfilter_ipv6.h | 50 ++++ include/net/ip.h | 39 +++ include/net/ipv6.h | 44 +++ include/net/netfilter/nf_conntrack.h | 1 + include/net/netfilter/nf_conntrack_bridge.h | 20 ++ include/net/netfilter/nf_conntrack_core.h | 3 + net/bridge/br_device.c | 1 + net/bridge/br_private.h | 1 + net/bridge/netfilter/Kconfig | 14 + net/bridge/netfilter/Makefile | 3 + net/bridge/netfilter/nf_conntrack_bridge.c | 433 ++++++++++++++++++++++++++++ net/ipv4/ip_output.c | 309 ++++++++++++-------- net/ipv6/ip6_output.c | 315 +++++++++++--------- net/ipv6/netfilter.c | 123 ++++++++ net/netfilter/nf_conntrack_proto.c | 126 ++++++-- 15 files changed, 1206 insertions(+), 276 deletions(-) create mode 100644 include/net/netfilter/nf_conntrack_bridge.h create mode 100644 net/bridge/netfilter/nf_conntrack_bridge.c
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 1/9 net: ipv4: add skbuff fraglist splitter
This patch adds the skbuff fraglist splitter. This API provides an iterator to transform the fraglist into single skbuff objects, it consists of:
* ip_fraglist_init(), that initializes the internal state of the fraglist splitter.
* ip_fraglist_prepare(), that restores the IPv4 header on the fragments.
* ip_fraglist_next(), that retrieves the fragment from the fraglist and it updates the internal state of the splitter to point to the next fragment skbuff in the fraglist.
The ip_fraglist_iter object stores the internal state of the iterator.
This code has been extracted from ip_do_fragment(). Symbols are also exported to allow to reuse this iterator from the bridge codepath to build its own refragmentation routine by reusing the existing codebase.
--- include/net/ip.h | 23 ++++++++++++++ net/ipv4/ip_output.c | 88 ++++++++++++++++++++++++++++++++-------------------- 2 files changed, 78 insertions(+), 33 deletions(-)
include/net/ip.h +23 -0
@@ -165,6 +165,29 @@ int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb);int ip_mc_output (struct net *net,struct sock *sk,struct sk_buff *skb);int ip_do_fragment (struct net *net,struct sock *sk,struct sk_buff *skb,int (*output)(struct net *,struct sock *,struct sk_buff *)); + +struct ip_fraglist_iter { +struct sk_buff *frag_list; +struct sk_buff *frag; +struct iphdr *iph; +int offset; +unsigned int hlen; +}; + +void ip_fraglist_init (struct sk_buff *skb,struct iphdr *iph, +unsigned int hlen,struct ip_fraglist_iter *iter); +void ip_fraglist_prepare (struct sk_buff *skb,struct ip_fraglist_iter *iter); + +static inline struct sk_buff *ip_fraglist_next (struct ip_fraglist_iter *iter) +{ +struct sk_buff *skb = iter->frag; + + iter->frag = skb->next; +skb_mark_not_on_list (skb); + +return skb; +} +void ip_send_check (struct iphdr *ip);int __ip_local_out (struct net *net,struct sock *sk,struct sk_buff *skb);int ip_local_out (struct net *net,struct sock *sk,struct sk_buff *skb);
net/ipv4/ip_output.c +55 -33
123 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 2/9 net: ipv6: add skbuff fraglist splitter
In reply to Pablo Neira AyusoThis patch adds the skbuff fraglist split iterator. This API provides an iterator to transform the fraglist into single skbuff objects, it consists of:
* ip6_fraglist_init(), that initializes the internal state of the fraglist iterator.
* ip6_fraglist_prepare(), that restores the IPv6 header on the fragment.
* ip6_fraglist_next(), that retrieves the fragment from the fraglist and updates the internal state of the iterator to point to the next fragment in the fraglist.
The ip6_fraglist_iter object stores the internal state of the iterator.
This code has been extracted from ip6_fragment(). Symbols are also exported to allow to reuse this iterator from the bridge codepath to build its own refragmentation routine by reusing the existing codebase.
--- include/net/ipv6.h | 25 ++++++++++ net/ipv6/ip6_output.c | 132 +++++++++++++++++++++++++++++--------------------- 2 files changed, 102 insertions(+), 55 deletions(-)
include/net/ipv6.h +25 -0
@@ -154,6 +154,31 @@ struct frag_hdr {#define IP6_MF 0x0001#define IP6_OFFSET 0xFFF8 +struct ip6_fraglist_iter { +struct ipv6hdr *tmp_hdr; +struct sk_buff *frag_list; +struct sk_buff *frag; +int offset; +unsigned int hlen; +__be32 frag_id; +u8 nexthdr; +}; + +int ip6_fraglist_init (struct sk_buff *skb,unsigned int hlen,u8 *prevhdr, +u8 nexthdr,__be32 frag_id, +struct ip6_fraglist_iter *iter); +void ip6_fraglist_prepare (struct sk_buff *skb,struct ip6_fraglist_iter *iter); + +static inline struct sk_buff *ip6_fraglist_next (struct ip6_fraglist_iter *iter) +{ +struct sk_buff *skb = iter->frag; + + iter->frag = skb->next; +skb_mark_not_on_list (skb); + +return skb; +} +#define IP6_REPLY_MARK (net, mark) \ ((net)->ipv6.sysctl.fwmark_reflect ? (mark) : 0)
net/ipv6/ip6_output.c +77 -55
177 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 3/9 net: ipv4: split skbuff into fragments transformer
In reply to Pablo Neira AyusoThis patch exposes a new API to refragment a skbuff. This allows you to split either a linear skbuff or to force the refragmentation of an existing fraglist using a different mtu. The API consists of:
* ip_frag_init(), that initializes the internal state of the transformer.
* ip_frag_next(), that allows you to fetch the next fragment. This function internally allocates the skbuff that represents the fragment, it pushes the IPv4 header, and it also copies the payload for each fragment.
The ip_frag_state object stores the internal state of the splitter.
This code has been extracted from ip_do_fragment(). Symbols are also exported to allow to reuse this iterator from the bridge codepath to build its own refragmentation routine by reusing the existing codebase.
--- include/net/ip.h | 16 +++++ net/ipv4/ip_output.c | 200 ++++++++++++++++++++++++++++----------------------- 2 files changed, 128 insertions(+), 88 deletions(-)
include/net/ip.h +16 -0
@@ -188,6 +188,22 @@ static inline struct sk_buff *ip_fraglist_next(struct ip_fraglist_iter *iter)return skb; } +struct ip_frag_state { +struct iphdr *iph; +unsigned int hlen; +unsigned int ll_rs; +unsigned int mtu; +unsigned int left; +int offset; +int ptr; +__be16 not_last_frag; +}; + +void ip_frag_init (struct sk_buff *skb,unsigned int hlen,unsigned int ll_rs, +unsigned int mtu,struct ip_frag_state *state); +struct sk_buff *ip_frag_next (struct sk_buff *skb, +struct ip_frag_state *state); +void ip_send_check (struct iphdr *ip);int __ip_local_out (struct net *net,struct sock *sk,struct sk_buff *skb);int ip_local_out (struct net *net,struct sock *sk,struct sk_buff *skb);
net/ipv4/ip_output.c +112 -88
236 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 4/9 net: ipv6: split skbuff into fragments transformer
In reply to Pablo Neira AyusoThis patch exposes a new API to refragment a skbuff. This allows you to split either a linear skbuff or to force the refragmentation of an existing fraglist using a different mtu. The API consists of:
* ip6_frag_init(), that initializes the internal state of the transformer.
* ip6_frag_next(), that allows you to fetch the next fragment. This function internally allocates the skbuff that represents the fragment, it pushes the IPv6 header, and it also copies the payload for each fragment.
The ip6_frag_state object stores the internal state of the splitter.
This code has been extracted from ip6_fragment(). Symbols are also exported to allow to reuse this iterator from the bridge codepath to build its own refragmentation routine by reusing the existing codebase.
--- include/net/ipv6.h | 19 ++++++ net/ipv6/ip6_output.c | 183 +++++++++++++++++++++++++++++--------------------- 2 files changed, 126 insertions(+), 76 deletions(-)
include/net/ipv6.h +19 -0
@@ -179,6 +179,25 @@ static inline struct sk_buff *ip6_fraglist_next(struct ip6_fraglist_iter *iter)return skb; } +struct ip6_frag_state { +u8 *prevhdr; +unsigned int hlen; +unsigned int mtu; +unsigned int left; +int offset; +int ptr; +int hroom; +int troom; +__be32 frag_id; +u8 nexthdr; +}; + +void ip6_frag_init (struct sk_buff *skb,unsigned int hlen,unsigned int mtu, +unsigned short needed_tailroom,int hdr_room,u8 *prevhdr, +u8 nexthdr,__be32 frag_id,struct ip6_frag_state *state); +struct sk_buff *ip6_frag_next (struct sk_buff *skb, +struct ip6_frag_state *state); +#define IP6_REPLY_MARK (net, mark) \ ((net)->ipv6.sysctl.fwmark_reflect ? (mark) : 0)
net/ipv6/ip6_output.c +107 -76
215 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 5/9 net: ipv4: place control buffer handling away from fragmentation iterators
In reply to Pablo Neira AyusoDeal with the IPCB() area away from the iterators.
The bridge codebase has its own control buffer layout, move specific IP control buffer handling into the IPv4 codepath.
--- net/ipv4/ip_output.c | 55 +++++++++++++++++++++++++++++++++++----------------- 1 file changed, 37 insertions(+), 18 deletions(-)
net/ipv4/ip_output.c +37 -18
@@ -525,9 +525,6 @@ static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)skb_copy_hash (to, from); -/* Copy the flags to each fragment. */ -IPCB (to)->flags =IPCB (from)->flags; -#ifdef CONFIG_NET_SCHED to->tc_index = from->tc_index;#endif
@@ -582,6 +579,18 @@ void ip_fraglist_init(struct sk_buff *skb, struct iphdr *iph, }EXPORT_SYMBOL (ip_fraglist_init); +static void ip_fraglist_ipcb_prepare (struct sk_buff *skb, +struct ip_fraglist_iter *iter) +{ +struct sk_buff *to = iter->frag; + +/* Copy the flags to each fragment. */ +IPCB (to)->flags =IPCB (skb)->flags; + +if (iter->offset ==0 ) +ip_options_fragment (to); +} +void ip_fraglist_prepare (struct sk_buff *skb,struct ip_fraglist_iter *iter) {unsigned int hlen = iter->hlen;
@@ -598,8 +607,6 @@ void ip_fraglist_prepare(struct sk_buff *skb, struct ip_fraglist_iter *iter) iph = iter->iph; iph->tot_len =htons (frag->len);ip_copy_metadata (frag, skb); -if (iter->offset ==0 ) -ip_options_fragment (frag); iter->offset += skb->len - hlen; iph->frag_off =htons (iter->offset >>3 );if (frag->next)
@@ -627,6 +634,25 @@ void ip_frag_init(struct sk_buff *skb, unsigned int hlen, }EXPORT_SYMBOL (ip_frag_init); +static void ip_frag_ipcb (struct sk_buff *from,struct sk_buff *to, +bool first_frag,struct ip_frag_state *state) +{ +/* Copy the flags to each fragment. */ +IPCB (to)->flags =IPCB (from)->flags; + +if (IPCB (from)->flags &IPSKB_FRAG_PMTU ) + state->iph->frag_off |=htons (IP_DF ); + +/* ANK: dirty, but effective trick. Upgrade options only if +* the segment to be fragmented was THE FIRST (otherwise, +* options are already fixed) and make it ONCE +* on the initial skb, so that all the following fragments +* will inherit fixed options. +*/ +if (first_frag) +ip_options_fragment (from); +} +struct sk_buff *ip_frag_next (struct sk_buff *skb,struct ip_frag_state *state) {unsigned int len = state->left;
@@ -685,18 +711,6 @@ struct sk_buff *ip_frag_next(struct sk_buff *skb, struct ip_frag_state *state) iph =ip_hdr (skb2); iph->frag_off =htons ((state->offset >>3 )); -if (IPCB (skb)->flags &IPSKB_FRAG_PMTU ) - iph->frag_off |=htons (IP_DF ); - -/* ANK: dirty, but effective trick. Upgrade options only if -* the segment to be fragmented was THE FIRST (otherwise, -* options are already fixed) and make it ONCE -* on the initial skb, so that all the following fragments -* will inherit fixed options. -*/ -if (state->offset ==0 ) -ip_options_fragment (skb); -/* * Added AC : If we are fragmenting a fragment that's not the * last fragment then keep MF on each bit
@@ -799,8 +813,10 @@ int ip_do_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,for (;;) {/* Prepare header of the next frame, * before previous one went down. */ -if (iter.frag) +if (iter.frag) { +ip_fraglist_ipcb_prepare (skb, &iter);ip_fraglist_prepare (skb, &iter); + } err =output (net, sk, skb);
@@ -844,11 +860,14 @@ int ip_do_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,*/ while (state.left >0 ) { +bool first_frag = (state.offset ==0 ); + skb2 =ip_frag_next (skb, &state);if (IS_ERR (skb2)) { err =PTR_ERR (skb2); goto fail; } +ip_frag_ipcb (skb, skb2, first_frag, &state);/* * Put this fragment into the sending queue.
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 6/9 netfilter: nf_conntrack: allow to register bridge support
In reply to Pablo Neira AyusoThis patch adds infrastructure to register and to unregister bridge support for the conntrack module via nf_ct_bridge_register() and nf_ct_bridge_unregister().
--- include/net/netfilter/nf_conntrack.h | 1 + include/net/netfilter/nf_conntrack_bridge.h | 13 ++++++ net/netfilter/nf_conntrack_proto.c | 61 +++++++++++++++++++++++++++-- 3 files changed, 72 insertions(+), 3 deletions(-) create mode 100644 include/net/netfilter/nf_conntrack_bridge.h
include/net/netfilter/nf_conntrack.h +1 -0
@@ -49,6 +49,7 @@ union nf_conntrack_expect_proto {struct nf_conntrack_net {unsigned int users4;unsigned int users6; +unsigned int users_bridge; };#include <linux/types.h>
include/net/netfilter/nf_conntrack_bridge.h new file +13 -0
@@ -0,0 +1,13 @@ +#ifndef NF_CONNTRACK_BRIDGE_ +#define NF_CONNTRACK_BRIDGE_ + +struct nf_ct_bridge_info { +struct nf_hook_ops *ops; +unsigned int ops_size; +struct module *me; +}; + +void nf_ct_bridge_register (struct nf_ct_bridge_info *info); +void nf_ct_bridge_unregister (struct nf_ct_bridge_info *info); + +#endif
net/netfilter/nf_conntrack_proto.c +58 -3
96 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 7/9 netfilter: bridge: add connection tracking system
In reply to Pablo Neira AyusoThis patch adds basic connection tracking support for the bridge, including initial IPv4 support.
This patch register two hooks to deal with the bridge forwarding path, one from the bridge prerouting hook to call nf_conntrack_in(); and another from the bridge postrouting hook to confirm the entry.
The conntrack bridge prerouting hook defragments packets before passing them to nf_conntrack_in() to look up for an existing entry, otherwise a new entry is allocated and it is attached to the skbuff. The conntrack bridge postrouting hook confirms new conntrack entries, ie. if this is the first packet seen, then it adds the entry to the hashtable and (if needed) it refragments the skbuff into the original fragments, leaving the geometry as is if possible. Exceptions are linearized skbuffs, eg. skbuffs that are passed up to nfqueue and conntrack helpers, as well as cloned skbuff for the local delivery (eg. tcpdump), also in case of bridge port flooding (cloned skbuff too).
The packet defragmentation is done through the ip_defrag() call. This forces us to save the bridge control buffer, reset the IP control buffer area and then restore it after call. This function also bumps the IP fragmentation statistics, it would be probably desiderable to have independent statistics for the bridge defragmentation/refragmentation. The maximum fragment length is stored in the control buffer and it is used to refragment the skbuff from the postrouting path.
The new fraglist splitter and fragment transformer APIs are used to implement the bridge refragmentation code. The br_ip_fragment() function drops the packet in case the maximum fragment size seen is larger than the output port MTU.
This patchset follows the principle that conntrack should not drop packets, so users can do it through policy via invalid state matching.
Like br_netfilter, there is no refragmentation for packets that are passed up for local delivery, ie. prerouting -> input path. There are calls to nf_reset() already in several spots in the stack since time ago already, eg. af_packet, that show that skbuff fraglist handling from the netif_rx path is supported already.
The helpers are called from the postrouting hook, before confirmation, from there we may see packet floods to bridge ports. Then, although unlikely, this may result in exercising the helpers many times for each clone. It would be good to explore how to pass all the packets in a list to the conntrack hook to do this handle only once for this case.
Thanks to Florian Westphal for handing me over an initial patchset version to add support for conntrack bridge.
--- include/net/netfilter/nf_conntrack_bridge.h | 7 + include/net/netfilter/nf_conntrack_core.h | 3 + net/bridge/br_device.c | 1 + net/bridge/br_private.h | 1 + net/bridge/netfilter/Kconfig | 14 ++ net/bridge/netfilter/Makefile | 3 + net/bridge/netfilter/nf_conntrack_bridge.c | 378 ++++++++++++++++++++++++++++ net/netfilter/nf_conntrack_proto.c | 7 +- 8 files changed, 410 insertions(+), 4 deletions(-) create mode 100644 net/bridge/netfilter/nf_conntrack_bridge.c
include/net/netfilter/nf_conntrack_bridge.h +7 -0
@@ -10,4 +10,11 @@ struct nf_ct_bridge_info {void nf_ct_bridge_register (struct nf_ct_bridge_info *info);void nf_ct_bridge_unregister (struct nf_ct_bridge_info *info); +struct nf_ct_bridge_frag_data { +char mac[ETH_HLEN ]; +bool vlan_present; +u16 vlan_tci; +__be16 vlan_proto; +}; +#endif
include/net/netfilter/nf_conntrack_core.h +3 -0
@@ -64,6 +64,9 @@ static inline int nf_conntrack_confirm(struct sk_buff *skb)return ret; } +unsigned int nf_confirm (struct sk_buff *skb,unsigned int protoff, +struct nf_conn *ct,enum ip_conntrack_info ctinfo); +void print_tuple (struct seq_file *s,const struct nf_conntrack_tuple *tuple,const struct nf_conntrack_l4proto *proto);
net/bridge/br_device.c +1 -0
@@ -56,6 +56,7 @@ netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)br_switchdev_frame_unmark (skb);BR_INPUT_SKB_CB (skb)->brdev = dev; +BR_INPUT_SKB_CB (skb)->frag_max_size =0 ;skb_reset_mac_header (skb); eth =eth_hdr (skb);
net/bridge/br_private.h +1 -0
@@ -425,6 +425,7 @@ struct net_bridge {struct br_input_skb_cb {struct net_device *brdev; +u16 frag_max_size;#ifdef CONFIG_BRIDGE_IGMP_SNOOPING u8 igmp;u8 mrouters_only:1 ;
net/bridge/netfilter/Kconfig +14 -0
@@ -19,6 +19,20 @@ config NF_LOG_BRIDGE tristate "Bridge packet logging" select NF_LOG_COMMON +config NF_CONNTRACK_BRIDGE + tristate "IPv4/IPV6 bridge connection tracking support" + depends on NF_CONNTRACK + default n + help + Connection tracking keeps a record of what packets have passed + through your machine, in order to figure out how they are related + into connections. This is used to enhance packet filtering via + stateful policies. Enable this if you want native tracking from + the bridge. This provides a replacement for the `br_netfilter' + infrastructure. + + To compile it as a module, choose M here. If unsure, say N. + endif # NF_TABLES_BRIDGE menuconfig BRIDGE_NF_EBTABLES
net/bridge/netfilter/Makefile +3 -0
@@ -5,6 +5,9 @@ obj-$(CONFIG_NFT_BRIDGE_REJECT) += nft_reject_bridge.o +# connection tracking +obj-$(CONFIG_NF_CONNTRACK_BRIDGE) += nf_conntrack_bridge.o + # packet logging obj-$(CONFIG_NF_LOG_BRIDGE) += nf_log_bridge.o
net/bridge/netfilter/nf_conntrack_bridge.c new file +378 -0
378 lines not on this page · raw message
net/netfilter/nf_conntrack_proto.c +3 -4
@@ -121,10 +121,8 @@ const struct nf_conntrack_l4proto *nf_ct_l4proto_find(u8 l4proto) };EXPORT_SYMBOL_GPL (nf_ct_l4proto_find); -static unsigned int nf_confirm (struct sk_buff *skb, -unsigned int protoff, -struct nf_conn *ct, -enum ip_conntrack_info ctinfo) +unsigned int nf_confirm (struct sk_buff *skb,unsigned int protoff, +struct nf_conn *ct,enum ip_conntrack_info ctinfo) {const struct nf_conn_help *help;
@@ -155,6 +153,7 @@ static unsigned int nf_confirm(struct sk_buff *skb,/* We've seen it coming out the other side: confirm it */ return nf_conntrack_confirm (skb); } +EXPORT_SYMBOL_GPL (nf_confirm); static unsigned int ipv4_confirm(void *priv, struct sk_buff *skb,
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 8/9 netfilter: nf_conntrack_bridge: add support for IPv6
In reply to Pablo Neira Ayusobr_defrag() and br_fragment() indirections are added in case that IPv6 support comes as a module, to avoid pulling innecessary dependencies in.
The new fraglist iterator and fragment transformer APIs are used to implement the refragmentation code.
--- include/linux/netfilter_ipv6.h | 50 ++++++++++++ net/bridge/netfilter/nf_conntrack_bridge.c | 59 +++++++++++++- net/ipv6/netfilter.c | 123 +++++++++++++++++++++++++++++ 3 files changed, 230 insertions(+), 2 deletions(-)
include/linux/netfilter_ipv6.h +50 -0
@@ -19,6 +19,7 @@ struct ip6_rt_info { };struct nf_queue_entry ; +struct nf_ct_bridge_frag_data ;/* * Hook functions for ipv6 to allow xt_* modules to be built-in even
@@ -39,6 +40,15 @@ struct nf_ipv6_ops {int (*fragment)(struct net *net,struct sock *sk,struct sk_buff *skb,int (*output)(struct net *,struct sock *,struct sk_buff *));int (*reroute)(struct sk_buff *skb,const struct nf_queue_entry *entry); +#if IS_MODULE (CONFIG_IPV6 ) +int (*br_defrag)(struct net *net,struct sk_buff *skb,u32 user); +int (*br_fragment)(struct net *net,struct sock *sk, +struct sk_buff *skb, +struct nf_ct_bridge_frag_data *data, +int (*output)(struct net *,struct sock *sk, +const struct nf_ct_bridge_frag_data *data, +struct sk_buff *)); +#endif };#ifdef CONFIG_NETFILTER
@@ -86,6 +96,46 @@ static inline int nf_ip6_route(struct net *net, struct dst_entry **dst,#endif } +static inline int nf_ipv6_br_defrag (struct net *net,struct sk_buff *skb, +u32 user) +{ +#if IS_MODULE (CONFIG_IPV6 ) +const struct nf_ipv6_ops *v6_ops =nf_get_ipv6_ops (); + +if (!v6_ops) +return 1 ; + +return v6_ops->br_defrag (net, skb, user); +#else +return nf_ct_frag6_gather (net, skb, user); +#endif +} + +int br_ip6_fragment (struct net *net,struct sock *sk,struct sk_buff *skb, +struct nf_ct_bridge_frag_data *data, +int (*output)(struct net *,struct sock *sk, +const struct nf_ct_bridge_frag_data *data, +struct sk_buff *)); + +static inline int nf_br_ip6_fragment (struct net *net,struct sock *sk, +struct sk_buff *skb, +struct nf_ct_bridge_frag_data *data, +int (*output)(struct net *,struct sock *sk, +const struct nf_ct_bridge_frag_data *data, +struct sk_buff *)) +{ +#if IS_MODULE (CONFIG_IPV6 ) +const struct nf_ipv6_ops *v6_ops =nf_get_ipv6_ops (); + +if (!v6_ops) +return 1 ; + +return v6_ops->br_fragment (net, sk, skb, data, output); +#else +return br_ip6_fragment (net, sk, skb, data, output); +#endif +} +int ip6_route_me_harder (struct net *net,struct sk_buff *skb);static inline int nf_ip6_route_me_harder (struct net *net,struct sk_buff *skb)
net/bridge/netfilter/nf_conntrack_bridge.c +57 -2
83 lines not on this page · raw message
net/ipv6/netfilter.c +123 -0
141 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 9/9 netfilter: nf_conntrack_bridge: register inet conntrack for bridge
In reply to Pablo Neira AyusoThis patch enables IPv4 and IPv6 conntrack from the bridge to deal with local traffic. Hence, packets that are passed up to the local input path are confirmed later on from the {ipv4,ipv6}_confirm() hooks.
For packets leaving the IP stack (ie. output path), fragmentation occurs after the inet postrouting hook. Therefore, the bridge local out and postrouting bridge hooks see fragments with conntrack objects, which is inconsistent. In this case, we could defragment again from the bridge output hook, but this is expensive. The recommended filtering spot for outgoing locally generated traffic leaving through the bridge interface is to use the classic IPv4/IPv6 output hook, which comes earlier.
--- net/netfilter/nf_conntrack_proto.c | 58 +++++++++++++++++++++++++++----------- 1 file changed, 42 insertions(+), 16 deletions(-)
net/netfilter/nf_conntrack_proto.c +42 -16
@@ -560,38 +560,64 @@ static void nf_ct_netns_do_put(struct net *net, u8 nfproto)mutex_unlock (&nf_ct_proto_mutex); } -int nf_ct_netns_get (struct net *net,u8 nfproto) +static int nf_ct_netns_inet_get (struct net *net) {int err; -if (nfproto ==NFPROTO_INET ) { - err =nf_ct_netns_do_get (net,NFPROTO_IPV4 ); -if (err <0 ) - goto err1; - err =nf_ct_netns_do_get (net,NFPROTO_IPV6 ); -if (err <0 ) - goto err2; - }else { - err =nf_ct_netns_do_get (net, nfproto); -if (err <0 ) - goto err1; - } -return 0 ; + err =nf_ct_netns_do_get (net,NFPROTO_IPV4 ); +if (err <0 ) + goto err1; + err =nf_ct_netns_do_get (net,NFPROTO_IPV6 ); +if (err <0 ) + goto err2; +return err; err2:nf_ct_netns_put (net,NFPROTO_IPV4 ); err1:return err; } + +int nf_ct_netns_get (struct net *net,u8 nfproto) +{ +int err; + +switch (nfproto) { +case NFPROTO_INET : + err =nf_ct_netns_inet_get (net); +break ; +case NFPROTO_BRIDGE : + err =nf_ct_netns_do_get (net,NFPROTO_BRIDGE ); +if (err <0 ) +return err; + + err =nf_ct_netns_inet_get (net); +if (err <0 ) { +nf_ct_netns_put (net,NFPROTO_BRIDGE ); +return err; + } +break ; +default : + err =nf_ct_netns_do_get (net, nfproto); +break ; + } +return err; +}EXPORT_SYMBOL_GPL (nf_ct_netns_get);void nf_ct_netns_put (struct net *net,uint8_t nfproto) { -if (nfproto ==NFPROTO_INET ) { +switch (nfproto) { +case NFPROTO_BRIDGE : +nf_ct_netns_do_put (net,NFPROTO_BRIDGE ); +/* fall through */ +case NFPROTO_INET :nf_ct_netns_do_put (net,NFPROTO_IPV4 );nf_ct_netns_do_put (net,NFPROTO_IPV6 ); - }else { +break ; +default :nf_ct_netns_do_put (net, nfproto); +break ; } }EXPORT_SYMBOL_GPL (nf_ct_netns_put);
Signature · 1 line
2.11.0
David Miller
maintainerFrom: Pablo Neira Ayuso <[email protected]>
Date: Wed, 29 May 2019 13:25:30 +0200
Quoted 1 line
This patchset adds native connection tracking support for the bridge.
Series applied.