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