~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv6/xfrm6_protocol.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /* xfrm6_protocol.c - Generic xfrm protocol multiplexer for ipv6.
  3  *
  4  * Copyright (C) 2013 secunet Security Networks AG
  5  *
  6  * Author:
  7  * Steffen Klassert <steffen.klassert@secunet.com>
  8  *
  9  * Based on:
 10  * net/ipv4/xfrm4_protocol.c
 11  */
 12 
 13 #include <linux/init.h>
 14 #include <linux/mutex.h>
 15 #include <linux/skbuff.h>
 16 #include <linux/icmpv6.h>
 17 #include <net/ipv6.h>
 18 #include <net/protocol.h>
 19 #include <net/xfrm.h>
 20 
 21 static struct xfrm6_protocol __rcu *esp6_handlers __read_mostly;
 22 static struct xfrm6_protocol __rcu *ah6_handlers __read_mostly;
 23 static struct xfrm6_protocol __rcu *ipcomp6_handlers __read_mostly;
 24 static DEFINE_MUTEX(xfrm6_protocol_mutex);
 25 
 26 static inline struct xfrm6_protocol __rcu **proto_handlers(u8 protocol)
 27 {
 28         switch (protocol) {
 29         case IPPROTO_ESP:
 30                 return &esp6_handlers;
 31         case IPPROTO_AH:
 32                 return &ah6_handlers;
 33         case IPPROTO_COMP:
 34                 return &ipcomp6_handlers;
 35         }
 36 
 37         return NULL;
 38 }
 39 
 40 #define for_each_protocol_rcu(head, handler)            \
 41         for (handler = rcu_dereference(head);           \
 42              handler != NULL;                           \
 43              handler = rcu_dereference(handler->next))  \
 44 
 45 static int xfrm6_rcv_cb(struct sk_buff *skb, u8 protocol, int err)
 46 {
 47         int ret;
 48         struct xfrm6_protocol *handler;
 49         struct xfrm6_protocol __rcu **head = proto_handlers(protocol);
 50 
 51         if (!head)
 52                 return 0;
 53 
 54         for_each_protocol_rcu(*proto_handlers(protocol), handler)
 55                 if ((ret = handler->cb_handler(skb, err)) <= 0)
 56                         return ret;
 57 
 58         return 0;
 59 }
 60 
 61 static int xfrm6_esp_rcv(struct sk_buff *skb)
 62 {
 63         int ret;
 64         struct xfrm6_protocol *handler;
 65 
 66         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL;
 67 
 68         for_each_protocol_rcu(esp6_handlers, handler)
 69                 if ((ret = handler->handler(skb)) != -EINVAL)
 70                         return ret;
 71 
 72         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
 73 
 74         kfree_skb(skb);
 75         return 0;
 76 }
 77 
 78 static int xfrm6_esp_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 79                           u8 type, u8 code, int offset, __be32 info)
 80 {
 81         struct xfrm6_protocol *handler;
 82 
 83         for_each_protocol_rcu(esp6_handlers, handler)
 84                 if (!handler->err_handler(skb, opt, type, code, offset, info))
 85                         return 0;
 86 
 87         return -ENOENT;
 88 }
 89 
 90 static int xfrm6_ah_rcv(struct sk_buff *skb)
 91 {
 92         int ret;
 93         struct xfrm6_protocol *handler;
 94 
 95         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL;
 96 
 97         for_each_protocol_rcu(ah6_handlers, handler)
 98                 if ((ret = handler->handler(skb)) != -EINVAL)
 99                         return ret;
100 
101         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
102 
103         kfree_skb(skb);
104         return 0;
105 }
106 
107 static int xfrm6_ah_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
108                          u8 type, u8 code, int offset, __be32 info)
109 {
110         struct xfrm6_protocol *handler;
111 
112         for_each_protocol_rcu(ah6_handlers, handler)
113                 if (!handler->err_handler(skb, opt, type, code, offset, info))
114                         return 0;
115 
116         return -ENOENT;
117 }
118 
119 static int xfrm6_ipcomp_rcv(struct sk_buff *skb)
120 {
121         int ret;
122         struct xfrm6_protocol *handler;
123 
124         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL;
125 
126         for_each_protocol_rcu(ipcomp6_handlers, handler)
127                 if ((ret = handler->handler(skb)) != -EINVAL)
128                         return ret;
129 
130         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
131 
132         kfree_skb(skb);
133         return 0;
134 }
135 
136 static int xfrm6_ipcomp_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
137                              u8 type, u8 code, int offset, __be32 info)
138 {
139         struct xfrm6_protocol *handler;
140 
141         for_each_protocol_rcu(ipcomp6_handlers, handler)
142                 if (!handler->err_handler(skb, opt, type, code, offset, info))
143                         return 0;
144 
145         return -ENOENT;
146 }
147 
148 static const struct inet6_protocol esp6_protocol = {
149         .handler        =       xfrm6_esp_rcv,
150         .err_handler    =       xfrm6_esp_err,
151         .flags          =       INET6_PROTO_NOPOLICY,
152 };
153 
154 static const struct inet6_protocol ah6_protocol = {
155         .handler        =       xfrm6_ah_rcv,
156         .err_handler    =       xfrm6_ah_err,
157         .flags          =       INET6_PROTO_NOPOLICY,
158 };
159 
160 static const struct inet6_protocol ipcomp6_protocol = {
161         .handler        =       xfrm6_ipcomp_rcv,
162         .err_handler    =       xfrm6_ipcomp_err,
163         .flags          =       INET6_PROTO_NOPOLICY,
164 };
165 
166 static const struct xfrm_input_afinfo xfrm6_input_afinfo = {
167         .family         =       AF_INET6,
168         .callback       =       xfrm6_rcv_cb,
169 };
170 
171 static inline const struct inet6_protocol *netproto(unsigned char protocol)
172 {
173         switch (protocol) {
174         case IPPROTO_ESP:
175                 return &esp6_protocol;
176         case IPPROTO_AH:
177                 return &ah6_protocol;
178         case IPPROTO_COMP:
179                 return &ipcomp6_protocol;
180         }
181 
182         return NULL;
183 }
184 
185 int xfrm6_protocol_register(struct xfrm6_protocol *handler,
186                             unsigned char protocol)
187 {
188         struct xfrm6_protocol __rcu **pprev;
189         struct xfrm6_protocol *t;
190         bool add_netproto = false;
191         int ret = -EEXIST;
192         int priority = handler->priority;
193 
194         if (!proto_handlers(protocol) || !netproto(protocol))
195                 return -EINVAL;
196 
197         mutex_lock(&xfrm6_protocol_mutex);
198 
199         if (!rcu_dereference_protected(*proto_handlers(protocol),
200                                        lockdep_is_held(&xfrm6_protocol_mutex)))
201                 add_netproto = true;
202 
203         for (pprev = proto_handlers(protocol);
204              (t = rcu_dereference_protected(*pprev,
205                         lockdep_is_held(&xfrm6_protocol_mutex))) != NULL;
206              pprev = &t->next) {
207                 if (t->priority < priority)
208                         break;
209                 if (t->priority == priority)
210                         goto err;
211         }
212 
213         handler->next = *pprev;
214         rcu_assign_pointer(*pprev, handler);
215 
216         ret = 0;
217 
218 err:
219         mutex_unlock(&xfrm6_protocol_mutex);
220 
221         if (add_netproto) {
222                 if (inet6_add_protocol(netproto(protocol), protocol)) {
223                         pr_err("%s: can't add protocol\n", __func__);
224                         ret = -EAGAIN;
225                 }
226         }
227 
228         return ret;
229 }
230 EXPORT_SYMBOL(xfrm6_protocol_register);
231 
232 int xfrm6_protocol_deregister(struct xfrm6_protocol *handler,
233                               unsigned char protocol)
234 {
235         struct xfrm6_protocol __rcu **pprev;
236         struct xfrm6_protocol *t;
237         int ret = -ENOENT;
238 
239         if (!proto_handlers(protocol) || !netproto(protocol))
240                 return -EINVAL;
241 
242         mutex_lock(&xfrm6_protocol_mutex);
243 
244         for (pprev = proto_handlers(protocol);
245              (t = rcu_dereference_protected(*pprev,
246                         lockdep_is_held(&xfrm6_protocol_mutex))) != NULL;
247              pprev = &t->next) {
248                 if (t == handler) {
249                         *pprev = handler->next;
250                         ret = 0;
251                         break;
252                 }
253         }
254 
255         if (!rcu_dereference_protected(*proto_handlers(protocol),
256                                        lockdep_is_held(&xfrm6_protocol_mutex))) {
257                 if (inet6_del_protocol(netproto(protocol), protocol) < 0) {
258                         pr_err("%s: can't remove protocol\n", __func__);
259                         ret = -EAGAIN;
260                 }
261         }
262 
263         mutex_unlock(&xfrm6_protocol_mutex);
264 
265         synchronize_net();
266 
267         return ret;
268 }
269 EXPORT_SYMBOL(xfrm6_protocol_deregister);
270 
271 int __init xfrm6_protocol_init(void)
272 {
273         return xfrm_input_register_afinfo(&xfrm6_input_afinfo);
274 }
275 
276 void xfrm6_protocol_fini(void)
277 {
278         xfrm_input_unregister_afinfo(&xfrm6_input_afinfo);
279 }
280 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp