GNU Linux-libre 4.19.211-gnu1
[releases.git] / net / ipv4 / xfrm4_protocol.c
1 /* xfrm4_protocol.c - Generic xfrm protocol multiplexer.
2  *
3  * Copyright (C) 2013 secunet Security Networks AG
4  *
5  * Author:
6  * Steffen Klassert <steffen.klassert@secunet.com>
7  *
8  * Based on:
9  * net/ipv4/tunnel4.c
10  *
11  *      This program is free software; you can redistribute it and/or
12  *      modify it under the terms of the GNU General Public License
13  *      as published by the Free Software Foundation; either version
14  *      2 of the License, or (at your option) any later version.
15  */
16
17 #include <linux/init.h>
18 #include <linux/mutex.h>
19 #include <linux/skbuff.h>
20 #include <net/icmp.h>
21 #include <net/ip.h>
22 #include <net/protocol.h>
23 #include <net/xfrm.h>
24
25 static struct xfrm4_protocol __rcu *esp4_handlers __read_mostly;
26 static struct xfrm4_protocol __rcu *ah4_handlers __read_mostly;
27 static struct xfrm4_protocol __rcu *ipcomp4_handlers __read_mostly;
28 static DEFINE_MUTEX(xfrm4_protocol_mutex);
29
30 static inline struct xfrm4_protocol __rcu **proto_handlers(u8 protocol)
31 {
32         switch (protocol) {
33         case IPPROTO_ESP:
34                 return &esp4_handlers;
35         case IPPROTO_AH:
36                 return &ah4_handlers;
37         case IPPROTO_COMP:
38                 return &ipcomp4_handlers;
39         }
40
41         return NULL;
42 }
43
44 #define for_each_protocol_rcu(head, handler)            \
45         for (handler = rcu_dereference(head);           \
46              handler != NULL;                           \
47              handler = rcu_dereference(handler->next))  \
48
49 int xfrm4_rcv_cb(struct sk_buff *skb, u8 protocol, int err)
50 {
51         int ret;
52         struct xfrm4_protocol *handler;
53         struct xfrm4_protocol __rcu **head = proto_handlers(protocol);
54
55         if (!head)
56                 return 0;
57
58         for_each_protocol_rcu(*head, handler)
59                 if ((ret = handler->cb_handler(skb, err)) <= 0)
60                         return ret;
61
62         return 0;
63 }
64 EXPORT_SYMBOL(xfrm4_rcv_cb);
65
66 int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
67                     int encap_type)
68 {
69         int ret;
70         struct xfrm4_protocol *handler;
71         struct xfrm4_protocol __rcu **head = proto_handlers(nexthdr);
72
73         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
74         XFRM_SPI_SKB_CB(skb)->family = AF_INET;
75         XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr);
76
77         if (!head)
78                 goto out;
79
80         for_each_protocol_rcu(*head, handler)
81                 if ((ret = handler->input_handler(skb, nexthdr, spi, encap_type)) != -EINVAL)
82                         return ret;
83
84 out:
85         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
86
87         kfree_skb(skb);
88         return 0;
89 }
90 EXPORT_SYMBOL(xfrm4_rcv_encap);
91
92 static int xfrm4_esp_rcv(struct sk_buff *skb)
93 {
94         int ret;
95         struct xfrm4_protocol *handler;
96
97         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
98
99         for_each_protocol_rcu(esp4_handlers, handler)
100                 if ((ret = handler->handler(skb)) != -EINVAL)
101                         return ret;
102
103         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
104
105         kfree_skb(skb);
106         return 0;
107 }
108
109 static void xfrm4_esp_err(struct sk_buff *skb, u32 info)
110 {
111         struct xfrm4_protocol *handler;
112
113         for_each_protocol_rcu(esp4_handlers, handler)
114                 if (!handler->err_handler(skb, info))
115                         break;
116 }
117
118 static int xfrm4_ah_rcv(struct sk_buff *skb)
119 {
120         int ret;
121         struct xfrm4_protocol *handler;
122
123         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
124
125         for_each_protocol_rcu(ah4_handlers, handler)
126                 if ((ret = handler->handler(skb)) != -EINVAL)
127                         return ret;
128
129         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
130
131         kfree_skb(skb);
132         return 0;
133 }
134
135 static void xfrm4_ah_err(struct sk_buff *skb, u32 info)
136 {
137         struct xfrm4_protocol *handler;
138
139         for_each_protocol_rcu(ah4_handlers, handler)
140                 if (!handler->err_handler(skb, info))
141                         break;
142 }
143
144 static int xfrm4_ipcomp_rcv(struct sk_buff *skb)
145 {
146         int ret;
147         struct xfrm4_protocol *handler;
148
149         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
150
151         for_each_protocol_rcu(ipcomp4_handlers, handler)
152                 if ((ret = handler->handler(skb)) != -EINVAL)
153                         return ret;
154
155         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
156
157         kfree_skb(skb);
158         return 0;
159 }
160
161 static void xfrm4_ipcomp_err(struct sk_buff *skb, u32 info)
162 {
163         struct xfrm4_protocol *handler;
164
165         for_each_protocol_rcu(ipcomp4_handlers, handler)
166                 if (!handler->err_handler(skb, info))
167                         break;
168 }
169
170 static const struct net_protocol esp4_protocol = {
171         .handler        =       xfrm4_esp_rcv,
172         .err_handler    =       xfrm4_esp_err,
173         .no_policy      =       1,
174         .netns_ok       =       1,
175 };
176
177 static const struct net_protocol ah4_protocol = {
178         .handler        =       xfrm4_ah_rcv,
179         .err_handler    =       xfrm4_ah_err,
180         .no_policy      =       1,
181         .netns_ok       =       1,
182 };
183
184 static const struct net_protocol ipcomp4_protocol = {
185         .handler        =       xfrm4_ipcomp_rcv,
186         .err_handler    =       xfrm4_ipcomp_err,
187         .no_policy      =       1,
188         .netns_ok       =       1,
189 };
190
191 static const struct xfrm_input_afinfo xfrm4_input_afinfo = {
192         .family         =       AF_INET,
193         .callback       =       xfrm4_rcv_cb,
194 };
195
196 static inline const struct net_protocol *netproto(unsigned char protocol)
197 {
198         switch (protocol) {
199         case IPPROTO_ESP:
200                 return &esp4_protocol;
201         case IPPROTO_AH:
202                 return &ah4_protocol;
203         case IPPROTO_COMP:
204                 return &ipcomp4_protocol;
205         }
206
207         return NULL;
208 }
209
210 int xfrm4_protocol_register(struct xfrm4_protocol *handler,
211                             unsigned char protocol)
212 {
213         struct xfrm4_protocol __rcu **pprev;
214         struct xfrm4_protocol *t;
215         bool add_netproto = false;
216         int ret = -EEXIST;
217         int priority = handler->priority;
218
219         if (!proto_handlers(protocol) || !netproto(protocol))
220                 return -EINVAL;
221
222         mutex_lock(&xfrm4_protocol_mutex);
223
224         if (!rcu_dereference_protected(*proto_handlers(protocol),
225                                        lockdep_is_held(&xfrm4_protocol_mutex)))
226                 add_netproto = true;
227
228         for (pprev = proto_handlers(protocol);
229              (t = rcu_dereference_protected(*pprev,
230                         lockdep_is_held(&xfrm4_protocol_mutex))) != NULL;
231              pprev = &t->next) {
232                 if (t->priority < priority)
233                         break;
234                 if (t->priority == priority)
235                         goto err;
236         }
237
238         handler->next = *pprev;
239         rcu_assign_pointer(*pprev, handler);
240
241         ret = 0;
242
243 err:
244         mutex_unlock(&xfrm4_protocol_mutex);
245
246         if (add_netproto) {
247                 if (inet_add_protocol(netproto(protocol), protocol)) {
248                         pr_err("%s: can't add protocol\n", __func__);
249                         ret = -EAGAIN;
250                 }
251         }
252
253         return ret;
254 }
255 EXPORT_SYMBOL(xfrm4_protocol_register);
256
257 int xfrm4_protocol_deregister(struct xfrm4_protocol *handler,
258                               unsigned char protocol)
259 {
260         struct xfrm4_protocol __rcu **pprev;
261         struct xfrm4_protocol *t;
262         int ret = -ENOENT;
263
264         if (!proto_handlers(protocol) || !netproto(protocol))
265                 return -EINVAL;
266
267         mutex_lock(&xfrm4_protocol_mutex);
268
269         for (pprev = proto_handlers(protocol);
270              (t = rcu_dereference_protected(*pprev,
271                         lockdep_is_held(&xfrm4_protocol_mutex))) != NULL;
272              pprev = &t->next) {
273                 if (t == handler) {
274                         *pprev = handler->next;
275                         ret = 0;
276                         break;
277                 }
278         }
279
280         if (!rcu_dereference_protected(*proto_handlers(protocol),
281                                        lockdep_is_held(&xfrm4_protocol_mutex))) {
282                 if (inet_del_protocol(netproto(protocol), protocol) < 0) {
283                         pr_err("%s: can't remove protocol\n", __func__);
284                         ret = -EAGAIN;
285                 }
286         }
287
288         mutex_unlock(&xfrm4_protocol_mutex);
289
290         synchronize_net();
291
292         return ret;
293 }
294 EXPORT_SYMBOL(xfrm4_protocol_deregister);
295
296 void __init xfrm4_protocol_init(void)
297 {
298         xfrm_input_register_afinfo(&xfrm4_input_afinfo);
299 }
300 EXPORT_SYMBOL(xfrm4_protocol_init);