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