aboutsummaryrefslogtreecommitdiffstats
path: root/net/ipv6/xfrm6_tunnel.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/ipv6/xfrm6_tunnel.c')
-rw-r--r--net/ipv6/xfrm6_tunnel.c543
1 files changed, 543 insertions, 0 deletions
diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
new file mode 100644
index 000000000000..ffcadd68b951
--- /dev/null
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -0,0 +1,543 @@
1/*
2 * Copyright (C)2003,2004 USAGI/WIDE Project
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Authors Mitsuru KANDA <mk@linux-ipv6.org>
19 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
20 *
21 * Based on net/ipv4/xfrm4_tunnel.c
22 *
23 */
24#include <linux/config.h>
25#include <linux/module.h>
26#include <linux/xfrm.h>
27#include <linux/list.h>
28#include <net/ip.h>
29#include <net/xfrm.h>
30#include <net/ipv6.h>
31#include <net/protocol.h>
32#include <linux/ipv6.h>
33#include <linux/icmpv6.h>
34
35#ifdef CONFIG_IPV6_XFRM6_TUNNEL_DEBUG
36# define X6TDEBUG 3
37#else
38# define X6TDEBUG 1
39#endif
40
41#define X6TPRINTK(fmt, args...) printk(fmt, ## args)
42#define X6TNOPRINTK(fmt, args...) do { ; } while(0)
43
44#if X6TDEBUG >= 1
45# define X6TPRINTK1 X6TPRINTK
46#else
47# define X6TPRINTK1 X6TNOPRINTK
48#endif
49
50#if X6TDEBUG >= 3
51# define X6TPRINTK3 X6TPRINTK
52#else
53# define X6TPRINTK3 X6TNOPRINTK
54#endif
55
56/*
57 * xfrm_tunnel_spi things are for allocating unique id ("spi")
58 * per xfrm_address_t.
59 */
60struct xfrm6_tunnel_spi {
61 struct hlist_node list_byaddr;
62 struct hlist_node list_byspi;
63 xfrm_address_t addr;
64 u32 spi;
65 atomic_t refcnt;
66#ifdef XFRM6_TUNNEL_SPI_MAGIC
67 u32 magic;
68#endif
69};
70
71#ifdef CONFIG_IPV6_XFRM6_TUNNEL_DEBUG
72# define XFRM6_TUNNEL_SPI_MAGIC 0xdeadbeef
73#endif
74
75static DEFINE_RWLOCK(xfrm6_tunnel_spi_lock);
76
77static u32 xfrm6_tunnel_spi;
78
79#define XFRM6_TUNNEL_SPI_MIN 1
80#define XFRM6_TUNNEL_SPI_MAX 0xffffffff
81
82static kmem_cache_t *xfrm6_tunnel_spi_kmem;
83
84#define XFRM6_TUNNEL_SPI_BYADDR_HSIZE 256
85#define XFRM6_TUNNEL_SPI_BYSPI_HSIZE 256
86
87static struct hlist_head xfrm6_tunnel_spi_byaddr[XFRM6_TUNNEL_SPI_BYADDR_HSIZE];
88static struct hlist_head xfrm6_tunnel_spi_byspi[XFRM6_TUNNEL_SPI_BYSPI_HSIZE];
89
90#ifdef XFRM6_TUNNEL_SPI_MAGIC
91static int x6spi_check_magic(const struct xfrm6_tunnel_spi *x6spi,
92 const char *name)
93{
94 if (unlikely(x6spi->magic != XFRM6_TUNNEL_SPI_MAGIC)) {
95 X6TPRINTK3(KERN_DEBUG "%s(): x6spi object "
96 "at %p has corrupted magic %08x "
97 "(should be %08x)\n",
98 name, x6spi, x6spi->magic, XFRM6_TUNNEL_SPI_MAGIC);
99 return -1;
100 }
101 return 0;
102}
103#else
104static int inline x6spi_check_magic(const struct xfrm6_tunnel_spi *x6spi,
105 const char *name)
106{
107 return 0;
108}
109#endif
110
111#define X6SPI_CHECK_MAGIC(x6spi) x6spi_check_magic((x6spi), __FUNCTION__)
112
113
114static unsigned inline xfrm6_tunnel_spi_hash_byaddr(xfrm_address_t *addr)
115{
116 unsigned h;
117
118 X6TPRINTK3(KERN_DEBUG "%s(addr=%p)\n", __FUNCTION__, addr);
119
120 h = addr->a6[0] ^ addr->a6[1] ^ addr->a6[2] ^ addr->a6[3];
121 h ^= h >> 16;
122 h ^= h >> 8;
123 h &= XFRM6_TUNNEL_SPI_BYADDR_HSIZE - 1;
124
125 X6TPRINTK3(KERN_DEBUG "%s() = %u\n", __FUNCTION__, h);
126
127 return h;
128}
129
130static unsigned inline xfrm6_tunnel_spi_hash_byspi(u32 spi)
131{
132 return spi % XFRM6_TUNNEL_SPI_BYSPI_HSIZE;
133}
134
135
136static int xfrm6_tunnel_spi_init(void)
137{
138 int i;
139
140 X6TPRINTK3(KERN_DEBUG "%s()\n", __FUNCTION__);
141
142 xfrm6_tunnel_spi = 0;
143 xfrm6_tunnel_spi_kmem = kmem_cache_create("xfrm6_tunnel_spi",
144 sizeof(struct xfrm6_tunnel_spi),
145 0, SLAB_HWCACHE_ALIGN,
146 NULL, NULL);
147 if (!xfrm6_tunnel_spi_kmem) {
148 X6TPRINTK1(KERN_ERR
149 "%s(): failed to allocate xfrm6_tunnel_spi_kmem\n",
150 __FUNCTION__);
151 return -ENOMEM;
152 }
153
154 for (i = 0; i < XFRM6_TUNNEL_SPI_BYADDR_HSIZE; i++)
155 INIT_HLIST_HEAD(&xfrm6_tunnel_spi_byaddr[i]);
156 for (i = 0; i < XFRM6_TUNNEL_SPI_BYSPI_HSIZE; i++)
157 INIT_HLIST_HEAD(&xfrm6_tunnel_spi_byspi[i]);
158 return 0;
159}
160
161static void xfrm6_tunnel_spi_fini(void)
162{
163 int i;
164
165 X6TPRINTK3(KERN_DEBUG "%s()\n", __FUNCTION__);
166
167 for (i = 0; i < XFRM6_TUNNEL_SPI_BYADDR_HSIZE; i++) {
168 if (!hlist_empty(&xfrm6_tunnel_spi_byaddr[i]))
169 goto err;
170 }
171 for (i = 0; i < XFRM6_TUNNEL_SPI_BYSPI_HSIZE; i++) {
172 if (!hlist_empty(&xfrm6_tunnel_spi_byspi[i]))
173 goto err;
174 }
175 kmem_cache_destroy(xfrm6_tunnel_spi_kmem);
176 xfrm6_tunnel_spi_kmem = NULL;
177 return;
178err:
179 X6TPRINTK1(KERN_ERR "%s(): table is not empty\n", __FUNCTION__);
180 return;
181}
182
183static struct xfrm6_tunnel_spi *__xfrm6_tunnel_spi_lookup(xfrm_address_t *saddr)
184{
185 struct xfrm6_tunnel_spi *x6spi;
186 struct hlist_node *pos;
187
188 X6TPRINTK3(KERN_DEBUG "%s(saddr=%p)\n", __FUNCTION__, saddr);
189
190 hlist_for_each_entry(x6spi, pos,
191 &xfrm6_tunnel_spi_byaddr[xfrm6_tunnel_spi_hash_byaddr(saddr)],
192 list_byaddr) {
193 if (memcmp(&x6spi->addr, saddr, sizeof(x6spi->addr)) == 0) {
194 X6SPI_CHECK_MAGIC(x6spi);
195 X6TPRINTK3(KERN_DEBUG "%s() = %p(%u)\n", __FUNCTION__, x6spi, x6spi->spi);
196 return x6spi;
197 }
198 }
199
200 X6TPRINTK3(KERN_DEBUG "%s() = NULL(0)\n", __FUNCTION__);
201 return NULL;
202}
203
204u32 xfrm6_tunnel_spi_lookup(xfrm_address_t *saddr)
205{
206 struct xfrm6_tunnel_spi *x6spi;
207 u32 spi;
208
209 X6TPRINTK3(KERN_DEBUG "%s(saddr=%p)\n", __FUNCTION__, saddr);
210
211 read_lock_bh(&xfrm6_tunnel_spi_lock);
212 x6spi = __xfrm6_tunnel_spi_lookup(saddr);
213 spi = x6spi ? x6spi->spi : 0;
214 read_unlock_bh(&xfrm6_tunnel_spi_lock);
215 return spi;
216}
217
218EXPORT_SYMBOL(xfrm6_tunnel_spi_lookup);
219
220static u32 __xfrm6_tunnel_alloc_spi(xfrm_address_t *saddr)
221{
222 u32 spi;
223 struct xfrm6_tunnel_spi *x6spi;
224 struct hlist_node *pos;
225 unsigned index;
226
227 X6TPRINTK3(KERN_DEBUG "%s(saddr=%p)\n", __FUNCTION__, saddr);
228
229 if (xfrm6_tunnel_spi < XFRM6_TUNNEL_SPI_MIN ||
230 xfrm6_tunnel_spi >= XFRM6_TUNNEL_SPI_MAX)
231 xfrm6_tunnel_spi = XFRM6_TUNNEL_SPI_MIN;
232 else
233 xfrm6_tunnel_spi++;
234
235 for (spi = xfrm6_tunnel_spi; spi <= XFRM6_TUNNEL_SPI_MAX; spi++) {
236 index = xfrm6_tunnel_spi_hash_byspi(spi);
237 hlist_for_each_entry(x6spi, pos,
238 &xfrm6_tunnel_spi_byspi[index],
239 list_byspi) {
240 if (x6spi->spi == spi)
241 goto try_next_1;
242 }
243 xfrm6_tunnel_spi = spi;
244 goto alloc_spi;
245try_next_1:;
246 }
247 for (spi = XFRM6_TUNNEL_SPI_MIN; spi < xfrm6_tunnel_spi; spi++) {
248 index = xfrm6_tunnel_spi_hash_byspi(spi);
249 hlist_for_each_entry(x6spi, pos,
250 &xfrm6_tunnel_spi_byspi[index],
251 list_byspi) {
252 if (x6spi->spi == spi)
253 goto try_next_2;
254 }
255 xfrm6_tunnel_spi = spi;
256 goto alloc_spi;
257try_next_2:;
258 }
259 spi = 0;
260 goto out;
261alloc_spi:
262 X6TPRINTK3(KERN_DEBUG "%s(): allocate new spi for "
263 "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
264 __FUNCTION__,
265 NIP6(*(struct in6_addr *)saddr));
266 x6spi = kmem_cache_alloc(xfrm6_tunnel_spi_kmem, SLAB_ATOMIC);
267 if (!x6spi) {
268 X6TPRINTK1(KERN_ERR "%s(): kmem_cache_alloc() failed\n",
269 __FUNCTION__);
270 goto out;
271 }
272#ifdef XFRM6_TUNNEL_SPI_MAGIC
273 x6spi->magic = XFRM6_TUNNEL_SPI_MAGIC;
274#endif
275 memcpy(&x6spi->addr, saddr, sizeof(x6spi->addr));
276 x6spi->spi = spi;
277 atomic_set(&x6spi->refcnt, 1);
278
279 hlist_add_head(&x6spi->list_byspi, &xfrm6_tunnel_spi_byspi[index]);
280
281 index = xfrm6_tunnel_spi_hash_byaddr(saddr);
282 hlist_add_head(&x6spi->list_byaddr, &xfrm6_tunnel_spi_byaddr[index]);
283 X6SPI_CHECK_MAGIC(x6spi);
284out:
285 X6TPRINTK3(KERN_DEBUG "%s() = %u\n", __FUNCTION__, spi);
286 return spi;
287}
288
289u32 xfrm6_tunnel_alloc_spi(xfrm_address_t *saddr)
290{
291 struct xfrm6_tunnel_spi *x6spi;
292 u32 spi;
293
294 X6TPRINTK3(KERN_DEBUG "%s(saddr=%p)\n", __FUNCTION__, saddr);
295
296 write_lock_bh(&xfrm6_tunnel_spi_lock);
297 x6spi = __xfrm6_tunnel_spi_lookup(saddr);
298 if (x6spi) {
299 atomic_inc(&x6spi->refcnt);
300 spi = x6spi->spi;
301 } else
302 spi = __xfrm6_tunnel_alloc_spi(saddr);
303 write_unlock_bh(&xfrm6_tunnel_spi_lock);
304
305 X6TPRINTK3(KERN_DEBUG "%s() = %u\n", __FUNCTION__, spi);
306
307 return spi;
308}
309
310EXPORT_SYMBOL(xfrm6_tunnel_alloc_spi);
311
312void xfrm6_tunnel_free_spi(xfrm_address_t *saddr)
313{
314 struct xfrm6_tunnel_spi *x6spi;
315 struct hlist_node *pos, *n;
316
317 X6TPRINTK3(KERN_DEBUG "%s(saddr=%p)\n", __FUNCTION__, saddr);
318
319 write_lock_bh(&xfrm6_tunnel_spi_lock);
320
321 hlist_for_each_entry_safe(x6spi, pos, n,
322 &xfrm6_tunnel_spi_byaddr[xfrm6_tunnel_spi_hash_byaddr(saddr)],
323 list_byaddr)
324 {
325 if (memcmp(&x6spi->addr, saddr, sizeof(x6spi->addr)) == 0) {
326 X6TPRINTK3(KERN_DEBUG "%s(): x6spi object "
327 "for %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x "
328 "found at %p\n",
329 __FUNCTION__,
330 NIP6(*(struct in6_addr *)saddr),
331 x6spi);
332 X6SPI_CHECK_MAGIC(x6spi);
333 if (atomic_dec_and_test(&x6spi->refcnt)) {
334 hlist_del(&x6spi->list_byaddr);
335 hlist_del(&x6spi->list_byspi);
336 kmem_cache_free(xfrm6_tunnel_spi_kmem, x6spi);
337 break;
338 }
339 }
340 }
341 write_unlock_bh(&xfrm6_tunnel_spi_lock);
342}
343
344EXPORT_SYMBOL(xfrm6_tunnel_free_spi);
345
346static int xfrm6_tunnel_output(struct xfrm_state *x, struct sk_buff *skb)
347{
348 struct ipv6hdr *top_iph;
349
350 top_iph = (struct ipv6hdr *)skb->data;
351 top_iph->payload_len = htons(skb->len - sizeof(struct ipv6hdr));
352
353 return 0;
354}
355
356static int xfrm6_tunnel_input(struct xfrm_state *x, struct xfrm_decap_state *decap, struct sk_buff *skb)
357{
358 return 0;
359}
360
361static struct xfrm6_tunnel *xfrm6_tunnel_handler;
362static DECLARE_MUTEX(xfrm6_tunnel_sem);
363
364int xfrm6_tunnel_register(struct xfrm6_tunnel *handler)
365{
366 int ret;
367
368 down(&xfrm6_tunnel_sem);
369 ret = 0;
370 if (xfrm6_tunnel_handler != NULL)
371 ret = -EINVAL;
372 if (!ret)
373 xfrm6_tunnel_handler = handler;
374 up(&xfrm6_tunnel_sem);
375
376 return ret;
377}
378
379EXPORT_SYMBOL(xfrm6_tunnel_register);
380
381int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler)
382{
383 int ret;
384
385 down(&xfrm6_tunnel_sem);
386 ret = 0;
387 if (xfrm6_tunnel_handler != handler)
388 ret = -EINVAL;
389 if (!ret)
390 xfrm6_tunnel_handler = NULL;
391 up(&xfrm6_tunnel_sem);
392
393 synchronize_net();
394
395 return ret;
396}
397
398EXPORT_SYMBOL(xfrm6_tunnel_deregister);
399
400static int xfrm6_tunnel_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
401{
402 struct sk_buff *skb = *pskb;
403 struct xfrm6_tunnel *handler = xfrm6_tunnel_handler;
404 struct ipv6hdr *iph = skb->nh.ipv6h;
405 u32 spi;
406
407 /* device-like_ip6ip6_handler() */
408 if (handler && handler->handler(pskb, nhoffp) == 0)
409 return 0;
410
411 spi = xfrm6_tunnel_spi_lookup((xfrm_address_t *)&iph->saddr);
412 return xfrm6_rcv_spi(pskb, nhoffp, spi);
413}
414
415static void xfrm6_tunnel_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
416 int type, int code, int offset, __u32 info)
417{
418 struct xfrm6_tunnel *handler = xfrm6_tunnel_handler;
419
420 /* call here first for device-like ip6ip6 err handling */
421 if (handler) {
422 handler->err_handler(skb, opt, type, code, offset, info);
423 return;
424 }
425
426 /* xfrm6_tunnel native err handling */
427 switch (type) {
428 case ICMPV6_DEST_UNREACH:
429 switch (code) {
430 case ICMPV6_NOROUTE:
431 case ICMPV6_ADM_PROHIBITED:
432 case ICMPV6_NOT_NEIGHBOUR:
433 case ICMPV6_ADDR_UNREACH:
434 case ICMPV6_PORT_UNREACH:
435 default:
436 X6TPRINTK3(KERN_DEBUG
437 "xfrm6_tunnel: Destination Unreach.\n");
438 break;
439 }
440 break;
441 case ICMPV6_PKT_TOOBIG:
442 X6TPRINTK3(KERN_DEBUG
443 "xfrm6_tunnel: Packet Too Big.\n");
444 break;
445 case ICMPV6_TIME_EXCEED:
446 switch (code) {
447 case ICMPV6_EXC_HOPLIMIT:
448 X6TPRINTK3(KERN_DEBUG
449 "xfrm6_tunnel: Too small Hoplimit.\n");
450 break;
451 case ICMPV6_EXC_FRAGTIME:
452 default:
453 break;
454 }
455 break;
456 case ICMPV6_PARAMPROB:
457 switch (code) {
458 case ICMPV6_HDR_FIELD: break;
459 case ICMPV6_UNK_NEXTHDR: break;
460 case ICMPV6_UNK_OPTION: break;
461 }
462 break;
463 default:
464 break;
465 }
466 return;
467}
468
469static int xfrm6_tunnel_init_state(struct xfrm_state *x, void *args)
470{
471 if (!x->props.mode)
472 return -EINVAL;
473
474 if (x->encap)
475 return -EINVAL;
476
477 x->props.header_len = sizeof(struct ipv6hdr);
478
479 return 0;
480}
481
482static void xfrm6_tunnel_destroy(struct xfrm_state *x)
483{
484 xfrm6_tunnel_free_spi((xfrm_address_t *)&x->props.saddr);
485}
486
487static struct xfrm_type xfrm6_tunnel_type = {
488 .description = "IP6IP6",
489 .owner = THIS_MODULE,
490 .proto = IPPROTO_IPV6,
491 .init_state = xfrm6_tunnel_init_state,
492 .destructor = xfrm6_tunnel_destroy,
493 .input = xfrm6_tunnel_input,
494 .output = xfrm6_tunnel_output,
495};
496
497static struct inet6_protocol xfrm6_tunnel_protocol = {
498 .handler = xfrm6_tunnel_rcv,
499 .err_handler = xfrm6_tunnel_err,
500 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
501};
502
503static int __init xfrm6_tunnel_init(void)
504{
505 X6TPRINTK3(KERN_DEBUG "%s()\n", __FUNCTION__);
506
507 if (xfrm_register_type(&xfrm6_tunnel_type, AF_INET6) < 0) {
508 X6TPRINTK1(KERN_ERR
509 "xfrm6_tunnel init: can't add xfrm type\n");
510 return -EAGAIN;
511 }
512 if (inet6_add_protocol(&xfrm6_tunnel_protocol, IPPROTO_IPV6) < 0) {
513 X6TPRINTK1(KERN_ERR
514 "xfrm6_tunnel init(): can't add protocol\n");
515 xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
516 return -EAGAIN;
517 }
518 if (xfrm6_tunnel_spi_init() < 0) {
519 X6TPRINTK1(KERN_ERR
520 "xfrm6_tunnel init: failed to initialize spi\n");
521 inet6_del_protocol(&xfrm6_tunnel_protocol, IPPROTO_IPV6);
522 xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
523 return -EAGAIN;
524 }
525 return 0;
526}
527
528static void __exit xfrm6_tunnel_fini(void)
529{
530 X6TPRINTK3(KERN_DEBUG "%s()\n", __FUNCTION__);
531
532 xfrm6_tunnel_spi_fini();
533 if (inet6_del_protocol(&xfrm6_tunnel_protocol, IPPROTO_IPV6) < 0)
534 X6TPRINTK1(KERN_ERR
535 "xfrm6_tunnel close: can't remove protocol\n");
536 if (xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6) < 0)
537 X6TPRINTK1(KERN_ERR
538 "xfrm6_tunnel close: can't remove xfrm type\n");
539}
540
541module_init(xfrm6_tunnel_init);
542module_exit(xfrm6_tunnel_fini);
543MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-03 15:10:02 -0500