2 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
27 #include <linux/capability.h>
28 #include <linux/config.h>
29 #include <linux/errno.h>
30 #include <linux/types.h>
31 #include <linux/times.h>
32 #include <linux/socket.h>
33 #include <linux/sockios.h>
34 #include <linux/net.h>
35 #include <linux/route.h>
36 #include <linux/netdevice.h>
37 #include <linux/in6.h>
38 #include <linux/init.h>
39 #include <linux/netlink.h>
40 #include <linux/if_arp.h>
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
49 #include <net/ip6_fib.h>
50 #include <net/ip6_route.h>
51 #include <net/ndisc.h>
52 #include <net/addrconf.h>
54 #include <linux/rtnetlink.h>
58 #include <asm/uaccess.h>
61 #include <linux/sysctl.h>
64 /* Set to 3 to get tracing. */
68 #define RDBG(x) printk x
69 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
72 #define RT6_TRACE(x...) do { ; } while (0)
75 #define CLONE_OFFLINK_ROUTE 0
77 static int ip6_rt_max_size = 4096;
78 static int ip6_rt_gc_min_interval = HZ / 2;
79 static int ip6_rt_gc_timeout = 60*HZ;
80 int ip6_rt_gc_interval = 30*HZ;
81 static int ip6_rt_gc_elasticity = 9;
82 static int ip6_rt_mtu_expires = 10*60*HZ;
83 static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
85 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
86 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
87 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
88 static void ip6_dst_destroy(struct dst_entry *);
89 static void ip6_dst_ifdown(struct dst_entry *,
90 struct net_device *dev, int how);
91 static int ip6_dst_gc(void);
93 static int ip6_pkt_discard(struct sk_buff *skb);
94 static int ip6_pkt_discard_out(struct sk_buff *skb);
95 static void ip6_link_failure(struct sk_buff *skb);
96 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
98 static struct dst_ops ip6_dst_ops = {
100 .protocol = __constant_htons(ETH_P_IPV6),
103 .check = ip6_dst_check,
104 .destroy = ip6_dst_destroy,
105 .ifdown = ip6_dst_ifdown,
106 .negative_advice = ip6_negative_advice,
107 .link_failure = ip6_link_failure,
108 .update_pmtu = ip6_rt_update_pmtu,
109 .entry_size = sizeof(struct rt6_info),
112 struct rt6_info ip6_null_entry = {
115 .__refcnt = ATOMIC_INIT(1),
117 .dev = &loopback_dev,
119 .error = -ENETUNREACH,
120 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
121 .input = ip6_pkt_discard,
122 .output = ip6_pkt_discard_out,
124 .path = (struct dst_entry*)&ip6_null_entry,
127 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
128 .rt6i_metric = ~(u32) 0,
129 .rt6i_ref = ATOMIC_INIT(1),
132 struct fib6_node ip6_routing_table = {
133 .leaf = &ip6_null_entry,
134 .fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO,
137 /* Protects all the ip6 fib */
139 DEFINE_RWLOCK(rt6_lock);
142 /* allocate dst with ip6_dst_ops */
143 static __inline__ struct rt6_info *ip6_dst_alloc(void)
145 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
148 static void ip6_dst_destroy(struct dst_entry *dst)
150 struct rt6_info *rt = (struct rt6_info *)dst;
151 struct inet6_dev *idev = rt->rt6i_idev;
154 rt->rt6i_idev = NULL;
159 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
162 struct rt6_info *rt = (struct rt6_info *)dst;
163 struct inet6_dev *idev = rt->rt6i_idev;
165 if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
166 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
167 if (loopback_idev != NULL) {
168 rt->rt6i_idev = loopback_idev;
174 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
176 return (rt->rt6i_flags & RTF_EXPIRES &&
177 time_after(jiffies, rt->rt6i_expires));
181 * Route lookup. Any rt6_lock is implied.
184 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
188 struct rt6_info *local = NULL;
189 struct rt6_info *sprt;
192 for (sprt = rt; sprt; sprt = sprt->u.next) {
193 struct net_device *dev = sprt->rt6i_dev;
194 if (dev->ifindex == oif)
196 if (dev->flags & IFF_LOOPBACK) {
197 if (sprt->rt6i_idev == NULL ||
198 sprt->rt6i_idev->dev->ifindex != oif) {
201 if (local && (!oif ||
202 local->rt6i_idev->dev->ifindex == oif))
213 return &ip6_null_entry;
219 * pointer to the last default router chosen. BH is disabled locally.
221 static struct rt6_info *rt6_dflt_pointer;
222 static DEFINE_SPINLOCK(rt6_dflt_lock);
224 void rt6_reset_dflt_pointer(struct rt6_info *rt)
226 spin_lock_bh(&rt6_dflt_lock);
227 if (rt == NULL || rt == rt6_dflt_pointer) {
228 RT6_TRACE("reset default router: %p->NULL\n", rt6_dflt_pointer);
229 rt6_dflt_pointer = NULL;
231 spin_unlock_bh(&rt6_dflt_lock);
234 /* Default Router Selection (RFC 2461 6.3.6) */
235 static struct rt6_info *rt6_best_dflt(struct rt6_info *rt, int oif)
237 struct rt6_info *match = NULL;
238 struct rt6_info *sprt;
241 for (sprt = rt; sprt; sprt = sprt->u.next) {
242 struct neighbour *neigh;
247 sprt->rt6i_dev->ifindex == oif))
250 if (rt6_check_expired(sprt))
253 if (sprt == rt6_dflt_pointer)
256 if ((neigh = sprt->rt6i_nexthop) != NULL) {
257 read_lock_bh(&neigh->lock);
258 switch (neigh->nud_state) {
276 read_unlock_bh(&neigh->lock);
279 read_unlock_bh(&neigh->lock);
284 if (m > mpri || m >= 12) {
288 /* we choose the last default router if it
289 * is in (probably) reachable state.
290 * If route changed, we should do pmtu
291 * discovery. --yoshfuji
298 spin_lock(&rt6_dflt_lock);
301 * No default routers are known to be reachable.
304 if (rt6_dflt_pointer) {
305 for (sprt = rt6_dflt_pointer->u.next;
306 sprt; sprt = sprt->u.next) {
307 if (sprt->u.dst.obsolete <= 0 &&
308 sprt->u.dst.error == 0 &&
309 !rt6_check_expired(sprt)) {
316 sprt = sprt->u.next) {
317 if (sprt->u.dst.obsolete <= 0 &&
318 sprt->u.dst.error == 0 &&
319 !rt6_check_expired(sprt)) {
323 if (sprt == rt6_dflt_pointer)
330 if (rt6_dflt_pointer != match)
331 RT6_TRACE("changed default router: %p->%p\n",
332 rt6_dflt_pointer, match);
333 rt6_dflt_pointer = match;
335 spin_unlock(&rt6_dflt_lock);
339 * Last Resort: if no default routers found,
340 * use addrconf default route.
341 * We don't record this route.
343 for (sprt = ip6_routing_table.leaf;
344 sprt; sprt = sprt->u.next) {
345 if (!rt6_check_expired(sprt) &&
346 (sprt->rt6i_flags & RTF_DEFAULT) &&
349 sprt->rt6i_dev->ifindex == oif))) {
355 /* no default route. give up. */
356 match = &ip6_null_entry;
363 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
366 struct fib6_node *fn;
369 read_lock_bh(&rt6_lock);
370 fn = fib6_lookup(&ip6_routing_table, daddr, saddr);
371 rt = rt6_device_match(fn->leaf, oif, strict);
372 dst_hold(&rt->u.dst);
374 read_unlock_bh(&rt6_lock);
376 rt->u.dst.lastuse = jiffies;
377 if (rt->u.dst.error == 0)
379 dst_release(&rt->u.dst);
383 /* ip6_ins_rt is called with FREE rt6_lock.
384 It takes new route entry, the addition fails by any reason the
385 route is freed. In any case, if caller does not hold it, it may
389 int ip6_ins_rt(struct rt6_info *rt, struct nlmsghdr *nlh,
390 void *_rtattr, struct netlink_skb_parms *req)
394 write_lock_bh(&rt6_lock);
395 err = fib6_add(&ip6_routing_table, rt, nlh, _rtattr, req);
396 write_unlock_bh(&rt6_lock);
401 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
402 struct in6_addr *saddr)
410 rt = ip6_rt_copy(ort);
413 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
414 if (rt->rt6i_dst.plen != 128 &&
415 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
416 rt->rt6i_flags |= RTF_ANYCAST;
417 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
420 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
421 rt->rt6i_dst.plen = 128;
422 rt->rt6i_flags |= RTF_CACHE;
423 rt->u.dst.flags |= DST_HOST;
425 #ifdef CONFIG_IPV6_SUBTREES
426 if (rt->rt6i_src.plen && saddr) {
427 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
428 rt->rt6i_src.plen = 128;
432 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
439 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
441 struct rt6_info *rt = ip6_rt_copy(ort);
443 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
444 rt->rt6i_dst.plen = 128;
445 rt->rt6i_flags |= RTF_CACHE;
446 if (rt->rt6i_flags & RTF_REJECT)
447 rt->u.dst.error = ort->u.dst.error;
448 rt->u.dst.flags |= DST_HOST;
449 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
454 #define BACKTRACK() \
455 if (rt == &ip6_null_entry && strict) { \
456 while ((fn = fn->parent) != NULL) { \
457 if (fn->fn_flags & RTN_ROOT) { \
460 if (fn->fn_flags & RTN_RTINFO) \
466 void ip6_route_input(struct sk_buff *skb)
468 struct fib6_node *fn;
469 struct rt6_info *rt, *nrt;
474 strict = ipv6_addr_type(&skb->nh.ipv6h->daddr) & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL);
477 read_lock_bh(&rt6_lock);
479 fn = fib6_lookup(&ip6_routing_table, &skb->nh.ipv6h->daddr,
480 &skb->nh.ipv6h->saddr);
485 if ((rt->rt6i_flags & RTF_CACHE)) {
486 rt = rt6_device_match(rt, skb->dev->ifindex, strict);
491 rt = rt6_device_match(rt, skb->dev->ifindex, strict);
494 dst_hold(&rt->u.dst);
495 read_unlock_bh(&rt6_lock);
497 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
498 nrt = rt6_alloc_cow(rt, &skb->nh.ipv6h->daddr, &skb->nh.ipv6h->saddr);
500 #if CLONE_OFFLINK_ROUTE
501 nrt = rt6_alloc_clone(rt, &skb->nh.ipv6h->daddr);
507 dst_release(&rt->u.dst);
508 rt = nrt ? : &ip6_null_entry;
510 dst_hold(&rt->u.dst);
512 err = ip6_ins_rt(nrt, NULL, NULL, &NETLINK_CB(skb));
521 * Race condition! In the gap, when rt6_lock was
522 * released someone could insert this route. Relookup.
524 dst_release(&rt->u.dst);
528 dst_hold(&rt->u.dst);
529 read_unlock_bh(&rt6_lock);
531 rt->u.dst.lastuse = jiffies;
533 skb->dst = (struct dst_entry *) rt;
537 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
539 struct fib6_node *fn;
540 struct rt6_info *rt, *nrt;
545 strict = ipv6_addr_type(&fl->fl6_dst) & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL);
548 read_lock_bh(&rt6_lock);
550 fn = fib6_lookup(&ip6_routing_table, &fl->fl6_dst, &fl->fl6_src);
555 if ((rt->rt6i_flags & RTF_CACHE)) {
556 rt = rt6_device_match(rt, fl->oif, strict);
560 if (rt->rt6i_flags & RTF_DEFAULT) {
561 if (rt->rt6i_metric >= IP6_RT_PRIO_ADDRCONF)
562 rt = rt6_best_dflt(rt, fl->oif);
564 rt = rt6_device_match(rt, fl->oif, strict);
568 dst_hold(&rt->u.dst);
569 read_unlock_bh(&rt6_lock);
571 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
572 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
574 #if CLONE_OFFLINK_ROUTE
575 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
581 dst_release(&rt->u.dst);
582 rt = nrt ? : &ip6_null_entry;
584 dst_hold(&rt->u.dst);
586 err = ip6_ins_rt(nrt, NULL, NULL, NULL);
595 * Race condition! In the gap, when rt6_lock was
596 * released someone could insert this route. Relookup.
598 dst_release(&rt->u.dst);
602 dst_hold(&rt->u.dst);
603 read_unlock_bh(&rt6_lock);
605 rt->u.dst.lastuse = jiffies;
612 * Destination cache support functions
615 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
619 rt = (struct rt6_info *) dst;
621 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
627 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
629 struct rt6_info *rt = (struct rt6_info *) dst;
632 if (rt->rt6i_flags & RTF_CACHE)
633 ip6_del_rt(rt, NULL, NULL, NULL);
640 static void ip6_link_failure(struct sk_buff *skb)
644 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
646 rt = (struct rt6_info *) skb->dst;
648 if (rt->rt6i_flags&RTF_CACHE) {
649 dst_set_expires(&rt->u.dst, 0);
650 rt->rt6i_flags |= RTF_EXPIRES;
651 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
652 rt->rt6i_node->fn_sernum = -1;
656 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
658 struct rt6_info *rt6 = (struct rt6_info*)dst;
660 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
661 rt6->rt6i_flags |= RTF_MODIFIED;
662 if (mtu < IPV6_MIN_MTU) {
664 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
666 dst->metrics[RTAX_MTU-1] = mtu;
670 /* Protected by rt6_lock. */
671 static struct dst_entry *ndisc_dst_gc_list;
672 static int ipv6_get_mtu(struct net_device *dev);
674 static inline unsigned int ipv6_advmss(unsigned int mtu)
676 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
678 if (mtu < ip6_rt_min_advmss)
679 mtu = ip6_rt_min_advmss;
682 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
683 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
684 * IPV6_MAXPLEN is also valid and means: "any MSS,
685 * rely only on pmtu discovery"
687 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
692 struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
693 struct neighbour *neigh,
694 struct in6_addr *addr,
695 int (*output)(struct sk_buff *))
698 struct inet6_dev *idev = in6_dev_get(dev);
700 if (unlikely(idev == NULL))
703 rt = ip6_dst_alloc();
704 if (unlikely(rt == NULL)) {
713 neigh = ndisc_get_neigh(dev, addr);
716 rt->rt6i_idev = idev;
717 rt->rt6i_nexthop = neigh;
718 atomic_set(&rt->u.dst.__refcnt, 1);
719 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
720 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
721 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
722 rt->u.dst.output = output;
724 #if 0 /* there's no chance to use these for ndisc */
725 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
728 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
729 rt->rt6i_dst.plen = 128;
732 write_lock_bh(&rt6_lock);
733 rt->u.dst.next = ndisc_dst_gc_list;
734 ndisc_dst_gc_list = &rt->u.dst;
735 write_unlock_bh(&rt6_lock);
737 fib6_force_start_gc();
740 return (struct dst_entry *)rt;
743 int ndisc_dst_gc(int *more)
745 struct dst_entry *dst, *next, **pprev;
749 pprev = &ndisc_dst_gc_list;
751 while ((dst = *pprev) != NULL) {
752 if (!atomic_read(&dst->__refcnt)) {
765 static int ip6_dst_gc(void)
767 static unsigned expire = 30*HZ;
768 static unsigned long last_gc;
769 unsigned long now = jiffies;
771 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
772 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
778 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
779 expire = ip6_rt_gc_timeout>>1;
782 expire -= expire>>ip6_rt_gc_elasticity;
783 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
786 /* Clean host part of a prefix. Not necessary in radix tree,
787 but results in cleaner routing tables.
789 Remove it only when all the things will work!
792 static int ipv6_get_mtu(struct net_device *dev)
794 int mtu = IPV6_MIN_MTU;
795 struct inet6_dev *idev;
797 idev = in6_dev_get(dev);
799 mtu = idev->cnf.mtu6;
805 int ipv6_get_hoplimit(struct net_device *dev)
807 int hoplimit = ipv6_devconf.hop_limit;
808 struct inet6_dev *idev;
810 idev = in6_dev_get(dev);
812 hoplimit = idev->cnf.hop_limit;
822 int ip6_route_add(struct in6_rtmsg *rtmsg, struct nlmsghdr *nlh,
823 void *_rtattr, struct netlink_skb_parms *req)
828 struct rt6_info *rt = NULL;
829 struct net_device *dev = NULL;
830 struct inet6_dev *idev = NULL;
833 rta = (struct rtattr **) _rtattr;
835 if (rtmsg->rtmsg_dst_len > 128 || rtmsg->rtmsg_src_len > 128)
837 #ifndef CONFIG_IPV6_SUBTREES
838 if (rtmsg->rtmsg_src_len)
841 if (rtmsg->rtmsg_ifindex) {
843 dev = dev_get_by_index(rtmsg->rtmsg_ifindex);
846 idev = in6_dev_get(dev);
851 if (rtmsg->rtmsg_metric == 0)
852 rtmsg->rtmsg_metric = IP6_RT_PRIO_USER;
854 rt = ip6_dst_alloc();
861 rt->u.dst.obsolete = -1;
862 rt->rt6i_expires = jiffies + clock_t_to_jiffies(rtmsg->rtmsg_info);
863 if (nlh && (r = NLMSG_DATA(nlh))) {
864 rt->rt6i_protocol = r->rtm_protocol;
866 rt->rt6i_protocol = RTPROT_BOOT;
869 addr_type = ipv6_addr_type(&rtmsg->rtmsg_dst);
871 if (addr_type & IPV6_ADDR_MULTICAST)
872 rt->u.dst.input = ip6_mc_input;
874 rt->u.dst.input = ip6_forward;
876 rt->u.dst.output = ip6_output;
878 ipv6_addr_prefix(&rt->rt6i_dst.addr,
879 &rtmsg->rtmsg_dst, rtmsg->rtmsg_dst_len);
880 rt->rt6i_dst.plen = rtmsg->rtmsg_dst_len;
881 if (rt->rt6i_dst.plen == 128)
882 rt->u.dst.flags = DST_HOST;
884 #ifdef CONFIG_IPV6_SUBTREES
885 ipv6_addr_prefix(&rt->rt6i_src.addr,
886 &rtmsg->rtmsg_src, rtmsg->rtmsg_src_len);
887 rt->rt6i_src.plen = rtmsg->rtmsg_src_len;
890 rt->rt6i_metric = rtmsg->rtmsg_metric;
892 /* We cannot add true routes via loopback here,
893 they would result in kernel looping; promote them to reject routes
895 if ((rtmsg->rtmsg_flags&RTF_REJECT) ||
896 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
897 /* hold loopback dev/idev if we haven't done so. */
898 if (dev != &loopback_dev) {
905 idev = in6_dev_get(dev);
911 rt->u.dst.output = ip6_pkt_discard_out;
912 rt->u.dst.input = ip6_pkt_discard;
913 rt->u.dst.error = -ENETUNREACH;
914 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
918 if (rtmsg->rtmsg_flags & RTF_GATEWAY) {
919 struct in6_addr *gw_addr;
922 gw_addr = &rtmsg->rtmsg_gateway;
923 ipv6_addr_copy(&rt->rt6i_gateway, &rtmsg->rtmsg_gateway);
924 gwa_type = ipv6_addr_type(gw_addr);
926 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
927 struct rt6_info *grt;
929 /* IPv6 strictly inhibits using not link-local
930 addresses as nexthop address.
931 Otherwise, router will not able to send redirects.
932 It is very good, but in some (rare!) circumstances
933 (SIT, PtP, NBMA NOARP links) it is handy to allow
934 some exceptions. --ANK
937 if (!(gwa_type&IPV6_ADDR_UNICAST))
940 grt = rt6_lookup(gw_addr, NULL, rtmsg->rtmsg_ifindex, 1);
946 if (dev != grt->rt6i_dev) {
947 dst_release(&grt->u.dst);
952 idev = grt->rt6i_idev;
954 in6_dev_hold(grt->rt6i_idev);
956 if (!(grt->rt6i_flags&RTF_GATEWAY))
958 dst_release(&grt->u.dst);
964 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
972 if (rtmsg->rtmsg_flags & (RTF_GATEWAY|RTF_NONEXTHOP)) {
973 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
974 if (IS_ERR(rt->rt6i_nexthop)) {
975 err = PTR_ERR(rt->rt6i_nexthop);
976 rt->rt6i_nexthop = NULL;
981 rt->rt6i_flags = rtmsg->rtmsg_flags;
984 if (rta && rta[RTA_METRICS-1]) {
985 int attrlen = RTA_PAYLOAD(rta[RTA_METRICS-1]);
986 struct rtattr *attr = RTA_DATA(rta[RTA_METRICS-1]);
988 while (RTA_OK(attr, attrlen)) {
989 unsigned flavor = attr->rta_type;
991 if (flavor > RTAX_MAX) {
995 rt->u.dst.metrics[flavor-1] =
996 *(u32 *)RTA_DATA(attr);
998 attr = RTA_NEXT(attr, attrlen);
1002 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1003 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1004 if (!rt->u.dst.metrics[RTAX_MTU-1])
1005 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1006 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1007 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1008 rt->u.dst.dev = dev;
1009 rt->rt6i_idev = idev;
1010 return ip6_ins_rt(rt, nlh, _rtattr, req);
1018 dst_free((struct dst_entry *) rt);
1022 int ip6_del_rt(struct rt6_info *rt, struct nlmsghdr *nlh, void *_rtattr, struct netlink_skb_parms *req)
1026 write_lock_bh(&rt6_lock);
1028 rt6_reset_dflt_pointer(NULL);
1030 err = fib6_del(rt, nlh, _rtattr, req);
1031 dst_release(&rt->u.dst);
1033 write_unlock_bh(&rt6_lock);
1038 static int ip6_route_del(struct in6_rtmsg *rtmsg, struct nlmsghdr *nlh, void *_rtattr, struct netlink_skb_parms *req)
1040 struct fib6_node *fn;
1041 struct rt6_info *rt;
1044 read_lock_bh(&rt6_lock);
1046 fn = fib6_locate(&ip6_routing_table,
1047 &rtmsg->rtmsg_dst, rtmsg->rtmsg_dst_len,
1048 &rtmsg->rtmsg_src, rtmsg->rtmsg_src_len);
1051 for (rt = fn->leaf; rt; rt = rt->u.next) {
1052 if (rtmsg->rtmsg_ifindex &&
1053 (rt->rt6i_dev == NULL ||
1054 rt->rt6i_dev->ifindex != rtmsg->rtmsg_ifindex))
1056 if (rtmsg->rtmsg_flags&RTF_GATEWAY &&
1057 !ipv6_addr_equal(&rtmsg->rtmsg_gateway, &rt->rt6i_gateway))
1059 if (rtmsg->rtmsg_metric &&
1060 rtmsg->rtmsg_metric != rt->rt6i_metric)
1062 dst_hold(&rt->u.dst);
1063 read_unlock_bh(&rt6_lock);
1065 return ip6_del_rt(rt, nlh, _rtattr, req);
1068 read_unlock_bh(&rt6_lock);
1076 void rt6_redirect(struct in6_addr *dest, struct in6_addr *saddr,
1077 struct neighbour *neigh, u8 *lladdr, int on_link)
1079 struct rt6_info *rt, *nrt;
1081 /* Locate old route to this destination. */
1082 rt = rt6_lookup(dest, NULL, neigh->dev->ifindex, 1);
1087 if (neigh->dev != rt->rt6i_dev)
1091 * Current route is on-link; redirect is always invalid.
1093 * Seems, previous statement is not true. It could
1094 * be node, which looks for us as on-link (f.e. proxy ndisc)
1095 * But then router serving it might decide, that we should
1096 * know truth 8)8) --ANK (980726).
1098 if (!(rt->rt6i_flags&RTF_GATEWAY))
1102 * RFC 2461 specifies that redirects should only be
1103 * accepted if they come from the nexthop to the target.
1104 * Due to the way default routers are chosen, this notion
1105 * is a bit fuzzy and one might need to check all default
1108 if (!ipv6_addr_equal(saddr, &rt->rt6i_gateway)) {
1109 if (rt->rt6i_flags & RTF_DEFAULT) {
1110 struct rt6_info *rt1;
1112 read_lock(&rt6_lock);
1113 for (rt1 = ip6_routing_table.leaf; rt1; rt1 = rt1->u.next) {
1114 if (ipv6_addr_equal(saddr, &rt1->rt6i_gateway)) {
1115 dst_hold(&rt1->u.dst);
1116 dst_release(&rt->u.dst);
1117 read_unlock(&rt6_lock);
1122 read_unlock(&rt6_lock);
1124 if (net_ratelimit())
1125 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1126 "for redirect target\n");
1133 * We have finally decided to accept it.
1136 neigh_update(neigh, lladdr, NUD_STALE,
1137 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1138 NEIGH_UPDATE_F_OVERRIDE|
1139 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1140 NEIGH_UPDATE_F_ISROUTER))
1144 * Redirect received -> path was valid.
1145 * Look, redirects are sent only in response to data packets,
1146 * so that this nexthop apparently is reachable. --ANK
1148 dst_confirm(&rt->u.dst);
1150 /* Duplicate redirect: silently ignore. */
1151 if (neigh == rt->u.dst.neighbour)
1154 nrt = ip6_rt_copy(rt);
1158 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1160 nrt->rt6i_flags &= ~RTF_GATEWAY;
1162 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1163 nrt->rt6i_dst.plen = 128;
1164 nrt->u.dst.flags |= DST_HOST;
1166 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1167 nrt->rt6i_nexthop = neigh_clone(neigh);
1168 /* Reset pmtu, it may be better */
1169 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1170 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1172 if (ip6_ins_rt(nrt, NULL, NULL, NULL))
1175 if (rt->rt6i_flags&RTF_CACHE) {
1176 ip6_del_rt(rt, NULL, NULL, NULL);
1181 dst_release(&rt->u.dst);
1186 * Handle ICMP "packet too big" messages
1187 * i.e. Path MTU discovery
1190 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1191 struct net_device *dev, u32 pmtu)
1193 struct rt6_info *rt, *nrt;
1196 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1200 if (pmtu >= dst_mtu(&rt->u.dst))
1203 if (pmtu < IPV6_MIN_MTU) {
1205 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1206 * MTU (1280) and a fragment header should always be included
1207 * after a node receiving Too Big message reporting PMTU is
1208 * less than the IPv6 Minimum Link MTU.
1210 pmtu = IPV6_MIN_MTU;
1214 /* New mtu received -> path was valid.
1215 They are sent only in response to data packets,
1216 so that this nexthop apparently is reachable. --ANK
1218 dst_confirm(&rt->u.dst);
1220 /* Host route. If it is static, it would be better
1221 not to override it, but add new one, so that
1222 when cache entry will expire old pmtu
1223 would return automatically.
1225 if (rt->rt6i_flags & RTF_CACHE) {
1226 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1228 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1229 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1230 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1235 Two cases are possible:
1236 1. It is connected route. Action: COW
1237 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1239 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1240 nrt = rt6_alloc_cow(rt, daddr, saddr);
1242 nrt = rt6_alloc_clone(rt, daddr);
1245 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1247 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1249 /* According to RFC 1981, detecting PMTU increase shouldn't be
1250 * happened within 5 mins, the recommended timer is 10 mins.
1251 * Here this route expiration time is set to ip6_rt_mtu_expires
1252 * which is 10 mins. After 10 mins the decreased pmtu is expired
1253 * and detecting PMTU increase will be automatically happened.
1255 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1256 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1258 ip6_ins_rt(nrt, NULL, NULL, NULL);
1261 dst_release(&rt->u.dst);
1265 * Misc support functions
1268 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1270 struct rt6_info *rt = ip6_dst_alloc();
1273 rt->u.dst.input = ort->u.dst.input;
1274 rt->u.dst.output = ort->u.dst.output;
1276 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1277 rt->u.dst.dev = ort->u.dst.dev;
1279 dev_hold(rt->u.dst.dev);
1280 rt->rt6i_idev = ort->rt6i_idev;
1282 in6_dev_hold(rt->rt6i_idev);
1283 rt->u.dst.lastuse = jiffies;
1284 rt->rt6i_expires = 0;
1286 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1287 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1288 rt->rt6i_metric = 0;
1290 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1291 #ifdef CONFIG_IPV6_SUBTREES
1292 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1298 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1300 struct rt6_info *rt;
1301 struct fib6_node *fn;
1303 fn = &ip6_routing_table;
1305 write_lock_bh(&rt6_lock);
1306 for (rt = fn->leaf; rt; rt=rt->u.next) {
1307 if (dev == rt->rt6i_dev &&
1308 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1312 dst_hold(&rt->u.dst);
1313 write_unlock_bh(&rt6_lock);
1317 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1318 struct net_device *dev)
1320 struct in6_rtmsg rtmsg;
1322 memset(&rtmsg, 0, sizeof(struct in6_rtmsg));
1323 rtmsg.rtmsg_type = RTMSG_NEWROUTE;
1324 ipv6_addr_copy(&rtmsg.rtmsg_gateway, gwaddr);
1325 rtmsg.rtmsg_metric = 1024;
1326 rtmsg.rtmsg_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT | RTF_UP | RTF_EXPIRES;
1328 rtmsg.rtmsg_ifindex = dev->ifindex;
1330 ip6_route_add(&rtmsg, NULL, NULL, NULL);
1331 return rt6_get_dflt_router(gwaddr, dev);
1334 void rt6_purge_dflt_routers(void)
1336 struct rt6_info *rt;
1339 read_lock_bh(&rt6_lock);
1340 for (rt = ip6_routing_table.leaf; rt; rt = rt->u.next) {
1341 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1342 dst_hold(&rt->u.dst);
1344 rt6_reset_dflt_pointer(NULL);
1346 read_unlock_bh(&rt6_lock);
1348 ip6_del_rt(rt, NULL, NULL, NULL);
1353 read_unlock_bh(&rt6_lock);
1356 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1358 struct in6_rtmsg rtmsg;
1362 case SIOCADDRT: /* Add a route */
1363 case SIOCDELRT: /* Delete a route */
1364 if (!capable(CAP_NET_ADMIN))
1366 err = copy_from_user(&rtmsg, arg,
1367 sizeof(struct in6_rtmsg));
1374 err = ip6_route_add(&rtmsg, NULL, NULL, NULL);
1377 err = ip6_route_del(&rtmsg, NULL, NULL, NULL);
1391 * Drop the packet on the floor
1394 static int ip6_pkt_discard(struct sk_buff *skb)
1396 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
1397 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_NOROUTE, 0, skb->dev);
1402 static int ip6_pkt_discard_out(struct sk_buff *skb)
1404 skb->dev = skb->dst->dev;
1405 return ip6_pkt_discard(skb);
1409 * Allocate a dst for local (unicast / anycast) address.
1412 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1413 const struct in6_addr *addr,
1416 struct rt6_info *rt = ip6_dst_alloc();
1419 return ERR_PTR(-ENOMEM);
1421 dev_hold(&loopback_dev);
1424 rt->u.dst.flags = DST_HOST;
1425 rt->u.dst.input = ip6_input;
1426 rt->u.dst.output = ip6_output;
1427 rt->rt6i_dev = &loopback_dev;
1428 rt->rt6i_idev = idev;
1429 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1430 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1431 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1432 rt->u.dst.obsolete = -1;
1434 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1436 rt->rt6i_flags |= RTF_ANYCAST;
1438 rt->rt6i_flags |= RTF_LOCAL;
1439 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1440 if (rt->rt6i_nexthop == NULL) {
1441 dst_free((struct dst_entry *) rt);
1442 return ERR_PTR(-ENOMEM);
1445 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1446 rt->rt6i_dst.plen = 128;
1448 atomic_set(&rt->u.dst.__refcnt, 1);
1453 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1455 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1456 rt != &ip6_null_entry) {
1457 RT6_TRACE("deleted by ifdown %p\n", rt);
1463 void rt6_ifdown(struct net_device *dev)
1465 write_lock_bh(&rt6_lock);
1466 fib6_clean_tree(&ip6_routing_table, fib6_ifdown, 0, dev);
1467 write_unlock_bh(&rt6_lock);
1470 struct rt6_mtu_change_arg
1472 struct net_device *dev;
1476 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1478 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1479 struct inet6_dev *idev;
1481 /* In IPv6 pmtu discovery is not optional,
1482 so that RTAX_MTU lock cannot disable it.
1483 We still use this lock to block changes
1484 caused by addrconf/ndisc.
1487 idev = __in6_dev_get(arg->dev);
1491 /* For administrative MTU increase, there is no way to discover
1492 IPv6 PMTU increase, so PMTU increase should be updated here.
1493 Since RFC 1981 doesn't include administrative MTU increase
1494 update PMTU increase is a MUST. (i.e. jumbo frame)
1497 If new MTU is less than route PMTU, this new MTU will be the
1498 lowest MTU in the path, update the route PMTU to reflect PMTU
1499 decreases; if new MTU is greater than route PMTU, and the
1500 old MTU is the lowest MTU in the path, update the route PMTU
1501 to reflect the increase. In this case if the other nodes' MTU
1502 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1505 if (rt->rt6i_dev == arg->dev &&
1506 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1507 (dst_mtu(&rt->u.dst) > arg->mtu ||
1508 (dst_mtu(&rt->u.dst) < arg->mtu &&
1509 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1510 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1511 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1515 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1517 struct rt6_mtu_change_arg arg;
1521 read_lock_bh(&rt6_lock);
1522 fib6_clean_tree(&ip6_routing_table, rt6_mtu_change_route, 0, &arg);
1523 read_unlock_bh(&rt6_lock);
1526 static int inet6_rtm_to_rtmsg(struct rtmsg *r, struct rtattr **rta,
1527 struct in6_rtmsg *rtmsg)
1529 memset(rtmsg, 0, sizeof(*rtmsg));
1531 rtmsg->rtmsg_dst_len = r->rtm_dst_len;
1532 rtmsg->rtmsg_src_len = r->rtm_src_len;
1533 rtmsg->rtmsg_flags = RTF_UP;
1534 if (r->rtm_type == RTN_UNREACHABLE)
1535 rtmsg->rtmsg_flags |= RTF_REJECT;
1537 if (rta[RTA_GATEWAY-1]) {
1538 if (rta[RTA_GATEWAY-1]->rta_len != RTA_LENGTH(16))
1540 memcpy(&rtmsg->rtmsg_gateway, RTA_DATA(rta[RTA_GATEWAY-1]), 16);
1541 rtmsg->rtmsg_flags |= RTF_GATEWAY;
1543 if (rta[RTA_DST-1]) {
1544 if (RTA_PAYLOAD(rta[RTA_DST-1]) < ((r->rtm_dst_len+7)>>3))
1546 memcpy(&rtmsg->rtmsg_dst, RTA_DATA(rta[RTA_DST-1]), ((r->rtm_dst_len+7)>>3));
1548 if (rta[RTA_SRC-1]) {
1549 if (RTA_PAYLOAD(rta[RTA_SRC-1]) < ((r->rtm_src_len+7)>>3))
1551 memcpy(&rtmsg->rtmsg_src, RTA_DATA(rta[RTA_SRC-1]), ((r->rtm_src_len+7)>>3));
1553 if (rta[RTA_OIF-1]) {
1554 if (rta[RTA_OIF-1]->rta_len != RTA_LENGTH(sizeof(int)))
1556 memcpy(&rtmsg->rtmsg_ifindex, RTA_DATA(rta[RTA_OIF-1]), sizeof(int));
1558 if (rta[RTA_PRIORITY-1]) {
1559 if (rta[RTA_PRIORITY-1]->rta_len != RTA_LENGTH(4))
1561 memcpy(&rtmsg->rtmsg_metric, RTA_DATA(rta[RTA_PRIORITY-1]), 4);
1566 int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1568 struct rtmsg *r = NLMSG_DATA(nlh);
1569 struct in6_rtmsg rtmsg;
1571 if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
1573 return ip6_route_del(&rtmsg, nlh, arg, &NETLINK_CB(skb));
1576 int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1578 struct rtmsg *r = NLMSG_DATA(nlh);
1579 struct in6_rtmsg rtmsg;
1581 if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
1583 return ip6_route_add(&rtmsg, nlh, arg, &NETLINK_CB(skb));
1586 struct rt6_rtnl_dump_arg
1588 struct sk_buff *skb;
1589 struct netlink_callback *cb;
1592 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
1593 struct in6_addr *dst, struct in6_addr *src,
1594 int iif, int type, u32 pid, u32 seq,
1595 int prefix, unsigned int flags)
1598 struct nlmsghdr *nlh;
1599 unsigned char *b = skb->tail;
1600 struct rta_cacheinfo ci;
1602 if (prefix) { /* user wants prefix routes only */
1603 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
1604 /* success since this is not a prefix route */
1609 nlh = NLMSG_NEW(skb, pid, seq, type, sizeof(*rtm), flags);
1610 rtm = NLMSG_DATA(nlh);
1611 rtm->rtm_family = AF_INET6;
1612 rtm->rtm_dst_len = rt->rt6i_dst.plen;
1613 rtm->rtm_src_len = rt->rt6i_src.plen;
1615 rtm->rtm_table = RT_TABLE_MAIN;
1616 if (rt->rt6i_flags&RTF_REJECT)
1617 rtm->rtm_type = RTN_UNREACHABLE;
1618 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
1619 rtm->rtm_type = RTN_LOCAL;
1621 rtm->rtm_type = RTN_UNICAST;
1623 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
1624 rtm->rtm_protocol = rt->rt6i_protocol;
1625 if (rt->rt6i_flags&RTF_DYNAMIC)
1626 rtm->rtm_protocol = RTPROT_REDIRECT;
1627 else if (rt->rt6i_flags & RTF_ADDRCONF)
1628 rtm->rtm_protocol = RTPROT_KERNEL;
1629 else if (rt->rt6i_flags&RTF_DEFAULT)
1630 rtm->rtm_protocol = RTPROT_RA;
1632 if (rt->rt6i_flags&RTF_CACHE)
1633 rtm->rtm_flags |= RTM_F_CLONED;
1636 RTA_PUT(skb, RTA_DST, 16, dst);
1637 rtm->rtm_dst_len = 128;
1638 } else if (rtm->rtm_dst_len)
1639 RTA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
1640 #ifdef CONFIG_IPV6_SUBTREES
1642 RTA_PUT(skb, RTA_SRC, 16, src);
1643 rtm->rtm_src_len = 128;
1644 } else if (rtm->rtm_src_len)
1645 RTA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
1648 RTA_PUT(skb, RTA_IIF, 4, &iif);
1650 struct in6_addr saddr_buf;
1651 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
1652 RTA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
1654 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
1655 goto rtattr_failure;
1656 if (rt->u.dst.neighbour)
1657 RTA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
1659 RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->rt6i_dev->ifindex);
1660 RTA_PUT(skb, RTA_PRIORITY, 4, &rt->rt6i_metric);
1661 ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
1662 if (rt->rt6i_expires)
1663 ci.rta_expires = jiffies_to_clock_t(rt->rt6i_expires - jiffies);
1666 ci.rta_used = rt->u.dst.__use;
1667 ci.rta_clntref = atomic_read(&rt->u.dst.__refcnt);
1668 ci.rta_error = rt->u.dst.error;
1672 RTA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
1673 nlh->nlmsg_len = skb->tail - b;
1678 skb_trim(skb, b - skb->data);
1682 static int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1684 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
1687 if (arg->cb->nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(struct rtmsg))) {
1688 struct rtmsg *rtm = NLMSG_DATA(arg->cb->nlh);
1689 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
1693 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
1694 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
1695 prefix, NLM_F_MULTI);
1698 static int fib6_dump_node(struct fib6_walker_t *w)
1701 struct rt6_info *rt;
1703 for (rt = w->leaf; rt; rt = rt->u.next) {
1704 res = rt6_dump_route(rt, w->args);
1706 /* Frame is full, suspend walking */
1716 static void fib6_dump_end(struct netlink_callback *cb)
1718 struct fib6_walker_t *w = (void*)cb->args[0];
1722 fib6_walker_unlink(w);
1725 cb->done = (void*)cb->args[1];
1729 static int fib6_dump_done(struct netlink_callback *cb)
1732 return cb->done ? cb->done(cb) : 0;
1735 int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
1737 struct rt6_rtnl_dump_arg arg;
1738 struct fib6_walker_t *w;
1744 w = (void*)cb->args[0];
1748 * 1. hook callback destructor.
1750 cb->args[1] = (long)cb->done;
1751 cb->done = fib6_dump_done;
1754 * 2. allocate and initialize walker.
1756 w = kmalloc(sizeof(*w), GFP_ATOMIC);
1759 RT6_TRACE("dump<%p", w);
1760 memset(w, 0, sizeof(*w));
1761 w->root = &ip6_routing_table;
1762 w->func = fib6_dump_node;
1764 cb->args[0] = (long)w;
1765 read_lock_bh(&rt6_lock);
1767 read_unlock_bh(&rt6_lock);
1770 read_lock_bh(&rt6_lock);
1771 res = fib6_walk_continue(w);
1772 read_unlock_bh(&rt6_lock);
1775 if (res <= 0 && skb->len == 0)
1776 RT6_TRACE("%p>dump end\n", w);
1778 res = res < 0 ? res : skb->len;
1779 /* res < 0 is an error. (really, impossible)
1780 res == 0 means that dump is complete, but skb still can contain data.
1781 res > 0 dump is not complete, but frame is full.
1783 /* Destroy walker, if dump of this table is complete. */
1789 int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
1791 struct rtattr **rta = arg;
1794 struct sk_buff *skb;
1796 struct rt6_info *rt;
1798 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1802 /* Reserve room for dummy headers, this skb can pass
1803 through good chunk of routing engine.
1805 skb->mac.raw = skb->data;
1806 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1808 memset(&fl, 0, sizeof(fl));
1810 ipv6_addr_copy(&fl.fl6_src,
1811 (struct in6_addr*)RTA_DATA(rta[RTA_SRC-1]));
1813 ipv6_addr_copy(&fl.fl6_dst,
1814 (struct in6_addr*)RTA_DATA(rta[RTA_DST-1]));
1817 memcpy(&iif, RTA_DATA(rta[RTA_IIF-1]), sizeof(int));
1820 struct net_device *dev;
1821 dev = __dev_get_by_index(iif);
1830 memcpy(&fl.oif, RTA_DATA(rta[RTA_OIF-1]), sizeof(int));
1832 rt = (struct rt6_info*)ip6_route_output(NULL, &fl);
1834 skb->dst = &rt->u.dst;
1836 NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
1837 err = rt6_fill_node(skb, rt,
1838 &fl.fl6_dst, &fl.fl6_src,
1840 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
1841 nlh->nlmsg_seq, 0, 0);
1847 err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
1857 void inet6_rt_notify(int event, struct rt6_info *rt, struct nlmsghdr *nlh,
1858 struct netlink_skb_parms *req)
1860 struct sk_buff *skb;
1861 int size = NLMSG_SPACE(sizeof(struct rtmsg)+256);
1862 u32 pid = current->pid;
1868 seq = nlh->nlmsg_seq;
1870 skb = alloc_skb(size, gfp_any());
1872 netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, ENOBUFS);
1875 if (rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0) < 0) {
1877 netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, EINVAL);
1880 NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_ROUTE;
1881 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_ROUTE, gfp_any());
1888 #ifdef CONFIG_PROC_FS
1890 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
1901 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
1903 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
1906 if (arg->skip < arg->offset / RT6_INFO_LEN) {
1911 if (arg->len >= arg->length)
1914 for (i=0; i<16; i++) {
1915 sprintf(arg->buffer + arg->len, "%02x",
1916 rt->rt6i_dst.addr.s6_addr[i]);
1919 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
1922 #ifdef CONFIG_IPV6_SUBTREES
1923 for (i=0; i<16; i++) {
1924 sprintf(arg->buffer + arg->len, "%02x",
1925 rt->rt6i_src.addr.s6_addr[i]);
1928 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
1931 sprintf(arg->buffer + arg->len,
1932 "00000000000000000000000000000000 00 ");
1936 if (rt->rt6i_nexthop) {
1937 for (i=0; i<16; i++) {
1938 sprintf(arg->buffer + arg->len, "%02x",
1939 rt->rt6i_nexthop->primary_key[i]);
1943 sprintf(arg->buffer + arg->len,
1944 "00000000000000000000000000000000");
1947 arg->len += sprintf(arg->buffer + arg->len,
1948 " %08x %08x %08x %08x %8s\n",
1949 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
1950 rt->u.dst.__use, rt->rt6i_flags,
1951 rt->rt6i_dev ? rt->rt6i_dev->name : "");
1955 static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
1957 struct rt6_proc_arg arg;
1958 arg.buffer = buffer;
1959 arg.offset = offset;
1960 arg.length = length;
1964 read_lock_bh(&rt6_lock);
1965 fib6_clean_tree(&ip6_routing_table, rt6_info_route, 0, &arg);
1966 read_unlock_bh(&rt6_lock);
1970 *start += offset % RT6_INFO_LEN;
1972 arg.len -= offset % RT6_INFO_LEN;
1974 if (arg.len > length)
1982 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
1984 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
1985 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
1986 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
1987 rt6_stats.fib_rt_cache,
1988 atomic_read(&ip6_dst_ops.entries),
1989 rt6_stats.fib_discarded_routes);
1994 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
1996 return single_open(file, rt6_stats_seq_show, NULL);
1999 static struct file_operations rt6_stats_seq_fops = {
2000 .owner = THIS_MODULE,
2001 .open = rt6_stats_seq_open,
2003 .llseek = seq_lseek,
2004 .release = single_release,
2006 #endif /* CONFIG_PROC_FS */
2008 #ifdef CONFIG_SYSCTL
2010 static int flush_delay;
2013 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2014 void __user *buffer, size_t *lenp, loff_t *ppos)
2017 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2018 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2024 ctl_table ipv6_route_table[] = {
2026 .ctl_name = NET_IPV6_ROUTE_FLUSH,
2027 .procname = "flush",
2028 .data = &flush_delay,
2029 .maxlen = sizeof(int),
2031 .proc_handler = &ipv6_sysctl_rtcache_flush
2034 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2035 .procname = "gc_thresh",
2036 .data = &ip6_dst_ops.gc_thresh,
2037 .maxlen = sizeof(int),
2039 .proc_handler = &proc_dointvec,
2042 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2043 .procname = "max_size",
2044 .data = &ip6_rt_max_size,
2045 .maxlen = sizeof(int),
2047 .proc_handler = &proc_dointvec,
2050 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2051 .procname = "gc_min_interval",
2052 .data = &ip6_rt_gc_min_interval,
2053 .maxlen = sizeof(int),
2055 .proc_handler = &proc_dointvec_jiffies,
2056 .strategy = &sysctl_jiffies,
2059 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2060 .procname = "gc_timeout",
2061 .data = &ip6_rt_gc_timeout,
2062 .maxlen = sizeof(int),
2064 .proc_handler = &proc_dointvec_jiffies,
2065 .strategy = &sysctl_jiffies,
2068 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2069 .procname = "gc_interval",
2070 .data = &ip6_rt_gc_interval,
2071 .maxlen = sizeof(int),
2073 .proc_handler = &proc_dointvec_jiffies,
2074 .strategy = &sysctl_jiffies,
2077 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2078 .procname = "gc_elasticity",
2079 .data = &ip6_rt_gc_elasticity,
2080 .maxlen = sizeof(int),
2082 .proc_handler = &proc_dointvec_jiffies,
2083 .strategy = &sysctl_jiffies,
2086 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2087 .procname = "mtu_expires",
2088 .data = &ip6_rt_mtu_expires,
2089 .maxlen = sizeof(int),
2091 .proc_handler = &proc_dointvec_jiffies,
2092 .strategy = &sysctl_jiffies,
2095 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2096 .procname = "min_adv_mss",
2097 .data = &ip6_rt_min_advmss,
2098 .maxlen = sizeof(int),
2100 .proc_handler = &proc_dointvec_jiffies,
2101 .strategy = &sysctl_jiffies,
2104 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2105 .procname = "gc_min_interval_ms",
2106 .data = &ip6_rt_gc_min_interval,
2107 .maxlen = sizeof(int),
2109 .proc_handler = &proc_dointvec_ms_jiffies,
2110 .strategy = &sysctl_ms_jiffies,
2117 void __init ip6_route_init(void)
2119 struct proc_dir_entry *p;
2121 ip6_dst_ops.kmem_cachep = kmem_cache_create("ip6_dst_cache",
2122 sizeof(struct rt6_info),
2123 0, SLAB_HWCACHE_ALIGN,
2125 if (!ip6_dst_ops.kmem_cachep)
2126 panic("cannot create ip6_dst_cache");
2129 #ifdef CONFIG_PROC_FS
2130 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2132 p->owner = THIS_MODULE;
2134 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2141 void ip6_route_cleanup(void)
2143 #ifdef CONFIG_PROC_FS
2144 proc_net_remove("ipv6_route");
2145 proc_net_remove("rt6_stats");
2152 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);