Merge tag 'drm-misc-next-fixes-2020-12-22' of git://anongit.freedesktop.org/drm/drm...
[linux-2.6-microblaze.git] / net / ipv4 / xfrm4_policy.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * xfrm4_policy.c
4  *
5  * Changes:
6  *      Kazunori MIYAZAWA @USAGI
7  *      YOSHIFUJI Hideaki @USAGI
8  *              Split up af-specific portion
9  *
10  */
11
12 #include <linux/err.h>
13 #include <linux/kernel.h>
14 #include <linux/inetdevice.h>
15 #include <net/dst.h>
16 #include <net/xfrm.h>
17 #include <net/ip.h>
18 #include <net/l3mdev.h>
19
20 static struct dst_entry *__xfrm4_dst_lookup(struct net *net, struct flowi4 *fl4,
21                                             int tos, int oif,
22                                             const xfrm_address_t *saddr,
23                                             const xfrm_address_t *daddr,
24                                             u32 mark)
25 {
26         struct rtable *rt;
27
28         memset(fl4, 0, sizeof(*fl4));
29         fl4->daddr = daddr->a4;
30         fl4->flowi4_tos = tos;
31         fl4->flowi4_oif = l3mdev_master_ifindex_by_index(net, oif);
32         fl4->flowi4_mark = mark;
33         if (saddr)
34                 fl4->saddr = saddr->a4;
35
36         fl4->flowi4_flags = FLOWI_FLAG_SKIP_NH_OIF;
37
38         rt = __ip_route_output_key(net, fl4);
39         if (!IS_ERR(rt))
40                 return &rt->dst;
41
42         return ERR_CAST(rt);
43 }
44
45 static struct dst_entry *xfrm4_dst_lookup(struct net *net, int tos, int oif,
46                                           const xfrm_address_t *saddr,
47                                           const xfrm_address_t *daddr,
48                                           u32 mark)
49 {
50         struct flowi4 fl4;
51
52         return __xfrm4_dst_lookup(net, &fl4, tos, oif, saddr, daddr, mark);
53 }
54
55 static int xfrm4_get_saddr(struct net *net, int oif,
56                            xfrm_address_t *saddr, xfrm_address_t *daddr,
57                            u32 mark)
58 {
59         struct dst_entry *dst;
60         struct flowi4 fl4;
61
62         dst = __xfrm4_dst_lookup(net, &fl4, 0, oif, NULL, daddr, mark);
63         if (IS_ERR(dst))
64                 return -EHOSTUNREACH;
65
66         saddr->a4 = fl4.saddr;
67         dst_release(dst);
68         return 0;
69 }
70
71 static int xfrm4_fill_dst(struct xfrm_dst *xdst, struct net_device *dev,
72                           const struct flowi *fl)
73 {
74         struct rtable *rt = (struct rtable *)xdst->route;
75         const struct flowi4 *fl4 = &fl->u.ip4;
76
77         xdst->u.rt.rt_iif = fl4->flowi4_iif;
78
79         xdst->u.dst.dev = dev;
80         dev_hold(dev);
81
82         /* Sheit... I remember I did this right. Apparently,
83          * it was magically lost, so this code needs audit */
84         xdst->u.rt.rt_is_input = rt->rt_is_input;
85         xdst->u.rt.rt_flags = rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST |
86                                               RTCF_LOCAL);
87         xdst->u.rt.rt_type = rt->rt_type;
88         xdst->u.rt.rt_uses_gateway = rt->rt_uses_gateway;
89         xdst->u.rt.rt_gw_family = rt->rt_gw_family;
90         if (rt->rt_gw_family == AF_INET)
91                 xdst->u.rt.rt_gw4 = rt->rt_gw4;
92         else if (rt->rt_gw_family == AF_INET6)
93                 xdst->u.rt.rt_gw6 = rt->rt_gw6;
94         xdst->u.rt.rt_pmtu = rt->rt_pmtu;
95         xdst->u.rt.rt_mtu_locked = rt->rt_mtu_locked;
96         INIT_LIST_HEAD(&xdst->u.rt.rt_uncached);
97         rt_add_uncached_list(&xdst->u.rt);
98
99         return 0;
100 }
101
102 static void xfrm4_update_pmtu(struct dst_entry *dst, struct sock *sk,
103                               struct sk_buff *skb, u32 mtu,
104                               bool confirm_neigh)
105 {
106         struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
107         struct dst_entry *path = xdst->route;
108
109         path->ops->update_pmtu(path, sk, skb, mtu, confirm_neigh);
110 }
111
112 static void xfrm4_redirect(struct dst_entry *dst, struct sock *sk,
113                            struct sk_buff *skb)
114 {
115         struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
116         struct dst_entry *path = xdst->route;
117
118         path->ops->redirect(path, sk, skb);
119 }
120
121 static void xfrm4_dst_destroy(struct dst_entry *dst)
122 {
123         struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
124
125         dst_destroy_metrics_generic(dst);
126         if (xdst->u.rt.rt_uncached_list)
127                 rt_del_uncached_list(&xdst->u.rt);
128         xfrm_dst_destroy(xdst);
129 }
130
131 static void xfrm4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
132                              int unregister)
133 {
134         if (!unregister)
135                 return;
136
137         xfrm_dst_ifdown(dst, dev);
138 }
139
140 static struct dst_ops xfrm4_dst_ops_template = {
141         .family =               AF_INET,
142         .update_pmtu =          xfrm4_update_pmtu,
143         .redirect =             xfrm4_redirect,
144         .cow_metrics =          dst_cow_metrics_generic,
145         .destroy =              xfrm4_dst_destroy,
146         .ifdown =               xfrm4_dst_ifdown,
147         .local_out =            __ip_local_out,
148         .gc_thresh =            32768,
149 };
150
151 static const struct xfrm_policy_afinfo xfrm4_policy_afinfo = {
152         .dst_ops =              &xfrm4_dst_ops_template,
153         .dst_lookup =           xfrm4_dst_lookup,
154         .get_saddr =            xfrm4_get_saddr,
155         .fill_dst =             xfrm4_fill_dst,
156         .blackhole_route =      ipv4_blackhole_route,
157 };
158
159 #ifdef CONFIG_SYSCTL
160 static struct ctl_table xfrm4_policy_table[] = {
161         {
162                 .procname       = "xfrm4_gc_thresh",
163                 .data           = &init_net.xfrm.xfrm4_dst_ops.gc_thresh,
164                 .maxlen         = sizeof(int),
165                 .mode           = 0644,
166                 .proc_handler   = proc_dointvec,
167         },
168         { }
169 };
170
171 static __net_init int xfrm4_net_sysctl_init(struct net *net)
172 {
173         struct ctl_table *table;
174         struct ctl_table_header *hdr;
175
176         table = xfrm4_policy_table;
177         if (!net_eq(net, &init_net)) {
178                 table = kmemdup(table, sizeof(xfrm4_policy_table), GFP_KERNEL);
179                 if (!table)
180                         goto err_alloc;
181
182                 table[0].data = &net->xfrm.xfrm4_dst_ops.gc_thresh;
183         }
184
185         hdr = register_net_sysctl(net, "net/ipv4", table);
186         if (!hdr)
187                 goto err_reg;
188
189         net->ipv4.xfrm4_hdr = hdr;
190         return 0;
191
192 err_reg:
193         if (!net_eq(net, &init_net))
194                 kfree(table);
195 err_alloc:
196         return -ENOMEM;
197 }
198
199 static __net_exit void xfrm4_net_sysctl_exit(struct net *net)
200 {
201         struct ctl_table *table;
202
203         if (!net->ipv4.xfrm4_hdr)
204                 return;
205
206         table = net->ipv4.xfrm4_hdr->ctl_table_arg;
207         unregister_net_sysctl_table(net->ipv4.xfrm4_hdr);
208         if (!net_eq(net, &init_net))
209                 kfree(table);
210 }
211 #else /* CONFIG_SYSCTL */
212 static inline int xfrm4_net_sysctl_init(struct net *net)
213 {
214         return 0;
215 }
216
217 static inline void xfrm4_net_sysctl_exit(struct net *net)
218 {
219 }
220 #endif
221
222 static int __net_init xfrm4_net_init(struct net *net)
223 {
224         int ret;
225
226         memcpy(&net->xfrm.xfrm4_dst_ops, &xfrm4_dst_ops_template,
227                sizeof(xfrm4_dst_ops_template));
228         ret = dst_entries_init(&net->xfrm.xfrm4_dst_ops);
229         if (ret)
230                 return ret;
231
232         ret = xfrm4_net_sysctl_init(net);
233         if (ret)
234                 dst_entries_destroy(&net->xfrm.xfrm4_dst_ops);
235
236         return ret;
237 }
238
239 static void __net_exit xfrm4_net_exit(struct net *net)
240 {
241         xfrm4_net_sysctl_exit(net);
242         dst_entries_destroy(&net->xfrm.xfrm4_dst_ops);
243 }
244
245 static struct pernet_operations __net_initdata xfrm4_net_ops = {
246         .init   = xfrm4_net_init,
247         .exit   = xfrm4_net_exit,
248 };
249
250 static void __init xfrm4_policy_init(void)
251 {
252         xfrm_policy_register_afinfo(&xfrm4_policy_afinfo, AF_INET);
253 }
254
255 void __init xfrm4_init(void)
256 {
257         xfrm4_state_init();
258         xfrm4_policy_init();
259         xfrm4_protocol_init();
260         register_pernet_subsys(&xfrm4_net_ops);
261 }