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