5 * Kazunori MIYAZAWA @USAGI
6 * YOSHIFUJI Hideaki @USAGI
7 * Split up af-specific portion
11 #include <linux/err.h>
12 #include <linux/kernel.h>
13 #include <linux/inetdevice.h>
14 #include <linux/if_tunnel.h>
18 #include <net/l3mdev.h>
20 static struct dst_entry
*__xfrm4_dst_lookup(struct net
*net
, struct flowi4
*fl4
,
22 const xfrm_address_t
*saddr
,
23 const xfrm_address_t
*daddr
)
27 memset(fl4
, 0, sizeof(*fl4
));
28 fl4
->daddr
= daddr
->a4
;
29 fl4
->flowi4_tos
= tos
;
30 fl4
->flowi4_oif
= l3mdev_master_ifindex_by_index(net
, oif
);
32 fl4
->saddr
= saddr
->a4
;
34 fl4
->flowi4_flags
= FLOWI_FLAG_SKIP_NH_OIF
;
36 rt
= __ip_route_output_key(net
, fl4
);
43 static struct dst_entry
*xfrm4_dst_lookup(struct net
*net
, int tos
, int oif
,
44 const xfrm_address_t
*saddr
,
45 const xfrm_address_t
*daddr
)
49 return __xfrm4_dst_lookup(net
, &fl4
, tos
, oif
, saddr
, daddr
);
52 static int xfrm4_get_saddr(struct net
*net
, int oif
,
53 xfrm_address_t
*saddr
, xfrm_address_t
*daddr
)
55 struct dst_entry
*dst
;
58 dst
= __xfrm4_dst_lookup(net
, &fl4
, 0, oif
, NULL
, daddr
);
62 saddr
->a4
= fl4
.saddr
;
67 static int xfrm4_get_tos(const struct flowi
*fl
)
69 return IPTOS_RT_MASK
& fl
->u
.ip4
.flowi4_tos
; /* Strip ECN bits */
72 static int xfrm4_init_path(struct xfrm_dst
*path
, struct dst_entry
*dst
,
78 static int xfrm4_fill_dst(struct xfrm_dst
*xdst
, struct net_device
*dev
,
79 const struct flowi
*fl
)
81 struct rtable
*rt
= (struct rtable
*)xdst
->route
;
82 const struct flowi4
*fl4
= &fl
->u
.ip4
;
84 xdst
->u
.rt
.rt_iif
= fl4
->flowi4_iif
;
86 xdst
->u
.dst
.dev
= dev
;
89 /* Sheit... I remember I did this right. Apparently,
90 * it was magically lost, so this code needs audit */
91 xdst
->u
.rt
.rt_is_input
= rt
->rt_is_input
;
92 xdst
->u
.rt
.rt_flags
= rt
->rt_flags
& (RTCF_BROADCAST
| RTCF_MULTICAST
|
94 xdst
->u
.rt
.rt_type
= rt
->rt_type
;
95 xdst
->u
.rt
.rt_gateway
= rt
->rt_gateway
;
96 xdst
->u
.rt
.rt_uses_gateway
= rt
->rt_uses_gateway
;
97 xdst
->u
.rt
.rt_pmtu
= rt
->rt_pmtu
;
98 xdst
->u
.rt
.rt_table_id
= rt
->rt_table_id
;
99 INIT_LIST_HEAD(&xdst
->u
.rt
.rt_uncached
);
105 _decode_session4(struct sk_buff
*skb
, struct flowi
*fl
, int reverse
)
107 const struct iphdr
*iph
= ip_hdr(skb
);
108 u8
*xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
109 struct flowi4
*fl4
= &fl
->u
.ip4
;
113 oif
= skb_dst(skb
)->dev
->ifindex
;
115 memset(fl4
, 0, sizeof(struct flowi4
));
116 fl4
->flowi4_mark
= skb
->mark
;
117 fl4
->flowi4_oif
= reverse
? skb
->skb_iif
: oif
;
119 if (!ip_is_fragment(iph
)) {
120 switch (iph
->protocol
) {
122 case IPPROTO_UDPLITE
:
126 if (xprth
+ 4 < skb
->data
||
127 pskb_may_pull(skb
, xprth
+ 4 - skb
->data
)) {
130 xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
131 ports
= (__be16
*)xprth
;
133 fl4
->fl4_sport
= ports
[!!reverse
];
134 fl4
->fl4_dport
= ports
[!reverse
];
139 if (xprth
+ 2 < skb
->data
||
140 pskb_may_pull(skb
, xprth
+ 2 - skb
->data
)) {
143 xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
146 fl4
->fl4_icmp_type
= icmp
[0];
147 fl4
->fl4_icmp_code
= icmp
[1];
152 if (xprth
+ 4 < skb
->data
||
153 pskb_may_pull(skb
, xprth
+ 4 - skb
->data
)) {
156 xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
157 ehdr
= (__be32
*)xprth
;
159 fl4
->fl4_ipsec_spi
= ehdr
[0];
164 if (xprth
+ 8 < skb
->data
||
165 pskb_may_pull(skb
, xprth
+ 8 - skb
->data
)) {
168 xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
169 ah_hdr
= (__be32
*)xprth
;
171 fl4
->fl4_ipsec_spi
= ah_hdr
[1];
176 if (xprth
+ 4 < skb
->data
||
177 pskb_may_pull(skb
, xprth
+ 4 - skb
->data
)) {
180 xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
181 ipcomp_hdr
= (__be16
*)xprth
;
183 fl4
->fl4_ipsec_spi
= htonl(ntohs(ipcomp_hdr
[1]));
188 if (xprth
+ 12 < skb
->data
||
189 pskb_may_pull(skb
, xprth
+ 12 - skb
->data
)) {
193 xprth
= skb_network_header(skb
) + iph
->ihl
* 4;
194 greflags
= (__be16
*)xprth
;
195 gre_hdr
= (__be32
*)xprth
;
197 if (greflags
[0] & GRE_KEY
) {
198 if (greflags
[0] & GRE_CSUM
)
200 fl4
->fl4_gre_key
= gre_hdr
[1];
206 fl4
->fl4_ipsec_spi
= 0;
210 fl4
->flowi4_proto
= iph
->protocol
;
211 fl4
->daddr
= reverse
? iph
->saddr
: iph
->daddr
;
212 fl4
->saddr
= reverse
? iph
->daddr
: iph
->saddr
;
213 fl4
->flowi4_tos
= iph
->tos
;
216 static inline int xfrm4_garbage_collect(struct dst_ops
*ops
)
218 struct net
*net
= container_of(ops
, struct net
, xfrm
.xfrm4_dst_ops
);
220 xfrm_garbage_collect_deferred(net
);
221 return (dst_entries_get_slow(ops
) > ops
->gc_thresh
* 2);
224 static void xfrm4_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
225 struct sk_buff
*skb
, u32 mtu
)
227 struct xfrm_dst
*xdst
= (struct xfrm_dst
*)dst
;
228 struct dst_entry
*path
= xdst
->route
;
230 path
->ops
->update_pmtu(path
, sk
, skb
, mtu
);
233 static void xfrm4_redirect(struct dst_entry
*dst
, struct sock
*sk
,
236 struct xfrm_dst
*xdst
= (struct xfrm_dst
*)dst
;
237 struct dst_entry
*path
= xdst
->route
;
239 path
->ops
->redirect(path
, sk
, skb
);
242 static void xfrm4_dst_destroy(struct dst_entry
*dst
)
244 struct xfrm_dst
*xdst
= (struct xfrm_dst
*)dst
;
246 dst_destroy_metrics_generic(dst
);
248 xfrm_dst_destroy(xdst
);
251 static void xfrm4_dst_ifdown(struct dst_entry
*dst
, struct net_device
*dev
,
257 xfrm_dst_ifdown(dst
, dev
);
260 static struct dst_ops xfrm4_dst_ops_template
= {
262 .gc
= xfrm4_garbage_collect
,
263 .update_pmtu
= xfrm4_update_pmtu
,
264 .redirect
= xfrm4_redirect
,
265 .cow_metrics
= dst_cow_metrics_generic
,
266 .destroy
= xfrm4_dst_destroy
,
267 .ifdown
= xfrm4_dst_ifdown
,
268 .local_out
= __ip_local_out
,
269 .gc_thresh
= INT_MAX
,
272 static struct xfrm_policy_afinfo xfrm4_policy_afinfo
= {
273 .dst_ops
= &xfrm4_dst_ops_template
,
274 .dst_lookup
= xfrm4_dst_lookup
,
275 .get_saddr
= xfrm4_get_saddr
,
276 .decode_session
= _decode_session4
,
277 .get_tos
= xfrm4_get_tos
,
278 .init_path
= xfrm4_init_path
,
279 .fill_dst
= xfrm4_fill_dst
,
280 .blackhole_route
= ipv4_blackhole_route
,
284 static struct ctl_table xfrm4_policy_table
[] = {
286 .procname
= "xfrm4_gc_thresh",
287 .data
= &init_net
.xfrm
.xfrm4_dst_ops
.gc_thresh
,
288 .maxlen
= sizeof(int),
290 .proc_handler
= proc_dointvec
,
295 static __net_init
int xfrm4_net_sysctl_init(struct net
*net
)
297 struct ctl_table
*table
;
298 struct ctl_table_header
*hdr
;
300 table
= xfrm4_policy_table
;
301 if (!net_eq(net
, &init_net
)) {
302 table
= kmemdup(table
, sizeof(xfrm4_policy_table
), GFP_KERNEL
);
306 table
[0].data
= &net
->xfrm
.xfrm4_dst_ops
.gc_thresh
;
309 hdr
= register_net_sysctl(net
, "net/ipv4", table
);
313 net
->ipv4
.xfrm4_hdr
= hdr
;
317 if (!net_eq(net
, &init_net
))
323 static __net_exit
void xfrm4_net_sysctl_exit(struct net
*net
)
325 struct ctl_table
*table
;
327 if (!net
->ipv4
.xfrm4_hdr
)
330 table
= net
->ipv4
.xfrm4_hdr
->ctl_table_arg
;
331 unregister_net_sysctl_table(net
->ipv4
.xfrm4_hdr
);
332 if (!net_eq(net
, &init_net
))
335 #else /* CONFIG_SYSCTL */
336 static inline int xfrm4_net_sysctl_init(struct net
*net
)
341 static inline void xfrm4_net_sysctl_exit(struct net
*net
)
346 static int __net_init
xfrm4_net_init(struct net
*net
)
350 memcpy(&net
->xfrm
.xfrm4_dst_ops
, &xfrm4_dst_ops_template
,
351 sizeof(xfrm4_dst_ops_template
));
352 ret
= dst_entries_init(&net
->xfrm
.xfrm4_dst_ops
);
356 ret
= xfrm4_net_sysctl_init(net
);
358 dst_entries_destroy(&net
->xfrm
.xfrm4_dst_ops
);
363 static void __net_exit
xfrm4_net_exit(struct net
*net
)
365 xfrm4_net_sysctl_exit(net
);
366 dst_entries_destroy(&net
->xfrm
.xfrm4_dst_ops
);
369 static struct pernet_operations __net_initdata xfrm4_net_ops
= {
370 .init
= xfrm4_net_init
,
371 .exit
= xfrm4_net_exit
,
374 static void __init
xfrm4_policy_init(void)
376 xfrm_policy_register_afinfo(&xfrm4_policy_afinfo
, AF_INET
);
379 void __init
xfrm4_init(void)
383 xfrm4_protocol_init();
384 register_pernet_subsys(&xfrm4_net_ops
);