~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv6/mip6.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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, see <http://www.gnu.org/licenses/>.
 17  */
 18 /*
 19  * Authors:
 20  *      Noriaki TAKAMIYA @USAGI
 21  *      Masahide NAKAMURA @USAGI
 22  */
 23 
 24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 25 
 26 #include <linux/module.h>
 27 #include <linux/skbuff.h>
 28 #include <linux/time.h>
 29 #include <linux/ipv6.h>
 30 #include <linux/icmpv6.h>
 31 #include <net/sock.h>
 32 #include <net/ipv6.h>
 33 #include <net/ip6_checksum.h>
 34 #include <net/rawv6.h>
 35 #include <net/xfrm.h>
 36 #include <net/mip6.h>
 37 
 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) {
 48                 data[0] = IPV6_TLV_PAD1;
 49         } else if (padlen > 1) {
 50                 data[0] = IPV6_TLV_PADN;
 51                 data[1] = padlen - 2;
 52                 if (padlen > 2)
 53                         memset(data+2, 0, data[1]);
 54         }
 55         return data + padlen;
 56 }
 57 
 58 static inline void mip6_param_prob(struct sk_buff *skb, u8 code, int pos)
 59 {
 60         icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
 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 
 86 static int mip6_mh_filter(struct sock *sk, struct sk_buff *skb)
 87 {
 88         struct ip6_mh _hdr;
 89         const struct ip6_mh *mh;
 90 
 91         mh = skb_header_pointer(skb, skb_transport_offset(skb),
 92                                 sizeof(_hdr), &_hdr);
 93         if (!mh)
 94                 return -1;
 95 
 96         if (((mh->ip6mh_hdrlen + 1) << 3) > skb->len)
 97                 return -1;
 98 
 99         if (mh->ip6mh_hdrlen < mip6_mh_len(mh->ip6mh_type)) {
100                 net_dbg_ratelimited("mip6: MH message too short: %d vs >=%d\n",
101                                     mh->ip6mh_hdrlen,
102                                     mip6_mh_len(mh->ip6mh_type));
103                 mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_hdrlen) +
104                                 skb_network_header_len(skb));
105                 return -1;
106         }
107 
108         if (mh->ip6mh_proto != IPPROTO_NONE) {
109                 net_dbg_ratelimited("mip6: MH invalid payload proto = %d\n",
110                                     mh->ip6mh_proto);
111                 mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_proto) +
112                                 skb_network_header_len(skb));
113                 return -1;
114         }
115 
116         return 0;
117 }
118 
119 struct mip6_report_rate_limiter {
120         spinlock_t lock;
121         ktime_t 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 = {
128         .lock = __SPIN_LOCK_UNLOCKED(mip6_report_rl.lock)
129 };
130 
131 static int mip6_destopt_input(struct xfrm_state *x, struct sk_buff *skb)
132 {
133         const struct ipv6hdr *iph = ipv6_hdr(skb);
134         struct ipv6_destopt_hdr *destopt = (struct ipv6_destopt_hdr *)skb->data;
135         int err = destopt->nexthdr;
136 
137         spin_lock(&x->lock);
138         if (!ipv6_addr_equal(&iph->saddr, (struct in6_addr *)x->coaddr) &&
139             !ipv6_addr_any((struct in6_addr *)x->coaddr))
140                 err = -ENOENT;
141         spin_unlock(&x->lock);
142 
143         return err;
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 
158         skb_push(skb, -skb_network_offset(skb));
159         iph = ipv6_hdr(skb);
160 
161         nexthdr = *skb_mac_header(skb);
162         *skb_mac_header(skb) = IPPROTO_DSTOPTS;
163 
164         dstopt = (struct ipv6_destopt_hdr *)skb_transport_header(skb);
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;
171         BUILD_BUG_ON(sizeof(*hao) != 18);
172         hao->length = sizeof(*hao) - 2;
173 
174         len = ((char *)hao - (char *)dstopt) + sizeof(*hao);
175 
176         memcpy(&hao->addr, &iph->saddr, sizeof(hao->addr));
177         spin_lock_bh(&x->lock);
178         memcpy(&iph->saddr, x->coaddr, sizeof(iph->saddr));
179         spin_unlock_bh(&x->lock);
180 
181         WARN_ON(len != x->props.header_len);
182         dstopt->hdrlen = (x->props.header_len >> 3) - 1;
183 
184         return 0;
185 }
186 
187 static inline int mip6_report_rl_allow(ktime_t stamp,
188                                        const struct in6_addr *dst,
189                                        const struct in6_addr *src, int iif)
190 {
191         int allow = 0;
192 
193         spin_lock_bh(&mip6_report_rl.lock);
194         if (mip6_report_rl.stamp != stamp ||
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 = stamp;
199                 mip6_report_rl.iif = iif;
200                 mip6_report_rl.src = *src;
201                 mip6_report_rl.dst = *dst;
202                 allow = 1;
203         }
204         spin_unlock_bh(&mip6_report_rl.lock);
205         return allow;
206 }
207 
208 static int mip6_destopt_reject(struct xfrm_state *x, struct sk_buff *skb,
209                                const struct flowi *fl)
210 {
211         struct net *net = xs_net(x);
212         struct inet6_skb_parm *opt = (struct inet6_skb_parm *)skb->cb;
213         const struct flowi6 *fl6 = &fl->u.ip6;
214         struct ipv6_destopt_hao *hao = NULL;
215         struct xfrm_selector sel;
216         int offset;
217         ktime_t stamp;
218         int err = 0;
219 
220         if (unlikely(fl6->flowi6_proto == IPPROTO_MH &&
221                      fl6->fl6_mh_type <= IP6_MH_TYPE_MAX))
222                 goto out;
223 
224         if (likely(opt->dsthao)) {
225                 offset = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
226                 if (likely(offset >= 0))
227                         hao = (struct ipv6_destopt_hao *)
228                                         (skb_network_header(skb) + offset);
229         }
230 
231         stamp = skb_get_ktime(skb);
232 
233         if (!mip6_report_rl_allow(stamp, &ipv6_hdr(skb)->daddr,
234                                   hao ? &hao->addr : &ipv6_hdr(skb)->saddr,
235                                   opt->iif))
236                 goto out;
237 
238         memset(&sel, 0, sizeof(sel));
239         memcpy(&sel.daddr, (xfrm_address_t *)&ipv6_hdr(skb)->daddr,
240                sizeof(sel.daddr));
241         sel.prefixlen_d = 128;
242         memcpy(&sel.saddr, (xfrm_address_t *)&ipv6_hdr(skb)->saddr,
243                sizeof(sel.saddr));
244         sel.prefixlen_s = 128;
245         sel.family = AF_INET6;
246         sel.proto = fl6->flowi6_proto;
247         sel.dport = xfrm_flowi_dport(fl, &fl6->uli);
248         if (sel.dport)
249                 sel.dport_mask = htons(~0);
250         sel.sport = xfrm_flowi_sport(fl, &fl6->uli);
251         if (sel.sport)
252                 sel.sport_mask = htons(~0);
253         sel.ifindex = fl6->flowi6_oif;
254 
255         err = km_report(net, IPPROTO_DSTOPTS, &sel,
256                         (hao ? (xfrm_address_t *)&hao->addr : NULL));
257 
258  out:
259         return err;
260 }
261 
262 static int mip6_destopt_offset(struct xfrm_state *x, struct sk_buff *skb,
263                                u8 **nexthdr)
264 {
265         u16 offset = sizeof(struct ipv6hdr);
266         struct ipv6_opt_hdr *exthdr =
267                                    (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1);
268         const unsigned char *nh = skb_network_header(skb);
269         unsigned int packet_len = skb_tail_pointer(skb) -
270                 skb_network_header(skb);
271         int found_rhdr = 0;
272 
273         *nexthdr = &ipv6_hdr(skb)->nexthdr;
274 
275         while (offset + 1 <= packet_len) {
276 
277                 switch (**nexthdr) {
278                 case NEXTHDR_HOP:
279                         break;
280                 case NEXTHDR_ROUTING:
281                         found_rhdr = 1;
282                         break;
283                 case NEXTHDR_DEST:
284                         /*
285                          * HAO MUST NOT appear more than once.
286                          * XXX: It is better to try to find by the end of
287                          * XXX: packet if HAO exists.
288                          */
289                         if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0) {
290                                 net_dbg_ratelimited("mip6: hao exists already, override\n");
291                                 return offset;
292                         }
293 
294                         if (found_rhdr)
295                                 return offset;
296 
297                         break;
298                 default:
299                         return offset;
300                 }
301 
302                 offset += ipv6_optlen(exthdr);
303                 *nexthdr = &exthdr->nexthdr;
304                 exthdr = (struct ipv6_opt_hdr *)(nh + offset);
305         }
306 
307         return offset;
308 }
309 
310 static int mip6_destopt_init_state(struct xfrm_state *x)
311 {
312         if (x->id.spi) {
313                 pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi);
314                 return -EINVAL;
315         }
316         if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) {
317                 pr_info("%s: state's mode is not %u: %u\n",
318                         __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode);
319                 return -EINVAL;
320         }
321 
322         x->props.header_len = sizeof(struct ipv6_destopt_hdr) +
323                 calc_padlen(sizeof(struct ipv6_destopt_hdr), 6) +
324                 sizeof(struct ipv6_destopt_hao);
325         WARN_ON(x->props.header_len != 24);
326 
327         return 0;
328 }
329 
330 /*
331  * Do nothing about destroying since it has no specific operation for
332  * destination options header unlike IPsec protocols.
333  */
334 static void mip6_destopt_destroy(struct xfrm_state *x)
335 {
336 }
337 
338 static const struct xfrm_type mip6_destopt_type = {
339         .description    = "MIP6DESTOPT",
340         .owner          = THIS_MODULE,
341         .proto          = IPPROTO_DSTOPTS,
342         .flags          = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_LOCAL_COADDR,
343         .init_state     = mip6_destopt_init_state,
344         .destructor     = mip6_destopt_destroy,
345         .input          = mip6_destopt_input,
346         .output         = mip6_destopt_output,
347         .reject         = mip6_destopt_reject,
348         .hdr_offset     = mip6_destopt_offset,
349 };
350 
351 static int mip6_rthdr_input(struct xfrm_state *x, struct sk_buff *skb)
352 {
353         const struct ipv6hdr *iph = ipv6_hdr(skb);
354         struct rt2_hdr *rt2 = (struct rt2_hdr *)skb->data;
355         int err = rt2->rt_hdr.nexthdr;
356 
357         spin_lock(&x->lock);
358         if (!ipv6_addr_equal(&iph->daddr, (struct in6_addr *)x->coaddr) &&
359             !ipv6_addr_any((struct in6_addr *)x->coaddr))
360                 err = -ENOENT;
361         spin_unlock(&x->lock);
362 
363         return err;
364 }
365 
366 /* Routing Header type 2 is inserted.
367  * IP Header's dst address is replaced with Routing Header's Home Address.
368  */
369 static int mip6_rthdr_output(struct xfrm_state *x, struct sk_buff *skb)
370 {
371         struct ipv6hdr *iph;
372         struct rt2_hdr *rt2;
373         u8 nexthdr;
374 
375         skb_push(skb, -skb_network_offset(skb));
376         iph = ipv6_hdr(skb);
377 
378         nexthdr = *skb_mac_header(skb);
379         *skb_mac_header(skb) = IPPROTO_ROUTING;
380 
381         rt2 = (struct rt2_hdr *)skb_transport_header(skb);
382         rt2->rt_hdr.nexthdr = nexthdr;
383         rt2->rt_hdr.hdrlen = (x->props.header_len >> 3) - 1;
384         rt2->rt_hdr.type = IPV6_SRCRT_TYPE_2;
385         rt2->rt_hdr.segments_left = 1;
386         memset(&rt2->reserved, 0, sizeof(rt2->reserved));
387 
388         WARN_ON(rt2->rt_hdr.hdrlen != 2);
389 
390         memcpy(&rt2->addr, &iph->daddr, sizeof(rt2->addr));
391         spin_lock_bh(&x->lock);
392         memcpy(&iph->daddr, x->coaddr, sizeof(iph->daddr));
393         spin_unlock_bh(&x->lock);
394 
395         return 0;
396 }
397 
398 static int mip6_rthdr_offset(struct xfrm_state *x, struct sk_buff *skb,
399                              u8 **nexthdr)
400 {
401         u16 offset = sizeof(struct ipv6hdr);
402         struct ipv6_opt_hdr *exthdr =
403                                    (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1);
404         const unsigned char *nh = skb_network_header(skb);
405         unsigned int packet_len = skb_tail_pointer(skb) -
406                 skb_network_header(skb);
407         int found_rhdr = 0;
408 
409         *nexthdr = &ipv6_hdr(skb)->nexthdr;
410 
411         while (offset + 1 <= packet_len) {
412 
413                 switch (**nexthdr) {
414                 case NEXTHDR_HOP:
415                         break;
416                 case NEXTHDR_ROUTING:
417                         if (offset + 3 <= packet_len) {
418                                 struct ipv6_rt_hdr *rt;
419                                 rt = (struct ipv6_rt_hdr *)(nh + offset);
420                                 if (rt->type != 0)
421                                         return offset;
422                         }
423                         found_rhdr = 1;
424                         break;
425                 case NEXTHDR_DEST:
426                         if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0)
427                                 return offset;
428 
429                         if (found_rhdr)
430                                 return offset;
431 
432                         break;
433                 default:
434                         return offset;
435                 }
436 
437                 offset += ipv6_optlen(exthdr);
438                 *nexthdr = &exthdr->nexthdr;
439                 exthdr = (struct ipv6_opt_hdr *)(nh + offset);
440         }
441 
442         return offset;
443 }
444 
445 static int mip6_rthdr_init_state(struct xfrm_state *x)
446 {
447         if (x->id.spi) {
448                 pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi);
449                 return -EINVAL;
450         }
451         if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) {
452                 pr_info("%s: state's mode is not %u: %u\n",
453                         __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode);
454                 return -EINVAL;
455         }
456 
457         x->props.header_len = sizeof(struct rt2_hdr);
458 
459         return 0;
460 }
461 
462 /*
463  * Do nothing about destroying since it has no specific operation for routing
464  * header type 2 unlike IPsec protocols.
465  */
466 static void mip6_rthdr_destroy(struct xfrm_state *x)
467 {
468 }
469 
470 static const struct xfrm_type mip6_rthdr_type = {
471         .description    = "MIP6RT",
472         .owner          = THIS_MODULE,
473         .proto          = IPPROTO_ROUTING,
474         .flags          = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_REMOTE_COADDR,
475         .init_state     = mip6_rthdr_init_state,
476         .destructor     = mip6_rthdr_destroy,
477         .input          = mip6_rthdr_input,
478         .output         = mip6_rthdr_output,
479         .hdr_offset     = mip6_rthdr_offset,
480 };
481 
482 static int __init mip6_init(void)
483 {
484         pr_info("Mobile IPv6\n");
485 
486         if (xfrm_register_type(&mip6_destopt_type, AF_INET6) < 0) {
487                 pr_info("%s: can't add xfrm type(destopt)\n", __func__);
488                 goto mip6_destopt_xfrm_fail;
489         }
490         if (xfrm_register_type(&mip6_rthdr_type, AF_INET6) < 0) {
491                 pr_info("%s: can't add xfrm type(rthdr)\n", __func__);
492                 goto mip6_rthdr_xfrm_fail;
493         }
494         if (rawv6_mh_filter_register(mip6_mh_filter) < 0) {
495                 pr_info("%s: can't add rawv6 mh filter\n", __func__);
496                 goto mip6_rawv6_mh_fail;
497         }
498 
499 
500         return 0;
501 
502  mip6_rawv6_mh_fail:
503         xfrm_unregister_type(&mip6_rthdr_type, AF_INET6);
504  mip6_rthdr_xfrm_fail:
505         xfrm_unregister_type(&mip6_destopt_type, AF_INET6);
506  mip6_destopt_xfrm_fail:
507         return -EAGAIN;
508 }
509 
510 static void __exit mip6_fini(void)
511 {
512         if (rawv6_mh_filter_unregister(mip6_mh_filter) < 0)
513                 pr_info("%s: can't remove rawv6 mh filter\n", __func__);
514         if (xfrm_unregister_type(&mip6_rthdr_type, AF_INET6) < 0)
515                 pr_info("%s: can't remove xfrm type(rthdr)\n", __func__);
516         if (xfrm_unregister_type(&mip6_destopt_type, AF_INET6) < 0)
517                 pr_info("%s: can't remove xfrm type(destopt)\n", __func__);
518 }
519 
520 module_init(mip6_init);
521 module_exit(mip6_fini);
522 
523 MODULE_LICENSE("GPL");
524 MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_DSTOPTS);
525 MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ROUTING);
526 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp