Commit | Line | Data |
---|---|---|
2c8d7ca0 NT |
1 | /* |
2 | * Copyright (C)2003-2006 Helsinki University of Technology | |
3 | * Copyright (C)2003-2006 USAGI/WIDE Project | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation; either version 2 of the License, or | |
8 | * (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
a99421d9 | 16 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
2c8d7ca0 NT |
17 | */ |
18 | /* | |
19 | * Authors: | |
20 | * Noriaki TAKAMIYA @USAGI | |
21 | * Masahide NAKAMURA @USAGI | |
22 | */ | |
23 | ||
f3213831 JP |
24 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
25 | ||
2c8d7ca0 NT |
26 | #include <linux/module.h> |
27 | #include <linux/skbuff.h> | |
70182ed2 | 28 | #include <linux/time.h> |
2c8d7ca0 | 29 | #include <linux/ipv6.h> |
7be96f76 MN |
30 | #include <linux/icmpv6.h> |
31 | #include <net/sock.h> | |
2c8d7ca0 | 32 | #include <net/ipv6.h> |
7be96f76 | 33 | #include <net/ip6_checksum.h> |
59fbb3a6 | 34 | #include <net/rawv6.h> |
2c8d7ca0 NT |
35 | #include <net/xfrm.h> |
36 | #include <net/mip6.h> | |
37 | ||
3d126890 NT |
38 | static inline unsigned int calc_padlen(unsigned int len, unsigned int n) |
39 | { | |
40 | return (n - len + 16) & 0x7; | |
41 | } | |
42 | ||
43 | static inline void *mip6_padn(__u8 *data, __u8 padlen) | |
44 | { | |
45 | if (!data) | |
46 | return NULL; | |
47 | if (padlen == 1) { | |
1de5a71c | 48 | data[0] = IPV6_TLV_PAD1; |
3d126890 | 49 | } else if (padlen > 1) { |
7f1eced8 | 50 | data[0] = IPV6_TLV_PADN; |
3d126890 NT |
51 | data[1] = padlen - 2; |
52 | if (padlen > 2) | |
53 | memset(data+2, 0, data[1]); | |
54 | } | |
55 | return data + padlen; | |
56 | } | |
57 | ||
d5fdd6ba | 58 | static inline void mip6_param_prob(struct sk_buff *skb, u8 code, int pos) |
7be96f76 | 59 | { |
3ffe533c | 60 | icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos); |
7be96f76 MN |
61 | } |
62 | ||
63 | static int mip6_mh_len(int type) | |
64 | { | |
65 | int len = 0; | |
66 | ||
67 | switch (type) { | |
68 | case IP6_MH_TYPE_BRR: | |
69 | len = 0; | |
70 | break; | |
71 | case IP6_MH_TYPE_HOTI: | |
72 | case IP6_MH_TYPE_COTI: | |
73 | case IP6_MH_TYPE_BU: | |
74 | case IP6_MH_TYPE_BACK: | |
75 | len = 1; | |
76 | break; | |
77 | case IP6_MH_TYPE_HOT: | |
78 | case IP6_MH_TYPE_COT: | |
79 | case IP6_MH_TYPE_BERROR: | |
80 | len = 2; | |
81 | break; | |
82 | } | |
83 | return len; | |
84 | } | |
85 | ||
59fbb3a6 | 86 | static int mip6_mh_filter(struct sock *sk, struct sk_buff *skb) |
7be96f76 | 87 | { |
96af69ea ED |
88 | struct ip6_mh _hdr; |
89 | const struct ip6_mh *mh; | |
7be96f76 | 90 | |
96af69ea ED |
91 | mh = skb_header_pointer(skb, skb_transport_offset(skb), |
92 | sizeof(_hdr), &_hdr); | |
93 | if (!mh) | |
7be96f76 MN |
94 | return -1; |
95 | ||
96af69ea ED |
96 | if (((mh->ip6mh_hdrlen + 1) << 3) > skb->len) |
97 | return -1; | |
7be96f76 MN |
98 | |
99 | if (mh->ip6mh_hdrlen < mip6_mh_len(mh->ip6mh_type)) { | |
100 | LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH message too short: %d vs >=%d\n", | |
101 | mh->ip6mh_hdrlen, mip6_mh_len(mh->ip6mh_type)); | |
96af69ea ED |
102 | mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_hdrlen) + |
103 | skb_network_header_len(skb)); | |
7be96f76 MN |
104 | return -1; |
105 | } | |
7be96f76 MN |
106 | |
107 | if (mh->ip6mh_proto != IPPROTO_NONE) { | |
108 | LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH invalid payload proto = %d\n", | |
109 | mh->ip6mh_proto); | |
96af69ea ED |
110 | mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_proto) + |
111 | skb_network_header_len(skb)); | |
7be96f76 MN |
112 | return -1; |
113 | } | |
114 | ||
115 | return 0; | |
116 | } | |
117 | ||
70182ed2 MN |
118 | struct mip6_report_rate_limiter { |
119 | spinlock_t lock; | |
120 | struct timeval stamp; | |
121 | int iif; | |
122 | struct in6_addr src; | |
123 | struct in6_addr dst; | |
124 | }; | |
125 | ||
126 | static struct mip6_report_rate_limiter mip6_report_rl = { | |
4ef8d0ae | 127 | .lock = __SPIN_LOCK_UNLOCKED(mip6_report_rl.lock) |
70182ed2 MN |
128 | }; |
129 | ||
3d126890 NT |
130 | static int mip6_destopt_input(struct xfrm_state *x, struct sk_buff *skb) |
131 | { | |
b71d1d42 | 132 | const struct ipv6hdr *iph = ipv6_hdr(skb); |
3d126890 | 133 | struct ipv6_destopt_hdr *destopt = (struct ipv6_destopt_hdr *)skb->data; |
0ebea8ef | 134 | int err = destopt->nexthdr; |
3d126890 | 135 | |
0ebea8ef | 136 | spin_lock(&x->lock); |
3d126890 NT |
137 | if (!ipv6_addr_equal(&iph->saddr, (struct in6_addr *)x->coaddr) && |
138 | !ipv6_addr_any((struct in6_addr *)x->coaddr)) | |
0ebea8ef HX |
139 | err = -ENOENT; |
140 | spin_unlock(&x->lock); | |
3d126890 | 141 | |
0ebea8ef | 142 | return err; |
3d126890 NT |
143 | } |
144 | ||
145 | /* Destination Option Header is inserted. | |
146 | * IP Header's src address is replaced with Home Address Option in | |
147 | * Destination Option Header. | |
148 | */ | |
149 | static int mip6_destopt_output(struct xfrm_state *x, struct sk_buff *skb) | |
150 | { | |
151 | struct ipv6hdr *iph; | |
152 | struct ipv6_destopt_hdr *dstopt; | |
153 | struct ipv6_destopt_hao *hao; | |
154 | u8 nexthdr; | |
155 | int len; | |
156 | ||
7b277b1a | 157 | skb_push(skb, -skb_network_offset(skb)); |
007f0211 | 158 | iph = ipv6_hdr(skb); |
3d126890 | 159 | |
007f0211 HX |
160 | nexthdr = *skb_mac_header(skb); |
161 | *skb_mac_header(skb) = IPPROTO_DSTOPTS; | |
3d126890 | 162 | |
9c70220b | 163 | dstopt = (struct ipv6_destopt_hdr *)skb_transport_header(skb); |
3d126890 NT |
164 | dstopt->nexthdr = nexthdr; |
165 | ||
166 | hao = mip6_padn((char *)(dstopt + 1), | |
167 | calc_padlen(sizeof(*dstopt), 6)); | |
168 | ||
169 | hao->type = IPV6_TLV_HAO; | |
547b792c | 170 | BUILD_BUG_ON(sizeof(*hao) != 18); |
3d126890 | 171 | hao->length = sizeof(*hao) - 2; |
3d126890 NT |
172 | |
173 | len = ((char *)hao - (char *)dstopt) + sizeof(*hao); | |
174 | ||
175 | memcpy(&hao->addr, &iph->saddr, sizeof(hao->addr)); | |
b7c6538c | 176 | spin_lock_bh(&x->lock); |
3d126890 | 177 | memcpy(&iph->saddr, x->coaddr, sizeof(iph->saddr)); |
b7c6538c | 178 | spin_unlock_bh(&x->lock); |
3d126890 | 179 | |
547b792c | 180 | WARN_ON(len != x->props.header_len); |
3d126890 NT |
181 | dstopt->hdrlen = (x->props.header_len >> 3) - 1; |
182 | ||
183 | return 0; | |
184 | } | |
185 | ||
70182ed2 | 186 | static inline int mip6_report_rl_allow(struct timeval *stamp, |
b71d1d42 ED |
187 | const struct in6_addr *dst, |
188 | const struct in6_addr *src, int iif) | |
70182ed2 MN |
189 | { |
190 | int allow = 0; | |
191 | ||
192 | spin_lock_bh(&mip6_report_rl.lock); | |
193 | if (mip6_report_rl.stamp.tv_sec != stamp->tv_sec || | |
194 | mip6_report_rl.stamp.tv_usec != stamp->tv_usec || | |
195 | mip6_report_rl.iif != iif || | |
196 | !ipv6_addr_equal(&mip6_report_rl.src, src) || | |
197 | !ipv6_addr_equal(&mip6_report_rl.dst, dst)) { | |
198 | mip6_report_rl.stamp.tv_sec = stamp->tv_sec; | |
199 | mip6_report_rl.stamp.tv_usec = stamp->tv_usec; | |
200 | mip6_report_rl.iif = iif; | |
4e3fd7a0 AD |
201 | mip6_report_rl.src = *src; |
202 | mip6_report_rl.dst = *dst; | |
70182ed2 MN |
203 | allow = 1; |
204 | } | |
205 | spin_unlock_bh(&mip6_report_rl.lock); | |
206 | return allow; | |
207 | } | |
208 | ||
8f029de2 DM |
209 | static int mip6_destopt_reject(struct xfrm_state *x, struct sk_buff *skb, |
210 | const struct flowi *fl) | |
70182ed2 | 211 | { |
db983c11 | 212 | struct net *net = xs_net(x); |
70182ed2 | 213 | struct inet6_skb_parm *opt = (struct inet6_skb_parm *)skb->cb; |
4c9483b2 | 214 | const struct flowi6 *fl6 = &fl->u.ip6; |
70182ed2 MN |
215 | struct ipv6_destopt_hao *hao = NULL; |
216 | struct xfrm_selector sel; | |
217 | int offset; | |
218 | struct timeval stamp; | |
219 | int err = 0; | |
220 | ||
4c9483b2 | 221 | if (unlikely(fl6->flowi6_proto == IPPROTO_MH && |
1958b856 | 222 | fl6->fl6_mh_type <= IP6_MH_TYPE_MAX)) |
01be8e5d MN |
223 | goto out; |
224 | ||
70182ed2 MN |
225 | if (likely(opt->dsthao)) { |
226 | offset = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO); | |
227 | if (likely(offset >= 0)) | |
d56f90a7 ACM |
228 | hao = (struct ipv6_destopt_hao *) |
229 | (skb_network_header(skb) + offset); | |
70182ed2 MN |
230 | } |
231 | ||
232 | skb_get_timestamp(skb, &stamp); | |
233 | ||
0660e03f ACM |
234 | if (!mip6_report_rl_allow(&stamp, &ipv6_hdr(skb)->daddr, |
235 | hao ? &hao->addr : &ipv6_hdr(skb)->saddr, | |
70182ed2 MN |
236 | opt->iif)) |
237 | goto out; | |
238 | ||
239 | memset(&sel, 0, sizeof(sel)); | |
0660e03f | 240 | memcpy(&sel.daddr, (xfrm_address_t *)&ipv6_hdr(skb)->daddr, |
70182ed2 MN |
241 | sizeof(sel.daddr)); |
242 | sel.prefixlen_d = 128; | |
0660e03f | 243 | memcpy(&sel.saddr, (xfrm_address_t *)&ipv6_hdr(skb)->saddr, |
70182ed2 MN |
244 | sizeof(sel.saddr)); |
245 | sel.prefixlen_s = 128; | |
246 | sel.family = AF_INET6; | |
4c9483b2 DM |
247 | sel.proto = fl6->flowi6_proto; |
248 | sel.dport = xfrm_flowi_dport(fl, &fl6->uli); | |
70182ed2 | 249 | if (sel.dport) |
e69a4adc | 250 | sel.dport_mask = htons(~0); |
4c9483b2 | 251 | sel.sport = xfrm_flowi_sport(fl, &fl6->uli); |
70182ed2 | 252 | if (sel.sport) |
e69a4adc | 253 | sel.sport_mask = htons(~0); |
4c9483b2 | 254 | sel.ifindex = fl6->flowi6_oif; |
70182ed2 | 255 | |
db983c11 | 256 | err = km_report(net, IPPROTO_DSTOPTS, &sel, |
70182ed2 MN |
257 | (hao ? (xfrm_address_t *)&hao->addr : NULL)); |
258 | ||
259 | out: | |
260 | return err; | |
261 | } | |
262 | ||
3d126890 NT |
263 | static int mip6_destopt_offset(struct xfrm_state *x, struct sk_buff *skb, |
264 | u8 **nexthdr) | |
265 | { | |
266 | u16 offset = sizeof(struct ipv6hdr); | |
0660e03f ACM |
267 | struct ipv6_opt_hdr *exthdr = |
268 | (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1); | |
d56f90a7 | 269 | const unsigned char *nh = skb_network_header(skb); |
29a3cad5 SH |
270 | unsigned int packet_len = skb_tail_pointer(skb) - |
271 | skb_network_header(skb); | |
3d126890 NT |
272 | int found_rhdr = 0; |
273 | ||
0660e03f | 274 | *nexthdr = &ipv6_hdr(skb)->nexthdr; |
3d126890 NT |
275 | |
276 | while (offset + 1 <= packet_len) { | |
277 | ||
278 | switch (**nexthdr) { | |
279 | case NEXTHDR_HOP: | |
280 | break; | |
281 | case NEXTHDR_ROUTING: | |
282 | found_rhdr = 1; | |
283 | break; | |
284 | case NEXTHDR_DEST: | |
285 | /* | |
286 | * HAO MUST NOT appear more than once. | |
287 | * XXX: It is better to try to find by the end of | |
288 | * XXX: packet if HAO exists. | |
289 | */ | |
290 | if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0) { | |
291 | LIMIT_NETDEBUG(KERN_WARNING "mip6: hao exists already, override\n"); | |
292 | return offset; | |
293 | } | |
294 | ||
295 | if (found_rhdr) | |
296 | return offset; | |
297 | ||
298 | break; | |
299 | default: | |
300 | return offset; | |
301 | } | |
302 | ||
303 | offset += ipv6_optlen(exthdr); | |
304 | *nexthdr = &exthdr->nexthdr; | |
d56f90a7 | 305 | exthdr = (struct ipv6_opt_hdr *)(nh + offset); |
3d126890 NT |
306 | } |
307 | ||
308 | return offset; | |
309 | } | |
310 | ||
311 | static int mip6_destopt_init_state(struct xfrm_state *x) | |
312 | { | |
313 | if (x->id.spi) { | |
f3213831 | 314 | pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi); |
3d126890 NT |
315 | return -EINVAL; |
316 | } | |
317 | if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) { | |
f3213831 JP |
318 | pr_info("%s: state's mode is not %u: %u\n", |
319 | __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode); | |
3d126890 NT |
320 | return -EINVAL; |
321 | } | |
322 | ||
323 | x->props.header_len = sizeof(struct ipv6_destopt_hdr) + | |
324 | calc_padlen(sizeof(struct ipv6_destopt_hdr), 6) + | |
325 | sizeof(struct ipv6_destopt_hao); | |
547b792c | 326 | WARN_ON(x->props.header_len != 24); |
3d126890 NT |
327 | |
328 | return 0; | |
329 | } | |
330 | ||
331 | /* | |
332 | * Do nothing about destroying since it has no specific operation for | |
333 | * destination options header unlike IPsec protocols. | |
334 | */ | |
335 | static void mip6_destopt_destroy(struct xfrm_state *x) | |
336 | { | |
337 | } | |
338 | ||
533cb5b0 | 339 | static const struct xfrm_type mip6_destopt_type = |
3d126890 NT |
340 | { |
341 | .description = "MIP6DESTOPT", | |
342 | .owner = THIS_MODULE, | |
343 | .proto = IPPROTO_DSTOPTS, | |
f04e7e8d | 344 | .flags = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_LOCAL_COADDR, |
3d126890 NT |
345 | .init_state = mip6_destopt_init_state, |
346 | .destructor = mip6_destopt_destroy, | |
347 | .input = mip6_destopt_input, | |
348 | .output = mip6_destopt_output, | |
1ab1457c | 349 | .reject = mip6_destopt_reject, |
3d126890 | 350 | .hdr_offset = mip6_destopt_offset, |
3d126890 NT |
351 | }; |
352 | ||
2c8d7ca0 NT |
353 | static int mip6_rthdr_input(struct xfrm_state *x, struct sk_buff *skb) |
354 | { | |
b71d1d42 | 355 | const struct ipv6hdr *iph = ipv6_hdr(skb); |
2c8d7ca0 | 356 | struct rt2_hdr *rt2 = (struct rt2_hdr *)skb->data; |
0ebea8ef | 357 | int err = rt2->rt_hdr.nexthdr; |
2c8d7ca0 | 358 | |
0ebea8ef | 359 | spin_lock(&x->lock); |
d9a9dc66 | 360 | if (!ipv6_addr_equal(&iph->daddr, (struct in6_addr *)x->coaddr) && |
2c8d7ca0 | 361 | !ipv6_addr_any((struct in6_addr *)x->coaddr)) |
0ebea8ef HX |
362 | err = -ENOENT; |
363 | spin_unlock(&x->lock); | |
2c8d7ca0 | 364 | |
0ebea8ef | 365 | return err; |
2c8d7ca0 NT |
366 | } |
367 | ||
368 | /* Routing Header type 2 is inserted. | |
369 | * IP Header's dst address is replaced with Routing Header's Home Address. | |
370 | */ | |
371 | static int mip6_rthdr_output(struct xfrm_state *x, struct sk_buff *skb) | |
372 | { | |
373 | struct ipv6hdr *iph; | |
374 | struct rt2_hdr *rt2; | |
375 | u8 nexthdr; | |
376 | ||
7b277b1a | 377 | skb_push(skb, -skb_network_offset(skb)); |
007f0211 | 378 | iph = ipv6_hdr(skb); |
2c8d7ca0 | 379 | |
007f0211 HX |
380 | nexthdr = *skb_mac_header(skb); |
381 | *skb_mac_header(skb) = IPPROTO_ROUTING; | |
2c8d7ca0 | 382 | |
9c70220b | 383 | rt2 = (struct rt2_hdr *)skb_transport_header(skb); |
2c8d7ca0 NT |
384 | rt2->rt_hdr.nexthdr = nexthdr; |
385 | rt2->rt_hdr.hdrlen = (x->props.header_len >> 3) - 1; | |
386 | rt2->rt_hdr.type = IPV6_SRCRT_TYPE_2; | |
387 | rt2->rt_hdr.segments_left = 1; | |
388 | memset(&rt2->reserved, 0, sizeof(rt2->reserved)); | |
389 | ||
547b792c | 390 | WARN_ON(rt2->rt_hdr.hdrlen != 2); |
2c8d7ca0 NT |
391 | |
392 | memcpy(&rt2->addr, &iph->daddr, sizeof(rt2->addr)); | |
b7c6538c | 393 | spin_lock_bh(&x->lock); |
2c8d7ca0 | 394 | memcpy(&iph->daddr, x->coaddr, sizeof(iph->daddr)); |
b7c6538c | 395 | spin_unlock_bh(&x->lock); |
2c8d7ca0 NT |
396 | |
397 | return 0; | |
398 | } | |
399 | ||
400 | static int mip6_rthdr_offset(struct xfrm_state *x, struct sk_buff *skb, | |
401 | u8 **nexthdr) | |
402 | { | |
403 | u16 offset = sizeof(struct ipv6hdr); | |
0660e03f ACM |
404 | struct ipv6_opt_hdr *exthdr = |
405 | (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1); | |
d56f90a7 | 406 | const unsigned char *nh = skb_network_header(skb); |
29a3cad5 SH |
407 | unsigned int packet_len = skb_tail_pointer(skb) - |
408 | skb_network_header(skb); | |
2c8d7ca0 NT |
409 | int found_rhdr = 0; |
410 | ||
0660e03f | 411 | *nexthdr = &ipv6_hdr(skb)->nexthdr; |
2c8d7ca0 NT |
412 | |
413 | while (offset + 1 <= packet_len) { | |
414 | ||
415 | switch (**nexthdr) { | |
416 | case NEXTHDR_HOP: | |
417 | break; | |
418 | case NEXTHDR_ROUTING: | |
419 | if (offset + 3 <= packet_len) { | |
420 | struct ipv6_rt_hdr *rt; | |
d56f90a7 | 421 | rt = (struct ipv6_rt_hdr *)(nh + offset); |
2c8d7ca0 NT |
422 | if (rt->type != 0) |
423 | return offset; | |
424 | } | |
425 | found_rhdr = 1; | |
426 | break; | |
427 | case NEXTHDR_DEST: | |
428 | if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0) | |
429 | return offset; | |
430 | ||
431 | if (found_rhdr) | |
432 | return offset; | |
433 | ||
434 | break; | |
435 | default: | |
436 | return offset; | |
437 | } | |
438 | ||
439 | offset += ipv6_optlen(exthdr); | |
440 | *nexthdr = &exthdr->nexthdr; | |
d56f90a7 | 441 | exthdr = (struct ipv6_opt_hdr *)(nh + offset); |
2c8d7ca0 NT |
442 | } |
443 | ||
444 | return offset; | |
445 | } | |
446 | ||
447 | static int mip6_rthdr_init_state(struct xfrm_state *x) | |
448 | { | |
449 | if (x->id.spi) { | |
f3213831 | 450 | pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi); |
2c8d7ca0 NT |
451 | return -EINVAL; |
452 | } | |
453 | if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) { | |
f3213831 JP |
454 | pr_info("%s: state's mode is not %u: %u\n", |
455 | __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode); | |
2c8d7ca0 NT |
456 | return -EINVAL; |
457 | } | |
458 | ||
459 | x->props.header_len = sizeof(struct rt2_hdr); | |
460 | ||
461 | return 0; | |
462 | } | |
463 | ||
464 | /* | |
465 | * Do nothing about destroying since it has no specific operation for routing | |
466 | * header type 2 unlike IPsec protocols. | |
467 | */ | |
468 | static void mip6_rthdr_destroy(struct xfrm_state *x) | |
469 | { | |
470 | } | |
471 | ||
533cb5b0 | 472 | static const struct xfrm_type mip6_rthdr_type = |
2c8d7ca0 NT |
473 | { |
474 | .description = "MIP6RT", | |
475 | .owner = THIS_MODULE, | |
476 | .proto = IPPROTO_ROUTING, | |
f04e7e8d | 477 | .flags = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_REMOTE_COADDR, |
2c8d7ca0 NT |
478 | .init_state = mip6_rthdr_init_state, |
479 | .destructor = mip6_rthdr_destroy, | |
480 | .input = mip6_rthdr_input, | |
481 | .output = mip6_rthdr_output, | |
482 | .hdr_offset = mip6_rthdr_offset, | |
2c8d7ca0 NT |
483 | }; |
484 | ||
59fbb3a6 | 485 | static int __init mip6_init(void) |
2c8d7ca0 | 486 | { |
f3213831 | 487 | pr_info("Mobile IPv6\n"); |
2c8d7ca0 | 488 | |
3d126890 | 489 | if (xfrm_register_type(&mip6_destopt_type, AF_INET6) < 0) { |
f3213831 | 490 | pr_info("%s: can't add xfrm type(destopt)\n", __func__); |
3d126890 NT |
491 | goto mip6_destopt_xfrm_fail; |
492 | } | |
2c8d7ca0 | 493 | if (xfrm_register_type(&mip6_rthdr_type, AF_INET6) < 0) { |
f3213831 | 494 | pr_info("%s: can't add xfrm type(rthdr)\n", __func__); |
2c8d7ca0 NT |
495 | goto mip6_rthdr_xfrm_fail; |
496 | } | |
59fbb3a6 | 497 | if (rawv6_mh_filter_register(mip6_mh_filter) < 0) { |
f3213831 | 498 | pr_info("%s: can't add rawv6 mh filter\n", __func__); |
59fbb3a6 MN |
499 | goto mip6_rawv6_mh_fail; |
500 | } | |
501 | ||
502 | ||
2c8d7ca0 NT |
503 | return 0; |
504 | ||
59fbb3a6 MN |
505 | mip6_rawv6_mh_fail: |
506 | xfrm_unregister_type(&mip6_rthdr_type, AF_INET6); | |
2c8d7ca0 | 507 | mip6_rthdr_xfrm_fail: |
3d126890 NT |
508 | xfrm_unregister_type(&mip6_destopt_type, AF_INET6); |
509 | mip6_destopt_xfrm_fail: | |
2c8d7ca0 NT |
510 | return -EAGAIN; |
511 | } | |
512 | ||
59fbb3a6 | 513 | static void __exit mip6_fini(void) |
2c8d7ca0 | 514 | { |
59fbb3a6 | 515 | if (rawv6_mh_filter_unregister(mip6_mh_filter) < 0) |
f3213831 | 516 | pr_info("%s: can't remove rawv6 mh filter\n", __func__); |
2c8d7ca0 | 517 | if (xfrm_unregister_type(&mip6_rthdr_type, AF_INET6) < 0) |
f3213831 | 518 | pr_info("%s: can't remove xfrm type(rthdr)\n", __func__); |
3d126890 | 519 | if (xfrm_unregister_type(&mip6_destopt_type, AF_INET6) < 0) |
f3213831 | 520 | pr_info("%s: can't remove xfrm type(destopt)\n", __func__); |
2c8d7ca0 | 521 | } |
59fbb3a6 MN |
522 | |
523 | module_init(mip6_init); | |
524 | module_exit(mip6_fini); | |
525 | ||
526 | MODULE_LICENSE("GPL"); | |
d3d6dd3a MN |
527 | MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_DSTOPTS); |
528 | MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ROUTING); |