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 | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 | */ | |
19 | /* | |
20 | * Authors: | |
21 | * Noriaki TAKAMIYA @USAGI | |
22 | * Masahide NAKAMURA @USAGI | |
23 | */ | |
24 | ||
f3213831 JP |
25 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
26 | ||
2c8d7ca0 NT |
27 | #include <linux/module.h> |
28 | #include <linux/skbuff.h> | |
70182ed2 | 29 | #include <linux/time.h> |
2c8d7ca0 | 30 | #include <linux/ipv6.h> |
7be96f76 MN |
31 | #include <linux/icmpv6.h> |
32 | #include <net/sock.h> | |
2c8d7ca0 | 33 | #include <net/ipv6.h> |
7be96f76 | 34 | #include <net/ip6_checksum.h> |
59fbb3a6 | 35 | #include <net/rawv6.h> |
2c8d7ca0 NT |
36 | #include <net/xfrm.h> |
37 | #include <net/mip6.h> | |
38 | ||
3d126890 NT |
39 | static inline unsigned int calc_padlen(unsigned int len, unsigned int n) |
40 | { | |
41 | return (n - len + 16) & 0x7; | |
42 | } | |
43 | ||
44 | static inline void *mip6_padn(__u8 *data, __u8 padlen) | |
45 | { | |
46 | if (!data) | |
47 | return NULL; | |
48 | if (padlen == 1) { | |
1de5a71c | 49 | data[0] = IPV6_TLV_PAD1; |
3d126890 | 50 | } else if (padlen > 1) { |
7f1eced8 | 51 | data[0] = IPV6_TLV_PADN; |
3d126890 NT |
52 | data[1] = padlen - 2; |
53 | if (padlen > 2) | |
54 | memset(data+2, 0, data[1]); | |
55 | } | |
56 | return data + padlen; | |
57 | } | |
58 | ||
d5fdd6ba | 59 | static inline void mip6_param_prob(struct sk_buff *skb, u8 code, int pos) |
7be96f76 | 60 | { |
3ffe533c | 61 | icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos); |
7be96f76 MN |
62 | } |
63 | ||
64 | static int mip6_mh_len(int type) | |
65 | { | |
66 | int len = 0; | |
67 | ||
68 | switch (type) { | |
69 | case IP6_MH_TYPE_BRR: | |
70 | len = 0; | |
71 | break; | |
72 | case IP6_MH_TYPE_HOTI: | |
73 | case IP6_MH_TYPE_COTI: | |
74 | case IP6_MH_TYPE_BU: | |
75 | case IP6_MH_TYPE_BACK: | |
76 | len = 1; | |
77 | break; | |
78 | case IP6_MH_TYPE_HOT: | |
79 | case IP6_MH_TYPE_COT: | |
80 | case IP6_MH_TYPE_BERROR: | |
81 | len = 2; | |
82 | break; | |
83 | } | |
84 | return len; | |
85 | } | |
86 | ||
59fbb3a6 | 87 | static int mip6_mh_filter(struct sock *sk, struct sk_buff *skb) |
7be96f76 | 88 | { |
96af69ea ED |
89 | struct ip6_mh _hdr; |
90 | const struct ip6_mh *mh; | |
7be96f76 | 91 | |
96af69ea ED |
92 | mh = skb_header_pointer(skb, skb_transport_offset(skb), |
93 | sizeof(_hdr), &_hdr); | |
94 | if (!mh) | |
7be96f76 MN |
95 | return -1; |
96 | ||
96af69ea ED |
97 | if (((mh->ip6mh_hdrlen + 1) << 3) > skb->len) |
98 | return -1; | |
7be96f76 MN |
99 | |
100 | if (mh->ip6mh_hdrlen < mip6_mh_len(mh->ip6mh_type)) { | |
101 | LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH message too short: %d vs >=%d\n", | |
102 | mh->ip6mh_hdrlen, mip6_mh_len(mh->ip6mh_type)); | |
96af69ea ED |
103 | mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_hdrlen) + |
104 | skb_network_header_len(skb)); | |
7be96f76 MN |
105 | return -1; |
106 | } | |
7be96f76 MN |
107 | |
108 | if (mh->ip6mh_proto != IPPROTO_NONE) { | |
109 | LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH invalid payload proto = %d\n", | |
110 | mh->ip6mh_proto); | |
96af69ea ED |
111 | mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_proto) + |
112 | skb_network_header_len(skb)); | |
7be96f76 MN |
113 | return -1; |
114 | } | |
115 | ||
116 | return 0; | |
117 | } | |
118 | ||
70182ed2 MN |
119 | struct mip6_report_rate_limiter { |
120 | spinlock_t lock; | |
121 | struct timeval stamp; | |
122 | int iif; | |
123 | struct in6_addr src; | |
124 | struct in6_addr dst; | |
125 | }; | |
126 | ||
127 | static struct mip6_report_rate_limiter mip6_report_rl = { | |
4ef8d0ae | 128 | .lock = __SPIN_LOCK_UNLOCKED(mip6_report_rl.lock) |
70182ed2 MN |
129 | }; |
130 | ||
3d126890 NT |
131 | static int mip6_destopt_input(struct xfrm_state *x, struct sk_buff *skb) |
132 | { | |
b71d1d42 | 133 | const struct ipv6hdr *iph = ipv6_hdr(skb); |
3d126890 | 134 | struct ipv6_destopt_hdr *destopt = (struct ipv6_destopt_hdr *)skb->data; |
0ebea8ef | 135 | int err = destopt->nexthdr; |
3d126890 | 136 | |
0ebea8ef | 137 | spin_lock(&x->lock); |
3d126890 NT |
138 | if (!ipv6_addr_equal(&iph->saddr, (struct in6_addr *)x->coaddr) && |
139 | !ipv6_addr_any((struct in6_addr *)x->coaddr)) | |
0ebea8ef HX |
140 | err = -ENOENT; |
141 | spin_unlock(&x->lock); | |
3d126890 | 142 | |
0ebea8ef | 143 | return err; |
3d126890 NT |
144 | } |
145 | ||
146 | /* Destination Option Header is inserted. | |
147 | * IP Header's src address is replaced with Home Address Option in | |
148 | * Destination Option Header. | |
149 | */ | |
150 | static int mip6_destopt_output(struct xfrm_state *x, struct sk_buff *skb) | |
151 | { | |
152 | struct ipv6hdr *iph; | |
153 | struct ipv6_destopt_hdr *dstopt; | |
154 | struct ipv6_destopt_hao *hao; | |
155 | u8 nexthdr; | |
156 | int len; | |
157 | ||
7b277b1a | 158 | skb_push(skb, -skb_network_offset(skb)); |
007f0211 | 159 | iph = ipv6_hdr(skb); |
3d126890 | 160 | |
007f0211 HX |
161 | nexthdr = *skb_mac_header(skb); |
162 | *skb_mac_header(skb) = IPPROTO_DSTOPTS; | |
3d126890 | 163 | |
9c70220b | 164 | dstopt = (struct ipv6_destopt_hdr *)skb_transport_header(skb); |
3d126890 NT |
165 | dstopt->nexthdr = nexthdr; |
166 | ||
167 | hao = mip6_padn((char *)(dstopt + 1), | |
168 | calc_padlen(sizeof(*dstopt), 6)); | |
169 | ||
170 | hao->type = IPV6_TLV_HAO; | |
547b792c | 171 | BUILD_BUG_ON(sizeof(*hao) != 18); |
3d126890 | 172 | hao->length = sizeof(*hao) - 2; |
3d126890 NT |
173 | |
174 | len = ((char *)hao - (char *)dstopt) + sizeof(*hao); | |
175 | ||
176 | memcpy(&hao->addr, &iph->saddr, sizeof(hao->addr)); | |
b7c6538c | 177 | spin_lock_bh(&x->lock); |
3d126890 | 178 | memcpy(&iph->saddr, x->coaddr, sizeof(iph->saddr)); |
b7c6538c | 179 | spin_unlock_bh(&x->lock); |
3d126890 | 180 | |
547b792c | 181 | WARN_ON(len != x->props.header_len); |
3d126890 NT |
182 | dstopt->hdrlen = (x->props.header_len >> 3) - 1; |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
70182ed2 | 187 | static inline int mip6_report_rl_allow(struct timeval *stamp, |
b71d1d42 ED |
188 | const struct in6_addr *dst, |
189 | const struct in6_addr *src, int iif) | |
70182ed2 MN |
190 | { |
191 | int allow = 0; | |
192 | ||
193 | spin_lock_bh(&mip6_report_rl.lock); | |
194 | if (mip6_report_rl.stamp.tv_sec != stamp->tv_sec || | |
195 | mip6_report_rl.stamp.tv_usec != stamp->tv_usec || | |
196 | mip6_report_rl.iif != iif || | |
197 | !ipv6_addr_equal(&mip6_report_rl.src, src) || | |
198 | !ipv6_addr_equal(&mip6_report_rl.dst, dst)) { | |
199 | mip6_report_rl.stamp.tv_sec = stamp->tv_sec; | |
200 | mip6_report_rl.stamp.tv_usec = stamp->tv_usec; | |
201 | mip6_report_rl.iif = iif; | |
4e3fd7a0 AD |
202 | mip6_report_rl.src = *src; |
203 | mip6_report_rl.dst = *dst; | |
70182ed2 MN |
204 | allow = 1; |
205 | } | |
206 | spin_unlock_bh(&mip6_report_rl.lock); | |
207 | return allow; | |
208 | } | |
209 | ||
8f029de2 DM |
210 | static int mip6_destopt_reject(struct xfrm_state *x, struct sk_buff *skb, |
211 | const struct flowi *fl) | |
70182ed2 | 212 | { |
db983c11 | 213 | struct net *net = xs_net(x); |
70182ed2 | 214 | struct inet6_skb_parm *opt = (struct inet6_skb_parm *)skb->cb; |
4c9483b2 | 215 | const struct flowi6 *fl6 = &fl->u.ip6; |
70182ed2 MN |
216 | struct ipv6_destopt_hao *hao = NULL; |
217 | struct xfrm_selector sel; | |
218 | int offset; | |
219 | struct timeval stamp; | |
220 | int err = 0; | |
221 | ||
4c9483b2 | 222 | if (unlikely(fl6->flowi6_proto == IPPROTO_MH && |
1958b856 | 223 | fl6->fl6_mh_type <= IP6_MH_TYPE_MAX)) |
01be8e5d MN |
224 | goto out; |
225 | ||
70182ed2 MN |
226 | if (likely(opt->dsthao)) { |
227 | offset = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO); | |
228 | if (likely(offset >= 0)) | |
d56f90a7 ACM |
229 | hao = (struct ipv6_destopt_hao *) |
230 | (skb_network_header(skb) + offset); | |
70182ed2 MN |
231 | } |
232 | ||
233 | skb_get_timestamp(skb, &stamp); | |
234 | ||
0660e03f ACM |
235 | if (!mip6_report_rl_allow(&stamp, &ipv6_hdr(skb)->daddr, |
236 | hao ? &hao->addr : &ipv6_hdr(skb)->saddr, | |
70182ed2 MN |
237 | opt->iif)) |
238 | goto out; | |
239 | ||
240 | memset(&sel, 0, sizeof(sel)); | |
0660e03f | 241 | memcpy(&sel.daddr, (xfrm_address_t *)&ipv6_hdr(skb)->daddr, |
70182ed2 MN |
242 | sizeof(sel.daddr)); |
243 | sel.prefixlen_d = 128; | |
0660e03f | 244 | memcpy(&sel.saddr, (xfrm_address_t *)&ipv6_hdr(skb)->saddr, |
70182ed2 MN |
245 | sizeof(sel.saddr)); |
246 | sel.prefixlen_s = 128; | |
247 | sel.family = AF_INET6; | |
4c9483b2 DM |
248 | sel.proto = fl6->flowi6_proto; |
249 | sel.dport = xfrm_flowi_dport(fl, &fl6->uli); | |
70182ed2 | 250 | if (sel.dport) |
e69a4adc | 251 | sel.dport_mask = htons(~0); |
4c9483b2 | 252 | sel.sport = xfrm_flowi_sport(fl, &fl6->uli); |
70182ed2 | 253 | if (sel.sport) |
e69a4adc | 254 | sel.sport_mask = htons(~0); |
4c9483b2 | 255 | sel.ifindex = fl6->flowi6_oif; |
70182ed2 | 256 | |
db983c11 | 257 | err = km_report(net, IPPROTO_DSTOPTS, &sel, |
70182ed2 MN |
258 | (hao ? (xfrm_address_t *)&hao->addr : NULL)); |
259 | ||
260 | out: | |
261 | return err; | |
262 | } | |
263 | ||
3d126890 NT |
264 | static int mip6_destopt_offset(struct xfrm_state *x, struct sk_buff *skb, |
265 | u8 **nexthdr) | |
266 | { | |
267 | u16 offset = sizeof(struct ipv6hdr); | |
0660e03f ACM |
268 | struct ipv6_opt_hdr *exthdr = |
269 | (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1); | |
d56f90a7 | 270 | const unsigned char *nh = skb_network_header(skb); |
27a884dc | 271 | unsigned int packet_len = skb->tail - skb->network_header; |
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); |
27a884dc | 407 | unsigned int packet_len = skb->tail - skb->network_header; |
2c8d7ca0 NT |
408 | int found_rhdr = 0; |
409 | ||
0660e03f | 410 | *nexthdr = &ipv6_hdr(skb)->nexthdr; |
2c8d7ca0 NT |
411 | |
412 | while (offset + 1 <= packet_len) { | |
413 | ||
414 | switch (**nexthdr) { | |
415 | case NEXTHDR_HOP: | |
416 | break; | |
417 | case NEXTHDR_ROUTING: | |
418 | if (offset + 3 <= packet_len) { | |
419 | struct ipv6_rt_hdr *rt; | |
d56f90a7 | 420 | rt = (struct ipv6_rt_hdr *)(nh + offset); |
2c8d7ca0 NT |
421 | if (rt->type != 0) |
422 | return offset; | |
423 | } | |
424 | found_rhdr = 1; | |
425 | break; | |
426 | case NEXTHDR_DEST: | |
427 | if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0) | |
428 | return offset; | |
429 | ||
430 | if (found_rhdr) | |
431 | return offset; | |
432 | ||
433 | break; | |
434 | default: | |
435 | return offset; | |
436 | } | |
437 | ||
438 | offset += ipv6_optlen(exthdr); | |
439 | *nexthdr = &exthdr->nexthdr; | |
d56f90a7 | 440 | exthdr = (struct ipv6_opt_hdr *)(nh + offset); |
2c8d7ca0 NT |
441 | } |
442 | ||
443 | return offset; | |
444 | } | |
445 | ||
446 | static int mip6_rthdr_init_state(struct xfrm_state *x) | |
447 | { | |
448 | if (x->id.spi) { | |
f3213831 | 449 | pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi); |
2c8d7ca0 NT |
450 | return -EINVAL; |
451 | } | |
452 | if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) { | |
f3213831 JP |
453 | pr_info("%s: state's mode is not %u: %u\n", |
454 | __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode); | |
2c8d7ca0 NT |
455 | return -EINVAL; |
456 | } | |
457 | ||
458 | x->props.header_len = sizeof(struct rt2_hdr); | |
459 | ||
460 | return 0; | |
461 | } | |
462 | ||
463 | /* | |
464 | * Do nothing about destroying since it has no specific operation for routing | |
465 | * header type 2 unlike IPsec protocols. | |
466 | */ | |
467 | static void mip6_rthdr_destroy(struct xfrm_state *x) | |
468 | { | |
469 | } | |
470 | ||
533cb5b0 | 471 | static const struct xfrm_type mip6_rthdr_type = |
2c8d7ca0 NT |
472 | { |
473 | .description = "MIP6RT", | |
474 | .owner = THIS_MODULE, | |
475 | .proto = IPPROTO_ROUTING, | |
f04e7e8d | 476 | .flags = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_REMOTE_COADDR, |
2c8d7ca0 NT |
477 | .init_state = mip6_rthdr_init_state, |
478 | .destructor = mip6_rthdr_destroy, | |
479 | .input = mip6_rthdr_input, | |
480 | .output = mip6_rthdr_output, | |
481 | .hdr_offset = mip6_rthdr_offset, | |
2c8d7ca0 NT |
482 | }; |
483 | ||
59fbb3a6 | 484 | static int __init mip6_init(void) |
2c8d7ca0 | 485 | { |
f3213831 | 486 | pr_info("Mobile IPv6\n"); |
2c8d7ca0 | 487 | |
3d126890 | 488 | if (xfrm_register_type(&mip6_destopt_type, AF_INET6) < 0) { |
f3213831 | 489 | pr_info("%s: can't add xfrm type(destopt)\n", __func__); |
3d126890 NT |
490 | goto mip6_destopt_xfrm_fail; |
491 | } | |
2c8d7ca0 | 492 | if (xfrm_register_type(&mip6_rthdr_type, AF_INET6) < 0) { |
f3213831 | 493 | pr_info("%s: can't add xfrm type(rthdr)\n", __func__); |
2c8d7ca0 NT |
494 | goto mip6_rthdr_xfrm_fail; |
495 | } | |
59fbb3a6 | 496 | if (rawv6_mh_filter_register(mip6_mh_filter) < 0) { |
f3213831 | 497 | pr_info("%s: can't add rawv6 mh filter\n", __func__); |
59fbb3a6 MN |
498 | goto mip6_rawv6_mh_fail; |
499 | } | |
500 | ||
501 | ||
2c8d7ca0 NT |
502 | return 0; |
503 | ||
59fbb3a6 MN |
504 | mip6_rawv6_mh_fail: |
505 | xfrm_unregister_type(&mip6_rthdr_type, AF_INET6); | |
2c8d7ca0 | 506 | mip6_rthdr_xfrm_fail: |
3d126890 NT |
507 | xfrm_unregister_type(&mip6_destopt_type, AF_INET6); |
508 | mip6_destopt_xfrm_fail: | |
2c8d7ca0 NT |
509 | return -EAGAIN; |
510 | } | |
511 | ||
59fbb3a6 | 512 | static void __exit mip6_fini(void) |
2c8d7ca0 | 513 | { |
59fbb3a6 | 514 | if (rawv6_mh_filter_unregister(mip6_mh_filter) < 0) |
f3213831 | 515 | pr_info("%s: can't remove rawv6 mh filter\n", __func__); |
2c8d7ca0 | 516 | if (xfrm_unregister_type(&mip6_rthdr_type, AF_INET6) < 0) |
f3213831 | 517 | pr_info("%s: can't remove xfrm type(rthdr)\n", __func__); |
3d126890 | 518 | if (xfrm_unregister_type(&mip6_destopt_type, AF_INET6) < 0) |
f3213831 | 519 | pr_info("%s: can't remove xfrm type(destopt)\n", __func__); |
2c8d7ca0 | 520 | } |
59fbb3a6 MN |
521 | |
522 | module_init(mip6_init); | |
523 | module_exit(mip6_fini); | |
524 | ||
525 | MODULE_LICENSE("GPL"); | |
d3d6dd3a MN |
526 | MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_DSTOPTS); |
527 | MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ROUTING); |