]> 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
[NETNS][IPV6] ip6_fib - fib6_clean_all handle several network namespaces
[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 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16 /* Changes:
17 *
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
25 * Ville Nuorvala
26 * Fixed routing subtrees.
27 */
28
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/types.h>
32 #include <linux/times.h>
33 #include <linux/socket.h>
34 #include <linux/sockios.h>
35 #include <linux/net.h>
36 #include <linux/route.h>
37 #include <linux/netdevice.h>
38 #include <linux/in6.h>
39 #include <linux/init.h>
40 #include <linux/if_arp.h>
41 #include <linux/proc_fs.h>
42 #include <linux/seq_file.h>
43 #include <net/net_namespace.h>
44 #include <net/snmp.h>
45 #include <net/ipv6.h>
46 #include <net/ip6_fib.h>
47 #include <net/ip6_route.h>
48 #include <net/ndisc.h>
49 #include <net/addrconf.h>
50 #include <net/tcp.h>
51 #include <linux/rtnetlink.h>
52 #include <net/dst.h>
53 #include <net/xfrm.h>
54 #include <net/netevent.h>
55 #include <net/netlink.h>
56
57 #include <asm/uaccess.h>
58
59 #ifdef CONFIG_SYSCTL
60 #include <linux/sysctl.h>
61 #endif
62
63 /* Set to 3 to get tracing. */
64 #define RT6_DEBUG 2
65
66 #if RT6_DEBUG >= 3
67 #define RDBG(x) printk x
68 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
69 #else
70 #define RDBG(x)
71 #define RT6_TRACE(x...) do { ; } while (0)
72 #endif
73
74 #define CLONE_OFFLINK_ROUTE 0
75
76 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
77 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
78 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
79 static void ip6_dst_destroy(struct dst_entry *);
80 static void ip6_dst_ifdown(struct dst_entry *,
81 struct net_device *dev, int how);
82 static int ip6_dst_gc(struct dst_ops *ops);
83
84 static int ip6_pkt_discard(struct sk_buff *skb);
85 static int ip6_pkt_discard_out(struct sk_buff *skb);
86 static void ip6_link_failure(struct sk_buff *skb);
87 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
88
89 #ifdef CONFIG_IPV6_ROUTE_INFO
90 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
91 struct in6_addr *gwaddr, int ifindex,
92 unsigned pref);
93 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
94 struct in6_addr *gwaddr, int ifindex);
95 #endif
96
97 static struct dst_ops ip6_dst_ops = {
98 .family = AF_INET6,
99 .protocol = __constant_htons(ETH_P_IPV6),
100 .gc = ip6_dst_gc,
101 .gc_thresh = 1024,
102 .check = ip6_dst_check,
103 .destroy = ip6_dst_destroy,
104 .ifdown = ip6_dst_ifdown,
105 .negative_advice = ip6_negative_advice,
106 .link_failure = ip6_link_failure,
107 .update_pmtu = ip6_rt_update_pmtu,
108 .local_out = ip6_local_out,
109 .entry_size = sizeof(struct rt6_info),
110 .entries = ATOMIC_INIT(0),
111 };
112
113 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
114 {
115 }
116
117 static struct dst_ops ip6_dst_blackhole_ops = {
118 .family = AF_INET6,
119 .protocol = __constant_htons(ETH_P_IPV6),
120 .destroy = ip6_dst_destroy,
121 .check = ip6_dst_check,
122 .update_pmtu = ip6_rt_blackhole_update_pmtu,
123 .entry_size = sizeof(struct rt6_info),
124 .entries = ATOMIC_INIT(0),
125 };
126
127 struct rt6_info ip6_null_entry = {
128 .u = {
129 .dst = {
130 .__refcnt = ATOMIC_INIT(1),
131 .__use = 1,
132 .obsolete = -1,
133 .error = -ENETUNREACH,
134 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
135 .input = ip6_pkt_discard,
136 .output = ip6_pkt_discard_out,
137 .ops = &ip6_dst_ops,
138 .path = (struct dst_entry*)&ip6_null_entry,
139 }
140 },
141 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
142 .rt6i_metric = ~(u32) 0,
143 .rt6i_ref = ATOMIC_INIT(1),
144 };
145
146 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
147
148 static int ip6_pkt_prohibit(struct sk_buff *skb);
149 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
150
151 struct rt6_info ip6_prohibit_entry = {
152 .u = {
153 .dst = {
154 .__refcnt = ATOMIC_INIT(1),
155 .__use = 1,
156 .obsolete = -1,
157 .error = -EACCES,
158 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
159 .input = ip6_pkt_prohibit,
160 .output = ip6_pkt_prohibit_out,
161 .ops = &ip6_dst_ops,
162 .path = (struct dst_entry*)&ip6_prohibit_entry,
163 }
164 },
165 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
166 .rt6i_metric = ~(u32) 0,
167 .rt6i_ref = ATOMIC_INIT(1),
168 };
169
170 struct rt6_info ip6_blk_hole_entry = {
171 .u = {
172 .dst = {
173 .__refcnt = ATOMIC_INIT(1),
174 .__use = 1,
175 .obsolete = -1,
176 .error = -EINVAL,
177 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
178 .input = dst_discard,
179 .output = dst_discard,
180 .ops = &ip6_dst_ops,
181 .path = (struct dst_entry*)&ip6_blk_hole_entry,
182 }
183 },
184 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
185 .rt6i_metric = ~(u32) 0,
186 .rt6i_ref = ATOMIC_INIT(1),
187 };
188
189 #endif
190
191 /* allocate dst with ip6_dst_ops */
192 static __inline__ struct rt6_info *ip6_dst_alloc(void)
193 {
194 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
195 }
196
197 static void ip6_dst_destroy(struct dst_entry *dst)
198 {
199 struct rt6_info *rt = (struct rt6_info *)dst;
200 struct inet6_dev *idev = rt->rt6i_idev;
201
202 if (idev != NULL) {
203 rt->rt6i_idev = NULL;
204 in6_dev_put(idev);
205 }
206 }
207
208 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
209 int how)
210 {
211 struct rt6_info *rt = (struct rt6_info *)dst;
212 struct inet6_dev *idev = rt->rt6i_idev;
213 struct net_device *loopback_dev =
214 dev->nd_net->loopback_dev;
215
216 if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
217 struct inet6_dev *loopback_idev =
218 in6_dev_get(loopback_dev);
219 if (loopback_idev != NULL) {
220 rt->rt6i_idev = loopback_idev;
221 in6_dev_put(idev);
222 }
223 }
224 }
225
226 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
227 {
228 return (rt->rt6i_flags & RTF_EXPIRES &&
229 time_after(jiffies, rt->rt6i_expires));
230 }
231
232 static inline int rt6_need_strict(struct in6_addr *daddr)
233 {
234 return (ipv6_addr_type(daddr) &
235 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
236 }
237
238 /*
239 * Route lookup. Any table->tb6_lock is implied.
240 */
241
242 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
243 int oif,
244 int strict)
245 {
246 struct rt6_info *local = NULL;
247 struct rt6_info *sprt;
248
249 if (oif) {
250 for (sprt = rt; sprt; sprt = sprt->u.dst.rt6_next) {
251 struct net_device *dev = sprt->rt6i_dev;
252 if (dev->ifindex == oif)
253 return sprt;
254 if (dev->flags & IFF_LOOPBACK) {
255 if (sprt->rt6i_idev == NULL ||
256 sprt->rt6i_idev->dev->ifindex != oif) {
257 if (strict && oif)
258 continue;
259 if (local && (!oif ||
260 local->rt6i_idev->dev->ifindex == oif))
261 continue;
262 }
263 local = sprt;
264 }
265 }
266
267 if (local)
268 return local;
269
270 if (strict)
271 return &ip6_null_entry;
272 }
273 return rt;
274 }
275
276 #ifdef CONFIG_IPV6_ROUTER_PREF
277 static void rt6_probe(struct rt6_info *rt)
278 {
279 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
280 /*
281 * Okay, this does not seem to be appropriate
282 * for now, however, we need to check if it
283 * is really so; aka Router Reachability Probing.
284 *
285 * Router Reachability Probe MUST be rate-limited
286 * to no more than one per minute.
287 */
288 if (!neigh || (neigh->nud_state & NUD_VALID))
289 return;
290 read_lock_bh(&neigh->lock);
291 if (!(neigh->nud_state & NUD_VALID) &&
292 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
293 struct in6_addr mcaddr;
294 struct in6_addr *target;
295
296 neigh->updated = jiffies;
297 read_unlock_bh(&neigh->lock);
298
299 target = (struct in6_addr *)&neigh->primary_key;
300 addrconf_addr_solict_mult(target, &mcaddr);
301 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
302 } else
303 read_unlock_bh(&neigh->lock);
304 }
305 #else
306 static inline void rt6_probe(struct rt6_info *rt)
307 {
308 return;
309 }
310 #endif
311
312 /*
313 * Default Router Selection (RFC 2461 6.3.6)
314 */
315 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
316 {
317 struct net_device *dev = rt->rt6i_dev;
318 if (!oif || dev->ifindex == oif)
319 return 2;
320 if ((dev->flags & IFF_LOOPBACK) &&
321 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
322 return 1;
323 return 0;
324 }
325
326 static inline int rt6_check_neigh(struct rt6_info *rt)
327 {
328 struct neighbour *neigh = rt->rt6i_nexthop;
329 int m;
330 if (rt->rt6i_flags & RTF_NONEXTHOP ||
331 !(rt->rt6i_flags & RTF_GATEWAY))
332 m = 1;
333 else if (neigh) {
334 read_lock_bh(&neigh->lock);
335 if (neigh->nud_state & NUD_VALID)
336 m = 2;
337 #ifdef CONFIG_IPV6_ROUTER_PREF
338 else if (neigh->nud_state & NUD_FAILED)
339 m = 0;
340 #endif
341 else
342 m = 1;
343 read_unlock_bh(&neigh->lock);
344 } else
345 m = 0;
346 return m;
347 }
348
349 static int rt6_score_route(struct rt6_info *rt, int oif,
350 int strict)
351 {
352 int m, n;
353
354 m = rt6_check_dev(rt, oif);
355 if (!m && (strict & RT6_LOOKUP_F_IFACE))
356 return -1;
357 #ifdef CONFIG_IPV6_ROUTER_PREF
358 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
359 #endif
360 n = rt6_check_neigh(rt);
361 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
362 return -1;
363 return m;
364 }
365
366 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
367 int *mpri, struct rt6_info *match)
368 {
369 int m;
370
371 if (rt6_check_expired(rt))
372 goto out;
373
374 m = rt6_score_route(rt, oif, strict);
375 if (m < 0)
376 goto out;
377
378 if (m > *mpri) {
379 if (strict & RT6_LOOKUP_F_REACHABLE)
380 rt6_probe(match);
381 *mpri = m;
382 match = rt;
383 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
384 rt6_probe(rt);
385 }
386
387 out:
388 return match;
389 }
390
391 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
392 struct rt6_info *rr_head,
393 u32 metric, int oif, int strict)
394 {
395 struct rt6_info *rt, *match;
396 int mpri = -1;
397
398 match = NULL;
399 for (rt = rr_head; rt && rt->rt6i_metric == metric;
400 rt = rt->u.dst.rt6_next)
401 match = find_match(rt, oif, strict, &mpri, match);
402 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
403 rt = rt->u.dst.rt6_next)
404 match = find_match(rt, oif, strict, &mpri, match);
405
406 return match;
407 }
408
409 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
410 {
411 struct rt6_info *match, *rt0;
412
413 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
414 __FUNCTION__, fn->leaf, oif);
415
416 rt0 = fn->rr_ptr;
417 if (!rt0)
418 fn->rr_ptr = rt0 = fn->leaf;
419
420 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
421
422 if (!match &&
423 (strict & RT6_LOOKUP_F_REACHABLE)) {
424 struct rt6_info *next = rt0->u.dst.rt6_next;
425
426 /* no entries matched; do round-robin */
427 if (!next || next->rt6i_metric != rt0->rt6i_metric)
428 next = fn->leaf;
429
430 if (next != rt0)
431 fn->rr_ptr = next;
432 }
433
434 RT6_TRACE("%s() => %p\n",
435 __FUNCTION__, match);
436
437 return (match ? match : &ip6_null_entry);
438 }
439
440 #ifdef CONFIG_IPV6_ROUTE_INFO
441 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
442 struct in6_addr *gwaddr)
443 {
444 struct route_info *rinfo = (struct route_info *) opt;
445 struct in6_addr prefix_buf, *prefix;
446 unsigned int pref;
447 u32 lifetime;
448 struct rt6_info *rt;
449
450 if (len < sizeof(struct route_info)) {
451 return -EINVAL;
452 }
453
454 /* Sanity check for prefix_len and length */
455 if (rinfo->length > 3) {
456 return -EINVAL;
457 } else if (rinfo->prefix_len > 128) {
458 return -EINVAL;
459 } else if (rinfo->prefix_len > 64) {
460 if (rinfo->length < 2) {
461 return -EINVAL;
462 }
463 } else if (rinfo->prefix_len > 0) {
464 if (rinfo->length < 1) {
465 return -EINVAL;
466 }
467 }
468
469 pref = rinfo->route_pref;
470 if (pref == ICMPV6_ROUTER_PREF_INVALID)
471 pref = ICMPV6_ROUTER_PREF_MEDIUM;
472
473 lifetime = ntohl(rinfo->lifetime);
474 if (lifetime == 0xffffffff) {
475 /* infinity */
476 } else if (lifetime > 0x7fffffff/HZ) {
477 /* Avoid arithmetic overflow */
478 lifetime = 0x7fffffff/HZ - 1;
479 }
480
481 if (rinfo->length == 3)
482 prefix = (struct in6_addr *)rinfo->prefix;
483 else {
484 /* this function is safe */
485 ipv6_addr_prefix(&prefix_buf,
486 (struct in6_addr *)rinfo->prefix,
487 rinfo->prefix_len);
488 prefix = &prefix_buf;
489 }
490
491 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
492
493 if (rt && !lifetime) {
494 ip6_del_rt(rt);
495 rt = NULL;
496 }
497
498 if (!rt && lifetime)
499 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
500 pref);
501 else if (rt)
502 rt->rt6i_flags = RTF_ROUTEINFO |
503 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
504
505 if (rt) {
506 if (lifetime == 0xffffffff) {
507 rt->rt6i_flags &= ~RTF_EXPIRES;
508 } else {
509 rt->rt6i_expires = jiffies + HZ * lifetime;
510 rt->rt6i_flags |= RTF_EXPIRES;
511 }
512 dst_release(&rt->u.dst);
513 }
514 return 0;
515 }
516 #endif
517
518 #define BACKTRACK(saddr) \
519 do { \
520 if (rt == &ip6_null_entry) { \
521 struct fib6_node *pn; \
522 while (1) { \
523 if (fn->fn_flags & RTN_TL_ROOT) \
524 goto out; \
525 pn = fn->parent; \
526 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
527 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
528 else \
529 fn = pn; \
530 if (fn->fn_flags & RTN_RTINFO) \
531 goto restart; \
532 } \
533 } \
534 } while(0)
535
536 static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
537 struct flowi *fl, int flags)
538 {
539 struct fib6_node *fn;
540 struct rt6_info *rt;
541
542 read_lock_bh(&table->tb6_lock);
543 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
544 restart:
545 rt = fn->leaf;
546 rt = rt6_device_match(rt, fl->oif, flags);
547 BACKTRACK(&fl->fl6_src);
548 out:
549 dst_use(&rt->u.dst, jiffies);
550 read_unlock_bh(&table->tb6_lock);
551 return rt;
552
553 }
554
555 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
556 int oif, int strict)
557 {
558 struct flowi fl = {
559 .oif = oif,
560 .nl_u = {
561 .ip6_u = {
562 .daddr = *daddr,
563 },
564 },
565 };
566 struct dst_entry *dst;
567 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
568
569 if (saddr) {
570 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
571 flags |= RT6_LOOKUP_F_HAS_SADDR;
572 }
573
574 dst = fib6_rule_lookup(&init_net, &fl, flags, ip6_pol_route_lookup);
575 if (dst->error == 0)
576 return (struct rt6_info *) dst;
577
578 dst_release(dst);
579
580 return NULL;
581 }
582
583 EXPORT_SYMBOL(rt6_lookup);
584
585 /* ip6_ins_rt is called with FREE table->tb6_lock.
586 It takes new route entry, the addition fails by any reason the
587 route is freed. In any case, if caller does not hold it, it may
588 be destroyed.
589 */
590
591 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
592 {
593 int err;
594 struct fib6_table *table;
595
596 table = rt->rt6i_table;
597 write_lock_bh(&table->tb6_lock);
598 err = fib6_add(&table->tb6_root, rt, info);
599 write_unlock_bh(&table->tb6_lock);
600
601 return err;
602 }
603
604 int ip6_ins_rt(struct rt6_info *rt)
605 {
606 struct nl_info info = {
607 .nl_net = &init_net,
608 };
609 return __ip6_ins_rt(rt, &info);
610 }
611
612 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
613 struct in6_addr *saddr)
614 {
615 struct rt6_info *rt;
616
617 /*
618 * Clone the route.
619 */
620
621 rt = ip6_rt_copy(ort);
622
623 if (rt) {
624 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
625 if (rt->rt6i_dst.plen != 128 &&
626 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
627 rt->rt6i_flags |= RTF_ANYCAST;
628 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
629 }
630
631 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
632 rt->rt6i_dst.plen = 128;
633 rt->rt6i_flags |= RTF_CACHE;
634 rt->u.dst.flags |= DST_HOST;
635
636 #ifdef CONFIG_IPV6_SUBTREES
637 if (rt->rt6i_src.plen && saddr) {
638 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
639 rt->rt6i_src.plen = 128;
640 }
641 #endif
642
643 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
644
645 }
646
647 return rt;
648 }
649
650 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
651 {
652 struct rt6_info *rt = ip6_rt_copy(ort);
653 if (rt) {
654 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
655 rt->rt6i_dst.plen = 128;
656 rt->rt6i_flags |= RTF_CACHE;
657 rt->u.dst.flags |= DST_HOST;
658 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
659 }
660 return rt;
661 }
662
663 static struct rt6_info *ip6_pol_route(struct fib6_table *table, int oif,
664 struct flowi *fl, int flags)
665 {
666 struct fib6_node *fn;
667 struct rt6_info *rt, *nrt;
668 int strict = 0;
669 int attempts = 3;
670 int err;
671 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
672
673 strict |= flags & RT6_LOOKUP_F_IFACE;
674
675 relookup:
676 read_lock_bh(&table->tb6_lock);
677
678 restart_2:
679 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
680
681 restart:
682 rt = rt6_select(fn, oif, strict | reachable);
683 BACKTRACK(&fl->fl6_src);
684 if (rt == &ip6_null_entry ||
685 rt->rt6i_flags & RTF_CACHE)
686 goto out;
687
688 dst_hold(&rt->u.dst);
689 read_unlock_bh(&table->tb6_lock);
690
691 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
692 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
693 else {
694 #if CLONE_OFFLINK_ROUTE
695 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
696 #else
697 goto out2;
698 #endif
699 }
700
701 dst_release(&rt->u.dst);
702 rt = nrt ? : &ip6_null_entry;
703
704 dst_hold(&rt->u.dst);
705 if (nrt) {
706 err = ip6_ins_rt(nrt);
707 if (!err)
708 goto out2;
709 }
710
711 if (--attempts <= 0)
712 goto out2;
713
714 /*
715 * Race condition! In the gap, when table->tb6_lock was
716 * released someone could insert this route. Relookup.
717 */
718 dst_release(&rt->u.dst);
719 goto relookup;
720
721 out:
722 if (reachable) {
723 reachable = 0;
724 goto restart_2;
725 }
726 dst_hold(&rt->u.dst);
727 read_unlock_bh(&table->tb6_lock);
728 out2:
729 rt->u.dst.lastuse = jiffies;
730 rt->u.dst.__use++;
731
732 return rt;
733 }
734
735 static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
736 struct flowi *fl, int flags)
737 {
738 return ip6_pol_route(table, fl->iif, fl, flags);
739 }
740
741 void ip6_route_input(struct sk_buff *skb)
742 {
743 struct ipv6hdr *iph = ipv6_hdr(skb);
744 int flags = RT6_LOOKUP_F_HAS_SADDR;
745 struct flowi fl = {
746 .iif = skb->dev->ifindex,
747 .nl_u = {
748 .ip6_u = {
749 .daddr = iph->daddr,
750 .saddr = iph->saddr,
751 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
752 },
753 },
754 .mark = skb->mark,
755 .proto = iph->nexthdr,
756 };
757
758 if (rt6_need_strict(&iph->daddr))
759 flags |= RT6_LOOKUP_F_IFACE;
760
761 skb->dst = fib6_rule_lookup(&init_net, &fl, flags, ip6_pol_route_input);
762 }
763
764 static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
765 struct flowi *fl, int flags)
766 {
767 return ip6_pol_route(table, fl->oif, fl, flags);
768 }
769
770 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
771 {
772 int flags = 0;
773
774 if (rt6_need_strict(&fl->fl6_dst))
775 flags |= RT6_LOOKUP_F_IFACE;
776
777 if (!ipv6_addr_any(&fl->fl6_src))
778 flags |= RT6_LOOKUP_F_HAS_SADDR;
779
780 return fib6_rule_lookup(&init_net, fl, flags, ip6_pol_route_output);
781 }
782
783 EXPORT_SYMBOL(ip6_route_output);
784
785 int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
786 {
787 struct rt6_info *ort = (struct rt6_info *) *dstp;
788 struct rt6_info *rt = (struct rt6_info *)
789 dst_alloc(&ip6_dst_blackhole_ops);
790 struct dst_entry *new = NULL;
791
792 if (rt) {
793 new = &rt->u.dst;
794
795 atomic_set(&new->__refcnt, 1);
796 new->__use = 1;
797 new->input = dst_discard;
798 new->output = dst_discard;
799
800 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
801 new->dev = ort->u.dst.dev;
802 if (new->dev)
803 dev_hold(new->dev);
804 rt->rt6i_idev = ort->rt6i_idev;
805 if (rt->rt6i_idev)
806 in6_dev_hold(rt->rt6i_idev);
807 rt->rt6i_expires = 0;
808
809 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
810 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
811 rt->rt6i_metric = 0;
812
813 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
814 #ifdef CONFIG_IPV6_SUBTREES
815 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
816 #endif
817
818 dst_free(new);
819 }
820
821 dst_release(*dstp);
822 *dstp = new;
823 return (new ? 0 : -ENOMEM);
824 }
825 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
826
827 /*
828 * Destination cache support functions
829 */
830
831 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
832 {
833 struct rt6_info *rt;
834
835 rt = (struct rt6_info *) dst;
836
837 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
838 return dst;
839
840 return NULL;
841 }
842
843 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
844 {
845 struct rt6_info *rt = (struct rt6_info *) dst;
846
847 if (rt) {
848 if (rt->rt6i_flags & RTF_CACHE)
849 ip6_del_rt(rt);
850 else
851 dst_release(dst);
852 }
853 return NULL;
854 }
855
856 static void ip6_link_failure(struct sk_buff *skb)
857 {
858 struct rt6_info *rt;
859
860 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
861
862 rt = (struct rt6_info *) skb->dst;
863 if (rt) {
864 if (rt->rt6i_flags&RTF_CACHE) {
865 dst_set_expires(&rt->u.dst, 0);
866 rt->rt6i_flags |= RTF_EXPIRES;
867 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
868 rt->rt6i_node->fn_sernum = -1;
869 }
870 }
871
872 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
873 {
874 struct rt6_info *rt6 = (struct rt6_info*)dst;
875
876 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
877 rt6->rt6i_flags |= RTF_MODIFIED;
878 if (mtu < IPV6_MIN_MTU) {
879 mtu = IPV6_MIN_MTU;
880 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
881 }
882 dst->metrics[RTAX_MTU-1] = mtu;
883 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
884 }
885 }
886
887 static int ipv6_get_mtu(struct net_device *dev);
888
889 static inline unsigned int ipv6_advmss(unsigned int mtu)
890 {
891 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
892
893 if (mtu < init_net.ipv6.sysctl.ip6_rt_min_advmss)
894 mtu = init_net.ipv6.sysctl.ip6_rt_min_advmss;
895
896 /*
897 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
898 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
899 * IPV6_MAXPLEN is also valid and means: "any MSS,
900 * rely only on pmtu discovery"
901 */
902 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
903 mtu = IPV6_MAXPLEN;
904 return mtu;
905 }
906
907 static struct dst_entry *icmp6_dst_gc_list;
908 static DEFINE_SPINLOCK(icmp6_dst_lock);
909
910 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
911 struct neighbour *neigh,
912 struct in6_addr *addr)
913 {
914 struct rt6_info *rt;
915 struct inet6_dev *idev = in6_dev_get(dev);
916
917 if (unlikely(idev == NULL))
918 return NULL;
919
920 rt = ip6_dst_alloc();
921 if (unlikely(rt == NULL)) {
922 in6_dev_put(idev);
923 goto out;
924 }
925
926 dev_hold(dev);
927 if (neigh)
928 neigh_hold(neigh);
929 else
930 neigh = ndisc_get_neigh(dev, addr);
931
932 rt->rt6i_dev = dev;
933 rt->rt6i_idev = idev;
934 rt->rt6i_nexthop = neigh;
935 atomic_set(&rt->u.dst.__refcnt, 1);
936 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
937 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
938 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
939 rt->u.dst.output = ip6_output;
940
941 #if 0 /* there's no chance to use these for ndisc */
942 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
943 ? DST_HOST
944 : 0;
945 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
946 rt->rt6i_dst.plen = 128;
947 #endif
948
949 spin_lock_bh(&icmp6_dst_lock);
950 rt->u.dst.next = icmp6_dst_gc_list;
951 icmp6_dst_gc_list = &rt->u.dst;
952 spin_unlock_bh(&icmp6_dst_lock);
953
954 fib6_force_start_gc();
955
956 out:
957 return &rt->u.dst;
958 }
959
960 int icmp6_dst_gc(int *more)
961 {
962 struct dst_entry *dst, *next, **pprev;
963 int freed;
964
965 next = NULL;
966 freed = 0;
967
968 spin_lock_bh(&icmp6_dst_lock);
969 pprev = &icmp6_dst_gc_list;
970
971 while ((dst = *pprev) != NULL) {
972 if (!atomic_read(&dst->__refcnt)) {
973 *pprev = dst->next;
974 dst_free(dst);
975 freed++;
976 } else {
977 pprev = &dst->next;
978 (*more)++;
979 }
980 }
981
982 spin_unlock_bh(&icmp6_dst_lock);
983
984 return freed;
985 }
986
987 static int ip6_dst_gc(struct dst_ops *ops)
988 {
989 static unsigned expire = 30*HZ;
990 static unsigned long last_gc;
991 unsigned long now = jiffies;
992
993 if (time_after(last_gc + init_net.ipv6.sysctl.ip6_rt_gc_min_interval, now) &&
994 atomic_read(&ip6_dst_ops.entries) <= init_net.ipv6.sysctl.ip6_rt_max_size)
995 goto out;
996
997 expire++;
998 fib6_run_gc(expire);
999 last_gc = now;
1000 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
1001 expire = init_net.ipv6.sysctl.ip6_rt_gc_timeout>>1;
1002
1003 out:
1004 expire -= expire>>init_net.ipv6.sysctl.ip6_rt_gc_elasticity;
1005 return (atomic_read(&ip6_dst_ops.entries) > init_net.ipv6.sysctl.ip6_rt_max_size);
1006 }
1007
1008 /* Clean host part of a prefix. Not necessary in radix tree,
1009 but results in cleaner routing tables.
1010
1011 Remove it only when all the things will work!
1012 */
1013
1014 static int ipv6_get_mtu(struct net_device *dev)
1015 {
1016 int mtu = IPV6_MIN_MTU;
1017 struct inet6_dev *idev;
1018
1019 idev = in6_dev_get(dev);
1020 if (idev) {
1021 mtu = idev->cnf.mtu6;
1022 in6_dev_put(idev);
1023 }
1024 return mtu;
1025 }
1026
1027 int ipv6_get_hoplimit(struct net_device *dev)
1028 {
1029 int hoplimit = ipv6_devconf.hop_limit;
1030 struct inet6_dev *idev;
1031
1032 idev = in6_dev_get(dev);
1033 if (idev) {
1034 hoplimit = idev->cnf.hop_limit;
1035 in6_dev_put(idev);
1036 }
1037 return hoplimit;
1038 }
1039
1040 /*
1041 *
1042 */
1043
1044 int ip6_route_add(struct fib6_config *cfg)
1045 {
1046 int err;
1047 struct rt6_info *rt = NULL;
1048 struct net_device *dev = NULL;
1049 struct inet6_dev *idev = NULL;
1050 struct fib6_table *table;
1051 int addr_type;
1052
1053 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1054 return -EINVAL;
1055 #ifndef CONFIG_IPV6_SUBTREES
1056 if (cfg->fc_src_len)
1057 return -EINVAL;
1058 #endif
1059 if (cfg->fc_ifindex) {
1060 err = -ENODEV;
1061 dev = dev_get_by_index(&init_net, cfg->fc_ifindex);
1062 if (!dev)
1063 goto out;
1064 idev = in6_dev_get(dev);
1065 if (!idev)
1066 goto out;
1067 }
1068
1069 if (cfg->fc_metric == 0)
1070 cfg->fc_metric = IP6_RT_PRIO_USER;
1071
1072 table = fib6_new_table(&init_net, cfg->fc_table);
1073 if (table == NULL) {
1074 err = -ENOBUFS;
1075 goto out;
1076 }
1077
1078 rt = ip6_dst_alloc();
1079
1080 if (rt == NULL) {
1081 err = -ENOMEM;
1082 goto out;
1083 }
1084
1085 rt->u.dst.obsolete = -1;
1086 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
1087
1088 if (cfg->fc_protocol == RTPROT_UNSPEC)
1089 cfg->fc_protocol = RTPROT_BOOT;
1090 rt->rt6i_protocol = cfg->fc_protocol;
1091
1092 addr_type = ipv6_addr_type(&cfg->fc_dst);
1093
1094 if (addr_type & IPV6_ADDR_MULTICAST)
1095 rt->u.dst.input = ip6_mc_input;
1096 else
1097 rt->u.dst.input = ip6_forward;
1098
1099 rt->u.dst.output = ip6_output;
1100
1101 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1102 rt->rt6i_dst.plen = cfg->fc_dst_len;
1103 if (rt->rt6i_dst.plen == 128)
1104 rt->u.dst.flags = DST_HOST;
1105
1106 #ifdef CONFIG_IPV6_SUBTREES
1107 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1108 rt->rt6i_src.plen = cfg->fc_src_len;
1109 #endif
1110
1111 rt->rt6i_metric = cfg->fc_metric;
1112
1113 /* We cannot add true routes via loopback here,
1114 they would result in kernel looping; promote them to reject routes
1115 */
1116 if ((cfg->fc_flags & RTF_REJECT) ||
1117 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1118 /* hold loopback dev/idev if we haven't done so. */
1119 if (dev != init_net.loopback_dev) {
1120 if (dev) {
1121 dev_put(dev);
1122 in6_dev_put(idev);
1123 }
1124 dev = init_net.loopback_dev;
1125 dev_hold(dev);
1126 idev = in6_dev_get(dev);
1127 if (!idev) {
1128 err = -ENODEV;
1129 goto out;
1130 }
1131 }
1132 rt->u.dst.output = ip6_pkt_discard_out;
1133 rt->u.dst.input = ip6_pkt_discard;
1134 rt->u.dst.error = -ENETUNREACH;
1135 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1136 goto install_route;
1137 }
1138
1139 if (cfg->fc_flags & RTF_GATEWAY) {
1140 struct in6_addr *gw_addr;
1141 int gwa_type;
1142
1143 gw_addr = &cfg->fc_gateway;
1144 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1145 gwa_type = ipv6_addr_type(gw_addr);
1146
1147 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1148 struct rt6_info *grt;
1149
1150 /* IPv6 strictly inhibits using not link-local
1151 addresses as nexthop address.
1152 Otherwise, router will not able to send redirects.
1153 It is very good, but in some (rare!) circumstances
1154 (SIT, PtP, NBMA NOARP links) it is handy to allow
1155 some exceptions. --ANK
1156 */
1157 err = -EINVAL;
1158 if (!(gwa_type&IPV6_ADDR_UNICAST))
1159 goto out;
1160
1161 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
1162
1163 err = -EHOSTUNREACH;
1164 if (grt == NULL)
1165 goto out;
1166 if (dev) {
1167 if (dev != grt->rt6i_dev) {
1168 dst_release(&grt->u.dst);
1169 goto out;
1170 }
1171 } else {
1172 dev = grt->rt6i_dev;
1173 idev = grt->rt6i_idev;
1174 dev_hold(dev);
1175 in6_dev_hold(grt->rt6i_idev);
1176 }
1177 if (!(grt->rt6i_flags&RTF_GATEWAY))
1178 err = 0;
1179 dst_release(&grt->u.dst);
1180
1181 if (err)
1182 goto out;
1183 }
1184 err = -EINVAL;
1185 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1186 goto out;
1187 }
1188
1189 err = -ENODEV;
1190 if (dev == NULL)
1191 goto out;
1192
1193 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1194 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1195 if (IS_ERR(rt->rt6i_nexthop)) {
1196 err = PTR_ERR(rt->rt6i_nexthop);
1197 rt->rt6i_nexthop = NULL;
1198 goto out;
1199 }
1200 }
1201
1202 rt->rt6i_flags = cfg->fc_flags;
1203
1204 install_route:
1205 if (cfg->fc_mx) {
1206 struct nlattr *nla;
1207 int remaining;
1208
1209 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1210 int type = nla_type(nla);
1211
1212 if (type) {
1213 if (type > RTAX_MAX) {
1214 err = -EINVAL;
1215 goto out;
1216 }
1217
1218 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1219 }
1220 }
1221 }
1222
1223 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1224 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1225 if (!rt->u.dst.metrics[RTAX_MTU-1])
1226 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1227 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1228 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1229 rt->u.dst.dev = dev;
1230 rt->rt6i_idev = idev;
1231 rt->rt6i_table = table;
1232 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1233
1234 out:
1235 if (dev)
1236 dev_put(dev);
1237 if (idev)
1238 in6_dev_put(idev);
1239 if (rt)
1240 dst_free(&rt->u.dst);
1241 return err;
1242 }
1243
1244 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1245 {
1246 int err;
1247 struct fib6_table *table;
1248
1249 if (rt == &ip6_null_entry)
1250 return -ENOENT;
1251
1252 table = rt->rt6i_table;
1253 write_lock_bh(&table->tb6_lock);
1254
1255 err = fib6_del(rt, info);
1256 dst_release(&rt->u.dst);
1257
1258 write_unlock_bh(&table->tb6_lock);
1259
1260 return err;
1261 }
1262
1263 int ip6_del_rt(struct rt6_info *rt)
1264 {
1265 struct nl_info info = {
1266 .nl_net = &init_net,
1267 };
1268 return __ip6_del_rt(rt, &info);
1269 }
1270
1271 static int ip6_route_del(struct fib6_config *cfg)
1272 {
1273 struct fib6_table *table;
1274 struct fib6_node *fn;
1275 struct rt6_info *rt;
1276 int err = -ESRCH;
1277
1278 table = fib6_get_table(&init_net, cfg->fc_table);
1279 if (table == NULL)
1280 return err;
1281
1282 read_lock_bh(&table->tb6_lock);
1283
1284 fn = fib6_locate(&table->tb6_root,
1285 &cfg->fc_dst, cfg->fc_dst_len,
1286 &cfg->fc_src, cfg->fc_src_len);
1287
1288 if (fn) {
1289 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1290 if (cfg->fc_ifindex &&
1291 (rt->rt6i_dev == NULL ||
1292 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1293 continue;
1294 if (cfg->fc_flags & RTF_GATEWAY &&
1295 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1296 continue;
1297 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1298 continue;
1299 dst_hold(&rt->u.dst);
1300 read_unlock_bh(&table->tb6_lock);
1301
1302 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1303 }
1304 }
1305 read_unlock_bh(&table->tb6_lock);
1306
1307 return err;
1308 }
1309
1310 /*
1311 * Handle redirects
1312 */
1313 struct ip6rd_flowi {
1314 struct flowi fl;
1315 struct in6_addr gateway;
1316 };
1317
1318 static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1319 struct flowi *fl,
1320 int flags)
1321 {
1322 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1323 struct rt6_info *rt;
1324 struct fib6_node *fn;
1325
1326 /*
1327 * Get the "current" route for this destination and
1328 * check if the redirect has come from approriate router.
1329 *
1330 * RFC 2461 specifies that redirects should only be
1331 * accepted if they come from the nexthop to the target.
1332 * Due to the way the routes are chosen, this notion
1333 * is a bit fuzzy and one might need to check all possible
1334 * routes.
1335 */
1336
1337 read_lock_bh(&table->tb6_lock);
1338 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1339 restart:
1340 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1341 /*
1342 * Current route is on-link; redirect is always invalid.
1343 *
1344 * Seems, previous statement is not true. It could
1345 * be node, which looks for us as on-link (f.e. proxy ndisc)
1346 * But then router serving it might decide, that we should
1347 * know truth 8)8) --ANK (980726).
1348 */
1349 if (rt6_check_expired(rt))
1350 continue;
1351 if (!(rt->rt6i_flags & RTF_GATEWAY))
1352 continue;
1353 if (fl->oif != rt->rt6i_dev->ifindex)
1354 continue;
1355 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1356 continue;
1357 break;
1358 }
1359
1360 if (!rt)
1361 rt = &ip6_null_entry;
1362 BACKTRACK(&fl->fl6_src);
1363 out:
1364 dst_hold(&rt->u.dst);
1365
1366 read_unlock_bh(&table->tb6_lock);
1367
1368 return rt;
1369 };
1370
1371 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1372 struct in6_addr *src,
1373 struct in6_addr *gateway,
1374 struct net_device *dev)
1375 {
1376 int flags = RT6_LOOKUP_F_HAS_SADDR;
1377 struct ip6rd_flowi rdfl = {
1378 .fl = {
1379 .oif = dev->ifindex,
1380 .nl_u = {
1381 .ip6_u = {
1382 .daddr = *dest,
1383 .saddr = *src,
1384 },
1385 },
1386 },
1387 .gateway = *gateway,
1388 };
1389
1390 if (rt6_need_strict(dest))
1391 flags |= RT6_LOOKUP_F_IFACE;
1392
1393 return (struct rt6_info *)fib6_rule_lookup(&init_net,
1394 (struct flowi *)&rdfl,
1395 flags, __ip6_route_redirect);
1396 }
1397
1398 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1399 struct in6_addr *saddr,
1400 struct neighbour *neigh, u8 *lladdr, int on_link)
1401 {
1402 struct rt6_info *rt, *nrt = NULL;
1403 struct netevent_redirect netevent;
1404
1405 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1406
1407 if (rt == &ip6_null_entry) {
1408 if (net_ratelimit())
1409 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1410 "for redirect target\n");
1411 goto out;
1412 }
1413
1414 /*
1415 * We have finally decided to accept it.
1416 */
1417
1418 neigh_update(neigh, lladdr, NUD_STALE,
1419 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1420 NEIGH_UPDATE_F_OVERRIDE|
1421 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1422 NEIGH_UPDATE_F_ISROUTER))
1423 );
1424
1425 /*
1426 * Redirect received -> path was valid.
1427 * Look, redirects are sent only in response to data packets,
1428 * so that this nexthop apparently is reachable. --ANK
1429 */
1430 dst_confirm(&rt->u.dst);
1431
1432 /* Duplicate redirect: silently ignore. */
1433 if (neigh == rt->u.dst.neighbour)
1434 goto out;
1435
1436 nrt = ip6_rt_copy(rt);
1437 if (nrt == NULL)
1438 goto out;
1439
1440 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1441 if (on_link)
1442 nrt->rt6i_flags &= ~RTF_GATEWAY;
1443
1444 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1445 nrt->rt6i_dst.plen = 128;
1446 nrt->u.dst.flags |= DST_HOST;
1447
1448 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1449 nrt->rt6i_nexthop = neigh_clone(neigh);
1450 /* Reset pmtu, it may be better */
1451 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1452 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1453
1454 if (ip6_ins_rt(nrt))
1455 goto out;
1456
1457 netevent.old = &rt->u.dst;
1458 netevent.new = &nrt->u.dst;
1459 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1460
1461 if (rt->rt6i_flags&RTF_CACHE) {
1462 ip6_del_rt(rt);
1463 return;
1464 }
1465
1466 out:
1467 dst_release(&rt->u.dst);
1468 return;
1469 }
1470
1471 /*
1472 * Handle ICMP "packet too big" messages
1473 * i.e. Path MTU discovery
1474 */
1475
1476 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1477 struct net_device *dev, u32 pmtu)
1478 {
1479 struct rt6_info *rt, *nrt;
1480 int allfrag = 0;
1481
1482 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1483 if (rt == NULL)
1484 return;
1485
1486 if (pmtu >= dst_mtu(&rt->u.dst))
1487 goto out;
1488
1489 if (pmtu < IPV6_MIN_MTU) {
1490 /*
1491 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1492 * MTU (1280) and a fragment header should always be included
1493 * after a node receiving Too Big message reporting PMTU is
1494 * less than the IPv6 Minimum Link MTU.
1495 */
1496 pmtu = IPV6_MIN_MTU;
1497 allfrag = 1;
1498 }
1499
1500 /* New mtu received -> path was valid.
1501 They are sent only in response to data packets,
1502 so that this nexthop apparently is reachable. --ANK
1503 */
1504 dst_confirm(&rt->u.dst);
1505
1506 /* Host route. If it is static, it would be better
1507 not to override it, but add new one, so that
1508 when cache entry will expire old pmtu
1509 would return automatically.
1510 */
1511 if (rt->rt6i_flags & RTF_CACHE) {
1512 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1513 if (allfrag)
1514 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1515 dst_set_expires(&rt->u.dst, init_net.ipv6.sysctl.ip6_rt_mtu_expires);
1516 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1517 goto out;
1518 }
1519
1520 /* Network route.
1521 Two cases are possible:
1522 1. It is connected route. Action: COW
1523 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1524 */
1525 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1526 nrt = rt6_alloc_cow(rt, daddr, saddr);
1527 else
1528 nrt = rt6_alloc_clone(rt, daddr);
1529
1530 if (nrt) {
1531 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1532 if (allfrag)
1533 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1534
1535 /* According to RFC 1981, detecting PMTU increase shouldn't be
1536 * happened within 5 mins, the recommended timer is 10 mins.
1537 * Here this route expiration time is set to ip6_rt_mtu_expires
1538 * which is 10 mins. After 10 mins the decreased pmtu is expired
1539 * and detecting PMTU increase will be automatically happened.
1540 */
1541 dst_set_expires(&nrt->u.dst, init_net.ipv6.sysctl.ip6_rt_mtu_expires);
1542 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1543
1544 ip6_ins_rt(nrt);
1545 }
1546 out:
1547 dst_release(&rt->u.dst);
1548 }
1549
1550 /*
1551 * Misc support functions
1552 */
1553
1554 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1555 {
1556 struct rt6_info *rt = ip6_dst_alloc();
1557
1558 if (rt) {
1559 rt->u.dst.input = ort->u.dst.input;
1560 rt->u.dst.output = ort->u.dst.output;
1561
1562 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1563 rt->u.dst.error = ort->u.dst.error;
1564 rt->u.dst.dev = ort->u.dst.dev;
1565 if (rt->u.dst.dev)
1566 dev_hold(rt->u.dst.dev);
1567 rt->rt6i_idev = ort->rt6i_idev;
1568 if (rt->rt6i_idev)
1569 in6_dev_hold(rt->rt6i_idev);
1570 rt->u.dst.lastuse = jiffies;
1571 rt->rt6i_expires = 0;
1572
1573 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1574 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1575 rt->rt6i_metric = 0;
1576
1577 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1578 #ifdef CONFIG_IPV6_SUBTREES
1579 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1580 #endif
1581 rt->rt6i_table = ort->rt6i_table;
1582 }
1583 return rt;
1584 }
1585
1586 #ifdef CONFIG_IPV6_ROUTE_INFO
1587 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1588 struct in6_addr *gwaddr, int ifindex)
1589 {
1590 struct fib6_node *fn;
1591 struct rt6_info *rt = NULL;
1592 struct fib6_table *table;
1593
1594 table = fib6_get_table(&init_net, RT6_TABLE_INFO);
1595 if (table == NULL)
1596 return NULL;
1597
1598 write_lock_bh(&table->tb6_lock);
1599 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1600 if (!fn)
1601 goto out;
1602
1603 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1604 if (rt->rt6i_dev->ifindex != ifindex)
1605 continue;
1606 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1607 continue;
1608 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1609 continue;
1610 dst_hold(&rt->u.dst);
1611 break;
1612 }
1613 out:
1614 write_unlock_bh(&table->tb6_lock);
1615 return rt;
1616 }
1617
1618 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1619 struct in6_addr *gwaddr, int ifindex,
1620 unsigned pref)
1621 {
1622 struct fib6_config cfg = {
1623 .fc_table = RT6_TABLE_INFO,
1624 .fc_metric = IP6_RT_PRIO_USER,
1625 .fc_ifindex = ifindex,
1626 .fc_dst_len = prefixlen,
1627 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1628 RTF_UP | RTF_PREF(pref),
1629 };
1630
1631 ipv6_addr_copy(&cfg.fc_dst, prefix);
1632 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1633
1634 /* We should treat it as a default route if prefix length is 0. */
1635 if (!prefixlen)
1636 cfg.fc_flags |= RTF_DEFAULT;
1637
1638 ip6_route_add(&cfg);
1639
1640 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1641 }
1642 #endif
1643
1644 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1645 {
1646 struct rt6_info *rt;
1647 struct fib6_table *table;
1648
1649 table = fib6_get_table(&init_net, RT6_TABLE_DFLT);
1650 if (table == NULL)
1651 return NULL;
1652
1653 write_lock_bh(&table->tb6_lock);
1654 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
1655 if (dev == rt->rt6i_dev &&
1656 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1657 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1658 break;
1659 }
1660 if (rt)
1661 dst_hold(&rt->u.dst);
1662 write_unlock_bh(&table->tb6_lock);
1663 return rt;
1664 }
1665
1666 EXPORT_SYMBOL(rt6_get_dflt_router);
1667
1668 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1669 struct net_device *dev,
1670 unsigned int pref)
1671 {
1672 struct fib6_config cfg = {
1673 .fc_table = RT6_TABLE_DFLT,
1674 .fc_metric = IP6_RT_PRIO_USER,
1675 .fc_ifindex = dev->ifindex,
1676 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1677 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1678 };
1679
1680 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1681
1682 ip6_route_add(&cfg);
1683
1684 return rt6_get_dflt_router(gwaddr, dev);
1685 }
1686
1687 void rt6_purge_dflt_routers(void)
1688 {
1689 struct rt6_info *rt;
1690 struct fib6_table *table;
1691
1692 /* NOTE: Keep consistent with rt6_get_dflt_router */
1693 table = fib6_get_table(&init_net, RT6_TABLE_DFLT);
1694 if (table == NULL)
1695 return;
1696
1697 restart:
1698 read_lock_bh(&table->tb6_lock);
1699 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
1700 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1701 dst_hold(&rt->u.dst);
1702 read_unlock_bh(&table->tb6_lock);
1703 ip6_del_rt(rt);
1704 goto restart;
1705 }
1706 }
1707 read_unlock_bh(&table->tb6_lock);
1708 }
1709
1710 static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1711 struct fib6_config *cfg)
1712 {
1713 memset(cfg, 0, sizeof(*cfg));
1714
1715 cfg->fc_table = RT6_TABLE_MAIN;
1716 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1717 cfg->fc_metric = rtmsg->rtmsg_metric;
1718 cfg->fc_expires = rtmsg->rtmsg_info;
1719 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1720 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1721 cfg->fc_flags = rtmsg->rtmsg_flags;
1722
1723 cfg->fc_nlinfo.nl_net = &init_net;
1724
1725 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1726 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1727 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1728 }
1729
1730 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1731 {
1732 struct fib6_config cfg;
1733 struct in6_rtmsg rtmsg;
1734 int err;
1735
1736 switch(cmd) {
1737 case SIOCADDRT: /* Add a route */
1738 case SIOCDELRT: /* Delete a route */
1739 if (!capable(CAP_NET_ADMIN))
1740 return -EPERM;
1741 err = copy_from_user(&rtmsg, arg,
1742 sizeof(struct in6_rtmsg));
1743 if (err)
1744 return -EFAULT;
1745
1746 rtmsg_to_fib6_config(&rtmsg, &cfg);
1747
1748 rtnl_lock();
1749 switch (cmd) {
1750 case SIOCADDRT:
1751 err = ip6_route_add(&cfg);
1752 break;
1753 case SIOCDELRT:
1754 err = ip6_route_del(&cfg);
1755 break;
1756 default:
1757 err = -EINVAL;
1758 }
1759 rtnl_unlock();
1760
1761 return err;
1762 }
1763
1764 return -EINVAL;
1765 }
1766
1767 /*
1768 * Drop the packet on the floor
1769 */
1770
1771 static int ip6_pkt_drop(struct sk_buff *skb, int code, int ipstats_mib_noroutes)
1772 {
1773 int type;
1774 switch (ipstats_mib_noroutes) {
1775 case IPSTATS_MIB_INNOROUTES:
1776 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
1777 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED) {
1778 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1779 break;
1780 }
1781 /* FALLTHROUGH */
1782 case IPSTATS_MIB_OUTNOROUTES:
1783 IP6_INC_STATS(ip6_dst_idev(skb->dst), ipstats_mib_noroutes);
1784 break;
1785 }
1786 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1787 kfree_skb(skb);
1788 return 0;
1789 }
1790
1791 static int ip6_pkt_discard(struct sk_buff *skb)
1792 {
1793 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
1794 }
1795
1796 static int ip6_pkt_discard_out(struct sk_buff *skb)
1797 {
1798 skb->dev = skb->dst->dev;
1799 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1800 }
1801
1802 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1803
1804 static int ip6_pkt_prohibit(struct sk_buff *skb)
1805 {
1806 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
1807 }
1808
1809 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1810 {
1811 skb->dev = skb->dst->dev;
1812 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
1813 }
1814
1815 #endif
1816
1817 /*
1818 * Allocate a dst for local (unicast / anycast) address.
1819 */
1820
1821 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1822 const struct in6_addr *addr,
1823 int anycast)
1824 {
1825 struct rt6_info *rt = ip6_dst_alloc();
1826
1827 if (rt == NULL)
1828 return ERR_PTR(-ENOMEM);
1829
1830 dev_hold(init_net.loopback_dev);
1831 in6_dev_hold(idev);
1832
1833 rt->u.dst.flags = DST_HOST;
1834 rt->u.dst.input = ip6_input;
1835 rt->u.dst.output = ip6_output;
1836 rt->rt6i_dev = init_net.loopback_dev;
1837 rt->rt6i_idev = idev;
1838 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1839 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1840 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1841 rt->u.dst.obsolete = -1;
1842
1843 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1844 if (anycast)
1845 rt->rt6i_flags |= RTF_ANYCAST;
1846 else
1847 rt->rt6i_flags |= RTF_LOCAL;
1848 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1849 if (rt->rt6i_nexthop == NULL) {
1850 dst_free(&rt->u.dst);
1851 return ERR_PTR(-ENOMEM);
1852 }
1853
1854 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1855 rt->rt6i_dst.plen = 128;
1856 rt->rt6i_table = fib6_get_table(&init_net, RT6_TABLE_LOCAL);
1857
1858 atomic_set(&rt->u.dst.__refcnt, 1);
1859
1860 return rt;
1861 }
1862
1863 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1864 {
1865 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1866 rt != &ip6_null_entry) {
1867 RT6_TRACE("deleted by ifdown %p\n", rt);
1868 return -1;
1869 }
1870 return 0;
1871 }
1872
1873 void rt6_ifdown(struct net *net, struct net_device *dev)
1874 {
1875 fib6_clean_all(net, fib6_ifdown, 0, dev);
1876 }
1877
1878 struct rt6_mtu_change_arg
1879 {
1880 struct net_device *dev;
1881 unsigned mtu;
1882 };
1883
1884 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1885 {
1886 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1887 struct inet6_dev *idev;
1888
1889 /* In IPv6 pmtu discovery is not optional,
1890 so that RTAX_MTU lock cannot disable it.
1891 We still use this lock to block changes
1892 caused by addrconf/ndisc.
1893 */
1894
1895 idev = __in6_dev_get(arg->dev);
1896 if (idev == NULL)
1897 return 0;
1898
1899 /* For administrative MTU increase, there is no way to discover
1900 IPv6 PMTU increase, so PMTU increase should be updated here.
1901 Since RFC 1981 doesn't include administrative MTU increase
1902 update PMTU increase is a MUST. (i.e. jumbo frame)
1903 */
1904 /*
1905 If new MTU is less than route PMTU, this new MTU will be the
1906 lowest MTU in the path, update the route PMTU to reflect PMTU
1907 decreases; if new MTU is greater than route PMTU, and the
1908 old MTU is the lowest MTU in the path, update the route PMTU
1909 to reflect the increase. In this case if the other nodes' MTU
1910 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1911 PMTU discouvery.
1912 */
1913 if (rt->rt6i_dev == arg->dev &&
1914 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1915 (dst_mtu(&rt->u.dst) >= arg->mtu ||
1916 (dst_mtu(&rt->u.dst) < arg->mtu &&
1917 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
1918 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1919 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1920 }
1921 return 0;
1922 }
1923
1924 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1925 {
1926 struct rt6_mtu_change_arg arg = {
1927 .dev = dev,
1928 .mtu = mtu,
1929 };
1930
1931 fib6_clean_all(dev->nd_net, rt6_mtu_change_route, 0, &arg);
1932 }
1933
1934 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
1935 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
1936 [RTA_OIF] = { .type = NLA_U32 },
1937 [RTA_IIF] = { .type = NLA_U32 },
1938 [RTA_PRIORITY] = { .type = NLA_U32 },
1939 [RTA_METRICS] = { .type = NLA_NESTED },
1940 };
1941
1942 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1943 struct fib6_config *cfg)
1944 {
1945 struct rtmsg *rtm;
1946 struct nlattr *tb[RTA_MAX+1];
1947 int err;
1948
1949 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1950 if (err < 0)
1951 goto errout;
1952
1953 err = -EINVAL;
1954 rtm = nlmsg_data(nlh);
1955 memset(cfg, 0, sizeof(*cfg));
1956
1957 cfg->fc_table = rtm->rtm_table;
1958 cfg->fc_dst_len = rtm->rtm_dst_len;
1959 cfg->fc_src_len = rtm->rtm_src_len;
1960 cfg->fc_flags = RTF_UP;
1961 cfg->fc_protocol = rtm->rtm_protocol;
1962
1963 if (rtm->rtm_type == RTN_UNREACHABLE)
1964 cfg->fc_flags |= RTF_REJECT;
1965
1966 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1967 cfg->fc_nlinfo.nlh = nlh;
1968 cfg->fc_nlinfo.nl_net = skb->sk->sk_net;
1969
1970 if (tb[RTA_GATEWAY]) {
1971 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1972 cfg->fc_flags |= RTF_GATEWAY;
1973 }
1974
1975 if (tb[RTA_DST]) {
1976 int plen = (rtm->rtm_dst_len + 7) >> 3;
1977
1978 if (nla_len(tb[RTA_DST]) < plen)
1979 goto errout;
1980
1981 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1982 }
1983
1984 if (tb[RTA_SRC]) {
1985 int plen = (rtm->rtm_src_len + 7) >> 3;
1986
1987 if (nla_len(tb[RTA_SRC]) < plen)
1988 goto errout;
1989
1990 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1991 }
1992
1993 if (tb[RTA_OIF])
1994 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1995
1996 if (tb[RTA_PRIORITY])
1997 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1998
1999 if (tb[RTA_METRICS]) {
2000 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2001 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2002 }
2003
2004 if (tb[RTA_TABLE])
2005 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2006
2007 err = 0;
2008 errout:
2009 return err;
2010 }
2011
2012 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2013 {
2014 struct net *net = skb->sk->sk_net;
2015 struct fib6_config cfg;
2016 int err;
2017
2018 if (net != &init_net)
2019 return -EINVAL;
2020
2021 err = rtm_to_fib6_config(skb, nlh, &cfg);
2022 if (err < 0)
2023 return err;
2024
2025 return ip6_route_del(&cfg);
2026 }
2027
2028 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2029 {
2030 struct net *net = skb->sk->sk_net;
2031 struct fib6_config cfg;
2032 int err;
2033
2034 if (net != &init_net)
2035 return -EINVAL;
2036
2037 err = rtm_to_fib6_config(skb, nlh, &cfg);
2038 if (err < 0)
2039 return err;
2040
2041 return ip6_route_add(&cfg);
2042 }
2043
2044 static inline size_t rt6_nlmsg_size(void)
2045 {
2046 return NLMSG_ALIGN(sizeof(struct rtmsg))
2047 + nla_total_size(16) /* RTA_SRC */
2048 + nla_total_size(16) /* RTA_DST */
2049 + nla_total_size(16) /* RTA_GATEWAY */
2050 + nla_total_size(16) /* RTA_PREFSRC */
2051 + nla_total_size(4) /* RTA_TABLE */
2052 + nla_total_size(4) /* RTA_IIF */
2053 + nla_total_size(4) /* RTA_OIF */
2054 + nla_total_size(4) /* RTA_PRIORITY */
2055 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2056 + nla_total_size(sizeof(struct rta_cacheinfo));
2057 }
2058
2059 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
2060 struct in6_addr *dst, struct in6_addr *src,
2061 int iif, int type, u32 pid, u32 seq,
2062 int prefix, unsigned int flags)
2063 {
2064 struct rtmsg *rtm;
2065 struct nlmsghdr *nlh;
2066 long expires;
2067 u32 table;
2068
2069 if (prefix) { /* user wants prefix routes only */
2070 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2071 /* success since this is not a prefix route */
2072 return 1;
2073 }
2074 }
2075
2076 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2077 if (nlh == NULL)
2078 return -EMSGSIZE;
2079
2080 rtm = nlmsg_data(nlh);
2081 rtm->rtm_family = AF_INET6;
2082 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2083 rtm->rtm_src_len = rt->rt6i_src.plen;
2084 rtm->rtm_tos = 0;
2085 if (rt->rt6i_table)
2086 table = rt->rt6i_table->tb6_id;
2087 else
2088 table = RT6_TABLE_UNSPEC;
2089 rtm->rtm_table = table;
2090 NLA_PUT_U32(skb, RTA_TABLE, table);
2091 if (rt->rt6i_flags&RTF_REJECT)
2092 rtm->rtm_type = RTN_UNREACHABLE;
2093 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2094 rtm->rtm_type = RTN_LOCAL;
2095 else
2096 rtm->rtm_type = RTN_UNICAST;
2097 rtm->rtm_flags = 0;
2098 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2099 rtm->rtm_protocol = rt->rt6i_protocol;
2100 if (rt->rt6i_flags&RTF_DYNAMIC)
2101 rtm->rtm_protocol = RTPROT_REDIRECT;
2102 else if (rt->rt6i_flags & RTF_ADDRCONF)
2103 rtm->rtm_protocol = RTPROT_KERNEL;
2104 else if (rt->rt6i_flags&RTF_DEFAULT)
2105 rtm->rtm_protocol = RTPROT_RA;
2106
2107 if (rt->rt6i_flags&RTF_CACHE)
2108 rtm->rtm_flags |= RTM_F_CLONED;
2109
2110 if (dst) {
2111 NLA_PUT(skb, RTA_DST, 16, dst);
2112 rtm->rtm_dst_len = 128;
2113 } else if (rtm->rtm_dst_len)
2114 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
2115 #ifdef CONFIG_IPV6_SUBTREES
2116 if (src) {
2117 NLA_PUT(skb, RTA_SRC, 16, src);
2118 rtm->rtm_src_len = 128;
2119 } else if (rtm->rtm_src_len)
2120 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
2121 #endif
2122 if (iif)
2123 NLA_PUT_U32(skb, RTA_IIF, iif);
2124 else if (dst) {
2125 struct in6_addr saddr_buf;
2126 if (ipv6_dev_get_saddr(ip6_dst_idev(&rt->u.dst)->dev,
2127 dst, &saddr_buf) == 0)
2128 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
2129 }
2130
2131 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2132 goto nla_put_failure;
2133
2134 if (rt->u.dst.neighbour)
2135 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2136
2137 if (rt->u.dst.dev)
2138 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2139
2140 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2141
2142 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2143 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2144 expires, rt->u.dst.error) < 0)
2145 goto nla_put_failure;
2146
2147 return nlmsg_end(skb, nlh);
2148
2149 nla_put_failure:
2150 nlmsg_cancel(skb, nlh);
2151 return -EMSGSIZE;
2152 }
2153
2154 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2155 {
2156 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2157 int prefix;
2158
2159 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2160 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2161 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2162 } else
2163 prefix = 0;
2164
2165 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2166 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2167 prefix, NLM_F_MULTI);
2168 }
2169
2170 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2171 {
2172 struct net *net = in_skb->sk->sk_net;
2173 struct nlattr *tb[RTA_MAX+1];
2174 struct rt6_info *rt;
2175 struct sk_buff *skb;
2176 struct rtmsg *rtm;
2177 struct flowi fl;
2178 int err, iif = 0;
2179
2180 if (net != &init_net)
2181 return -EINVAL;
2182
2183 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2184 if (err < 0)
2185 goto errout;
2186
2187 err = -EINVAL;
2188 memset(&fl, 0, sizeof(fl));
2189
2190 if (tb[RTA_SRC]) {
2191 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2192 goto errout;
2193
2194 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2195 }
2196
2197 if (tb[RTA_DST]) {
2198 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2199 goto errout;
2200
2201 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2202 }
2203
2204 if (tb[RTA_IIF])
2205 iif = nla_get_u32(tb[RTA_IIF]);
2206
2207 if (tb[RTA_OIF])
2208 fl.oif = nla_get_u32(tb[RTA_OIF]);
2209
2210 if (iif) {
2211 struct net_device *dev;
2212 dev = __dev_get_by_index(&init_net, iif);
2213 if (!dev) {
2214 err = -ENODEV;
2215 goto errout;
2216 }
2217 }
2218
2219 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2220 if (skb == NULL) {
2221 err = -ENOBUFS;
2222 goto errout;
2223 }
2224
2225 /* Reserve room for dummy headers, this skb can pass
2226 through good chunk of routing engine.
2227 */
2228 skb_reset_mac_header(skb);
2229 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2230
2231 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
2232 skb->dst = &rt->u.dst;
2233
2234 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
2235 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2236 nlh->nlmsg_seq, 0, 0);
2237 if (err < 0) {
2238 kfree_skb(skb);
2239 goto errout;
2240 }
2241
2242 err = rtnl_unicast(skb, &init_net, NETLINK_CB(in_skb).pid);
2243 errout:
2244 return err;
2245 }
2246
2247 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2248 {
2249 struct sk_buff *skb;
2250 u32 seq;
2251 int err;
2252
2253 err = -ENOBUFS;
2254 seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
2255
2256 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2257 if (skb == NULL)
2258 goto errout;
2259
2260 err = rt6_fill_node(skb, rt, NULL, NULL, 0,
2261 event, info->pid, seq, 0, 0);
2262 if (err < 0) {
2263 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2264 WARN_ON(err == -EMSGSIZE);
2265 kfree_skb(skb);
2266 goto errout;
2267 }
2268 err = rtnl_notify(skb, &init_net, info->pid,
2269 RTNLGRP_IPV6_ROUTE, info->nlh, gfp_any());
2270 errout:
2271 if (err < 0)
2272 rtnl_set_sk_err(&init_net, RTNLGRP_IPV6_ROUTE, err);
2273 }
2274
2275 /*
2276 * /proc
2277 */
2278
2279 #ifdef CONFIG_PROC_FS
2280
2281 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2282
2283 struct rt6_proc_arg
2284 {
2285 char *buffer;
2286 int offset;
2287 int length;
2288 int skip;
2289 int len;
2290 };
2291
2292 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2293 {
2294 struct seq_file *m = p_arg;
2295
2296 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_dst.addr),
2297 rt->rt6i_dst.plen);
2298
2299 #ifdef CONFIG_IPV6_SUBTREES
2300 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_src.addr),
2301 rt->rt6i_src.plen);
2302 #else
2303 seq_puts(m, "00000000000000000000000000000000 00 ");
2304 #endif
2305
2306 if (rt->rt6i_nexthop) {
2307 seq_printf(m, NIP6_SEQFMT,
2308 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
2309 } else {
2310 seq_puts(m, "00000000000000000000000000000000");
2311 }
2312 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2313 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2314 rt->u.dst.__use, rt->rt6i_flags,
2315 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2316 return 0;
2317 }
2318
2319 static int ipv6_route_show(struct seq_file *m, void *v)
2320 {
2321 struct net *net = (struct net *)m->private;
2322 fib6_clean_all(net, rt6_info_route, 0, m);
2323 return 0;
2324 }
2325
2326 static int ipv6_route_open(struct inode *inode, struct file *file)
2327 {
2328 struct net *net = get_proc_net(inode);
2329 if (!net)
2330 return -ENXIO;
2331 return single_open(file, ipv6_route_show, net);
2332 }
2333
2334 static int ipv6_route_release(struct inode *inode, struct file *file)
2335 {
2336 struct seq_file *seq = file->private_data;
2337 struct net *net = seq->private;
2338 put_net(net);
2339 return single_release(inode, file);
2340 }
2341
2342 static const struct file_operations ipv6_route_proc_fops = {
2343 .owner = THIS_MODULE,
2344 .open = ipv6_route_open,
2345 .read = seq_read,
2346 .llseek = seq_lseek,
2347 .release = ipv6_route_release,
2348 };
2349
2350 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2351 {
2352 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2353 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2354 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2355 rt6_stats.fib_rt_cache,
2356 atomic_read(&ip6_dst_ops.entries),
2357 rt6_stats.fib_discarded_routes);
2358
2359 return 0;
2360 }
2361
2362 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2363 {
2364 return single_open(file, rt6_stats_seq_show, NULL);
2365 }
2366
2367 static const struct file_operations rt6_stats_seq_fops = {
2368 .owner = THIS_MODULE,
2369 .open = rt6_stats_seq_open,
2370 .read = seq_read,
2371 .llseek = seq_lseek,
2372 .release = single_release,
2373 };
2374
2375 static int ipv6_route_proc_init(struct net *net)
2376 {
2377 int ret = -ENOMEM;
2378 if (!proc_net_fops_create(net, "ipv6_route",
2379 0, &ipv6_route_proc_fops))
2380 goto out;
2381
2382 if (!proc_net_fops_create(net, "rt6_stats",
2383 S_IRUGO, &rt6_stats_seq_fops))
2384 goto out_ipv6_route;
2385
2386 ret = 0;
2387 out:
2388 return ret;
2389 out_ipv6_route:
2390 proc_net_remove(net, "ipv6_route");
2391 goto out;
2392 }
2393
2394 static void ipv6_route_proc_fini(struct net *net)
2395 {
2396 proc_net_remove(net, "ipv6_route");
2397 proc_net_remove(net, "rt6_stats");
2398 }
2399 #else
2400 static inline int ipv6_route_proc_init(struct net *net)
2401 {
2402 return 0;
2403 }
2404 static inline void ipv6_route_proc_fini(struct net *net)
2405 {
2406 return ;
2407 }
2408 #endif /* CONFIG_PROC_FS */
2409
2410 #ifdef CONFIG_SYSCTL
2411
2412 static
2413 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2414 void __user *buffer, size_t *lenp, loff_t *ppos)
2415 {
2416 int delay = init_net.ipv6.sysctl.flush_delay;
2417 if (write) {
2418 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2419 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay);
2420 return 0;
2421 } else
2422 return -EINVAL;
2423 }
2424
2425 ctl_table ipv6_route_table_template[] = {
2426 {
2427 .procname = "flush",
2428 .data = &init_net.ipv6.sysctl.flush_delay,
2429 .maxlen = sizeof(int),
2430 .mode = 0200,
2431 .proc_handler = &ipv6_sysctl_rtcache_flush
2432 },
2433 {
2434 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2435 .procname = "gc_thresh",
2436 .data = &ip6_dst_ops.gc_thresh,
2437 .maxlen = sizeof(int),
2438 .mode = 0644,
2439 .proc_handler = &proc_dointvec,
2440 },
2441 {
2442 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2443 .procname = "max_size",
2444 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2445 .maxlen = sizeof(int),
2446 .mode = 0644,
2447 .proc_handler = &proc_dointvec,
2448 },
2449 {
2450 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2451 .procname = "gc_min_interval",
2452 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2453 .maxlen = sizeof(int),
2454 .mode = 0644,
2455 .proc_handler = &proc_dointvec_jiffies,
2456 .strategy = &sysctl_jiffies,
2457 },
2458 {
2459 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2460 .procname = "gc_timeout",
2461 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2462 .maxlen = sizeof(int),
2463 .mode = 0644,
2464 .proc_handler = &proc_dointvec_jiffies,
2465 .strategy = &sysctl_jiffies,
2466 },
2467 {
2468 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2469 .procname = "gc_interval",
2470 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2471 .maxlen = sizeof(int),
2472 .mode = 0644,
2473 .proc_handler = &proc_dointvec_jiffies,
2474 .strategy = &sysctl_jiffies,
2475 },
2476 {
2477 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2478 .procname = "gc_elasticity",
2479 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2480 .maxlen = sizeof(int),
2481 .mode = 0644,
2482 .proc_handler = &proc_dointvec_jiffies,
2483 .strategy = &sysctl_jiffies,
2484 },
2485 {
2486 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2487 .procname = "mtu_expires",
2488 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2489 .maxlen = sizeof(int),
2490 .mode = 0644,
2491 .proc_handler = &proc_dointvec_jiffies,
2492 .strategy = &sysctl_jiffies,
2493 },
2494 {
2495 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2496 .procname = "min_adv_mss",
2497 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2498 .maxlen = sizeof(int),
2499 .mode = 0644,
2500 .proc_handler = &proc_dointvec_jiffies,
2501 .strategy = &sysctl_jiffies,
2502 },
2503 {
2504 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2505 .procname = "gc_min_interval_ms",
2506 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2507 .maxlen = sizeof(int),
2508 .mode = 0644,
2509 .proc_handler = &proc_dointvec_ms_jiffies,
2510 .strategy = &sysctl_ms_jiffies,
2511 },
2512 { .ctl_name = 0 }
2513 };
2514
2515 struct ctl_table *ipv6_route_sysctl_init(struct net *net)
2516 {
2517 struct ctl_table *table;
2518
2519 table = kmemdup(ipv6_route_table_template,
2520 sizeof(ipv6_route_table_template),
2521 GFP_KERNEL);
2522
2523 if (table) {
2524 table[0].data = &net->ipv6.sysctl.flush_delay;
2525 /* table[1].data will be handled when we have
2526 routes per namespace */
2527 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2528 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2529 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2530 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2531 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2532 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2533 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2534 }
2535
2536 return table;
2537 }
2538 #endif
2539
2540 int __init ip6_route_init(void)
2541 {
2542 int ret;
2543
2544 ip6_dst_ops.kmem_cachep =
2545 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2546 SLAB_HWCACHE_ALIGN, NULL);
2547 if (!ip6_dst_ops.kmem_cachep)
2548 return -ENOMEM;
2549
2550 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
2551
2552 ret = fib6_init();
2553 if (ret)
2554 goto out_kmem_cache;
2555
2556 ret = ipv6_route_proc_init(&init_net);
2557 if (ret)
2558 goto out_fib6_init;
2559
2560 ret = xfrm6_init();
2561 if (ret)
2562 goto out_proc_init;
2563
2564 ret = fib6_rules_init();
2565 if (ret)
2566 goto xfrm6_init;
2567
2568 ret = -ENOBUFS;
2569 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2570 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2571 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2572 goto fib6_rules_init;
2573
2574 ret = 0;
2575 out:
2576 return ret;
2577
2578 fib6_rules_init:
2579 fib6_rules_cleanup();
2580 xfrm6_init:
2581 xfrm6_fini();
2582 out_proc_init:
2583 ipv6_route_proc_fini(&init_net);
2584 out_fib6_init:
2585 rt6_ifdown(&init_net, NULL);
2586 fib6_gc_cleanup();
2587 out_kmem_cache:
2588 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2589 goto out;
2590 }
2591
2592 void ip6_route_cleanup(void)
2593 {
2594 fib6_rules_cleanup();
2595 ipv6_route_proc_fini(&init_net);
2596 xfrm6_fini();
2597 rt6_ifdown(&init_net, NULL);
2598 fib6_gc_cleanup();
2599 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2600 }
Ubuntu Artful kernel mirror