1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include <linux/types.h>
4 #include <linux/netfilter.h>
5 #include <linux/netfilter_ipv6.h>
6 #include <linux/netfilter_bridge.h>
7 #include <linux/module.h>
8 #include <linux/skbuff.h>
9 #include <linux/icmp.h>
10 #include <linux/sysctl.h>
11 #include <net/route.h>
14 #include <net/netfilter/nf_conntrack.h>
15 #include <net/netfilter/nf_conntrack_core.h>
16 #include <net/netfilter/nf_conntrack_helper.h>
17 #include <net/netfilter/nf_conntrack_bridge.h>
19 #include <linux/netfilter/nf_tables.h>
20 #include <net/netfilter/nf_tables.h>
22 #include "../br_private.h"
24 /* Best effort variant of ip_do_fragment which preserves geometry, unless skbuff
25 * has been linearized or cloned.
27 static int nf_br_ip_fragment(struct net *net, struct sock *sk,
29 struct nf_bridge_frag_data *data,
30 int (*output)(struct net *, struct sock *sk,
31 const struct nf_bridge_frag_data *data,
34 int frag_max_size = BR_INPUT_SKB_CB(skb)->frag_max_size;
35 unsigned int hlen, ll_rs, mtu;
36 ktime_t tstamp = skb->tstamp;
37 struct ip_frag_state state;
41 /* for offloaded checksums cleanup checksum before fragmentation */
42 if (skb->ip_summed == CHECKSUM_PARTIAL &&
43 (err = skb_checksum_help(skb)))
49 * Setup starting values
53 frag_max_size -= hlen;
54 ll_rs = LL_RESERVED_SPACE(skb->dev);
57 if (skb_has_frag_list(skb)) {
58 unsigned int first_len = skb_pagelen(skb);
59 struct ip_fraglist_iter iter;
62 if (first_len - hlen > mtu ||
63 skb_headroom(skb) < ll_rs)
69 skb_walk_frags(skb, frag) {
70 if (frag->len > mtu ||
71 skb_headroom(frag) < hlen + ll_rs)
78 ip_fraglist_init(skb, iph, hlen, &iter);
82 ip_fraglist_prepare(skb, &iter);
85 err = output(net, sk, data, skb);
86 if (err || !iter.frag)
89 skb = ip_fraglist_next(&iter);
95 kfree_skb_list(iter.frag);
100 /* This is a linearized skbuff, the original geometry is lost for us.
101 * This may also be a clone skbuff, we could preserve the geometry for
102 * the copies but probably not worth the effort.
104 ip_frag_init(skb, hlen, ll_rs, frag_max_size, false, &state);
106 while (state.left > 0) {
107 struct sk_buff *skb2;
109 skb2 = ip_frag_next(skb, &state);
115 skb2->tstamp = tstamp;
116 err = output(net, sk, data, skb2);
128 /* ip_defrag() expects IPCB() in place. */
129 static void br_skb_cb_save(struct sk_buff *skb, struct br_input_skb_cb *cb,
130 size_t inet_skb_parm_size)
132 memcpy(cb, skb->cb, sizeof(*cb));
133 memset(skb->cb, 0, inet_skb_parm_size);
136 static void br_skb_cb_restore(struct sk_buff *skb,
137 const struct br_input_skb_cb *cb,
140 memcpy(skb->cb, cb, sizeof(*cb));
141 BR_INPUT_SKB_CB(skb)->frag_max_size = fragsz;
144 static unsigned int nf_ct_br_defrag4(struct sk_buff *skb,
145 const struct nf_hook_state *state)
147 u16 zone_id = NF_CT_DEFAULT_ZONE_ID;
148 enum ip_conntrack_info ctinfo;
149 struct br_input_skb_cb cb;
150 const struct nf_conn *ct;
153 if (!ip_is_fragment(ip_hdr(skb)))
156 ct = nf_ct_get(skb, &ctinfo);
158 zone_id = nf_ct_zone_id(nf_ct_zone(ct), CTINFO2DIR(ctinfo));
160 br_skb_cb_save(skb, &cb, sizeof(struct inet_skb_parm));
162 err = ip_defrag(state->net, skb,
163 IP_DEFRAG_CONNTRACK_BRIDGE_IN + zone_id);
166 br_skb_cb_restore(skb, &cb, IPCB(skb)->frag_max_size);
174 static unsigned int nf_ct_br_defrag6(struct sk_buff *skb,
175 const struct nf_hook_state *state)
177 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
178 u16 zone_id = NF_CT_DEFAULT_ZONE_ID;
179 enum ip_conntrack_info ctinfo;
180 struct br_input_skb_cb cb;
181 const struct nf_conn *ct;
184 ct = nf_ct_get(skb, &ctinfo);
186 zone_id = nf_ct_zone_id(nf_ct_zone(ct), CTINFO2DIR(ctinfo));
188 br_skb_cb_save(skb, &cb, sizeof(struct inet6_skb_parm));
190 err = nf_ct_frag6_gather(state->net, skb,
191 IP_DEFRAG_CONNTRACK_BRIDGE_IN + zone_id);
193 if (err == -EINPROGRESS)
196 br_skb_cb_restore(skb, &cb, IP6CB(skb)->frag_max_size);
197 return err == 0 ? NF_ACCEPT : NF_DROP;
203 static int nf_ct_br_ip_check(const struct sk_buff *skb)
205 const struct iphdr *iph;
208 nhoff = skb_network_offset(skb);
214 len = ntohs(iph->tot_len);
215 if (skb->len < nhoff + len ||
216 len < (iph->ihl * 4))
222 static int nf_ct_br_ipv6_check(const struct sk_buff *skb)
224 const struct ipv6hdr *hdr;
227 nhoff = skb_network_offset(skb);
229 if (hdr->version != 6)
232 len = ntohs(hdr->payload_len) + sizeof(struct ipv6hdr) + nhoff;
239 static unsigned int nf_ct_bridge_pre(void *priv, struct sk_buff *skb,
240 const struct nf_hook_state *state)
242 struct nf_hook_state bridge_state = *state;
243 enum ip_conntrack_info ctinfo;
248 ct = nf_ct_get(skb, &ctinfo);
249 if ((ct && !nf_ct_is_template(ct)) ||
250 ctinfo == IP_CT_UNTRACKED)
253 switch (skb->protocol) {
254 case htons(ETH_P_IP):
255 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
258 len = ntohs(ip_hdr(skb)->tot_len);
259 if (pskb_trim_rcsum(skb, len))
262 if (nf_ct_br_ip_check(skb))
265 bridge_state.pf = NFPROTO_IPV4;
266 ret = nf_ct_br_defrag4(skb, &bridge_state);
268 case htons(ETH_P_IPV6):
269 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
272 len = sizeof(struct ipv6hdr) + ntohs(ipv6_hdr(skb)->payload_len);
273 if (pskb_trim_rcsum(skb, len))
276 if (nf_ct_br_ipv6_check(skb))
279 bridge_state.pf = NFPROTO_IPV6;
280 ret = nf_ct_br_defrag6(skb, &bridge_state);
283 nf_ct_set(skb, NULL, IP_CT_UNTRACKED);
287 if (ret != NF_ACCEPT)
290 return nf_conntrack_in(skb, &bridge_state);
293 static void nf_ct_bridge_frag_save(struct sk_buff *skb,
294 struct nf_bridge_frag_data *data)
296 if (skb_vlan_tag_present(skb)) {
297 data->vlan_present = true;
298 data->vlan_tci = skb->vlan_tci;
299 data->vlan_proto = skb->vlan_proto;
301 data->vlan_present = false;
303 skb_copy_from_linear_data_offset(skb, -ETH_HLEN, data->mac, ETH_HLEN);
307 nf_ct_bridge_refrag(struct sk_buff *skb, const struct nf_hook_state *state,
308 int (*output)(struct net *, struct sock *sk,
309 const struct nf_bridge_frag_data *data,
312 struct nf_bridge_frag_data data;
314 if (!BR_INPUT_SKB_CB(skb)->frag_max_size)
317 nf_ct_bridge_frag_save(skb, &data);
318 switch (skb->protocol) {
319 case htons(ETH_P_IP):
320 nf_br_ip_fragment(state->net, state->sk, skb, &data, output);
322 case htons(ETH_P_IPV6):
323 nf_br_ip6_fragment(state->net, state->sk, skb, &data, output);
333 /* Actually only slow path refragmentation needs this. */
334 static int nf_ct_bridge_frag_restore(struct sk_buff *skb,
335 const struct nf_bridge_frag_data *data)
339 err = skb_cow_head(skb, ETH_HLEN);
344 if (data->vlan_present)
345 __vlan_hwaccel_put_tag(skb, data->vlan_proto, data->vlan_tci);
346 else if (skb_vlan_tag_present(skb))
347 __vlan_hwaccel_clear_tag(skb);
349 skb_copy_to_linear_data_offset(skb, -ETH_HLEN, data->mac, ETH_HLEN);
350 skb_reset_mac_header(skb);
355 static int nf_ct_bridge_refrag_post(struct net *net, struct sock *sk,
356 const struct nf_bridge_frag_data *data,
361 err = nf_ct_bridge_frag_restore(skb, data);
365 return br_dev_queue_push_xmit(net, sk, skb);
368 static unsigned int nf_ct_bridge_confirm(struct sk_buff *skb)
370 enum ip_conntrack_info ctinfo;
374 ct = nf_ct_get(skb, &ctinfo);
375 if (!ct || ctinfo == IP_CT_RELATED_REPLY)
376 return nf_conntrack_confirm(skb);
378 switch (skb->protocol) {
379 case htons(ETH_P_IP):
380 protoff = skb_network_offset(skb) + ip_hdrlen(skb);
382 case htons(ETH_P_IPV6): {
383 unsigned char pnum = ipv6_hdr(skb)->nexthdr;
386 protoff = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &pnum,
388 if (protoff < 0 || (frag_off & htons(~0x7)) != 0)
389 return nf_conntrack_confirm(skb);
395 return nf_confirm(skb, protoff, ct, ctinfo);
398 static unsigned int nf_ct_bridge_post(void *priv, struct sk_buff *skb,
399 const struct nf_hook_state *state)
403 ret = nf_ct_bridge_confirm(skb);
404 if (ret != NF_ACCEPT)
407 return nf_ct_bridge_refrag(skb, state, nf_ct_bridge_refrag_post);
410 static struct nf_hook_ops nf_ct_bridge_hook_ops[] __read_mostly = {
412 .hook = nf_ct_bridge_pre,
413 .pf = NFPROTO_BRIDGE,
414 .hooknum = NF_BR_PRE_ROUTING,
415 .priority = NF_IP_PRI_CONNTRACK,
418 .hook = nf_ct_bridge_post,
419 .pf = NFPROTO_BRIDGE,
420 .hooknum = NF_BR_POST_ROUTING,
421 .priority = NF_IP_PRI_CONNTRACK_CONFIRM,
425 static struct nf_ct_bridge_info bridge_info = {
426 .ops = nf_ct_bridge_hook_ops,
427 .ops_size = ARRAY_SIZE(nf_ct_bridge_hook_ops),
431 static int __init nf_conntrack_l3proto_bridge_init(void)
433 nf_ct_bridge_register(&bridge_info);
438 static void __exit nf_conntrack_l3proto_bridge_fini(void)
440 nf_ct_bridge_unregister(&bridge_info);
443 module_init(nf_conntrack_l3proto_bridge_init);
444 module_exit(nf_conntrack_l3proto_bridge_fini);
446 MODULE_ALIAS("nf_conntrack-" __stringify(AF_BRIDGE));
447 MODULE_LICENSE("GPL");