LXR linux/net/ipv6/tunnel6.c

   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
  22#include <linux/icmpv6.h>
  23#include <linux/init.h>
  24#include <linux/module.h>
  25#include <linux/mutex.h>
  26#include <linux/netdevice.h>
  27#include <linux/skbuff.h>
  28#include <net/ipv6.h>
  29#include <net/protocol.h>
  30#include <net/xfrm.h>
  31
  32static struct xfrm6_tunnel *tunnel6_handlers;
  33static struct xfrm6_tunnel *tunnel46_handlers;
  34static DEFINE_MUTEX(tunnel6_mutex);
  35
  36int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family)
  37{
  38        struct xfrm6_tunnel **pprev;
  39        int ret = -EEXIST;
  40        int priority = handler->priority;
  41
  42        mutex_lock(&tunnel6_mutex);
  43
  44        for (pprev = (family == AF_INET6) ? &tunnel6_handlers : &tunnel46_handlers;
  45             *pprev; pprev = &(*pprev)->next) {
  46                if ((*pprev)->priority > priority)
  47                        break;
  48                if ((*pprev)->priority == priority)
  49                        goto err;
  50        }
  51
  52        handler->next = *pprev;
  53        *pprev = handler;
  54
  55        ret = 0;
  56
  57err:
  58        mutex_unlock(&tunnel6_mutex);
  59
  60        return ret;
  61}
  62
  63EXPORT_SYMBOL(xfrm6_tunnel_register);
  64
  65int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family)
  66{
  67        struct xfrm6_tunnel **pprev;
  68        int ret = -ENOENT;
  69
  70        mutex_lock(&tunnel6_mutex);
  71
  72        for (pprev = (family == AF_INET6) ? &tunnel6_handlers : &tunnel46_handlers;
  73             *pprev; pprev = &(*pprev)->next) {
  74                if (*pprev == handler) {
  75                        *pprev = handler->next;
  76                        ret = 0;
  77                        break;
  78                }
  79        }
  80
  81        mutex_unlock(&tunnel6_mutex);
  82
  83        synchronize_net();
  84
  85        return ret;
  86}
  87
  88EXPORT_SYMBOL(xfrm6_tunnel_deregister);
  89
  90static int tunnel6_rcv(struct sk_buff *skb)
  91{
  92        struct xfrm6_tunnel *handler;
  93
  94        if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
  95                goto drop;
  96
  97        for (handler = tunnel6_handlers; handler; handler = handler->next)
  98                if (!handler->handler(skb))
  99                        return 0;
 100
 101        icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0, skb->dev);
 102
 103drop:
 104        kfree_skb(skb);
 105        return 0;
 106}
 107
 108static int tunnel46_rcv(struct sk_buff *skb)
 109{
 110        struct xfrm6_tunnel *handler;
 111
 112        if (!pskb_may_pull(skb, sizeof(struct iphdr)))
 113                goto drop;
 114
 115        for (handler = tunnel46_handlers; handler; handler = handler->next)
 116                if (!handler->handler(skb))
 117                        return 0;
 118
 119        icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0, skb->dev);
 120
 121drop:
 122        kfree_skb(skb);
 123        return 0;
 124}
 125
 126static void tunnel6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 127                        u8 type, u8 code, int offset, __be32 info)
 128{
 129        struct xfrm6_tunnel *handler;
 130
 131        for (handler = tunnel6_handlers; handler; handler = handler->next)
 132                if (!handler->err_handler(skb, opt, type, code, offset, info))
 133                        break;
 134}
 135
 136static const struct inet6_protocol tunnel6_protocol = {
 137        .handler        = tunnel6_rcv,
 138        .err_handler    = tunnel6_err,
 139        .flags          = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
 140};
 141
 142static const struct inet6_protocol tunnel46_protocol = {
 143        .handler        = tunnel46_rcv,
 144        .err_handler    = tunnel6_err,
 145        .flags          = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
 146};
 147
 148static int __init tunnel6_init(void)
 149{
 150        if (inet6_add_protocol(&tunnel6_protocol, IPPROTO_IPV6)) {
 151                printk(KERN_ERR "tunnel6 init(): can't add protocol\n");
 152                return -EAGAIN;
 153        }
 154        if (inet6_add_protocol(&tunnel46_protocol, IPPROTO_IPIP)) {
 155                printk(KERN_ERR "tunnel6 init(): can't add protocol\n");
 156                inet6_del_protocol(&tunnel6_protocol, IPPROTO_IPV6);
 157                return -EAGAIN;
 158        }
 159        return 0;
 160}
 161
 162static void __exit tunnel6_fini(void)
 163{
 164        if (inet6_del_protocol(&tunnel46_protocol, IPPROTO_IPIP))
 165                printk(KERN_ERR "tunnel6 close: can't remove protocol\n");
 166        if (inet6_del_protocol(&tunnel6_protocol, IPPROTO_IPV6))
 167                printk(KERN_ERR "tunnel6 close: can't remove protocol\n");
 168}
 169
 170module_init(tunnel6_init);
 171module_exit(tunnel6_fini);
 172MODULE_LICENSE("GPL");
 173