xref: /openbmc/linux/net/ipv6/tunnel6.c (revision b9ccfda2)
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