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