?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
KEYS: add missing permission check for request_key() destination
[linux/fpc-iii.git] / net / ipv6 / route.c
blobd791d769d858fefa809750f48eff60016b3471de
1 /*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14 /* Changes:
15 *
16 * YOSHIFUJI Hideaki @USAGI
17 * reworked default router selection.
18 * - respect outgoing interface
19 * - select from (probably) reachable routers (i.e.
20 * routers in REACHABLE, STALE, DELAY or PROBE states).
21 * - always select the same router if it is (probably)
22 * reachable. otherwise, round-robin the list.
23 * Ville Nuorvala
24 * Fixed routing subtrees.
25 */
26
27 #define pr_fmt(fmt) "IPv6: " fmt
28
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/export.h>
32 #include <linux/types.h>
33 #include <linux/times.h>
34 #include <linux/socket.h>
35 #include <linux/sockios.h>
36 #include <linux/net.h>
37 #include <linux/route.h>
38 #include <linux/netdevice.h>
39 #include <linux/in6.h>
40 #include <linux/mroute6.h>
41 #include <linux/init.h>
42 #include <linux/if_arp.h>
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
45 #include <linux/nsproxy.h>
46 #include <linux/slab.h>
47 #include <net/net_namespace.h>
48 #include <net/snmp.h>
49 #include <net/ipv6.h>
50 #include <net/ip6_fib.h>
51 #include <net/ip6_route.h>
52 #include <net/ndisc.h>
53 #include <net/addrconf.h>
54 #include <net/tcp.h>
55 #include <linux/rtnetlink.h>
56 #include <net/dst.h>
57 #include <net/xfrm.h>
58 #include <net/netevent.h>
59 #include <net/netlink.h>
60 #include <net/nexthop.h>
61
62 #include <asm/uaccess.h>
63
64 #ifdef CONFIG_SYSCTL
65 #include <linux/sysctl.h>
66 #endif
67
68 enum rt6_nud_state {
69 RT6_NUD_FAIL_HARD = -3,
70 RT6_NUD_FAIL_PROBE = -2,
71 RT6_NUD_FAIL_DO_RR = -1,
72 RT6_NUD_SUCCEED = 1
73 };
74
75 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
76 const struct in6_addr *dest);
77 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
78 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
79 static unsigned int ip6_mtu(const struct dst_entry *dst);
80 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
81 static void ip6_dst_destroy(struct dst_entry *);
82 static void ip6_dst_ifdown(struct dst_entry *,
83 struct net_device *dev, int how);
84 static int ip6_dst_gc(struct dst_ops *ops);
85
86 static int ip6_pkt_discard(struct sk_buff *skb);
87 static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb);
88 static int ip6_pkt_prohibit(struct sk_buff *skb);
89 static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb);
90 static void ip6_link_failure(struct sk_buff *skb);
91 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
92 struct sk_buff *skb, u32 mtu);
93 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
94 struct sk_buff *skb);
95 static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
96
97 #ifdef CONFIG_IPV6_ROUTE_INFO
98 static struct rt6_info *rt6_add_route_info(struct net *net,
99 const struct in6_addr *prefix, int prefixlen,
100 const struct in6_addr *gwaddr, int ifindex,
101 unsigned int pref);
102 static struct rt6_info *rt6_get_route_info(struct net *net,
103 const struct in6_addr *prefix, int prefixlen,
104 const struct in6_addr *gwaddr, int ifindex);
105 #endif
106
107 static void rt6_bind_peer(struct rt6_info *rt, int create)
108 {
109 struct inet_peer_base *base;
110 struct inet_peer *peer;
111
112 base = inetpeer_base_ptr(rt->_rt6i_peer);
113 if (!base)
114 return;
115
116 peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
117 if (peer) {
118 if (!rt6_set_peer(rt, peer))
119 inet_putpeer(peer);
120 }
121 }
122
123 static struct inet_peer *__rt6_get_peer(struct rt6_info *rt, int create)
124 {
125 if (rt6_has_peer(rt))
126 return rt6_peer_ptr(rt);
127
128 rt6_bind_peer(rt, create);
129 return (rt6_has_peer(rt) ? rt6_peer_ptr(rt) : NULL);
130 }
131
132 static struct inet_peer *rt6_get_peer_create(struct rt6_info *rt)
133 {
134 return __rt6_get_peer(rt, 1);
135 }
136
137 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
138 {
139 struct rt6_info *rt = (struct rt6_info *) dst;
140 struct inet_peer *peer;
141 u32 *p = NULL;
142
143 if (!(rt->dst.flags & DST_HOST))
144 return dst_cow_metrics_generic(dst, old);
145
146 peer = rt6_get_peer_create(rt);
147 if (peer) {
148 u32 *old_p = __DST_METRICS_PTR(old);
149 unsigned long prev, new;
150
151 p = peer->metrics;
152 if (inet_metrics_new(peer) ||
153 (old & DST_METRICS_FORCE_OVERWRITE))
154 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
155
156 new = (unsigned long) p;
157 prev = cmpxchg(&dst->_metrics, old, new);
158
159 if (prev != old) {
160 p = __DST_METRICS_PTR(prev);
161 if (prev & DST_METRICS_READ_ONLY)
162 p = NULL;
163 }
164 }
165 return p;
166 }
167
168 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
169 struct sk_buff *skb,
170 const void *daddr)
171 {
172 struct in6_addr *p = &rt->rt6i_gateway;
173
174 if (!ipv6_addr_any(p))
175 return (const void *) p;
176 else if (skb)
177 return &ipv6_hdr(skb)->daddr;
178 return daddr;
179 }
180
181 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
182 struct sk_buff *skb,
183 const void *daddr)
184 {
185 struct rt6_info *rt = (struct rt6_info *) dst;
186 struct neighbour *n;
187
188 daddr = choose_neigh_daddr(rt, skb, daddr);
189 n = __ipv6_neigh_lookup(dst->dev, daddr);
190 if (n)
191 return n;
192 return neigh_create(&nd_tbl, daddr, dst->dev);
193 }
194
195 static struct dst_ops ip6_dst_ops_template = {
196 .family = AF_INET6,
197 .protocol = cpu_to_be16(ETH_P_IPV6),
198 .gc = ip6_dst_gc,
199 .gc_thresh = 1024,
200 .check = ip6_dst_check,
201 .default_advmss = ip6_default_advmss,
202 .mtu = ip6_mtu,
203 .cow_metrics = ipv6_cow_metrics,
204 .destroy = ip6_dst_destroy,
205 .ifdown = ip6_dst_ifdown,
206 .negative_advice = ip6_negative_advice,
207 .link_failure = ip6_link_failure,
208 .update_pmtu = ip6_rt_update_pmtu,
209 .redirect = rt6_do_redirect,
210 .local_out = __ip6_local_out,
211 .neigh_lookup = ip6_neigh_lookup,
212 };
213
214 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
215 {
216 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
217
218 return mtu ? : dst->dev->mtu;
219 }
220
221 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
222 struct sk_buff *skb, u32 mtu)
223 {
224 }
225
226 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
227 struct sk_buff *skb)
228 {
229 }
230
231 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
232 unsigned long old)
233 {
234 return NULL;
235 }
236
237 static struct dst_ops ip6_dst_blackhole_ops = {
238 .family = AF_INET6,
239 .protocol = cpu_to_be16(ETH_P_IPV6),
240 .destroy = ip6_dst_destroy,
241 .check = ip6_dst_check,
242 .mtu = ip6_blackhole_mtu,
243 .default_advmss = ip6_default_advmss,
244 .update_pmtu = ip6_rt_blackhole_update_pmtu,
245 .redirect = ip6_rt_blackhole_redirect,
246 .cow_metrics = ip6_rt_blackhole_cow_metrics,
247 .neigh_lookup = ip6_neigh_lookup,
248 };
249
250 static const u32 ip6_template_metrics[RTAX_MAX] __aligned(DST_METRICS_ALIGNMENT) = {
251 [RTAX_HOPLIMIT - 1] = 0,
252 };
253
254 static const struct rt6_info ip6_null_entry_template = {
255 .dst = {
256 .__refcnt = ATOMIC_INIT(1),
257 .__use = 1,
258 .obsolete = DST_OBSOLETE_FORCE_CHK,
259 .error = -ENETUNREACH,
260 .input = ip6_pkt_discard,
261 .output = ip6_pkt_discard_out,
262 },
263 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
264 .rt6i_protocol = RTPROT_KERNEL,
265 .rt6i_metric = ~(u32) 0,
266 .rt6i_ref = ATOMIC_INIT(1),
267 };
268
269 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
270
271 static const struct rt6_info ip6_prohibit_entry_template = {
272 .dst = {
273 .__refcnt = ATOMIC_INIT(1),
274 .__use = 1,
275 .obsolete = DST_OBSOLETE_FORCE_CHK,
276 .error = -EACCES,
277 .input = ip6_pkt_prohibit,
278 .output = ip6_pkt_prohibit_out,
279 },
280 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
281 .rt6i_protocol = RTPROT_KERNEL,
282 .rt6i_metric = ~(u32) 0,
283 .rt6i_ref = ATOMIC_INIT(1),
284 };
285
286 static const struct rt6_info ip6_blk_hole_entry_template = {
287 .dst = {
288 .__refcnt = ATOMIC_INIT(1),
289 .__use = 1,
290 .obsolete = DST_OBSOLETE_FORCE_CHK,
291 .error = -EINVAL,
292 .input = dst_discard,
293 .output = dst_discard_sk,
294 },
295 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
296 .rt6i_protocol = RTPROT_KERNEL,
297 .rt6i_metric = ~(u32) 0,
298 .rt6i_ref = ATOMIC_INIT(1),
299 };
300
301 #endif
302
303 /* allocate dst with ip6_dst_ops */
304 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
305 struct net_device *dev,
306 int flags,
307 struct fib6_table *table)
308 {
309 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
310 0, DST_OBSOLETE_FORCE_CHK, flags);
311
312 if (rt) {
313 struct dst_entry *dst = &rt->dst;
314
315 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
316 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
317 INIT_LIST_HEAD(&rt->rt6i_siblings);
318 }
319 return rt;
320 }
321
322 static void ip6_dst_destroy(struct dst_entry *dst)
323 {
324 struct rt6_info *rt = (struct rt6_info *)dst;
325 struct inet6_dev *idev = rt->rt6i_idev;
326 struct dst_entry *from = dst->from;
327
328 if (!(rt->dst.flags & DST_HOST))
329 dst_destroy_metrics_generic(dst);
330
331 if (idev) {
332 rt->rt6i_idev = NULL;
333 in6_dev_put(idev);
334 }
335
336 dst->from = NULL;
337 dst_release(from);
338
339 if (rt6_has_peer(rt)) {
340 struct inet_peer *peer = rt6_peer_ptr(rt);
341 inet_putpeer(peer);
342 }
343 }
344
345 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
346 int how)
347 {
348 struct rt6_info *rt = (struct rt6_info *)dst;
349 struct inet6_dev *idev = rt->rt6i_idev;
350 struct net_device *loopback_dev =
351 dev_net(dev)->loopback_dev;
352
353 if (dev != loopback_dev) {
354 if (idev && idev->dev == dev) {
355 struct inet6_dev *loopback_idev =
356 in6_dev_get(loopback_dev);
357 if (loopback_idev) {
358 rt->rt6i_idev = loopback_idev;
359 in6_dev_put(idev);
360 }
361 }
362 }
363 }
364
365 static bool rt6_check_expired(const struct rt6_info *rt)
366 {
367 if (rt->rt6i_flags & RTF_EXPIRES) {
368 if (time_after(jiffies, rt->dst.expires))
369 return true;
370 } else if (rt->dst.from) {
371 return rt6_check_expired((struct rt6_info *) rt->dst.from);
372 }
373 return false;
374 }
375
376 /* Multipath route selection:
377 * Hash based function using packet header and flowlabel.
378 * Adapted from fib_info_hashfn()
379 */
380 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
381 const struct flowi6 *fl6)
382 {
383 unsigned int val = fl6->flowi6_proto;
384
385 val ^= ipv6_addr_hash(&fl6->daddr);
386 val ^= ipv6_addr_hash(&fl6->saddr);
387
388 /* Work only if this not encapsulated */
389 switch (fl6->flowi6_proto) {
390 case IPPROTO_UDP:
391 case IPPROTO_TCP:
392 case IPPROTO_SCTP:
393 val ^= (__force u16)fl6->fl6_sport;
394 val ^= (__force u16)fl6->fl6_dport;
395 break;
396
397 case IPPROTO_ICMPV6:
398 val ^= (__force u16)fl6->fl6_icmp_type;
399 val ^= (__force u16)fl6->fl6_icmp_code;
400 break;
401 }
402 /* RFC6438 recommands to use flowlabel */
403 val ^= (__force u32)fl6->flowlabel;
404
405 /* Perhaps, we need to tune, this function? */
406 val = val ^ (val >> 7) ^ (val >> 12);
407 return val % candidate_count;
408 }
409
410 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
411 struct flowi6 *fl6, int oif,
412 int strict)
413 {
414 struct rt6_info *sibling, *next_sibling;
415 int route_choosen;
416
417 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
418 /* Don't change the route, if route_choosen == 0
419 * (siblings does not include ourself)
420 */
421 if (route_choosen)
422 list_for_each_entry_safe(sibling, next_sibling,
423 &match->rt6i_siblings, rt6i_siblings) {
424 route_choosen--;
425 if (route_choosen == 0) {
426 if (rt6_score_route(sibling, oif, strict) < 0)
427 break;
428 match = sibling;
429 break;
430 }
431 }
432 return match;
433 }
434
435 /*
436 * Route lookup. Any table->tb6_lock is implied.
437 */
438
439 static inline struct rt6_info *rt6_device_match(struct net *net,
440 struct rt6_info *rt,
441 const struct in6_addr *saddr,
442 int oif,
443 int flags)
444 {
445 struct rt6_info *local = NULL;
446 struct rt6_info *sprt;
447
448 if (!oif && ipv6_addr_any(saddr))
449 goto out;
450
451 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
452 struct net_device *dev = sprt->dst.dev;
453
454 if (oif) {
455 if (dev->ifindex == oif)
456 return sprt;
457 if (dev->flags & IFF_LOOPBACK) {
458 if (!sprt->rt6i_idev ||
459 sprt->rt6i_idev->dev->ifindex != oif) {
460 if (flags & RT6_LOOKUP_F_IFACE && oif)
461 continue;
462 if (local && (!oif ||
463 local->rt6i_idev->dev->ifindex == oif))
464 continue;
465 }
466 local = sprt;
467 }
468 } else {
469 if (ipv6_chk_addr(net, saddr, dev,
470 flags & RT6_LOOKUP_F_IFACE))
471 return sprt;
472 }
473 }
474
475 if (oif) {
476 if (local)
477 return local;
478
479 if (flags & RT6_LOOKUP_F_IFACE)
480 return net->ipv6.ip6_null_entry;
481 }
482 out:
483 return rt;
484 }
485
486 #ifdef CONFIG_IPV6_ROUTER_PREF
487 struct __rt6_probe_work {
488 struct work_struct work;
489 struct in6_addr target;
490 struct net_device *dev;
491 };
492
493 static void rt6_probe_deferred(struct work_struct *w)
494 {
495 struct in6_addr mcaddr;
496 struct __rt6_probe_work *work =
497 container_of(w, struct __rt6_probe_work, work);
498
499 addrconf_addr_solict_mult(&work->target, &mcaddr);
500 ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
501 dev_put(work->dev);
502 kfree(w);
503 }
504
505 static void rt6_probe(struct rt6_info *rt)
506 {
507 struct neighbour *neigh;
508 /*
509 * Okay, this does not seem to be appropriate
510 * for now, however, we need to check if it
511 * is really so; aka Router Reachability Probing.
512 *
513 * Router Reachability Probe MUST be rate-limited
514 * to no more than one per minute.
515 */
516 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
517 return;
518 rcu_read_lock_bh();
519 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
520 if (neigh) {
521 write_lock(&neigh->lock);
522 if (neigh->nud_state & NUD_VALID)
523 goto out;
524 }
525
526 if (!neigh ||
527 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
528 struct __rt6_probe_work *work;
529
530 work = kmalloc(sizeof(*work), GFP_ATOMIC);
531
532 if (neigh && work)
533 __neigh_set_probe_once(neigh);
534
535 if (neigh)
536 write_unlock(&neigh->lock);
537
538 if (work) {
539 INIT_WORK(&work->work, rt6_probe_deferred);
540 work->target = rt->rt6i_gateway;
541 dev_hold(rt->dst.dev);
542 work->dev = rt->dst.dev;
543 schedule_work(&work->work);
544 }
545 } else {
546 out:
547 write_unlock(&neigh->lock);
548 }
549 rcu_read_unlock_bh();
550 }
551 #else
552 static inline void rt6_probe(struct rt6_info *rt)
553 {
554 }
555 #endif
556
557 /*
558 * Default Router Selection (RFC 2461 6.3.6)
559 */
560 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
561 {
562 struct net_device *dev = rt->dst.dev;
563 if (!oif || dev->ifindex == oif)
564 return 2;
565 if ((dev->flags & IFF_LOOPBACK) &&
566 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
567 return 1;
568 return 0;
569 }
570
571 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
572 {
573 struct neighbour *neigh;
574 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
575
576 if (rt->rt6i_flags & RTF_NONEXTHOP ||
577 !(rt->rt6i_flags & RTF_GATEWAY))
578 return RT6_NUD_SUCCEED;
579
580 rcu_read_lock_bh();
581 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
582 if (neigh) {
583 read_lock(&neigh->lock);
584 if (neigh->nud_state & NUD_VALID)
585 ret = RT6_NUD_SUCCEED;
586 #ifdef CONFIG_IPV6_ROUTER_PREF
587 else if (!(neigh->nud_state & NUD_FAILED))
588 ret = RT6_NUD_SUCCEED;
589 else
590 ret = RT6_NUD_FAIL_PROBE;
591 #endif
592 read_unlock(&neigh->lock);
593 } else {
594 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
595 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
596 }
597 rcu_read_unlock_bh();
598
599 return ret;
600 }
601
602 static int rt6_score_route(struct rt6_info *rt, int oif,
603 int strict)
604 {
605 int m;
606
607 m = rt6_check_dev(rt, oif);
608 if (!m && (strict & RT6_LOOKUP_F_IFACE))
609 return RT6_NUD_FAIL_HARD;
610 #ifdef CONFIG_IPV6_ROUTER_PREF
611 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
612 #endif
613 if (strict & RT6_LOOKUP_F_REACHABLE) {
614 int n = rt6_check_neigh(rt);
615 if (n < 0)
616 return n;
617 }
618 return m;
619 }
620
621 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
622 int *mpri, struct rt6_info *match,
623 bool *do_rr)
624 {
625 int m;
626 bool match_do_rr = false;
627
628 if (rt6_check_expired(rt))
629 goto out;
630
631 m = rt6_score_route(rt, oif, strict);
632 if (m == RT6_NUD_FAIL_DO_RR) {
633 match_do_rr = true;
634 m = 0; /* lowest valid score */
635 } else if (m == RT6_NUD_FAIL_HARD) {
636 goto out;
637 }
638
639 if (strict & RT6_LOOKUP_F_REACHABLE)
640 rt6_probe(rt);
641
642 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
643 if (m > *mpri) {
644 *do_rr = match_do_rr;
645 *mpri = m;
646 match = rt;
647 }
648 out:
649 return match;
650 }
651
652 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
653 struct rt6_info *rr_head,
654 u32 metric, int oif, int strict,
655 bool *do_rr)
656 {
657 struct rt6_info *rt, *match;
658 int mpri = -1;
659
660 match = NULL;
661 for (rt = rr_head; rt && rt->rt6i_metric == metric;
662 rt = rt->dst.rt6_next)
663 match = find_match(rt, oif, strict, &mpri, match, do_rr);
664 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
665 rt = rt->dst.rt6_next)
666 match = find_match(rt, oif, strict, &mpri, match, do_rr);
667
668 return match;
669 }
670
671 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
672 {
673 struct rt6_info *match, *rt0;
674 struct net *net;
675 bool do_rr = false;
676
677 rt0 = fn->rr_ptr;
678 if (!rt0)
679 fn->rr_ptr = rt0 = fn->leaf;
680
681 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
682 &do_rr);
683
684 if (do_rr) {
685 struct rt6_info *next = rt0->dst.rt6_next;
686
687 /* no entries matched; do round-robin */
688 if (!next || next->rt6i_metric != rt0->rt6i_metric)
689 next = fn->leaf;
690
691 if (next != rt0)
692 fn->rr_ptr = next;
693 }
694
695 net = dev_net(rt0->dst.dev);
696 return match ? match : net->ipv6.ip6_null_entry;
697 }
698
699 #ifdef CONFIG_IPV6_ROUTE_INFO
700 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
701 const struct in6_addr *gwaddr)
702 {
703 struct net *net = dev_net(dev);
704 struct route_info *rinfo = (struct route_info *) opt;
705 struct in6_addr prefix_buf, *prefix;
706 unsigned int pref;
707 unsigned long lifetime;
708 struct rt6_info *rt;
709
710 if (len < sizeof(struct route_info)) {
711 return -EINVAL;
712 }
713
714 /* Sanity check for prefix_len and length */
715 if (rinfo->length > 3) {
716 return -EINVAL;
717 } else if (rinfo->prefix_len > 128) {
718 return -EINVAL;
719 } else if (rinfo->prefix_len > 64) {
720 if (rinfo->length < 2) {
721 return -EINVAL;
722 }
723 } else if (rinfo->prefix_len > 0) {
724 if (rinfo->length < 1) {
725 return -EINVAL;
726 }
727 }
728
729 pref = rinfo->route_pref;
730 if (pref == ICMPV6_ROUTER_PREF_INVALID)
731 return -EINVAL;
732
733 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
734
735 if (rinfo->length == 3)
736 prefix = (struct in6_addr *)rinfo->prefix;
737 else {
738 /* this function is safe */
739 ipv6_addr_prefix(&prefix_buf,
740 (struct in6_addr *)rinfo->prefix,
741 rinfo->prefix_len);
742 prefix = &prefix_buf;
743 }
744
745 if (rinfo->prefix_len == 0)
746 rt = rt6_get_dflt_router(gwaddr, dev);
747 else
748 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
749 gwaddr, dev->ifindex);
750
751 if (rt && !lifetime) {
752 ip6_del_rt(rt);
753 rt = NULL;
754 }
755
756 if (!rt && lifetime)
757 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
758 pref);
759 else if (rt)
760 rt->rt6i_flags = RTF_ROUTEINFO |
761 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
762
763 if (rt) {
764 if (!addrconf_finite_timeout(lifetime))
765 rt6_clean_expires(rt);
766 else
767 rt6_set_expires(rt, jiffies + HZ * lifetime);
768
769 ip6_rt_put(rt);
770 }
771 return 0;
772 }
773 #endif
774
775 #define BACKTRACK(__net, saddr) \
776 do { \
777 if (rt == __net->ipv6.ip6_null_entry) { \
778 struct fib6_node *pn; \
779 while (1) { \
780 if (fn->fn_flags & RTN_TL_ROOT) \
781 goto out; \
782 pn = fn->parent; \
783 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
784 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
785 else \
786 fn = pn; \
787 if (fn->fn_flags & RTN_RTINFO) \
788 goto restart; \
789 } \
790 } \
791 } while (0)
792
793 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
794 struct fib6_table *table,
795 struct flowi6 *fl6, int flags)
796 {
797 struct fib6_node *fn;
798 struct rt6_info *rt;
799
800 read_lock_bh(&table->tb6_lock);
801 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
802 restart:
803 rt = fn->leaf;
804 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
805 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
806 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
807 BACKTRACK(net, &fl6->saddr);
808 out:
809 dst_use(&rt->dst, jiffies);
810 read_unlock_bh(&table->tb6_lock);
811 return rt;
812
813 }
814
815 struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
816 int flags)
817 {
818 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
819 }
820 EXPORT_SYMBOL_GPL(ip6_route_lookup);
821
822 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
823 const struct in6_addr *saddr, int oif, int strict)
824 {
825 struct flowi6 fl6 = {
826 .flowi6_oif = oif,
827 .daddr = *daddr,
828 };
829 struct dst_entry *dst;
830 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
831
832 if (saddr) {
833 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
834 flags |= RT6_LOOKUP_F_HAS_SADDR;
835 }
836
837 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
838 if (dst->error == 0)
839 return (struct rt6_info *) dst;
840
841 dst_release(dst);
842
843 return NULL;
844 }
845
846 EXPORT_SYMBOL(rt6_lookup);
847
848 /* ip6_ins_rt is called with FREE table->tb6_lock.
849 It takes new route entry, the addition fails by any reason the
850 route is freed. In any case, if caller does not hold it, it may
851 be destroyed.
852 */
853
854 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
855 struct nlattr *mx, int mx_len)
856 {
857 int err;
858 struct fib6_table *table;
859
860 table = rt->rt6i_table;
861 write_lock_bh(&table->tb6_lock);
862 err = fib6_add(&table->tb6_root, rt, info, mx, mx_len);
863 write_unlock_bh(&table->tb6_lock);
864
865 return err;
866 }
867
868 int ip6_ins_rt(struct rt6_info *rt)
869 {
870 struct nl_info info = {
871 .nl_net = dev_net(rt->dst.dev),
872 };
873 return __ip6_ins_rt(rt, &info, NULL, 0);
874 }
875
876 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
877 const struct in6_addr *daddr,
878 const struct in6_addr *saddr)
879 {
880 struct rt6_info *rt;
881
882 /*
883 * Clone the route.
884 */
885
886 rt = ip6_rt_copy(ort, daddr);
887
888 if (rt) {
889 if (ort->rt6i_dst.plen != 128 &&
890 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
891 rt->rt6i_flags |= RTF_ANYCAST;
892
893 rt->rt6i_flags |= RTF_CACHE;
894
895 #ifdef CONFIG_IPV6_SUBTREES
896 if (rt->rt6i_src.plen && saddr) {
897 rt->rt6i_src.addr = *saddr;
898 rt->rt6i_src.plen = 128;
899 }
900 #endif
901 }
902
903 return rt;
904 }
905
906 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
907 const struct in6_addr *daddr)
908 {
909 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
910
911 if (rt)
912 rt->rt6i_flags |= RTF_CACHE;
913 return rt;
914 }
915
916 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
917 struct flowi6 *fl6, int flags)
918 {
919 struct fib6_node *fn;
920 struct rt6_info *rt, *nrt;
921 int strict = 0;
922 int attempts = 3;
923 int err;
924 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
925
926 strict |= flags & RT6_LOOKUP_F_IFACE;
927
928 relookup:
929 read_lock_bh(&table->tb6_lock);
930
931 restart_2:
932 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
933
934 restart:
935 rt = rt6_select(fn, oif, strict | reachable);
936 if (rt->rt6i_nsiblings)
937 rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);
938 BACKTRACK(net, &fl6->saddr);
939 if (rt == net->ipv6.ip6_null_entry ||
940 rt->rt6i_flags & RTF_CACHE)
941 goto out;
942
943 dst_hold(&rt->dst);
944 read_unlock_bh(&table->tb6_lock);
945
946 if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
947 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
948 else if (!(rt->dst.flags & DST_HOST))
949 nrt = rt6_alloc_clone(rt, &fl6->daddr);
950 else
951 goto out2;
952
953 ip6_rt_put(rt);
954 rt = nrt ? : net->ipv6.ip6_null_entry;
955
956 dst_hold(&rt->dst);
957 if (nrt) {
958 err = ip6_ins_rt(nrt);
959 if (!err)
960 goto out2;
961 }
962
963 if (--attempts <= 0)
964 goto out2;
965
966 /*
967 * Race condition! In the gap, when table->tb6_lock was
968 * released someone could insert this route. Relookup.
969 */
970 ip6_rt_put(rt);
971 goto relookup;
972
973 out:
974 if (reachable) {
975 reachable = 0;
976 goto restart_2;
977 }
978 dst_hold(&rt->dst);
979 read_unlock_bh(&table->tb6_lock);
980 out2:
981 rt->dst.lastuse = jiffies;
982 rt->dst.__use++;
983
984 return rt;
985 }
986
987 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
988 struct flowi6 *fl6, int flags)
989 {
990 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
991 }
992
993 static struct dst_entry *ip6_route_input_lookup(struct net *net,
994 struct net_device *dev,
995 struct flowi6 *fl6, int flags)
996 {
997 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
998 flags |= RT6_LOOKUP_F_IFACE;
999
1000 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1001 }
1002
1003 void ip6_route_input(struct sk_buff *skb)
1004 {
1005 const struct ipv6hdr *iph = ipv6_hdr(skb);
1006 struct net *net = dev_net(skb->dev);
1007 int flags = RT6_LOOKUP_F_HAS_SADDR;
1008 struct flowi6 fl6 = {
1009 .flowi6_iif = skb->dev->ifindex,
1010 .daddr = iph->daddr,
1011 .saddr = iph->saddr,
1012 .flowlabel = ip6_flowinfo(iph),
1013 .flowi6_mark = skb->mark,
1014 .flowi6_proto = iph->nexthdr,
1015 };
1016
1017 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1018 }
1019
1020 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1021 struct flowi6 *fl6, int flags)
1022 {
1023 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1024 }
1025
1026 struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
1027 struct flowi6 *fl6)
1028 {
1029 int flags = 0;
1030
1031 fl6->flowi6_iif = LOOPBACK_IFINDEX;
1032
1033 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
1034 flags |= RT6_LOOKUP_F_IFACE;
1035
1036 if (!ipv6_addr_any(&fl6->saddr))
1037 flags |= RT6_LOOKUP_F_HAS_SADDR;
1038 else if (sk)
1039 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1040
1041 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1042 }
1043
1044 EXPORT_SYMBOL(ip6_route_output);
1045
1046 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1047 {
1048 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1049 struct dst_entry *new = NULL;
1050
1051 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1052 if (rt) {
1053 new = &rt->dst;
1054
1055 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1056 rt6_init_peer(rt, net->ipv6.peers);
1057
1058 new->__use = 1;
1059 new->input = dst_discard;
1060 new->output = dst_discard_sk;
1061
1062 if (dst_metrics_read_only(&ort->dst))
1063 new->_metrics = ort->dst._metrics;
1064 else
1065 dst_copy_metrics(new, &ort->dst);
1066 rt->rt6i_idev = ort->rt6i_idev;
1067 if (rt->rt6i_idev)
1068 in6_dev_hold(rt->rt6i_idev);
1069
1070 rt->rt6i_gateway = ort->rt6i_gateway;
1071 rt->rt6i_flags = ort->rt6i_flags;
1072 rt->rt6i_metric = 0;
1073
1074 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1075 #ifdef CONFIG_IPV6_SUBTREES
1076 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1077 #endif
1078
1079 dst_free(new);
1080 }
1081
1082 dst_release(dst_orig);
1083 return new ? new : ERR_PTR(-ENOMEM);
1084 }
1085
1086 /*
1087 * Destination cache support functions
1088 */
1089
1090 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1091 {
1092 struct rt6_info *rt;
1093 u32 rt_cookie = 0;
1094
1095 rt = (struct rt6_info *) dst;
1096
1097 /* All IPV6 dsts are created with ->obsolete set to the value
1098 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1099 * into this function always.
1100 */
1101 if (!rt6_get_cookie_safe(rt, &rt_cookie) || rt_cookie != cookie)
1102 return NULL;
1103
1104 if (rt6_check_expired(rt))
1105 return NULL;
1106
1107 return dst;
1108 }
1109
1110 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1111 {
1112 struct rt6_info *rt = (struct rt6_info *) dst;
1113
1114 if (rt) {
1115 if (rt->rt6i_flags & RTF_CACHE) {
1116 if (rt6_check_expired(rt)) {
1117 ip6_del_rt(rt);
1118 dst = NULL;
1119 }
1120 } else {
1121 dst_release(dst);
1122 dst = NULL;
1123 }
1124 }
1125 return dst;
1126 }
1127
1128 static void ip6_link_failure(struct sk_buff *skb)
1129 {
1130 struct rt6_info *rt;
1131
1132 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1133
1134 rt = (struct rt6_info *) skb_dst(skb);
1135 if (rt) {
1136 if (rt->rt6i_flags & RTF_CACHE) {
1137 dst_hold(&rt->dst);
1138 if (ip6_del_rt(rt))
1139 dst_free(&rt->dst);
1140 } else {
1141 struct fib6_node *fn;
1142
1143 rcu_read_lock();
1144 fn = rcu_dereference(rt->rt6i_node);
1145 if (fn && (rt->rt6i_flags & RTF_DEFAULT))
1146 fn->fn_sernum = -1;
1147 rcu_read_unlock();
1148 }
1149 }
1150 }
1151
1152 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1153 struct sk_buff *skb, u32 mtu)
1154 {
1155 struct rt6_info *rt6 = (struct rt6_info*)dst;
1156
1157 dst_confirm(dst);
1158 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1159 struct net *net = dev_net(dst->dev);
1160
1161 rt6->rt6i_flags |= RTF_MODIFIED;
1162 if (mtu < IPV6_MIN_MTU)
1163 mtu = IPV6_MIN_MTU;
1164
1165 dst_metric_set(dst, RTAX_MTU, mtu);
1166 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1167 }
1168 }
1169
1170 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1171 int oif, u32 mark)
1172 {
1173 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1174 struct dst_entry *dst;
1175 struct flowi6 fl6;
1176
1177 memset(&fl6, 0, sizeof(fl6));
1178 fl6.flowi6_oif = oif;
1179 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1180 fl6.daddr = iph->daddr;
1181 fl6.saddr = iph->saddr;
1182 fl6.flowlabel = ip6_flowinfo(iph);
1183
1184 dst = ip6_route_output(net, NULL, &fl6);
1185 if (!dst->error)
1186 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1187 dst_release(dst);
1188 }
1189 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1190
1191 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1192 {
1193 ip6_update_pmtu(skb, sock_net(sk), mtu,
1194 sk->sk_bound_dev_if, sk->sk_mark);
1195 }
1196 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1197
1198 /* Handle redirects */
1199 struct ip6rd_flowi {
1200 struct flowi6 fl6;
1201 struct in6_addr gateway;
1202 };
1203
1204 static struct rt6_info *__ip6_route_redirect(struct net *net,
1205 struct fib6_table *table,
1206 struct flowi6 *fl6,
1207 int flags)
1208 {
1209 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1210 struct rt6_info *rt;
1211 struct fib6_node *fn;
1212
1213 /* Get the "current" route for this destination and
1214 * check if the redirect has come from approriate router.
1215 *
1216 * RFC 4861 specifies that redirects should only be
1217 * accepted if they come from the nexthop to the target.
1218 * Due to the way the routes are chosen, this notion
1219 * is a bit fuzzy and one might need to check all possible
1220 * routes.
1221 */
1222
1223 read_lock_bh(&table->tb6_lock);
1224 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1225 restart:
1226 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1227 if (rt6_check_expired(rt))
1228 continue;
1229 if (rt->dst.error)
1230 break;
1231 if (!(rt->rt6i_flags & RTF_GATEWAY))
1232 continue;
1233 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1234 continue;
1235 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1236 continue;
1237 break;
1238 }
1239
1240 if (!rt)
1241 rt = net->ipv6.ip6_null_entry;
1242 else if (rt->dst.error) {
1243 rt = net->ipv6.ip6_null_entry;
1244 goto out;
1245 }
1246 BACKTRACK(net, &fl6->saddr);
1247 out:
1248 dst_hold(&rt->dst);
1249
1250 read_unlock_bh(&table->tb6_lock);
1251
1252 return rt;
1253 };
1254
1255 static struct dst_entry *ip6_route_redirect(struct net *net,
1256 const struct flowi6 *fl6,
1257 const struct in6_addr *gateway)
1258 {
1259 int flags = RT6_LOOKUP_F_HAS_SADDR;
1260 struct ip6rd_flowi rdfl;
1261
1262 rdfl.fl6 = *fl6;
1263 rdfl.gateway = *gateway;
1264
1265 return fib6_rule_lookup(net, &rdfl.fl6,
1266 flags, __ip6_route_redirect);
1267 }
1268
1269 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1270 {
1271 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1272 struct dst_entry *dst;
1273 struct flowi6 fl6;
1274
1275 memset(&fl6, 0, sizeof(fl6));
1276 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1277 fl6.flowi6_oif = oif;
1278 fl6.flowi6_mark = mark;
1279 fl6.daddr = iph->daddr;
1280 fl6.saddr = iph->saddr;
1281 fl6.flowlabel = ip6_flowinfo(iph);
1282
1283 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1284 rt6_do_redirect(dst, NULL, skb);
1285 dst_release(dst);
1286 }
1287 EXPORT_SYMBOL_GPL(ip6_redirect);
1288
1289 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1290 u32 mark)
1291 {
1292 const struct ipv6hdr *iph = ipv6_hdr(skb);
1293 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1294 struct dst_entry *dst;
1295 struct flowi6 fl6;
1296
1297 memset(&fl6, 0, sizeof(fl6));
1298 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1299 fl6.flowi6_oif = oif;
1300 fl6.flowi6_mark = mark;
1301 fl6.daddr = msg->dest;
1302 fl6.saddr = iph->daddr;
1303
1304 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1305 rt6_do_redirect(dst, NULL, skb);
1306 dst_release(dst);
1307 }
1308
1309 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1310 {
1311 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1312 }
1313 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1314
1315 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1316 {
1317 struct net_device *dev = dst->dev;
1318 unsigned int mtu = dst_mtu(dst);
1319 struct net *net = dev_net(dev);
1320
1321 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1322
1323 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1324 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1325
1326 /*
1327 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1328 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1329 * IPV6_MAXPLEN is also valid and means: "any MSS,
1330 * rely only on pmtu discovery"
1331 */
1332 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1333 mtu = IPV6_MAXPLEN;
1334 return mtu;
1335 }
1336
1337 static unsigned int ip6_mtu(const struct dst_entry *dst)
1338 {
1339 struct inet6_dev *idev;
1340 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1341
1342 if (mtu)
1343 goto out;
1344
1345 mtu = IPV6_MIN_MTU;
1346
1347 rcu_read_lock();
1348 idev = __in6_dev_get(dst->dev);
1349 if (idev)
1350 mtu = idev->cnf.mtu6;
1351 rcu_read_unlock();
1352
1353 out:
1354 return min_t(unsigned int, mtu, IP6_MAX_MTU);
1355 }
1356
1357 static struct dst_entry *icmp6_dst_gc_list;
1358 static DEFINE_SPINLOCK(icmp6_dst_lock);
1359
1360 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1361 struct flowi6 *fl6)
1362 {
1363 struct dst_entry *dst;
1364 struct rt6_info *rt;
1365 struct inet6_dev *idev = in6_dev_get(dev);
1366 struct net *net = dev_net(dev);
1367
1368 if (unlikely(!idev))
1369 return ERR_PTR(-ENODEV);
1370
1371 rt = ip6_dst_alloc(net, dev, 0, NULL);
1372 if (unlikely(!rt)) {
1373 in6_dev_put(idev);
1374 dst = ERR_PTR(-ENOMEM);
1375 goto out;
1376 }
1377
1378 rt->dst.flags |= DST_HOST;
1379 rt->dst.output = ip6_output;
1380 atomic_set(&rt->dst.__refcnt, 1);
1381 rt->rt6i_gateway = fl6->daddr;
1382 rt->rt6i_dst.addr = fl6->daddr;
1383 rt->rt6i_dst.plen = 128;
1384 rt->rt6i_idev = idev;
1385 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1386
1387 spin_lock_bh(&icmp6_dst_lock);
1388 rt->dst.next = icmp6_dst_gc_list;
1389 icmp6_dst_gc_list = &rt->dst;
1390 spin_unlock_bh(&icmp6_dst_lock);
1391
1392 fib6_force_start_gc(net);
1393
1394 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1395
1396 out:
1397 return dst;
1398 }
1399
1400 int icmp6_dst_gc(void)
1401 {
1402 struct dst_entry *dst, **pprev;
1403 int more = 0;
1404
1405 spin_lock_bh(&icmp6_dst_lock);
1406 pprev = &icmp6_dst_gc_list;
1407
1408 while ((dst = *pprev) != NULL) {
1409 if (!atomic_read(&dst->__refcnt)) {
1410 *pprev = dst->next;
1411 dst_free(dst);
1412 } else {
1413 pprev = &dst->next;
1414 ++more;
1415 }
1416 }
1417
1418 spin_unlock_bh(&icmp6_dst_lock);
1419
1420 return more;
1421 }
1422
1423 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1424 void *arg)
1425 {
1426 struct dst_entry *dst, **pprev;
1427
1428 spin_lock_bh(&icmp6_dst_lock);
1429 pprev = &icmp6_dst_gc_list;
1430 while ((dst = *pprev) != NULL) {
1431 struct rt6_info *rt = (struct rt6_info *) dst;
1432 if (func(rt, arg)) {
1433 *pprev = dst->next;
1434 dst_free(dst);
1435 } else {
1436 pprev = &dst->next;
1437 }
1438 }
1439 spin_unlock_bh(&icmp6_dst_lock);
1440 }
1441
1442 static int ip6_dst_gc(struct dst_ops *ops)
1443 {
1444 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1445 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1446 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1447 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1448 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1449 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1450 int entries;
1451
1452 entries = dst_entries_get_fast(ops);
1453 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1454 entries <= rt_max_size)
1455 goto out;
1456
1457 net->ipv6.ip6_rt_gc_expire++;
1458 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1459 entries = dst_entries_get_slow(ops);
1460 if (entries < ops->gc_thresh)
1461 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1462 out:
1463 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1464 return entries > rt_max_size;
1465 }
1466
1467 /*
1468 *
1469 */
1470
1471 int ip6_route_add(struct fib6_config *cfg)
1472 {
1473 int err;
1474 struct net *net = cfg->fc_nlinfo.nl_net;
1475 struct rt6_info *rt = NULL;
1476 struct net_device *dev = NULL;
1477 struct inet6_dev *idev = NULL;
1478 struct fib6_table *table;
1479 int addr_type;
1480
1481 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1482 return -EINVAL;
1483 #ifndef CONFIG_IPV6_SUBTREES
1484 if (cfg->fc_src_len)
1485 return -EINVAL;
1486 #endif
1487 if (cfg->fc_ifindex) {
1488 err = -ENODEV;
1489 dev = dev_get_by_index(net, cfg->fc_ifindex);
1490 if (!dev)
1491 goto out;
1492 idev = in6_dev_get(dev);
1493 if (!idev)
1494 goto out;
1495 }
1496
1497 if (cfg->fc_metric == 0)
1498 cfg->fc_metric = IP6_RT_PRIO_USER;
1499
1500 err = -ENOBUFS;
1501 if (cfg->fc_nlinfo.nlh &&
1502 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1503 table = fib6_get_table(net, cfg->fc_table);
1504 if (!table) {
1505 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1506 table = fib6_new_table(net, cfg->fc_table);
1507 }
1508 } else {
1509 table = fib6_new_table(net, cfg->fc_table);
1510 }
1511
1512 if (!table)
1513 goto out;
1514
1515 rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
1516
1517 if (!rt) {
1518 err = -ENOMEM;
1519 goto out;
1520 }
1521
1522 if (cfg->fc_flags & RTF_EXPIRES)
1523 rt6_set_expires(rt, jiffies +
1524 clock_t_to_jiffies(cfg->fc_expires));
1525 else
1526 rt6_clean_expires(rt);
1527
1528 if (cfg->fc_protocol == RTPROT_UNSPEC)
1529 cfg->fc_protocol = RTPROT_BOOT;
1530 rt->rt6i_protocol = cfg->fc_protocol;
1531
1532 addr_type = ipv6_addr_type(&cfg->fc_dst);
1533
1534 if (addr_type & IPV6_ADDR_MULTICAST)
1535 rt->dst.input = ip6_mc_input;
1536 else if (cfg->fc_flags & RTF_LOCAL)
1537 rt->dst.input = ip6_input;
1538 else
1539 rt->dst.input = ip6_forward;
1540
1541 rt->dst.output = ip6_output;
1542
1543 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1544 rt->rt6i_dst.plen = cfg->fc_dst_len;
1545 if (rt->rt6i_dst.plen == 128) {
1546 rt->dst.flags |= DST_HOST;
1547 dst_metrics_set_force_overwrite(&rt->dst);
1548 }
1549
1550 #ifdef CONFIG_IPV6_SUBTREES
1551 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1552 rt->rt6i_src.plen = cfg->fc_src_len;
1553 #endif
1554
1555 rt->rt6i_metric = cfg->fc_metric;
1556
1557 /* We cannot add true routes via loopback here,
1558 they would result in kernel looping; promote them to reject routes
1559 */
1560 if ((cfg->fc_flags & RTF_REJECT) ||
1561 (dev && (dev->flags & IFF_LOOPBACK) &&
1562 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1563 !(cfg->fc_flags & RTF_LOCAL))) {
1564 /* hold loopback dev/idev if we haven't done so. */
1565 if (dev != net->loopback_dev) {
1566 if (dev) {
1567 dev_put(dev);
1568 in6_dev_put(idev);
1569 }
1570 dev = net->loopback_dev;
1571 dev_hold(dev);
1572 idev = in6_dev_get(dev);
1573 if (!idev) {
1574 err = -ENODEV;
1575 goto out;
1576 }
1577 }
1578 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1579 switch (cfg->fc_type) {
1580 case RTN_BLACKHOLE:
1581 rt->dst.error = -EINVAL;
1582 rt->dst.output = dst_discard_sk;
1583 rt->dst.input = dst_discard;
1584 break;
1585 case RTN_PROHIBIT:
1586 rt->dst.error = -EACCES;
1587 rt->dst.output = ip6_pkt_prohibit_out;
1588 rt->dst.input = ip6_pkt_prohibit;
1589 break;
1590 case RTN_THROW:
1591 default:
1592 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1593 : -ENETUNREACH;
1594 rt->dst.output = ip6_pkt_discard_out;
1595 rt->dst.input = ip6_pkt_discard;
1596 break;
1597 }
1598 goto install_route;
1599 }
1600
1601 if (cfg->fc_flags & RTF_GATEWAY) {
1602 const struct in6_addr *gw_addr;
1603 int gwa_type;
1604
1605 gw_addr = &cfg->fc_gateway;
1606 rt->rt6i_gateway = *gw_addr;
1607 gwa_type = ipv6_addr_type(gw_addr);
1608
1609 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1610 struct rt6_info *grt;
1611
1612 /* IPv6 strictly inhibits using not link-local
1613 addresses as nexthop address.
1614 Otherwise, router will not able to send redirects.
1615 It is very good, but in some (rare!) circumstances
1616 (SIT, PtP, NBMA NOARP links) it is handy to allow
1617 some exceptions. --ANK
1618 */
1619 err = -EINVAL;
1620 if (!(gwa_type & IPV6_ADDR_UNICAST))
1621 goto out;
1622
1623 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1624
1625 err = -EHOSTUNREACH;
1626 if (!grt)
1627 goto out;
1628 if (dev) {
1629 if (dev != grt->dst.dev) {
1630 ip6_rt_put(grt);
1631 goto out;
1632 }
1633 } else {
1634 dev = grt->dst.dev;
1635 idev = grt->rt6i_idev;
1636 dev_hold(dev);
1637 in6_dev_hold(grt->rt6i_idev);
1638 }
1639 if (!(grt->rt6i_flags & RTF_GATEWAY))
1640 err = 0;
1641 ip6_rt_put(grt);
1642
1643 if (err)
1644 goto out;
1645 }
1646 err = -EINVAL;
1647 if (!dev || (dev->flags & IFF_LOOPBACK))
1648 goto out;
1649 }
1650
1651 err = -ENODEV;
1652 if (!dev)
1653 goto out;
1654
1655 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1656 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1657 err = -EINVAL;
1658 goto out;
1659 }
1660 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1661 rt->rt6i_prefsrc.plen = 128;
1662 } else
1663 rt->rt6i_prefsrc.plen = 0;
1664
1665 rt->rt6i_flags = cfg->fc_flags;
1666
1667 install_route:
1668 rt->dst.dev = dev;
1669 rt->rt6i_idev = idev;
1670 rt->rt6i_table = table;
1671
1672 cfg->fc_nlinfo.nl_net = dev_net(dev);
1673
1674 return __ip6_ins_rt(rt, &cfg->fc_nlinfo, cfg->fc_mx, cfg->fc_mx_len);
1675
1676 out:
1677 if (dev)
1678 dev_put(dev);
1679 if (idev)
1680 in6_dev_put(idev);
1681 if (rt)
1682 dst_free(&rt->dst);
1683 return err;
1684 }
1685
1686 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1687 {
1688 int err;
1689 struct fib6_table *table;
1690 struct net *net = dev_net(rt->dst.dev);
1691
1692 if (rt == net->ipv6.ip6_null_entry) {
1693 err = -ENOENT;
1694 goto out;
1695 }
1696
1697 table = rt->rt6i_table;
1698 write_lock_bh(&table->tb6_lock);
1699 err = fib6_del(rt, info);
1700 write_unlock_bh(&table->tb6_lock);
1701
1702 out:
1703 ip6_rt_put(rt);
1704 return err;
1705 }
1706
1707 int ip6_del_rt(struct rt6_info *rt)
1708 {
1709 struct nl_info info = {
1710 .nl_net = dev_net(rt->dst.dev),
1711 };
1712 return __ip6_del_rt(rt, &info);
1713 }
1714
1715 static int ip6_route_del(struct fib6_config *cfg)
1716 {
1717 struct fib6_table *table;
1718 struct fib6_node *fn;
1719 struct rt6_info *rt;
1720 int err = -ESRCH;
1721
1722 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1723 if (!table)
1724 return err;
1725
1726 read_lock_bh(&table->tb6_lock);
1727
1728 fn = fib6_locate(&table->tb6_root,
1729 &cfg->fc_dst, cfg->fc_dst_len,
1730 &cfg->fc_src, cfg->fc_src_len);
1731
1732 if (fn) {
1733 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1734 if (cfg->fc_ifindex &&
1735 (!rt->dst.dev ||
1736 rt->dst.dev->ifindex != cfg->fc_ifindex))
1737 continue;
1738 if (cfg->fc_flags & RTF_GATEWAY &&
1739 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1740 continue;
1741 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1742 continue;
1743 if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
1744 continue;
1745 dst_hold(&rt->dst);
1746 read_unlock_bh(&table->tb6_lock);
1747
1748 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1749 }
1750 }
1751 read_unlock_bh(&table->tb6_lock);
1752
1753 return err;
1754 }
1755
1756 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1757 {
1758 struct net *net = dev_net(skb->dev);
1759 struct netevent_redirect netevent;
1760 struct rt6_info *rt, *nrt = NULL;
1761 struct ndisc_options ndopts;
1762 struct inet6_dev *in6_dev;
1763 struct neighbour *neigh;
1764 struct rd_msg *msg;
1765 int optlen, on_link;
1766 u8 *lladdr;
1767
1768 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
1769 optlen -= sizeof(*msg);
1770
1771 if (optlen < 0) {
1772 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1773 return;
1774 }
1775
1776 msg = (struct rd_msg *)icmp6_hdr(skb);
1777
1778 if (ipv6_addr_is_multicast(&msg->dest)) {
1779 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1780 return;
1781 }
1782
1783 on_link = 0;
1784 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1785 on_link = 1;
1786 } else if (ipv6_addr_type(&msg->target) !=
1787 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1788 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1789 return;
1790 }
1791
1792 in6_dev = __in6_dev_get(skb->dev);
1793 if (!in6_dev)
1794 return;
1795 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1796 return;
1797
1798 /* RFC2461 8.1:
1799 * The IP source address of the Redirect MUST be the same as the current
1800 * first-hop router for the specified ICMP Destination Address.
1801 */
1802
1803 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1804 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1805 return;
1806 }
1807
1808 lladdr = NULL;
1809 if (ndopts.nd_opts_tgt_lladdr) {
1810 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1811 skb->dev);
1812 if (!lladdr) {
1813 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1814 return;
1815 }
1816 }
1817
1818 rt = (struct rt6_info *) dst;
1819 if (rt == net->ipv6.ip6_null_entry) {
1820 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1821 return;
1822 }
1823
1824 /* Redirect received -> path was valid.
1825 * Look, redirects are sent only in response to data packets,
1826 * so that this nexthop apparently is reachable. --ANK
1827 */
1828 dst_confirm(&rt->dst);
1829
1830 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1831 if (!neigh)
1832 return;
1833
1834 /*
1835 * We have finally decided to accept it.
1836 */
1837
1838 neigh_update(neigh, lladdr, NUD_STALE,
1839 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1840 NEIGH_UPDATE_F_OVERRIDE|
1841 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1842 NEIGH_UPDATE_F_ISROUTER))
1843 );
1844
1845 nrt = ip6_rt_copy(rt, &msg->dest);
1846 if (!nrt)
1847 goto out;
1848
1849 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1850 if (on_link)
1851 nrt->rt6i_flags &= ~RTF_GATEWAY;
1852
1853 nrt->rt6i_protocol = RTPROT_REDIRECT;
1854 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1855
1856 if (ip6_ins_rt(nrt))
1857 goto out;
1858
1859 netevent.old = &rt->dst;
1860 netevent.new = &nrt->dst;
1861 netevent.daddr = &msg->dest;
1862 netevent.neigh = neigh;
1863 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1864
1865 if (rt->rt6i_flags & RTF_CACHE) {
1866 rt = (struct rt6_info *) dst_clone(&rt->dst);
1867 ip6_del_rt(rt);
1868 }
1869
1870 out:
1871 neigh_release(neigh);
1872 }
1873
1874 /*
1875 * Misc support functions
1876 */
1877
1878 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1879 const struct in6_addr *dest)
1880 {
1881 struct net *net = dev_net(ort->dst.dev);
1882 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1883 ort->rt6i_table);
1884
1885 if (rt) {
1886 rt->dst.input = ort->dst.input;
1887 rt->dst.output = ort->dst.output;
1888 rt->dst.flags |= DST_HOST;
1889
1890 rt->rt6i_dst.addr = *dest;
1891 rt->rt6i_dst.plen = 128;
1892 dst_copy_metrics(&rt->dst, &ort->dst);
1893 rt->dst.error = ort->dst.error;
1894 rt->rt6i_idev = ort->rt6i_idev;
1895 if (rt->rt6i_idev)
1896 in6_dev_hold(rt->rt6i_idev);
1897 rt->dst.lastuse = jiffies;
1898
1899 if (ort->rt6i_flags & RTF_GATEWAY)
1900 rt->rt6i_gateway = ort->rt6i_gateway;
1901 else
1902 rt->rt6i_gateway = *dest;
1903 rt->rt6i_flags = ort->rt6i_flags;
1904 rt6_set_from(rt, ort);
1905 rt->rt6i_metric = 0;
1906
1907 #ifdef CONFIG_IPV6_SUBTREES
1908 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1909 #endif
1910 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1911 rt->rt6i_table = ort->rt6i_table;
1912 }
1913 return rt;
1914 }
1915
1916 #ifdef CONFIG_IPV6_ROUTE_INFO
1917 static struct rt6_info *rt6_get_route_info(struct net *net,
1918 const struct in6_addr *prefix, int prefixlen,
1919 const struct in6_addr *gwaddr, int ifindex)
1920 {
1921 struct fib6_node *fn;
1922 struct rt6_info *rt = NULL;
1923 struct fib6_table *table;
1924
1925 table = fib6_get_table(net, RT6_TABLE_INFO);
1926 if (!table)
1927 return NULL;
1928
1929 read_lock_bh(&table->tb6_lock);
1930 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1931 if (!fn)
1932 goto out;
1933
1934 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1935 if (rt->dst.dev->ifindex != ifindex)
1936 continue;
1937 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1938 continue;
1939 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1940 continue;
1941 dst_hold(&rt->dst);
1942 break;
1943 }
1944 out:
1945 read_unlock_bh(&table->tb6_lock);
1946 return rt;
1947 }
1948
1949 static struct rt6_info *rt6_add_route_info(struct net *net,
1950 const struct in6_addr *prefix, int prefixlen,
1951 const struct in6_addr *gwaddr, int ifindex,
1952 unsigned int pref)
1953 {
1954 struct fib6_config cfg = {
1955 .fc_table = RT6_TABLE_INFO,
1956 .fc_metric = IP6_RT_PRIO_USER,
1957 .fc_ifindex = ifindex,
1958 .fc_dst_len = prefixlen,
1959 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1960 RTF_UP | RTF_PREF(pref),
1961 .fc_protocol = RTPROT_RA,
1962 .fc_nlinfo.portid = 0,
1963 .fc_nlinfo.nlh = NULL,
1964 .fc_nlinfo.nl_net = net,
1965 };
1966
1967 cfg.fc_dst = *prefix;
1968 cfg.fc_gateway = *gwaddr;
1969
1970 /* We should treat it as a default route if prefix length is 0. */
1971 if (!prefixlen)
1972 cfg.fc_flags |= RTF_DEFAULT;
1973
1974 ip6_route_add(&cfg);
1975
1976 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1977 }
1978 #endif
1979
1980 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1981 {
1982 struct rt6_info *rt;
1983 struct fib6_table *table;
1984
1985 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1986 if (!table)
1987 return NULL;
1988
1989 read_lock_bh(&table->tb6_lock);
1990 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1991 if (dev == rt->dst.dev &&
1992 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1993 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1994 break;
1995 }
1996 if (rt)
1997 dst_hold(&rt->dst);
1998 read_unlock_bh(&table->tb6_lock);
1999 return rt;
2000 }
2001
2002 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
2003 struct net_device *dev,
2004 unsigned int pref)
2005 {
2006 struct fib6_config cfg = {
2007 .fc_table = RT6_TABLE_DFLT,
2008 .fc_metric = IP6_RT_PRIO_USER,
2009 .fc_ifindex = dev->ifindex,
2010 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2011 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2012 .fc_protocol = RTPROT_RA,
2013 .fc_nlinfo.portid = 0,
2014 .fc_nlinfo.nlh = NULL,
2015 .fc_nlinfo.nl_net = dev_net(dev),
2016 };
2017
2018 cfg.fc_gateway = *gwaddr;
2019
2020 ip6_route_add(&cfg);
2021
2022 return rt6_get_dflt_router(gwaddr, dev);
2023 }
2024
2025 void rt6_purge_dflt_routers(struct net *net)
2026 {
2027 struct rt6_info *rt;
2028 struct fib6_table *table;
2029
2030 /* NOTE: Keep consistent with rt6_get_dflt_router */
2031 table = fib6_get_table(net, RT6_TABLE_DFLT);
2032 if (!table)
2033 return;
2034
2035 restart:
2036 read_lock_bh(&table->tb6_lock);
2037 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2038 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2039 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2040 dst_hold(&rt->dst);
2041 read_unlock_bh(&table->tb6_lock);
2042 ip6_del_rt(rt);
2043 goto restart;
2044 }
2045 }
2046 read_unlock_bh(&table->tb6_lock);
2047 }
2048
2049 static void rtmsg_to_fib6_config(struct net *net,
2050 struct in6_rtmsg *rtmsg,
2051 struct fib6_config *cfg)
2052 {
2053 memset(cfg, 0, sizeof(*cfg));
2054
2055 cfg->fc_table = RT6_TABLE_MAIN;
2056 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2057 cfg->fc_metric = rtmsg->rtmsg_metric;
2058 cfg->fc_expires = rtmsg->rtmsg_info;
2059 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2060 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2061 cfg->fc_flags = rtmsg->rtmsg_flags;
2062
2063 cfg->fc_nlinfo.nl_net = net;
2064
2065 cfg->fc_dst = rtmsg->rtmsg_dst;
2066 cfg->fc_src = rtmsg->rtmsg_src;
2067 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2068 }
2069
2070 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2071 {
2072 struct fib6_config cfg;
2073 struct in6_rtmsg rtmsg;
2074 int err;
2075
2076 switch(cmd) {
2077 case SIOCADDRT: /* Add a route */
2078 case SIOCDELRT: /* Delete a route */
2079 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2080 return -EPERM;
2081 err = copy_from_user(&rtmsg, arg,
2082 sizeof(struct in6_rtmsg));
2083 if (err)
2084 return -EFAULT;
2085
2086 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2087
2088 rtnl_lock();
2089 switch (cmd) {
2090 case SIOCADDRT:
2091 err = ip6_route_add(&cfg);
2092 break;
2093 case SIOCDELRT:
2094 err = ip6_route_del(&cfg);
2095 break;
2096 default:
2097 err = -EINVAL;
2098 }
2099 rtnl_unlock();
2100
2101 return err;
2102 }
2103
2104 return -EINVAL;
2105 }
2106
2107 /*
2108 * Drop the packet on the floor
2109 */
2110
2111 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2112 {
2113 int type;
2114 struct dst_entry *dst = skb_dst(skb);
2115 switch (ipstats_mib_noroutes) {
2116 case IPSTATS_MIB_INNOROUTES:
2117 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2118 if (type == IPV6_ADDR_ANY) {
2119 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2120 IPSTATS_MIB_INADDRERRORS);
2121 break;
2122 }
2123 /* FALLTHROUGH */
2124 case IPSTATS_MIB_OUTNOROUTES:
2125 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2126 ipstats_mib_noroutes);
2127 break;
2128 }
2129 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2130 kfree_skb(skb);
2131 return 0;
2132 }
2133
2134 static int ip6_pkt_discard(struct sk_buff *skb)
2135 {
2136 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2137 }
2138
2139 static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
2140 {
2141 skb->dev = skb_dst(skb)->dev;
2142 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2143 }
2144
2145 static int ip6_pkt_prohibit(struct sk_buff *skb)
2146 {
2147 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2148 }
2149
2150 static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
2151 {
2152 skb->dev = skb_dst(skb)->dev;
2153 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2154 }
2155
2156 /*
2157 * Allocate a dst for local (unicast / anycast) address.
2158 */
2159
2160 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2161 const struct in6_addr *addr,
2162 bool anycast)
2163 {
2164 struct net *net = dev_net(idev->dev);
2165 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2166 DST_NOCOUNT, NULL);
2167 if (!rt)
2168 return ERR_PTR(-ENOMEM);
2169
2170 in6_dev_hold(idev);
2171
2172 rt->dst.flags |= DST_HOST;
2173 rt->dst.input = ip6_input;
2174 rt->dst.output = ip6_output;
2175 rt->rt6i_idev = idev;
2176
2177 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2178 if (anycast)
2179 rt->rt6i_flags |= RTF_ANYCAST;
2180 else
2181 rt->rt6i_flags |= RTF_LOCAL;
2182
2183 rt->rt6i_gateway = *addr;
2184 rt->rt6i_dst.addr = *addr;
2185 rt->rt6i_dst.plen = 128;
2186 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2187
2188 atomic_set(&rt->dst.__refcnt, 1);
2189
2190 return rt;
2191 }
2192
2193 int ip6_route_get_saddr(struct net *net,
2194 struct rt6_info *rt,
2195 const struct in6_addr *daddr,
2196 unsigned int prefs,
2197 struct in6_addr *saddr)
2198 {
2199 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2200 int err = 0;
2201 if (rt->rt6i_prefsrc.plen)
2202 *saddr = rt->rt6i_prefsrc.addr;
2203 else
2204 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2205 daddr, prefs, saddr);
2206 return err;
2207 }
2208
2209 /* remove deleted ip from prefsrc entries */
2210 struct arg_dev_net_ip {
2211 struct net_device *dev;
2212 struct net *net;
2213 struct in6_addr *addr;
2214 };
2215
2216 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2217 {
2218 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2219 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2220 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2221
2222 if (((void *)rt->dst.dev == dev || !dev) &&
2223 rt != net->ipv6.ip6_null_entry &&
2224 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2225 /* remove prefsrc entry */
2226 rt->rt6i_prefsrc.plen = 0;
2227 }
2228 return 0;
2229 }
2230
2231 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2232 {
2233 struct net *net = dev_net(ifp->idev->dev);
2234 struct arg_dev_net_ip adni = {
2235 .dev = ifp->idev->dev,
2236 .net = net,
2237 .addr = &ifp->addr,
2238 };
2239 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2240 }
2241
2242 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2243 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2244
2245 /* Remove routers and update dst entries when gateway turn into host. */
2246 static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2247 {
2248 struct in6_addr *gateway = (struct in6_addr *)arg;
2249
2250 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2251 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2252 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2253 return -1;
2254 }
2255 return 0;
2256 }
2257
2258 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2259 {
2260 fib6_clean_all(net, fib6_clean_tohost, gateway);
2261 }
2262
2263 struct arg_dev_net {
2264 struct net_device *dev;
2265 struct net *net;
2266 };
2267
2268 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2269 {
2270 const struct arg_dev_net *adn = arg;
2271 const struct net_device *dev = adn->dev;
2272
2273 if ((rt->dst.dev == dev || !dev) &&
2274 rt != adn->net->ipv6.ip6_null_entry)
2275 return -1;
2276
2277 return 0;
2278 }
2279
2280 void rt6_ifdown(struct net *net, struct net_device *dev)
2281 {
2282 struct arg_dev_net adn = {
2283 .dev = dev,
2284 .net = net,
2285 };
2286
2287 fib6_clean_all(net, fib6_ifdown, &adn);
2288 icmp6_clean_all(fib6_ifdown, &adn);
2289 }
2290
2291 struct rt6_mtu_change_arg {
2292 struct net_device *dev;
2293 unsigned int mtu;
2294 };
2295
2296 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2297 {
2298 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2299 struct inet6_dev *idev;
2300
2301 /* In IPv6 pmtu discovery is not optional,
2302 so that RTAX_MTU lock cannot disable it.
2303 We still use this lock to block changes
2304 caused by addrconf/ndisc.
2305 */
2306
2307 idev = __in6_dev_get(arg->dev);
2308 if (!idev)
2309 return 0;
2310
2311 /* For administrative MTU increase, there is no way to discover
2312 IPv6 PMTU increase, so PMTU increase should be updated here.
2313 Since RFC 1981 doesn't include administrative MTU increase
2314 update PMTU increase is a MUST. (i.e. jumbo frame)
2315 */
2316 /*
2317 If new MTU is less than route PMTU, this new MTU will be the
2318 lowest MTU in the path, update the route PMTU to reflect PMTU
2319 decreases; if new MTU is greater than route PMTU, and the
2320 old MTU is the lowest MTU in the path, update the route PMTU
2321 to reflect the increase. In this case if the other nodes' MTU
2322 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2323 PMTU discouvery.
2324 */
2325 if (rt->dst.dev == arg->dev &&
2326 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2327 (dst_mtu(&rt->dst) >= arg->mtu ||
2328 (dst_mtu(&rt->dst) < arg->mtu &&
2329 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2330 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2331 }
2332 return 0;
2333 }
2334
2335 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2336 {
2337 struct rt6_mtu_change_arg arg = {
2338 .dev = dev,
2339 .mtu = mtu,
2340 };
2341
2342 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2343 }
2344
2345 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2346 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2347 [RTA_OIF] = { .type = NLA_U32 },
2348 [RTA_IIF] = { .type = NLA_U32 },
2349 [RTA_PRIORITY] = { .type = NLA_U32 },
2350 [RTA_METRICS] = { .type = NLA_NESTED },
2351 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2352 };
2353
2354 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2355 struct fib6_config *cfg)
2356 {
2357 struct rtmsg *rtm;
2358 struct nlattr *tb[RTA_MAX+1];
2359 int err;
2360
2361 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2362 if (err < 0)
2363 goto errout;
2364
2365 err = -EINVAL;
2366 rtm = nlmsg_data(nlh);
2367 memset(cfg, 0, sizeof(*cfg));
2368
2369 cfg->fc_table = rtm->rtm_table;
2370 cfg->fc_dst_len = rtm->rtm_dst_len;
2371 cfg->fc_src_len = rtm->rtm_src_len;
2372 cfg->fc_flags = RTF_UP;
2373 cfg->fc_protocol = rtm->rtm_protocol;
2374 cfg->fc_type = rtm->rtm_type;
2375
2376 if (rtm->rtm_type == RTN_UNREACHABLE ||
2377 rtm->rtm_type == RTN_BLACKHOLE ||
2378 rtm->rtm_type == RTN_PROHIBIT ||
2379 rtm->rtm_type == RTN_THROW)
2380 cfg->fc_flags |= RTF_REJECT;
2381
2382 if (rtm->rtm_type == RTN_LOCAL)
2383 cfg->fc_flags |= RTF_LOCAL;
2384
2385 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2386 cfg->fc_nlinfo.nlh = nlh;
2387 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2388
2389 if (tb[RTA_GATEWAY]) {
2390 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2391 cfg->fc_flags |= RTF_GATEWAY;
2392 }
2393
2394 if (tb[RTA_DST]) {
2395 int plen = (rtm->rtm_dst_len + 7) >> 3;
2396
2397 if (nla_len(tb[RTA_DST]) < plen)
2398 goto errout;
2399
2400 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2401 }
2402
2403 if (tb[RTA_SRC]) {
2404 int plen = (rtm->rtm_src_len + 7) >> 3;
2405
2406 if (nla_len(tb[RTA_SRC]) < plen)
2407 goto errout;
2408
2409 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2410 }
2411
2412 if (tb[RTA_PREFSRC])
2413 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2414
2415 if (tb[RTA_OIF])
2416 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2417
2418 if (tb[RTA_PRIORITY])
2419 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2420
2421 if (tb[RTA_METRICS]) {
2422 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2423 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2424 }
2425
2426 if (tb[RTA_TABLE])
2427 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2428
2429 if (tb[RTA_MULTIPATH]) {
2430 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2431 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2432 }
2433
2434 err = 0;
2435 errout:
2436 return err;
2437 }
2438
2439 static int ip6_route_multipath(struct fib6_config *cfg, int add)
2440 {
2441 struct fib6_config r_cfg;
2442 struct rtnexthop *rtnh;
2443 int remaining;
2444 int attrlen;
2445 int err = 0, last_err = 0;
2446
2447 remaining = cfg->fc_mp_len;
2448 beginning:
2449 rtnh = (struct rtnexthop *)cfg->fc_mp;
2450
2451 /* Parse a Multipath Entry */
2452 while (rtnh_ok(rtnh, remaining)) {
2453 memcpy(&r_cfg, cfg, sizeof(*cfg));
2454 if (rtnh->rtnh_ifindex)
2455 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2456
2457 attrlen = rtnh_attrlen(rtnh);
2458 if (attrlen > 0) {
2459 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2460
2461 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2462 if (nla) {
2463 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2464 r_cfg.fc_flags |= RTF_GATEWAY;
2465 }
2466 }
2467 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2468 if (err) {
2469 last_err = err;
2470 /* If we are trying to remove a route, do not stop the
2471 * loop when ip6_route_del() fails (because next hop is
2472 * already gone), we should try to remove all next hops.
2473 */
2474 if (add) {
2475 /* If add fails, we should try to delete all
2476 * next hops that have been already added.
2477 */
2478 add = 0;
2479 remaining = cfg->fc_mp_len - remaining;
2480 goto beginning;
2481 }
2482 }
2483 /* Because each route is added like a single route we remove
2484 * these flags after the first nexthop: if there is a collision,
2485 * we have already failed to add the first nexthop:
2486 * fib6_add_rt2node() has rejected it; when replacing, old
2487 * nexthops have been replaced by first new, the rest should
2488 * be added to it.
2489 */
2490 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
2491 NLM_F_REPLACE);
2492 rtnh = rtnh_next(rtnh, &remaining);
2493 }
2494
2495 return last_err;
2496 }
2497
2498 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2499 {
2500 struct fib6_config cfg;
2501 int err;
2502
2503 err = rtm_to_fib6_config(skb, nlh, &cfg);
2504 if (err < 0)
2505 return err;
2506
2507 if (cfg.fc_mp)
2508 return ip6_route_multipath(&cfg, 0);
2509 else
2510 return ip6_route_del(&cfg);
2511 }
2512
2513 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2514 {
2515 struct fib6_config cfg;
2516 int err;
2517
2518 err = rtm_to_fib6_config(skb, nlh, &cfg);
2519 if (err < 0)
2520 return err;
2521
2522 if (cfg.fc_mp)
2523 return ip6_route_multipath(&cfg, 1);
2524 else
2525 return ip6_route_add(&cfg);
2526 }
2527
2528 static inline size_t rt6_nlmsg_size(void)
2529 {
2530 return NLMSG_ALIGN(sizeof(struct rtmsg))
2531 + nla_total_size(16) /* RTA_SRC */
2532 + nla_total_size(16) /* RTA_DST */
2533 + nla_total_size(16) /* RTA_GATEWAY */
2534 + nla_total_size(16) /* RTA_PREFSRC */
2535 + nla_total_size(4) /* RTA_TABLE */
2536 + nla_total_size(4) /* RTA_IIF */
2537 + nla_total_size(4) /* RTA_OIF */
2538 + nla_total_size(4) /* RTA_PRIORITY */
2539 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2540 + nla_total_size(sizeof(struct rta_cacheinfo));
2541 }
2542
2543 static int rt6_fill_node(struct net *net,
2544 struct sk_buff *skb, struct rt6_info *rt,
2545 struct in6_addr *dst, struct in6_addr *src,
2546 int iif, int type, u32 portid, u32 seq,
2547 int prefix, int nowait, unsigned int flags)
2548 {
2549 struct rtmsg *rtm;
2550 struct nlmsghdr *nlh;
2551 long expires;
2552 u32 table;
2553
2554 if (prefix) { /* user wants prefix routes only */
2555 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2556 /* success since this is not a prefix route */
2557 return 1;
2558 }
2559 }
2560
2561 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2562 if (!nlh)
2563 return -EMSGSIZE;
2564
2565 rtm = nlmsg_data(nlh);
2566 rtm->rtm_family = AF_INET6;
2567 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2568 rtm->rtm_src_len = rt->rt6i_src.plen;
2569 rtm->rtm_tos = 0;
2570 if (rt->rt6i_table)
2571 table = rt->rt6i_table->tb6_id;
2572 else
2573 table = RT6_TABLE_UNSPEC;
2574 rtm->rtm_table = table;
2575 if (nla_put_u32(skb, RTA_TABLE, table))
2576 goto nla_put_failure;
2577 if (rt->rt6i_flags & RTF_REJECT) {
2578 switch (rt->dst.error) {
2579 case -EINVAL:
2580 rtm->rtm_type = RTN_BLACKHOLE;
2581 break;
2582 case -EACCES:
2583 rtm->rtm_type = RTN_PROHIBIT;
2584 break;
2585 case -EAGAIN:
2586 rtm->rtm_type = RTN_THROW;
2587 break;
2588 default:
2589 rtm->rtm_type = RTN_UNREACHABLE;
2590 break;
2591 }
2592 }
2593 else if (rt->rt6i_flags & RTF_LOCAL)
2594 rtm->rtm_type = RTN_LOCAL;
2595 else if (rt->rt6i_flags & RTF_ANYCAST)
2596 rtm->rtm_type = RTN_ANYCAST;
2597 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2598 rtm->rtm_type = RTN_LOCAL;
2599 else
2600 rtm->rtm_type = RTN_UNICAST;
2601 rtm->rtm_flags = 0;
2602 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2603 rtm->rtm_protocol = rt->rt6i_protocol;
2604
2605 if (rt->rt6i_flags & RTF_CACHE)
2606 rtm->rtm_flags |= RTM_F_CLONED;
2607
2608 if (dst) {
2609 if (nla_put(skb, RTA_DST, 16, dst))
2610 goto nla_put_failure;
2611 rtm->rtm_dst_len = 128;
2612 } else if (rtm->rtm_dst_len)
2613 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2614 goto nla_put_failure;
2615 #ifdef CONFIG_IPV6_SUBTREES
2616 if (src) {
2617 if (nla_put(skb, RTA_SRC, 16, src))
2618 goto nla_put_failure;
2619 rtm->rtm_src_len = 128;
2620 } else if (rtm->rtm_src_len &&
2621 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2622 goto nla_put_failure;
2623 #endif
2624 if (iif) {
2625 #ifdef CONFIG_IPV6_MROUTE
2626 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2627 int err = ip6mr_get_route(net, skb, rtm, nowait,
2628 portid);
2629
2630 if (err <= 0) {
2631 if (!nowait) {
2632 if (err == 0)
2633 return 0;
2634 goto nla_put_failure;
2635 } else {
2636 if (err == -EMSGSIZE)
2637 goto nla_put_failure;
2638 }
2639 }
2640 } else
2641 #endif
2642 if (nla_put_u32(skb, RTA_IIF, iif))
2643 goto nla_put_failure;
2644 } else if (dst) {
2645 struct in6_addr saddr_buf;
2646 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2647 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2648 goto nla_put_failure;
2649 }
2650
2651 if (rt->rt6i_prefsrc.plen) {
2652 struct in6_addr saddr_buf;
2653 saddr_buf = rt->rt6i_prefsrc.addr;
2654 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2655 goto nla_put_failure;
2656 }
2657
2658 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2659 goto nla_put_failure;
2660
2661 if (rt->rt6i_flags & RTF_GATEWAY) {
2662 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2663 goto nla_put_failure;
2664 }
2665
2666 if (rt->dst.dev &&
2667 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2668 goto nla_put_failure;
2669 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2670 goto nla_put_failure;
2671
2672 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2673
2674 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2675 goto nla_put_failure;
2676
2677 return nlmsg_end(skb, nlh);
2678
2679 nla_put_failure:
2680 nlmsg_cancel(skb, nlh);
2681 return -EMSGSIZE;
2682 }
2683
2684 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2685 {
2686 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2687 int prefix;
2688
2689 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2690 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2691 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2692 } else
2693 prefix = 0;
2694
2695 return rt6_fill_node(arg->net,
2696 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2697 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2698 prefix, 0, NLM_F_MULTI);
2699 }
2700
2701 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh)
2702 {
2703 struct net *net = sock_net(in_skb->sk);
2704 struct nlattr *tb[RTA_MAX+1];
2705 struct rt6_info *rt;
2706 struct sk_buff *skb;
2707 struct rtmsg *rtm;
2708 struct flowi6 fl6;
2709 int err, iif = 0, oif = 0;
2710
2711 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2712 if (err < 0)
2713 goto errout;
2714
2715 err = -EINVAL;
2716 memset(&fl6, 0, sizeof(fl6));
2717
2718 if (tb[RTA_SRC]) {
2719 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2720 goto errout;
2721
2722 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2723 }
2724
2725 if (tb[RTA_DST]) {
2726 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2727 goto errout;
2728
2729 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2730 }
2731
2732 if (tb[RTA_IIF])
2733 iif = nla_get_u32(tb[RTA_IIF]);
2734
2735 if (tb[RTA_OIF])
2736 oif = nla_get_u32(tb[RTA_OIF]);
2737
2738 if (tb[RTA_MARK])
2739 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2740
2741 if (iif) {
2742 struct net_device *dev;
2743 int flags = 0;
2744
2745 dev = __dev_get_by_index(net, iif);
2746 if (!dev) {
2747 err = -ENODEV;
2748 goto errout;
2749 }
2750
2751 fl6.flowi6_iif = iif;
2752
2753 if (!ipv6_addr_any(&fl6.saddr))
2754 flags |= RT6_LOOKUP_F_HAS_SADDR;
2755
2756 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2757 flags);
2758 } else {
2759 fl6.flowi6_oif = oif;
2760
2761 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2762 }
2763
2764 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2765 if (!skb) {
2766 ip6_rt_put(rt);
2767 err = -ENOBUFS;
2768 goto errout;
2769 }
2770
2771 /* Reserve room for dummy headers, this skb can pass
2772 through good chunk of routing engine.
2773 */
2774 skb_reset_mac_header(skb);
2775 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2776
2777 skb_dst_set(skb, &rt->dst);
2778
2779 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2780 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2781 nlh->nlmsg_seq, 0, 0, 0);
2782 if (err < 0) {
2783 kfree_skb(skb);
2784 goto errout;
2785 }
2786
2787 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2788 errout:
2789 return err;
2790 }
2791
2792 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2793 {
2794 struct sk_buff *skb;
2795 struct net *net = info->nl_net;
2796 u32 seq;
2797 int err;
2798
2799 err = -ENOBUFS;
2800 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2801
2802 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2803 if (!skb)
2804 goto errout;
2805
2806 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2807 event, info->portid, seq, 0, 0, 0);
2808 if (err < 0) {
2809 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2810 WARN_ON(err == -EMSGSIZE);
2811 kfree_skb(skb);
2812 goto errout;
2813 }
2814 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2815 info->nlh, gfp_any());
2816 return;
2817 errout:
2818 if (err < 0)
2819 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2820 }
2821
2822 static int ip6_route_dev_notify(struct notifier_block *this,
2823 unsigned long event, void *ptr)
2824 {
2825 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2826 struct net *net = dev_net(dev);
2827
2828 if (!(dev->flags & IFF_LOOPBACK))
2829 return NOTIFY_OK;
2830
2831 if (event == NETDEV_REGISTER) {
2832 net->ipv6.ip6_null_entry->dst.dev = dev;
2833 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2834 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2835 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2836 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2837 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2838 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2839 #endif
2840 } else if (event == NETDEV_UNREGISTER &&
2841 dev->reg_state != NETREG_UNREGISTERED) {
2842 /* NETDEV_UNREGISTER could be fired for multiple times by
2843 * netdev_wait_allrefs(). Make sure we only call this once.
2844 */
2845 in6_dev_put(net->ipv6.ip6_null_entry->rt6i_idev);
2846 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2847 in6_dev_put(net->ipv6.ip6_prohibit_entry->rt6i_idev);
2848 in6_dev_put(net->ipv6.ip6_blk_hole_entry->rt6i_idev);
2849 #endif
2850 }
2851
2852 return NOTIFY_OK;
2853 }
2854
2855 /*
2856 * /proc
2857 */
2858
2859 #ifdef CONFIG_PROC_FS
2860
2861 static const struct file_operations ipv6_route_proc_fops = {
2862 .owner = THIS_MODULE,
2863 .open = ipv6_route_open,
2864 .read = seq_read,
2865 .llseek = seq_lseek,
2866 .release = seq_release_net,
2867 };
2868
2869 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2870 {
2871 struct net *net = (struct net *)seq->private;
2872 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2873 net->ipv6.rt6_stats->fib_nodes,
2874 net->ipv6.rt6_stats->fib_route_nodes,
2875 net->ipv6.rt6_stats->fib_rt_alloc,
2876 net->ipv6.rt6_stats->fib_rt_entries,
2877 net->ipv6.rt6_stats->fib_rt_cache,
2878 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2879 net->ipv6.rt6_stats->fib_discarded_routes);
2880
2881 return 0;
2882 }
2883
2884 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2885 {
2886 return single_open_net(inode, file, rt6_stats_seq_show);
2887 }
2888
2889 static const struct file_operations rt6_stats_seq_fops = {
2890 .owner = THIS_MODULE,
2891 .open = rt6_stats_seq_open,
2892 .read = seq_read,
2893 .llseek = seq_lseek,
2894 .release = single_release_net,
2895 };
2896 #endif /* CONFIG_PROC_FS */
2897
2898 #ifdef CONFIG_SYSCTL
2899
2900 static
2901 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
2902 void __user *buffer, size_t *lenp, loff_t *ppos)
2903 {
2904 struct net *net;
2905 int delay;
2906 if (!write)
2907 return -EINVAL;
2908
2909 net = (struct net *)ctl->extra1;
2910 delay = net->ipv6.sysctl.flush_delay;
2911 proc_dointvec(ctl, write, buffer, lenp, ppos);
2912 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
2913 return 0;
2914 }
2915
2916 struct ctl_table ipv6_route_table_template[] = {
2917 {
2918 .procname = "flush",
2919 .data = &init_net.ipv6.sysctl.flush_delay,
2920 .maxlen = sizeof(int),
2921 .mode = 0200,
2922 .proc_handler = ipv6_sysctl_rtcache_flush
2923 },
2924 {
2925 .procname = "gc_thresh",
2926 .data = &ip6_dst_ops_template.gc_thresh,
2927 .maxlen = sizeof(int),
2928 .mode = 0644,
2929 .proc_handler = proc_dointvec,
2930 },
2931 {
2932 .procname = "max_size",
2933 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2934 .maxlen = sizeof(int),
2935 .mode = 0644,
2936 .proc_handler = proc_dointvec,
2937 },
2938 {
2939 .procname = "gc_min_interval",
2940 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2941 .maxlen = sizeof(int),
2942 .mode = 0644,
2943 .proc_handler = proc_dointvec_jiffies,
2944 },
2945 {
2946 .procname = "gc_timeout",
2947 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2948 .maxlen = sizeof(int),
2949 .mode = 0644,
2950 .proc_handler = proc_dointvec_jiffies,
2951 },
2952 {
2953 .procname = "gc_interval",
2954 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2955 .maxlen = sizeof(int),
2956 .mode = 0644,
2957 .proc_handler = proc_dointvec_jiffies,
2958 },
2959 {
2960 .procname = "gc_elasticity",
2961 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2962 .maxlen = sizeof(int),
2963 .mode = 0644,
2964 .proc_handler = proc_dointvec,
2965 },
2966 {
2967 .procname = "mtu_expires",
2968 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2969 .maxlen = sizeof(int),
2970 .mode = 0644,
2971 .proc_handler = proc_dointvec_jiffies,
2972 },
2973 {
2974 .procname = "min_adv_mss",
2975 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2976 .maxlen = sizeof(int),
2977 .mode = 0644,
2978 .proc_handler = proc_dointvec,
2979 },
2980 {
2981 .procname = "gc_min_interval_ms",
2982 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2983 .maxlen = sizeof(int),
2984 .mode = 0644,
2985 .proc_handler = proc_dointvec_ms_jiffies,
2986 },
2987 { }
2988 };
2989
2990 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2991 {
2992 struct ctl_table *table;
2993
2994 table = kmemdup(ipv6_route_table_template,
2995 sizeof(ipv6_route_table_template),
2996 GFP_KERNEL);
2997
2998 if (table) {
2999 table[0].data = &net->ipv6.sysctl.flush_delay;
3000 table[0].extra1 = net;
3001 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
3002 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3003 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3004 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3005 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3006 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3007 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3008 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
3009 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3010
3011 /* Don't export sysctls to unprivileged users */
3012 if (net->user_ns != &init_user_ns)
3013 table[0].procname = NULL;
3014 }
3015
3016 return table;
3017 }
3018 #endif
3019
3020 static int __net_init ip6_route_net_init(struct net *net)
3021 {
3022 int ret = -ENOMEM;
3023
3024 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3025 sizeof(net->ipv6.ip6_dst_ops));
3026
3027 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3028 goto out_ip6_dst_ops;
3029
3030 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3031 sizeof(*net->ipv6.ip6_null_entry),
3032 GFP_KERNEL);
3033 if (!net->ipv6.ip6_null_entry)
3034 goto out_ip6_dst_entries;
3035 net->ipv6.ip6_null_entry->dst.path =
3036 (struct dst_entry *)net->ipv6.ip6_null_entry;
3037 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3038 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3039 ip6_template_metrics, true);
3040
3041 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3042 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3043 sizeof(*net->ipv6.ip6_prohibit_entry),
3044 GFP_KERNEL);
3045 if (!net->ipv6.ip6_prohibit_entry)
3046 goto out_ip6_null_entry;
3047 net->ipv6.ip6_prohibit_entry->dst.path =
3048 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3049 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3050 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3051 ip6_template_metrics, true);
3052
3053 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3054 sizeof(*net->ipv6.ip6_blk_hole_entry),
3055 GFP_KERNEL);
3056 if (!net->ipv6.ip6_blk_hole_entry)
3057 goto out_ip6_prohibit_entry;
3058 net->ipv6.ip6_blk_hole_entry->dst.path =
3059 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3060 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3061 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3062 ip6_template_metrics, true);
3063 #endif
3064
3065 net->ipv6.sysctl.flush_delay = 0;
3066 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3067 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3068 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3069 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3070 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3071 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3072 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3073
3074 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3075
3076 ret = 0;
3077 out:
3078 return ret;
3079
3080 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3081 out_ip6_prohibit_entry:
3082 kfree(net->ipv6.ip6_prohibit_entry);
3083 out_ip6_null_entry:
3084 kfree(net->ipv6.ip6_null_entry);
3085 #endif
3086 out_ip6_dst_entries:
3087 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3088 out_ip6_dst_ops:
3089 goto out;
3090 }
3091
3092 static void __net_exit ip6_route_net_exit(struct net *net)
3093 {
3094 kfree(net->ipv6.ip6_null_entry);
3095 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3096 kfree(net->ipv6.ip6_prohibit_entry);
3097 kfree(net->ipv6.ip6_blk_hole_entry);
3098 #endif
3099 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3100 }
3101
3102 static int __net_init ip6_route_net_init_late(struct net *net)
3103 {
3104 #ifdef CONFIG_PROC_FS
3105 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3106 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3107 #endif
3108 return 0;
3109 }
3110
3111 static void __net_exit ip6_route_net_exit_late(struct net *net)
3112 {
3113 #ifdef CONFIG_PROC_FS
3114 remove_proc_entry("ipv6_route", net->proc_net);
3115 remove_proc_entry("rt6_stats", net->proc_net);
3116 #endif
3117 }
3118
3119 static struct pernet_operations ip6_route_net_ops = {
3120 .init = ip6_route_net_init,
3121 .exit = ip6_route_net_exit,
3122 };
3123
3124 static int __net_init ipv6_inetpeer_init(struct net *net)
3125 {
3126 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3127
3128 if (!bp)
3129 return -ENOMEM;
3130 inet_peer_base_init(bp);
3131 net->ipv6.peers = bp;
3132 return 0;
3133 }
3134
3135 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3136 {
3137 struct inet_peer_base *bp = net->ipv6.peers;
3138
3139 net->ipv6.peers = NULL;
3140 inetpeer_invalidate_tree(bp);
3141 kfree(bp);
3142 }
3143
3144 static struct pernet_operations ipv6_inetpeer_ops = {
3145 .init = ipv6_inetpeer_init,
3146 .exit = ipv6_inetpeer_exit,
3147 };
3148
3149 static struct pernet_operations ip6_route_net_late_ops = {
3150 .init = ip6_route_net_init_late,
3151 .exit = ip6_route_net_exit_late,
3152 };
3153
3154 static struct notifier_block ip6_route_dev_notifier = {
3155 .notifier_call = ip6_route_dev_notify,
3156 .priority = ADDRCONF_NOTIFY_PRIORITY - 10,
3157 };
3158
3159 void __init ip6_route_init_special_entries(void)
3160 {
3161 /* Registering of the loopback is done before this portion of code,
3162 * the loopback reference in rt6_info will not be taken, do it
3163 * manually for init_net */
3164 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3165 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3166 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3167 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3168 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3169 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3170 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3171 #endif
3172 }
3173
3174 int __init ip6_route_init(void)
3175 {
3176 int ret;
3177
3178 ret = -ENOMEM;
3179 ip6_dst_ops_template.kmem_cachep =
3180 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3181 SLAB_HWCACHE_ALIGN, NULL);
3182 if (!ip6_dst_ops_template.kmem_cachep)
3183 goto out;
3184
3185 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3186 if (ret)
3187 goto out_kmem_cache;
3188
3189 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3190 if (ret)
3191 goto out_dst_entries;
3192
3193 ret = register_pernet_subsys(&ip6_route_net_ops);
3194 if (ret)
3195 goto out_register_inetpeer;
3196
3197 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3198
3199 ret = fib6_init();
3200 if (ret)
3201 goto out_register_subsys;
3202
3203 ret = xfrm6_init();
3204 if (ret)
3205 goto out_fib6_init;
3206
3207 ret = fib6_rules_init();
3208 if (ret)
3209 goto xfrm6_init;
3210
3211 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3212 if (ret)
3213 goto fib6_rules_init;
3214
3215 ret = -ENOBUFS;
3216 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3217 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3218 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3219 goto out_register_late_subsys;
3220
3221 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3222 if (ret)
3223 goto out_register_late_subsys;
3224
3225 out:
3226 return ret;
3227
3228 out_register_late_subsys:
3229 unregister_pernet_subsys(&ip6_route_net_late_ops);
3230 fib6_rules_init:
3231 fib6_rules_cleanup();
3232 xfrm6_init:
3233 xfrm6_fini();
3234 out_fib6_init:
3235 fib6_gc_cleanup();
3236 out_register_subsys:
3237 unregister_pernet_subsys(&ip6_route_net_ops);
3238 out_register_inetpeer:
3239 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3240 out_dst_entries:
3241 dst_entries_destroy(&ip6_dst_blackhole_ops);
3242 out_kmem_cache:
3243 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3244 goto out;
3245 }
3246
3247 void ip6_route_cleanup(void)
3248 {
3249 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3250 unregister_pernet_subsys(&ip6_route_net_late_ops);
3251 fib6_rules_cleanup();
3252 xfrm6_fini();
3253 fib6_gc_cleanup();
3254 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3255 unregister_pernet_subsys(&ip6_route_net_ops);
3256 dst_entries_destroy(&ip6_dst_blackhole_ops);
3257 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3258 }
Linux with added FPC-III support