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