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