11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Linux INET6 implementation 31da177e4SLinus Torvalds * FIB front-end. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Authors: 61da177e4SLinus Torvalds * Pedro Roque <roque@di.fc.ul.pt> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 91da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 101da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 111da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds /* Changes: 151da177e4SLinus Torvalds * 161da177e4SLinus Torvalds * YOSHIFUJI Hideaki @USAGI 171da177e4SLinus Torvalds * reworked default router selection. 181da177e4SLinus Torvalds * - respect outgoing interface 191da177e4SLinus Torvalds * - select from (probably) reachable routers (i.e. 201da177e4SLinus Torvalds * routers in REACHABLE, STALE, DELAY or PROBE states). 211da177e4SLinus Torvalds * - always select the same router if it is (probably) 221da177e4SLinus Torvalds * reachable. otherwise, round-robin the list. 23c0bece9fSYOSHIFUJI Hideaki * Ville Nuorvala 24c0bece9fSYOSHIFUJI Hideaki * Fixed routing subtrees. 251da177e4SLinus Torvalds */ 261da177e4SLinus Torvalds 274fc268d2SRandy Dunlap #include <linux/capability.h> 281da177e4SLinus Torvalds #include <linux/errno.h> 291da177e4SLinus Torvalds #include <linux/types.h> 301da177e4SLinus Torvalds #include <linux/times.h> 311da177e4SLinus Torvalds #include <linux/socket.h> 321da177e4SLinus Torvalds #include <linux/sockios.h> 331da177e4SLinus Torvalds #include <linux/net.h> 341da177e4SLinus Torvalds #include <linux/route.h> 351da177e4SLinus Torvalds #include <linux/netdevice.h> 361da177e4SLinus Torvalds #include <linux/in6.h> 377bc570c8SYOSHIFUJI Hideaki #include <linux/mroute6.h> 381da177e4SLinus Torvalds #include <linux/init.h> 391da177e4SLinus Torvalds #include <linux/if_arp.h> 401da177e4SLinus Torvalds #include <linux/proc_fs.h> 411da177e4SLinus Torvalds #include <linux/seq_file.h> 425b7c931dSDaniel Lezcano #include <linux/nsproxy.h> 435a0e3ad6STejun Heo #include <linux/slab.h> 44457c4cbcSEric W. Biederman #include <net/net_namespace.h> 451da177e4SLinus Torvalds #include <net/snmp.h> 461da177e4SLinus Torvalds #include <net/ipv6.h> 471da177e4SLinus Torvalds #include <net/ip6_fib.h> 481da177e4SLinus Torvalds #include <net/ip6_route.h> 491da177e4SLinus Torvalds #include <net/ndisc.h> 501da177e4SLinus Torvalds #include <net/addrconf.h> 511da177e4SLinus Torvalds #include <net/tcp.h> 521da177e4SLinus Torvalds #include <linux/rtnetlink.h> 531da177e4SLinus Torvalds #include <net/dst.h> 541da177e4SLinus Torvalds #include <net/xfrm.h> 558d71740cSTom Tucker #include <net/netevent.h> 5621713ebcSThomas Graf #include <net/netlink.h> 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds #include <asm/uaccess.h> 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 611da177e4SLinus Torvalds #include <linux/sysctl.h> 621da177e4SLinus Torvalds #endif 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* Set to 3 to get tracing. */ 651da177e4SLinus Torvalds #define RT6_DEBUG 2 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds #if RT6_DEBUG >= 3 681da177e4SLinus Torvalds #define RDBG(x) printk x 691da177e4SLinus Torvalds #define RT6_TRACE(x...) printk(KERN_DEBUG x) 701da177e4SLinus Torvalds #else 711da177e4SLinus Torvalds #define RDBG(x) 721da177e4SLinus Torvalds #define RT6_TRACE(x...) do { ; } while (0) 731da177e4SLinus Torvalds #endif 741da177e4SLinus Torvalds 75519fbd87SYOSHIFUJI Hideaki #define CLONE_OFFLINK_ROUTE 0 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds static struct rt6_info * ip6_rt_copy(struct rt6_info *ort); 781da177e4SLinus Torvalds static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie); 791da177e4SLinus Torvalds static struct dst_entry *ip6_negative_advice(struct dst_entry *); 801da177e4SLinus Torvalds static void ip6_dst_destroy(struct dst_entry *); 811da177e4SLinus Torvalds static void ip6_dst_ifdown(struct dst_entry *, 821da177e4SLinus Torvalds struct net_device *dev, int how); 83569d3645SDaniel Lezcano static int ip6_dst_gc(struct dst_ops *ops); 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds static int ip6_pkt_discard(struct sk_buff *skb); 861da177e4SLinus Torvalds static int ip6_pkt_discard_out(struct sk_buff *skb); 871da177e4SLinus Torvalds static void ip6_link_failure(struct sk_buff *skb); 881da177e4SLinus Torvalds static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu); 891da177e4SLinus Torvalds 9070ceb4f5SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO 91efa2cea0SDaniel Lezcano static struct rt6_info *rt6_add_route_info(struct net *net, 92efa2cea0SDaniel Lezcano struct in6_addr *prefix, int prefixlen, 9370ceb4f5SYOSHIFUJI Hideaki struct in6_addr *gwaddr, int ifindex, 9470ceb4f5SYOSHIFUJI Hideaki unsigned pref); 95efa2cea0SDaniel Lezcano static struct rt6_info *rt6_get_route_info(struct net *net, 96efa2cea0SDaniel Lezcano struct in6_addr *prefix, int prefixlen, 9770ceb4f5SYOSHIFUJI Hideaki struct in6_addr *gwaddr, int ifindex); 9870ceb4f5SYOSHIFUJI Hideaki #endif 9970ceb4f5SYOSHIFUJI Hideaki 1009a7ec3a9SDaniel Lezcano static struct dst_ops ip6_dst_ops_template = { 1011da177e4SLinus Torvalds .family = AF_INET6, 10209640e63SHarvey Harrison .protocol = cpu_to_be16(ETH_P_IPV6), 1031da177e4SLinus Torvalds .gc = ip6_dst_gc, 1041da177e4SLinus Torvalds .gc_thresh = 1024, 1051da177e4SLinus Torvalds .check = ip6_dst_check, 1061da177e4SLinus Torvalds .destroy = ip6_dst_destroy, 1071da177e4SLinus Torvalds .ifdown = ip6_dst_ifdown, 1081da177e4SLinus Torvalds .negative_advice = ip6_negative_advice, 1091da177e4SLinus Torvalds .link_failure = ip6_link_failure, 1101da177e4SLinus Torvalds .update_pmtu = ip6_rt_update_pmtu, 1111ac06e03SHerbert Xu .local_out = __ip6_local_out, 112e2422970SEric Dumazet .entries = ATOMIC_INIT(0), 1131da177e4SLinus Torvalds }; 1141da177e4SLinus Torvalds 11514e50e57SDavid S. Miller static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu) 11614e50e57SDavid S. Miller { 11714e50e57SDavid S. Miller } 11814e50e57SDavid S. Miller 11914e50e57SDavid S. Miller static struct dst_ops ip6_dst_blackhole_ops = { 12014e50e57SDavid S. Miller .family = AF_INET6, 12109640e63SHarvey Harrison .protocol = cpu_to_be16(ETH_P_IPV6), 12214e50e57SDavid S. Miller .destroy = ip6_dst_destroy, 12314e50e57SDavid S. Miller .check = ip6_dst_check, 12414e50e57SDavid S. Miller .update_pmtu = ip6_rt_blackhole_update_pmtu, 125e2422970SEric Dumazet .entries = ATOMIC_INIT(0), 12614e50e57SDavid S. Miller }; 12714e50e57SDavid S. Miller 128bdb3289fSDaniel Lezcano static struct rt6_info ip6_null_entry_template = { 1291da177e4SLinus Torvalds .dst = { 1301da177e4SLinus Torvalds .__refcnt = ATOMIC_INIT(1), 1311da177e4SLinus Torvalds .__use = 1, 1321da177e4SLinus Torvalds .obsolete = -1, 1331da177e4SLinus Torvalds .error = -ENETUNREACH, 1341da177e4SLinus Torvalds .metrics = { [RTAX_HOPLIMIT - 1] = 255, }, 1351da177e4SLinus Torvalds .input = ip6_pkt_discard, 1361da177e4SLinus Torvalds .output = ip6_pkt_discard_out, 1371da177e4SLinus Torvalds }, 1381da177e4SLinus Torvalds .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP), 1394f724279SJean-Mickael Guerin .rt6i_protocol = RTPROT_KERNEL, 1401da177e4SLinus Torvalds .rt6i_metric = ~(u32) 0, 1411da177e4SLinus Torvalds .rt6i_ref = ATOMIC_INIT(1), 1421da177e4SLinus Torvalds }; 1431da177e4SLinus Torvalds 144101367c2SThomas Graf #ifdef CONFIG_IPV6_MULTIPLE_TABLES 145101367c2SThomas Graf 1466723ab54SDavid S. Miller static int ip6_pkt_prohibit(struct sk_buff *skb); 1476723ab54SDavid S. Miller static int ip6_pkt_prohibit_out(struct sk_buff *skb); 1486723ab54SDavid S. Miller 149280a34c8SAdrian Bunk static struct rt6_info ip6_prohibit_entry_template = { 150101367c2SThomas Graf .dst = { 151101367c2SThomas Graf .__refcnt = ATOMIC_INIT(1), 152101367c2SThomas Graf .__use = 1, 153101367c2SThomas Graf .obsolete = -1, 154101367c2SThomas Graf .error = -EACCES, 155101367c2SThomas Graf .metrics = { [RTAX_HOPLIMIT - 1] = 255, }, 1569ce8ade0SThomas Graf .input = ip6_pkt_prohibit, 1579ce8ade0SThomas Graf .output = ip6_pkt_prohibit_out, 158101367c2SThomas Graf }, 159101367c2SThomas Graf .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP), 1604f724279SJean-Mickael Guerin .rt6i_protocol = RTPROT_KERNEL, 161101367c2SThomas Graf .rt6i_metric = ~(u32) 0, 162101367c2SThomas Graf .rt6i_ref = ATOMIC_INIT(1), 163101367c2SThomas Graf }; 164101367c2SThomas Graf 165bdb3289fSDaniel Lezcano static struct rt6_info ip6_blk_hole_entry_template = { 166101367c2SThomas Graf .dst = { 167101367c2SThomas Graf .__refcnt = ATOMIC_INIT(1), 168101367c2SThomas Graf .__use = 1, 169101367c2SThomas Graf .obsolete = -1, 170101367c2SThomas Graf .error = -EINVAL, 171101367c2SThomas Graf .metrics = { [RTAX_HOPLIMIT - 1] = 255, }, 172352e512cSHerbert Xu .input = dst_discard, 173352e512cSHerbert Xu .output = dst_discard, 174101367c2SThomas Graf }, 175101367c2SThomas Graf .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP), 1764f724279SJean-Mickael Guerin .rt6i_protocol = RTPROT_KERNEL, 177101367c2SThomas Graf .rt6i_metric = ~(u32) 0, 178101367c2SThomas Graf .rt6i_ref = ATOMIC_INIT(1), 179101367c2SThomas Graf }; 180101367c2SThomas Graf 181101367c2SThomas Graf #endif 182101367c2SThomas Graf 1831da177e4SLinus Torvalds /* allocate dst with ip6_dst_ops */ 184f2fc6a54SBenjamin Thery static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops) 1851da177e4SLinus Torvalds { 186f2fc6a54SBenjamin Thery return (struct rt6_info *)dst_alloc(ops); 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds static void ip6_dst_destroy(struct dst_entry *dst) 1901da177e4SLinus Torvalds { 1911da177e4SLinus Torvalds struct rt6_info *rt = (struct rt6_info *)dst; 1921da177e4SLinus Torvalds struct inet6_dev *idev = rt->rt6i_idev; 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds if (idev != NULL) { 1951da177e4SLinus Torvalds rt->rt6i_idev = NULL; 1961da177e4SLinus Torvalds in6_dev_put(idev); 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds } 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev, 2011da177e4SLinus Torvalds int how) 2021da177e4SLinus Torvalds { 2031da177e4SLinus Torvalds struct rt6_info *rt = (struct rt6_info *)dst; 2041da177e4SLinus Torvalds struct inet6_dev *idev = rt->rt6i_idev; 2055a3e55d6SDenis V. Lunev struct net_device *loopback_dev = 206c346dca1SYOSHIFUJI Hideaki dev_net(dev)->loopback_dev; 2071da177e4SLinus Torvalds 2085a3e55d6SDenis V. Lunev if (dev != loopback_dev && idev != NULL && idev->dev == dev) { 2095a3e55d6SDenis V. Lunev struct inet6_dev *loopback_idev = 2105a3e55d6SDenis V. Lunev in6_dev_get(loopback_dev); 2111da177e4SLinus Torvalds if (loopback_idev != NULL) { 2121da177e4SLinus Torvalds rt->rt6i_idev = loopback_idev; 2131da177e4SLinus Torvalds in6_dev_put(idev); 2141da177e4SLinus Torvalds } 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds static __inline__ int rt6_check_expired(const struct rt6_info *rt) 2191da177e4SLinus Torvalds { 2201da177e4SLinus Torvalds return (rt->rt6i_flags & RTF_EXPIRES && 2211da177e4SLinus Torvalds time_after(jiffies, rt->rt6i_expires)); 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 224c71099acSThomas Graf static inline int rt6_need_strict(struct in6_addr *daddr) 225c71099acSThomas Graf { 226c71099acSThomas Graf return (ipv6_addr_type(daddr) & 2275ce83afaSYOSHIFUJI Hideaki (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK)); 228c71099acSThomas Graf } 229c71099acSThomas Graf 2301da177e4SLinus Torvalds /* 231c71099acSThomas Graf * Route lookup. Any table->tb6_lock is implied. 2321da177e4SLinus Torvalds */ 2331da177e4SLinus Torvalds 2348ed67789SDaniel Lezcano static inline struct rt6_info *rt6_device_match(struct net *net, 2358ed67789SDaniel Lezcano struct rt6_info *rt, 236dd3abc4eSYOSHIFUJI Hideaki struct in6_addr *saddr, 2371da177e4SLinus Torvalds int oif, 238d420895eSYOSHIFUJI Hideaki int flags) 2391da177e4SLinus Torvalds { 2401da177e4SLinus Torvalds struct rt6_info *local = NULL; 2411da177e4SLinus Torvalds struct rt6_info *sprt; 2421da177e4SLinus Torvalds 243dd3abc4eSYOSHIFUJI Hideaki if (!oif && ipv6_addr_any(saddr)) 244dd3abc4eSYOSHIFUJI Hideaki goto out; 245dd3abc4eSYOSHIFUJI Hideaki 246d8d1f30bSChangli Gao for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) { 2471da177e4SLinus Torvalds struct net_device *dev = sprt->rt6i_dev; 248dd3abc4eSYOSHIFUJI Hideaki 249dd3abc4eSYOSHIFUJI Hideaki if (oif) { 2501da177e4SLinus Torvalds if (dev->ifindex == oif) 2511da177e4SLinus Torvalds return sprt; 2521da177e4SLinus Torvalds if (dev->flags & IFF_LOOPBACK) { 2531da177e4SLinus Torvalds if (sprt->rt6i_idev == NULL || 2541da177e4SLinus Torvalds sprt->rt6i_idev->dev->ifindex != oif) { 255d420895eSYOSHIFUJI Hideaki if (flags & RT6_LOOKUP_F_IFACE && oif) 2561da177e4SLinus Torvalds continue; 2571da177e4SLinus Torvalds if (local && (!oif || 2581da177e4SLinus Torvalds local->rt6i_idev->dev->ifindex == oif)) 2591da177e4SLinus Torvalds continue; 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds local = sprt; 2621da177e4SLinus Torvalds } 263dd3abc4eSYOSHIFUJI Hideaki } else { 264dd3abc4eSYOSHIFUJI Hideaki if (ipv6_chk_addr(net, saddr, dev, 265dd3abc4eSYOSHIFUJI Hideaki flags & RT6_LOOKUP_F_IFACE)) 266dd3abc4eSYOSHIFUJI Hideaki return sprt; 267dd3abc4eSYOSHIFUJI Hideaki } 2681da177e4SLinus Torvalds } 2691da177e4SLinus Torvalds 270dd3abc4eSYOSHIFUJI Hideaki if (oif) { 2711da177e4SLinus Torvalds if (local) 2721da177e4SLinus Torvalds return local; 2731da177e4SLinus Torvalds 274d420895eSYOSHIFUJI Hideaki if (flags & RT6_LOOKUP_F_IFACE) 2758ed67789SDaniel Lezcano return net->ipv6.ip6_null_entry; 2761da177e4SLinus Torvalds } 277dd3abc4eSYOSHIFUJI Hideaki out: 2781da177e4SLinus Torvalds return rt; 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 28127097255SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 28227097255SYOSHIFUJI Hideaki static void rt6_probe(struct rt6_info *rt) 28327097255SYOSHIFUJI Hideaki { 28427097255SYOSHIFUJI Hideaki struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL; 28527097255SYOSHIFUJI Hideaki /* 28627097255SYOSHIFUJI Hideaki * Okay, this does not seem to be appropriate 28727097255SYOSHIFUJI Hideaki * for now, however, we need to check if it 28827097255SYOSHIFUJI Hideaki * is really so; aka Router Reachability Probing. 28927097255SYOSHIFUJI Hideaki * 29027097255SYOSHIFUJI Hideaki * Router Reachability Probe MUST be rate-limited 29127097255SYOSHIFUJI Hideaki * to no more than one per minute. 29227097255SYOSHIFUJI Hideaki */ 29327097255SYOSHIFUJI Hideaki if (!neigh || (neigh->nud_state & NUD_VALID)) 29427097255SYOSHIFUJI Hideaki return; 29527097255SYOSHIFUJI Hideaki read_lock_bh(&neigh->lock); 29627097255SYOSHIFUJI Hideaki if (!(neigh->nud_state & NUD_VALID) && 29752e16356SYOSHIFUJI Hideaki time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) { 29827097255SYOSHIFUJI Hideaki struct in6_addr mcaddr; 29927097255SYOSHIFUJI Hideaki struct in6_addr *target; 30027097255SYOSHIFUJI Hideaki 30127097255SYOSHIFUJI Hideaki neigh->updated = jiffies; 30227097255SYOSHIFUJI Hideaki read_unlock_bh(&neigh->lock); 30327097255SYOSHIFUJI Hideaki 30427097255SYOSHIFUJI Hideaki target = (struct in6_addr *)&neigh->primary_key; 30527097255SYOSHIFUJI Hideaki addrconf_addr_solict_mult(target, &mcaddr); 30627097255SYOSHIFUJI Hideaki ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL); 30727097255SYOSHIFUJI Hideaki } else 30827097255SYOSHIFUJI Hideaki read_unlock_bh(&neigh->lock); 30927097255SYOSHIFUJI Hideaki } 31027097255SYOSHIFUJI Hideaki #else 31127097255SYOSHIFUJI Hideaki static inline void rt6_probe(struct rt6_info *rt) 31227097255SYOSHIFUJI Hideaki { 31327097255SYOSHIFUJI Hideaki } 31427097255SYOSHIFUJI Hideaki #endif 31527097255SYOSHIFUJI Hideaki 3161da177e4SLinus Torvalds /* 317554cfb7eSYOSHIFUJI Hideaki * Default Router Selection (RFC 2461 6.3.6) 3181da177e4SLinus Torvalds */ 319b6f99a21SDave Jones static inline int rt6_check_dev(struct rt6_info *rt, int oif) 3201da177e4SLinus Torvalds { 321554cfb7eSYOSHIFUJI Hideaki struct net_device *dev = rt->rt6i_dev; 322161980f4SDavid S. Miller if (!oif || dev->ifindex == oif) 323554cfb7eSYOSHIFUJI Hideaki return 2; 324161980f4SDavid S. Miller if ((dev->flags & IFF_LOOPBACK) && 325161980f4SDavid S. Miller rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif) 326161980f4SDavid S. Miller return 1; 327554cfb7eSYOSHIFUJI Hideaki return 0; 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds 330b6f99a21SDave Jones static inline int rt6_check_neigh(struct rt6_info *rt) 3311da177e4SLinus Torvalds { 332554cfb7eSYOSHIFUJI Hideaki struct neighbour *neigh = rt->rt6i_nexthop; 333398bcbebSYOSHIFUJI Hideaki int m; 3344d0c5911SYOSHIFUJI Hideaki if (rt->rt6i_flags & RTF_NONEXTHOP || 3354d0c5911SYOSHIFUJI Hideaki !(rt->rt6i_flags & RTF_GATEWAY)) 3364d0c5911SYOSHIFUJI Hideaki m = 1; 3374d0c5911SYOSHIFUJI Hideaki else if (neigh) { 3381da177e4SLinus Torvalds read_lock_bh(&neigh->lock); 339554cfb7eSYOSHIFUJI Hideaki if (neigh->nud_state & NUD_VALID) 3404d0c5911SYOSHIFUJI Hideaki m = 2; 341398bcbebSYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 342398bcbebSYOSHIFUJI Hideaki else if (neigh->nud_state & NUD_FAILED) 343398bcbebSYOSHIFUJI Hideaki m = 0; 344398bcbebSYOSHIFUJI Hideaki #endif 345398bcbebSYOSHIFUJI Hideaki else 346ea73ee23SYOSHIFUJI Hideaki m = 1; 3471da177e4SLinus Torvalds read_unlock_bh(&neigh->lock); 348398bcbebSYOSHIFUJI Hideaki } else 349398bcbebSYOSHIFUJI Hideaki m = 0; 350554cfb7eSYOSHIFUJI Hideaki return m; 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds 353554cfb7eSYOSHIFUJI Hideaki static int rt6_score_route(struct rt6_info *rt, int oif, 354554cfb7eSYOSHIFUJI Hideaki int strict) 355554cfb7eSYOSHIFUJI Hideaki { 3564d0c5911SYOSHIFUJI Hideaki int m, n; 3574d0c5911SYOSHIFUJI Hideaki 3584d0c5911SYOSHIFUJI Hideaki m = rt6_check_dev(rt, oif); 35977d16f45SYOSHIFUJI Hideaki if (!m && (strict & RT6_LOOKUP_F_IFACE)) 360554cfb7eSYOSHIFUJI Hideaki return -1; 361ebacaaa0SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 362ebacaaa0SYOSHIFUJI Hideaki m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2; 363ebacaaa0SYOSHIFUJI Hideaki #endif 3644d0c5911SYOSHIFUJI Hideaki n = rt6_check_neigh(rt); 365557e92efSYOSHIFUJI Hideaki if (!n && (strict & RT6_LOOKUP_F_REACHABLE)) 366554cfb7eSYOSHIFUJI Hideaki return -1; 367554cfb7eSYOSHIFUJI Hideaki return m; 368554cfb7eSYOSHIFUJI Hideaki } 369554cfb7eSYOSHIFUJI Hideaki 370f11e6659SDavid S. Miller static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict, 371f11e6659SDavid S. Miller int *mpri, struct rt6_info *match) 372554cfb7eSYOSHIFUJI Hideaki { 373554cfb7eSYOSHIFUJI Hideaki int m; 374554cfb7eSYOSHIFUJI Hideaki 375554cfb7eSYOSHIFUJI Hideaki if (rt6_check_expired(rt)) 376f11e6659SDavid S. Miller goto out; 377554cfb7eSYOSHIFUJI Hideaki 378554cfb7eSYOSHIFUJI Hideaki m = rt6_score_route(rt, oif, strict); 379554cfb7eSYOSHIFUJI Hideaki if (m < 0) 380f11e6659SDavid S. Miller goto out; 381554cfb7eSYOSHIFUJI Hideaki 382f11e6659SDavid S. Miller if (m > *mpri) { 383ea659e07SYOSHIFUJI Hideaki if (strict & RT6_LOOKUP_F_REACHABLE) 38427097255SYOSHIFUJI Hideaki rt6_probe(match); 385f11e6659SDavid S. Miller *mpri = m; 386554cfb7eSYOSHIFUJI Hideaki match = rt; 387ea659e07SYOSHIFUJI Hideaki } else if (strict & RT6_LOOKUP_F_REACHABLE) { 38827097255SYOSHIFUJI Hideaki rt6_probe(rt); 3891da177e4SLinus Torvalds } 390f11e6659SDavid S. Miller 391f11e6659SDavid S. Miller out: 392f11e6659SDavid S. Miller return match; 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds 395f11e6659SDavid S. Miller static struct rt6_info *find_rr_leaf(struct fib6_node *fn, 396f11e6659SDavid S. Miller struct rt6_info *rr_head, 397f11e6659SDavid S. Miller u32 metric, int oif, int strict) 398f11e6659SDavid S. Miller { 399f11e6659SDavid S. Miller struct rt6_info *rt, *match; 400f11e6659SDavid S. Miller int mpri = -1; 401f11e6659SDavid S. Miller 402f11e6659SDavid S. Miller match = NULL; 403f11e6659SDavid S. Miller for (rt = rr_head; rt && rt->rt6i_metric == metric; 404d8d1f30bSChangli Gao rt = rt->dst.rt6_next) 405f11e6659SDavid S. Miller match = find_match(rt, oif, strict, &mpri, match); 406f11e6659SDavid S. Miller for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric; 407d8d1f30bSChangli Gao rt = rt->dst.rt6_next) 408f11e6659SDavid S. Miller match = find_match(rt, oif, strict, &mpri, match); 409f11e6659SDavid S. Miller 410f11e6659SDavid S. Miller return match; 411f11e6659SDavid S. Miller } 412f11e6659SDavid S. Miller 413f11e6659SDavid S. Miller static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict) 414f11e6659SDavid S. Miller { 415f11e6659SDavid S. Miller struct rt6_info *match, *rt0; 4168ed67789SDaniel Lezcano struct net *net; 417f11e6659SDavid S. Miller 418f11e6659SDavid S. Miller RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n", 4190dc47877SHarvey Harrison __func__, fn->leaf, oif); 420f11e6659SDavid S. Miller 421f11e6659SDavid S. Miller rt0 = fn->rr_ptr; 422f11e6659SDavid S. Miller if (!rt0) 423f11e6659SDavid S. Miller fn->rr_ptr = rt0 = fn->leaf; 424f11e6659SDavid S. Miller 425f11e6659SDavid S. Miller match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict); 426f11e6659SDavid S. Miller 427554cfb7eSYOSHIFUJI Hideaki if (!match && 428f11e6659SDavid S. Miller (strict & RT6_LOOKUP_F_REACHABLE)) { 429d8d1f30bSChangli Gao struct rt6_info *next = rt0->dst.rt6_next; 430f11e6659SDavid S. Miller 431554cfb7eSYOSHIFUJI Hideaki /* no entries matched; do round-robin */ 432f11e6659SDavid S. Miller if (!next || next->rt6i_metric != rt0->rt6i_metric) 433f11e6659SDavid S. Miller next = fn->leaf; 434f11e6659SDavid S. Miller 435f11e6659SDavid S. Miller if (next != rt0) 436f11e6659SDavid S. Miller fn->rr_ptr = next; 437554cfb7eSYOSHIFUJI Hideaki } 438554cfb7eSYOSHIFUJI Hideaki 439f11e6659SDavid S. Miller RT6_TRACE("%s() => %p\n", 4400dc47877SHarvey Harrison __func__, match); 441554cfb7eSYOSHIFUJI Hideaki 442c346dca1SYOSHIFUJI Hideaki net = dev_net(rt0->rt6i_dev); 4438ed67789SDaniel Lezcano return (match ? match : net->ipv6.ip6_null_entry); 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds 44670ceb4f5SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO 44770ceb4f5SYOSHIFUJI Hideaki int rt6_route_rcv(struct net_device *dev, u8 *opt, int len, 44870ceb4f5SYOSHIFUJI Hideaki struct in6_addr *gwaddr) 44970ceb4f5SYOSHIFUJI Hideaki { 450c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 45170ceb4f5SYOSHIFUJI Hideaki struct route_info *rinfo = (struct route_info *) opt; 45270ceb4f5SYOSHIFUJI Hideaki struct in6_addr prefix_buf, *prefix; 45370ceb4f5SYOSHIFUJI Hideaki unsigned int pref; 4544bed72e4SYOSHIFUJI Hideaki unsigned long lifetime; 45570ceb4f5SYOSHIFUJI Hideaki struct rt6_info *rt; 45670ceb4f5SYOSHIFUJI Hideaki 45770ceb4f5SYOSHIFUJI Hideaki if (len < sizeof(struct route_info)) { 45870ceb4f5SYOSHIFUJI Hideaki return -EINVAL; 45970ceb4f5SYOSHIFUJI Hideaki } 46070ceb4f5SYOSHIFUJI Hideaki 46170ceb4f5SYOSHIFUJI Hideaki /* Sanity check for prefix_len and length */ 46270ceb4f5SYOSHIFUJI Hideaki if (rinfo->length > 3) { 46370ceb4f5SYOSHIFUJI Hideaki return -EINVAL; 46470ceb4f5SYOSHIFUJI Hideaki } else if (rinfo->prefix_len > 128) { 46570ceb4f5SYOSHIFUJI Hideaki return -EINVAL; 46670ceb4f5SYOSHIFUJI Hideaki } else if (rinfo->prefix_len > 64) { 46770ceb4f5SYOSHIFUJI Hideaki if (rinfo->length < 2) { 46870ceb4f5SYOSHIFUJI Hideaki return -EINVAL; 46970ceb4f5SYOSHIFUJI Hideaki } 47070ceb4f5SYOSHIFUJI Hideaki } else if (rinfo->prefix_len > 0) { 47170ceb4f5SYOSHIFUJI Hideaki if (rinfo->length < 1) { 47270ceb4f5SYOSHIFUJI Hideaki return -EINVAL; 47370ceb4f5SYOSHIFUJI Hideaki } 47470ceb4f5SYOSHIFUJI Hideaki } 47570ceb4f5SYOSHIFUJI Hideaki 47670ceb4f5SYOSHIFUJI Hideaki pref = rinfo->route_pref; 47770ceb4f5SYOSHIFUJI Hideaki if (pref == ICMPV6_ROUTER_PREF_INVALID) 4783933fc95SJens Rosenboom return -EINVAL; 47970ceb4f5SYOSHIFUJI Hideaki 4804bed72e4SYOSHIFUJI Hideaki lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ); 48170ceb4f5SYOSHIFUJI Hideaki 48270ceb4f5SYOSHIFUJI Hideaki if (rinfo->length == 3) 48370ceb4f5SYOSHIFUJI Hideaki prefix = (struct in6_addr *)rinfo->prefix; 48470ceb4f5SYOSHIFUJI Hideaki else { 48570ceb4f5SYOSHIFUJI Hideaki /* this function is safe */ 48670ceb4f5SYOSHIFUJI Hideaki ipv6_addr_prefix(&prefix_buf, 48770ceb4f5SYOSHIFUJI Hideaki (struct in6_addr *)rinfo->prefix, 48870ceb4f5SYOSHIFUJI Hideaki rinfo->prefix_len); 48970ceb4f5SYOSHIFUJI Hideaki prefix = &prefix_buf; 49070ceb4f5SYOSHIFUJI Hideaki } 49170ceb4f5SYOSHIFUJI Hideaki 492efa2cea0SDaniel Lezcano rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr, 493efa2cea0SDaniel Lezcano dev->ifindex); 49470ceb4f5SYOSHIFUJI Hideaki 49570ceb4f5SYOSHIFUJI Hideaki if (rt && !lifetime) { 496e0a1ad73SThomas Graf ip6_del_rt(rt); 49770ceb4f5SYOSHIFUJI Hideaki rt = NULL; 49870ceb4f5SYOSHIFUJI Hideaki } 49970ceb4f5SYOSHIFUJI Hideaki 50070ceb4f5SYOSHIFUJI Hideaki if (!rt && lifetime) 501efa2cea0SDaniel Lezcano rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex, 50270ceb4f5SYOSHIFUJI Hideaki pref); 50370ceb4f5SYOSHIFUJI Hideaki else if (rt) 50470ceb4f5SYOSHIFUJI Hideaki rt->rt6i_flags = RTF_ROUTEINFO | 50570ceb4f5SYOSHIFUJI Hideaki (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref); 50670ceb4f5SYOSHIFUJI Hideaki 50770ceb4f5SYOSHIFUJI Hideaki if (rt) { 5084bed72e4SYOSHIFUJI Hideaki if (!addrconf_finite_timeout(lifetime)) { 50970ceb4f5SYOSHIFUJI Hideaki rt->rt6i_flags &= ~RTF_EXPIRES; 51070ceb4f5SYOSHIFUJI Hideaki } else { 51170ceb4f5SYOSHIFUJI Hideaki rt->rt6i_expires = jiffies + HZ * lifetime; 51270ceb4f5SYOSHIFUJI Hideaki rt->rt6i_flags |= RTF_EXPIRES; 51370ceb4f5SYOSHIFUJI Hideaki } 514d8d1f30bSChangli Gao dst_release(&rt->dst); 51570ceb4f5SYOSHIFUJI Hideaki } 51670ceb4f5SYOSHIFUJI Hideaki return 0; 51770ceb4f5SYOSHIFUJI Hideaki } 51870ceb4f5SYOSHIFUJI Hideaki #endif 51970ceb4f5SYOSHIFUJI Hideaki 5208ed67789SDaniel Lezcano #define BACKTRACK(__net, saddr) \ 521982f56f3SYOSHIFUJI Hideaki do { \ 5228ed67789SDaniel Lezcano if (rt == __net->ipv6.ip6_null_entry) { \ 523982f56f3SYOSHIFUJI Hideaki struct fib6_node *pn; \ 524e0eda7bbSVille Nuorvala while (1) { \ 525982f56f3SYOSHIFUJI Hideaki if (fn->fn_flags & RTN_TL_ROOT) \ 526c71099acSThomas Graf goto out; \ 527982f56f3SYOSHIFUJI Hideaki pn = fn->parent; \ 528982f56f3SYOSHIFUJI Hideaki if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \ 5298bce65b9SKim Nordlund fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \ 530982f56f3SYOSHIFUJI Hideaki else \ 531982f56f3SYOSHIFUJI Hideaki fn = pn; \ 532c71099acSThomas Graf if (fn->fn_flags & RTN_RTINFO) \ 533c71099acSThomas Graf goto restart; \ 534c71099acSThomas Graf } \ 535982f56f3SYOSHIFUJI Hideaki } \ 536982f56f3SYOSHIFUJI Hideaki } while(0) 537c71099acSThomas Graf 5388ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route_lookup(struct net *net, 5398ed67789SDaniel Lezcano struct fib6_table *table, 540c71099acSThomas Graf struct flowi *fl, int flags) 5411da177e4SLinus Torvalds { 5421da177e4SLinus Torvalds struct fib6_node *fn; 5431da177e4SLinus Torvalds struct rt6_info *rt; 5441da177e4SLinus Torvalds 545c71099acSThomas Graf read_lock_bh(&table->tb6_lock); 546c71099acSThomas Graf fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src); 547c71099acSThomas Graf restart: 548c71099acSThomas Graf rt = fn->leaf; 549dd3abc4eSYOSHIFUJI Hideaki rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags); 5508ed67789SDaniel Lezcano BACKTRACK(net, &fl->fl6_src); 551c71099acSThomas Graf out: 552d8d1f30bSChangli Gao dst_use(&rt->dst, jiffies); 553c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 5541da177e4SLinus Torvalds return rt; 555c71099acSThomas Graf 556c71099acSThomas Graf } 557c71099acSThomas Graf 5589acd9f3aSYOSHIFUJI Hideaki struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr, 5599acd9f3aSYOSHIFUJI Hideaki const struct in6_addr *saddr, int oif, int strict) 560c71099acSThomas Graf { 561c71099acSThomas Graf struct flowi fl = { 562c71099acSThomas Graf .oif = oif, 563c71099acSThomas Graf .nl_u = { 564c71099acSThomas Graf .ip6_u = { 565c71099acSThomas Graf .daddr = *daddr, 566c71099acSThomas Graf }, 567c71099acSThomas Graf }, 568c71099acSThomas Graf }; 569c71099acSThomas Graf struct dst_entry *dst; 57077d16f45SYOSHIFUJI Hideaki int flags = strict ? RT6_LOOKUP_F_IFACE : 0; 571c71099acSThomas Graf 572adaa70bbSThomas Graf if (saddr) { 573adaa70bbSThomas Graf memcpy(&fl.fl6_src, saddr, sizeof(*saddr)); 574adaa70bbSThomas Graf flags |= RT6_LOOKUP_F_HAS_SADDR; 575adaa70bbSThomas Graf } 576adaa70bbSThomas Graf 577606a2b48SDaniel Lezcano dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup); 578c71099acSThomas Graf if (dst->error == 0) 579c71099acSThomas Graf return (struct rt6_info *) dst; 580c71099acSThomas Graf 581c71099acSThomas Graf dst_release(dst); 582c71099acSThomas Graf 5831da177e4SLinus Torvalds return NULL; 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds 5867159039aSYOSHIFUJI Hideaki EXPORT_SYMBOL(rt6_lookup); 5877159039aSYOSHIFUJI Hideaki 588c71099acSThomas Graf /* ip6_ins_rt is called with FREE table->tb6_lock. 5891da177e4SLinus Torvalds It takes new route entry, the addition fails by any reason the 5901da177e4SLinus Torvalds route is freed. In any case, if caller does not hold it, it may 5911da177e4SLinus Torvalds be destroyed. 5921da177e4SLinus Torvalds */ 5931da177e4SLinus Torvalds 59486872cb5SThomas Graf static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info) 5951da177e4SLinus Torvalds { 5961da177e4SLinus Torvalds int err; 597c71099acSThomas Graf struct fib6_table *table; 5981da177e4SLinus Torvalds 599c71099acSThomas Graf table = rt->rt6i_table; 600c71099acSThomas Graf write_lock_bh(&table->tb6_lock); 60186872cb5SThomas Graf err = fib6_add(&table->tb6_root, rt, info); 602c71099acSThomas Graf write_unlock_bh(&table->tb6_lock); 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds return err; 6051da177e4SLinus Torvalds } 6061da177e4SLinus Torvalds 60740e22e8fSThomas Graf int ip6_ins_rt(struct rt6_info *rt) 60840e22e8fSThomas Graf { 6094d1169c1SDenis V. Lunev struct nl_info info = { 610c346dca1SYOSHIFUJI Hideaki .nl_net = dev_net(rt->rt6i_dev), 6114d1169c1SDenis V. Lunev }; 612528c4cebSDenis V. Lunev return __ip6_ins_rt(rt, &info); 61340e22e8fSThomas Graf } 61440e22e8fSThomas Graf 61595a9a5baSYOSHIFUJI Hideaki static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr, 61695a9a5baSYOSHIFUJI Hideaki struct in6_addr *saddr) 6171da177e4SLinus Torvalds { 6181da177e4SLinus Torvalds struct rt6_info *rt; 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds /* 6211da177e4SLinus Torvalds * Clone the route. 6221da177e4SLinus Torvalds */ 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds rt = ip6_rt_copy(ort); 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds if (rt) { 62714deae41SDavid S. Miller struct neighbour *neigh; 62814deae41SDavid S. Miller int attempts = !in_softirq(); 62914deae41SDavid S. Miller 63058c4fb86SYOSHIFUJI Hideaki if (!(rt->rt6i_flags&RTF_GATEWAY)) { 63158c4fb86SYOSHIFUJI Hideaki if (rt->rt6i_dst.plen != 128 && 63258c4fb86SYOSHIFUJI Hideaki ipv6_addr_equal(&rt->rt6i_dst.addr, daddr)) 63358c4fb86SYOSHIFUJI Hideaki rt->rt6i_flags |= RTF_ANYCAST; 6341da177e4SLinus Torvalds ipv6_addr_copy(&rt->rt6i_gateway, daddr); 63558c4fb86SYOSHIFUJI Hideaki } 6361da177e4SLinus Torvalds 63758c4fb86SYOSHIFUJI Hideaki ipv6_addr_copy(&rt->rt6i_dst.addr, daddr); 6381da177e4SLinus Torvalds rt->rt6i_dst.plen = 128; 6391da177e4SLinus Torvalds rt->rt6i_flags |= RTF_CACHE; 640d8d1f30bSChangli Gao rt->dst.flags |= DST_HOST; 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES 6431da177e4SLinus Torvalds if (rt->rt6i_src.plen && saddr) { 6441da177e4SLinus Torvalds ipv6_addr_copy(&rt->rt6i_src.addr, saddr); 6451da177e4SLinus Torvalds rt->rt6i_src.plen = 128; 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds #endif 6481da177e4SLinus Torvalds 64914deae41SDavid S. Miller retry: 65014deae41SDavid S. Miller neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway); 65114deae41SDavid S. Miller if (IS_ERR(neigh)) { 65214deae41SDavid S. Miller struct net *net = dev_net(rt->rt6i_dev); 65314deae41SDavid S. Miller int saved_rt_min_interval = 65414deae41SDavid S. Miller net->ipv6.sysctl.ip6_rt_gc_min_interval; 65514deae41SDavid S. Miller int saved_rt_elasticity = 65614deae41SDavid S. Miller net->ipv6.sysctl.ip6_rt_gc_elasticity; 65714deae41SDavid S. Miller 65814deae41SDavid S. Miller if (attempts-- > 0) { 65914deae41SDavid S. Miller net->ipv6.sysctl.ip6_rt_gc_elasticity = 1; 66014deae41SDavid S. Miller net->ipv6.sysctl.ip6_rt_gc_min_interval = 0; 66114deae41SDavid S. Miller 66286393e52SAlexey Dobriyan ip6_dst_gc(&net->ipv6.ip6_dst_ops); 66314deae41SDavid S. Miller 66414deae41SDavid S. Miller net->ipv6.sysctl.ip6_rt_gc_elasticity = 66514deae41SDavid S. Miller saved_rt_elasticity; 66614deae41SDavid S. Miller net->ipv6.sysctl.ip6_rt_gc_min_interval = 66714deae41SDavid S. Miller saved_rt_min_interval; 66814deae41SDavid S. Miller goto retry; 66914deae41SDavid S. Miller } 67014deae41SDavid S. Miller 67114deae41SDavid S. Miller if (net_ratelimit()) 67214deae41SDavid S. Miller printk(KERN_WARNING 67314deae41SDavid S. Miller "Neighbour table overflow.\n"); 674d8d1f30bSChangli Gao dst_free(&rt->dst); 67514deae41SDavid S. Miller return NULL; 67614deae41SDavid S. Miller } 67714deae41SDavid S. Miller rt->rt6i_nexthop = neigh; 6781da177e4SLinus Torvalds 67995a9a5baSYOSHIFUJI Hideaki } 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds return rt; 6821da177e4SLinus Torvalds } 68395a9a5baSYOSHIFUJI Hideaki 684299d9939SYOSHIFUJI Hideaki static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr) 685299d9939SYOSHIFUJI Hideaki { 686299d9939SYOSHIFUJI Hideaki struct rt6_info *rt = ip6_rt_copy(ort); 687299d9939SYOSHIFUJI Hideaki if (rt) { 688299d9939SYOSHIFUJI Hideaki ipv6_addr_copy(&rt->rt6i_dst.addr, daddr); 689299d9939SYOSHIFUJI Hideaki rt->rt6i_dst.plen = 128; 690299d9939SYOSHIFUJI Hideaki rt->rt6i_flags |= RTF_CACHE; 691d8d1f30bSChangli Gao rt->dst.flags |= DST_HOST; 692299d9939SYOSHIFUJI Hideaki rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop); 693299d9939SYOSHIFUJI Hideaki } 694299d9939SYOSHIFUJI Hideaki return rt; 695299d9939SYOSHIFUJI Hideaki } 696299d9939SYOSHIFUJI Hideaki 6978ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif, 6988ce11e6aSAdrian Bunk struct flowi *fl, int flags) 6991da177e4SLinus Torvalds { 7001da177e4SLinus Torvalds struct fib6_node *fn; 701519fbd87SYOSHIFUJI Hideaki struct rt6_info *rt, *nrt; 702c71099acSThomas Graf int strict = 0; 7031da177e4SLinus Torvalds int attempts = 3; 704519fbd87SYOSHIFUJI Hideaki int err; 70553b7997fSYOSHIFUJI Hideaki int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE; 7061da177e4SLinus Torvalds 70777d16f45SYOSHIFUJI Hideaki strict |= flags & RT6_LOOKUP_F_IFACE; 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds relookup: 710c71099acSThomas Graf read_lock_bh(&table->tb6_lock); 7111da177e4SLinus Torvalds 7128238dd06SYOSHIFUJI Hideaki restart_2: 713c71099acSThomas Graf fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src); 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds restart: 7164acad72dSPavel Emelyanov rt = rt6_select(fn, oif, strict | reachable); 7178ed67789SDaniel Lezcano 7188ed67789SDaniel Lezcano BACKTRACK(net, &fl->fl6_src); 7198ed67789SDaniel Lezcano if (rt == net->ipv6.ip6_null_entry || 7208238dd06SYOSHIFUJI Hideaki rt->rt6i_flags & RTF_CACHE) 7211da177e4SLinus Torvalds goto out; 7221da177e4SLinus Torvalds 723d8d1f30bSChangli Gao dst_hold(&rt->dst); 724c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 7251da177e4SLinus Torvalds 726519fbd87SYOSHIFUJI Hideaki if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP)) 727e40cf353SYOSHIFUJI Hideaki nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src); 728519fbd87SYOSHIFUJI Hideaki else { 729519fbd87SYOSHIFUJI Hideaki #if CLONE_OFFLINK_ROUTE 730519fbd87SYOSHIFUJI Hideaki nrt = rt6_alloc_clone(rt, &fl->fl6_dst); 731519fbd87SYOSHIFUJI Hideaki #else 732519fbd87SYOSHIFUJI Hideaki goto out2; 733519fbd87SYOSHIFUJI Hideaki #endif 734519fbd87SYOSHIFUJI Hideaki } 7351da177e4SLinus Torvalds 736d8d1f30bSChangli Gao dst_release(&rt->dst); 7378ed67789SDaniel Lezcano rt = nrt ? : net->ipv6.ip6_null_entry; 7381da177e4SLinus Torvalds 739d8d1f30bSChangli Gao dst_hold(&rt->dst); 740e40cf353SYOSHIFUJI Hideaki if (nrt) { 74140e22e8fSThomas Graf err = ip6_ins_rt(nrt); 742e40cf353SYOSHIFUJI Hideaki if (!err) 743e40cf353SYOSHIFUJI Hideaki goto out2; 744e40cf353SYOSHIFUJI Hideaki } 745e40cf353SYOSHIFUJI Hideaki 746e40cf353SYOSHIFUJI Hideaki if (--attempts <= 0) 7471da177e4SLinus Torvalds goto out2; 7481da177e4SLinus Torvalds 749519fbd87SYOSHIFUJI Hideaki /* 750c71099acSThomas Graf * Race condition! In the gap, when table->tb6_lock was 751519fbd87SYOSHIFUJI Hideaki * released someone could insert this route. Relookup. 7521da177e4SLinus Torvalds */ 753d8d1f30bSChangli Gao dst_release(&rt->dst); 7541da177e4SLinus Torvalds goto relookup; 755e40cf353SYOSHIFUJI Hideaki 756519fbd87SYOSHIFUJI Hideaki out: 7578238dd06SYOSHIFUJI Hideaki if (reachable) { 7588238dd06SYOSHIFUJI Hideaki reachable = 0; 7598238dd06SYOSHIFUJI Hideaki goto restart_2; 7608238dd06SYOSHIFUJI Hideaki } 761d8d1f30bSChangli Gao dst_hold(&rt->dst); 762c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 7631da177e4SLinus Torvalds out2: 764d8d1f30bSChangli Gao rt->dst.lastuse = jiffies; 765d8d1f30bSChangli Gao rt->dst.__use++; 766c71099acSThomas Graf 767c71099acSThomas Graf return rt; 768c71099acSThomas Graf } 769c71099acSThomas Graf 7708ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table, 7714acad72dSPavel Emelyanov struct flowi *fl, int flags) 7724acad72dSPavel Emelyanov { 7738ed67789SDaniel Lezcano return ip6_pol_route(net, table, fl->iif, fl, flags); 7744acad72dSPavel Emelyanov } 7754acad72dSPavel Emelyanov 776c71099acSThomas Graf void ip6_route_input(struct sk_buff *skb) 777c71099acSThomas Graf { 7780660e03fSArnaldo Carvalho de Melo struct ipv6hdr *iph = ipv6_hdr(skb); 779c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(skb->dev); 780adaa70bbSThomas Graf int flags = RT6_LOOKUP_F_HAS_SADDR; 781c71099acSThomas Graf struct flowi fl = { 782c71099acSThomas Graf .iif = skb->dev->ifindex, 783c71099acSThomas Graf .nl_u = { 784c71099acSThomas Graf .ip6_u = { 785c71099acSThomas Graf .daddr = iph->daddr, 786c71099acSThomas Graf .saddr = iph->saddr, 78790bcaf7bSAl Viro .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK, 788c71099acSThomas Graf }, 789c71099acSThomas Graf }, 79047dcf0cbSThomas Graf .mark = skb->mark, 791c71099acSThomas Graf .proto = iph->nexthdr, 792c71099acSThomas Graf }; 793adaa70bbSThomas Graf 7941d6e55f1SThomas Goff if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG) 795adaa70bbSThomas Graf flags |= RT6_LOOKUP_F_IFACE; 796c71099acSThomas Graf 797adf30907SEric Dumazet skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input)); 798c71099acSThomas Graf } 799c71099acSThomas Graf 8008ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table, 801c71099acSThomas Graf struct flowi *fl, int flags) 802c71099acSThomas Graf { 8038ed67789SDaniel Lezcano return ip6_pol_route(net, table, fl->oif, fl, flags); 804c71099acSThomas Graf } 805c71099acSThomas Graf 8064591db4fSDaniel Lezcano struct dst_entry * ip6_route_output(struct net *net, struct sock *sk, 8074591db4fSDaniel Lezcano struct flowi *fl) 808c71099acSThomas Graf { 809c71099acSThomas Graf int flags = 0; 810c71099acSThomas Graf 8116057fd78SBrian Haley if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst)) 81277d16f45SYOSHIFUJI Hideaki flags |= RT6_LOOKUP_F_IFACE; 813c71099acSThomas Graf 814adaa70bbSThomas Graf if (!ipv6_addr_any(&fl->fl6_src)) 815adaa70bbSThomas Graf flags |= RT6_LOOKUP_F_HAS_SADDR; 8160c9a2ac1SYOSHIFUJI Hideaki / 吉藤英明 else if (sk) 8170c9a2ac1SYOSHIFUJI Hideaki / 吉藤英明 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs); 818adaa70bbSThomas Graf 8194591db4fSDaniel Lezcano return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output); 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds 8227159039aSYOSHIFUJI Hideaki EXPORT_SYMBOL(ip6_route_output); 8231da177e4SLinus Torvalds 82414e50e57SDavid S. Miller int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl) 82514e50e57SDavid S. Miller { 82614e50e57SDavid S. Miller struct rt6_info *ort = (struct rt6_info *) *dstp; 82714e50e57SDavid S. Miller struct rt6_info *rt = (struct rt6_info *) 82814e50e57SDavid S. Miller dst_alloc(&ip6_dst_blackhole_ops); 82914e50e57SDavid S. Miller struct dst_entry *new = NULL; 83014e50e57SDavid S. Miller 83114e50e57SDavid S. Miller if (rt) { 832d8d1f30bSChangli Gao new = &rt->dst; 83314e50e57SDavid S. Miller 83414e50e57SDavid S. Miller atomic_set(&new->__refcnt, 1); 83514e50e57SDavid S. Miller new->__use = 1; 836352e512cSHerbert Xu new->input = dst_discard; 837352e512cSHerbert Xu new->output = dst_discard; 83814e50e57SDavid S. Miller 839d8d1f30bSChangli Gao memcpy(new->metrics, ort->dst.metrics, RTAX_MAX*sizeof(u32)); 840d8d1f30bSChangli Gao new->dev = ort->dst.dev; 84114e50e57SDavid S. Miller if (new->dev) 84214e50e57SDavid S. Miller dev_hold(new->dev); 84314e50e57SDavid S. Miller rt->rt6i_idev = ort->rt6i_idev; 84414e50e57SDavid S. Miller if (rt->rt6i_idev) 84514e50e57SDavid S. Miller in6_dev_hold(rt->rt6i_idev); 84614e50e57SDavid S. Miller rt->rt6i_expires = 0; 84714e50e57SDavid S. Miller 84814e50e57SDavid S. Miller ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway); 84914e50e57SDavid S. Miller rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES; 85014e50e57SDavid S. Miller rt->rt6i_metric = 0; 85114e50e57SDavid S. Miller 85214e50e57SDavid S. Miller memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key)); 85314e50e57SDavid S. Miller #ifdef CONFIG_IPV6_SUBTREES 85414e50e57SDavid S. Miller memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key)); 85514e50e57SDavid S. Miller #endif 85614e50e57SDavid S. Miller 85714e50e57SDavid S. Miller dst_free(new); 85814e50e57SDavid S. Miller } 85914e50e57SDavid S. Miller 86014e50e57SDavid S. Miller dst_release(*dstp); 86114e50e57SDavid S. Miller *dstp = new; 86214e50e57SDavid S. Miller return (new ? 0 : -ENOMEM); 86314e50e57SDavid S. Miller } 86414e50e57SDavid S. Miller EXPORT_SYMBOL_GPL(ip6_dst_blackhole); 86514e50e57SDavid S. Miller 8661da177e4SLinus Torvalds /* 8671da177e4SLinus Torvalds * Destination cache support functions 8681da177e4SLinus Torvalds */ 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie) 8711da177e4SLinus Torvalds { 8721da177e4SLinus Torvalds struct rt6_info *rt; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds rt = (struct rt6_info *) dst; 8751da177e4SLinus Torvalds 87610414444SHerbert Xu if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie)) 8771da177e4SLinus Torvalds return dst; 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds return NULL; 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds static struct dst_entry *ip6_negative_advice(struct dst_entry *dst) 8831da177e4SLinus Torvalds { 8841da177e4SLinus Torvalds struct rt6_info *rt = (struct rt6_info *) dst; 8851da177e4SLinus Torvalds 8861da177e4SLinus Torvalds if (rt) { 88754c1a859SYOSHIFUJI Hideaki / 吉藤英明 if (rt->rt6i_flags & RTF_CACHE) { 88854c1a859SYOSHIFUJI Hideaki / 吉藤英明 if (rt6_check_expired(rt)) { 889e0a1ad73SThomas Graf ip6_del_rt(rt); 89054c1a859SYOSHIFUJI Hideaki / 吉藤英明 dst = NULL; 8911da177e4SLinus Torvalds } 89254c1a859SYOSHIFUJI Hideaki / 吉藤英明 } else { 89354c1a859SYOSHIFUJI Hideaki / 吉藤英明 dst_release(dst); 89454c1a859SYOSHIFUJI Hideaki / 吉藤英明 dst = NULL; 89554c1a859SYOSHIFUJI Hideaki / 吉藤英明 } 89654c1a859SYOSHIFUJI Hideaki / 吉藤英明 } 89754c1a859SYOSHIFUJI Hideaki / 吉藤英明 return dst; 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds static void ip6_link_failure(struct sk_buff *skb) 9011da177e4SLinus Torvalds { 9021da177e4SLinus Torvalds struct rt6_info *rt; 9031da177e4SLinus Torvalds 9043ffe533cSAlexey Dobriyan icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0); 9051da177e4SLinus Torvalds 906adf30907SEric Dumazet rt = (struct rt6_info *) skb_dst(skb); 9071da177e4SLinus Torvalds if (rt) { 9081da177e4SLinus Torvalds if (rt->rt6i_flags&RTF_CACHE) { 909d8d1f30bSChangli Gao dst_set_expires(&rt->dst, 0); 9101da177e4SLinus Torvalds rt->rt6i_flags |= RTF_EXPIRES; 9111da177e4SLinus Torvalds } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) 9121da177e4SLinus Torvalds rt->rt6i_node->fn_sernum = -1; 9131da177e4SLinus Torvalds } 9141da177e4SLinus Torvalds } 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu) 9171da177e4SLinus Torvalds { 9181da177e4SLinus Torvalds struct rt6_info *rt6 = (struct rt6_info*)dst; 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) { 9211da177e4SLinus Torvalds rt6->rt6i_flags |= RTF_MODIFIED; 9221da177e4SLinus Torvalds if (mtu < IPV6_MIN_MTU) { 9231da177e4SLinus Torvalds mtu = IPV6_MIN_MTU; 9241da177e4SLinus Torvalds dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds dst->metrics[RTAX_MTU-1] = mtu; 9278d71740cSTom Tucker call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst); 9281da177e4SLinus Torvalds } 9291da177e4SLinus Torvalds } 9301da177e4SLinus Torvalds 9311da177e4SLinus Torvalds static int ipv6_get_mtu(struct net_device *dev); 9321da177e4SLinus Torvalds 9335578689aSDaniel Lezcano static inline unsigned int ipv6_advmss(struct net *net, unsigned int mtu) 9341da177e4SLinus Torvalds { 9351da177e4SLinus Torvalds mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr); 9361da177e4SLinus Torvalds 9375578689aSDaniel Lezcano if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss) 9385578689aSDaniel Lezcano mtu = net->ipv6.sysctl.ip6_rt_min_advmss; 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds /* 9411da177e4SLinus Torvalds * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and 9421da177e4SLinus Torvalds * corresponding MSS is IPV6_MAXPLEN - tcp_header_size. 9431da177e4SLinus Torvalds * IPV6_MAXPLEN is also valid and means: "any MSS, 9441da177e4SLinus Torvalds * rely only on pmtu discovery" 9451da177e4SLinus Torvalds */ 9461da177e4SLinus Torvalds if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr)) 9471da177e4SLinus Torvalds mtu = IPV6_MAXPLEN; 9481da177e4SLinus Torvalds return mtu; 9491da177e4SLinus Torvalds } 9501da177e4SLinus Torvalds 9513b00944cSYOSHIFUJI Hideaki static struct dst_entry *icmp6_dst_gc_list; 9523b00944cSYOSHIFUJI Hideaki static DEFINE_SPINLOCK(icmp6_dst_lock); 9535d0bbeebSThomas Graf 9543b00944cSYOSHIFUJI Hideaki struct dst_entry *icmp6_dst_alloc(struct net_device *dev, 9551da177e4SLinus Torvalds struct neighbour *neigh, 9569acd9f3aSYOSHIFUJI Hideaki const struct in6_addr *addr) 9571da177e4SLinus Torvalds { 9581da177e4SLinus Torvalds struct rt6_info *rt; 9591da177e4SLinus Torvalds struct inet6_dev *idev = in6_dev_get(dev); 960c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds if (unlikely(idev == NULL)) 9631da177e4SLinus Torvalds return NULL; 9641da177e4SLinus Torvalds 96586393e52SAlexey Dobriyan rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops); 9661da177e4SLinus Torvalds if (unlikely(rt == NULL)) { 9671da177e4SLinus Torvalds in6_dev_put(idev); 9681da177e4SLinus Torvalds goto out; 9691da177e4SLinus Torvalds } 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds dev_hold(dev); 9721da177e4SLinus Torvalds if (neigh) 9731da177e4SLinus Torvalds neigh_hold(neigh); 97414deae41SDavid S. Miller else { 9751da177e4SLinus Torvalds neigh = ndisc_get_neigh(dev, addr); 97614deae41SDavid S. Miller if (IS_ERR(neigh)) 97714deae41SDavid S. Miller neigh = NULL; 97814deae41SDavid S. Miller } 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds rt->rt6i_dev = dev; 9811da177e4SLinus Torvalds rt->rt6i_idev = idev; 9821da177e4SLinus Torvalds rt->rt6i_nexthop = neigh; 983d8d1f30bSChangli Gao atomic_set(&rt->dst.__refcnt, 1); 984d8d1f30bSChangli Gao rt->dst.metrics[RTAX_HOPLIMIT-1] = 255; 985d8d1f30bSChangli Gao rt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev); 986d8d1f30bSChangli Gao rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->dst)); 987d8d1f30bSChangli Gao rt->dst.output = ip6_output; 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds #if 0 /* there's no chance to use these for ndisc */ 990d8d1f30bSChangli Gao rt->dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST 9911da177e4SLinus Torvalds ? DST_HOST 9921da177e4SLinus Torvalds : 0; 9931da177e4SLinus Torvalds ipv6_addr_copy(&rt->rt6i_dst.addr, addr); 9941da177e4SLinus Torvalds rt->rt6i_dst.plen = 128; 9951da177e4SLinus Torvalds #endif 9961da177e4SLinus Torvalds 9973b00944cSYOSHIFUJI Hideaki spin_lock_bh(&icmp6_dst_lock); 998d8d1f30bSChangli Gao rt->dst.next = icmp6_dst_gc_list; 999d8d1f30bSChangli Gao icmp6_dst_gc_list = &rt->dst; 10003b00944cSYOSHIFUJI Hideaki spin_unlock_bh(&icmp6_dst_lock); 10011da177e4SLinus Torvalds 10025578689aSDaniel Lezcano fib6_force_start_gc(net); 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds out: 1005d8d1f30bSChangli Gao return &rt->dst; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds 10083d0f24a7SStephen Hemminger int icmp6_dst_gc(void) 10091da177e4SLinus Torvalds { 10101da177e4SLinus Torvalds struct dst_entry *dst, *next, **pprev; 10113d0f24a7SStephen Hemminger int more = 0; 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds next = NULL; 10145d0bbeebSThomas Graf 10153b00944cSYOSHIFUJI Hideaki spin_lock_bh(&icmp6_dst_lock); 10163b00944cSYOSHIFUJI Hideaki pprev = &icmp6_dst_gc_list; 10175d0bbeebSThomas Graf 10181da177e4SLinus Torvalds while ((dst = *pprev) != NULL) { 10191da177e4SLinus Torvalds if (!atomic_read(&dst->__refcnt)) { 10201da177e4SLinus Torvalds *pprev = dst->next; 10211da177e4SLinus Torvalds dst_free(dst); 10221da177e4SLinus Torvalds } else { 10231da177e4SLinus Torvalds pprev = &dst->next; 10243d0f24a7SStephen Hemminger ++more; 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds } 10271da177e4SLinus Torvalds 10283b00944cSYOSHIFUJI Hideaki spin_unlock_bh(&icmp6_dst_lock); 10295d0bbeebSThomas Graf 10303d0f24a7SStephen Hemminger return more; 10311da177e4SLinus Torvalds } 10321da177e4SLinus Torvalds 10331e493d19SDavid S. Miller static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg), 10341e493d19SDavid S. Miller void *arg) 10351e493d19SDavid S. Miller { 10361e493d19SDavid S. Miller struct dst_entry *dst, **pprev; 10371e493d19SDavid S. Miller 10381e493d19SDavid S. Miller spin_lock_bh(&icmp6_dst_lock); 10391e493d19SDavid S. Miller pprev = &icmp6_dst_gc_list; 10401e493d19SDavid S. Miller while ((dst = *pprev) != NULL) { 10411e493d19SDavid S. Miller struct rt6_info *rt = (struct rt6_info *) dst; 10421e493d19SDavid S. Miller if (func(rt, arg)) { 10431e493d19SDavid S. Miller *pprev = dst->next; 10441e493d19SDavid S. Miller dst_free(dst); 10451e493d19SDavid S. Miller } else { 10461e493d19SDavid S. Miller pprev = &dst->next; 10471e493d19SDavid S. Miller } 10481e493d19SDavid S. Miller } 10491e493d19SDavid S. Miller spin_unlock_bh(&icmp6_dst_lock); 10501e493d19SDavid S. Miller } 10511e493d19SDavid S. Miller 1052569d3645SDaniel Lezcano static int ip6_dst_gc(struct dst_ops *ops) 10531da177e4SLinus Torvalds { 10541da177e4SLinus Torvalds unsigned long now = jiffies; 105586393e52SAlexey Dobriyan struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops); 10567019b78eSDaniel Lezcano int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval; 10577019b78eSDaniel Lezcano int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size; 10587019b78eSDaniel Lezcano int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity; 10597019b78eSDaniel Lezcano int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout; 10607019b78eSDaniel Lezcano unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc; 10611da177e4SLinus Torvalds 10627019b78eSDaniel Lezcano if (time_after(rt_last_gc + rt_min_interval, now) && 10637019b78eSDaniel Lezcano atomic_read(&ops->entries) <= rt_max_size) 10641da177e4SLinus Torvalds goto out; 10651da177e4SLinus Torvalds 10666891a346SBenjamin Thery net->ipv6.ip6_rt_gc_expire++; 10676891a346SBenjamin Thery fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net); 10686891a346SBenjamin Thery net->ipv6.ip6_rt_last_gc = now; 10697019b78eSDaniel Lezcano if (atomic_read(&ops->entries) < ops->gc_thresh) 10707019b78eSDaniel Lezcano net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1; 10711da177e4SLinus Torvalds out: 10727019b78eSDaniel Lezcano net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity; 10737019b78eSDaniel Lezcano return (atomic_read(&ops->entries) > rt_max_size); 10741da177e4SLinus Torvalds } 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds /* Clean host part of a prefix. Not necessary in radix tree, 10771da177e4SLinus Torvalds but results in cleaner routing tables. 10781da177e4SLinus Torvalds 10791da177e4SLinus Torvalds Remove it only when all the things will work! 10801da177e4SLinus Torvalds */ 10811da177e4SLinus Torvalds 10821da177e4SLinus Torvalds static int ipv6_get_mtu(struct net_device *dev) 10831da177e4SLinus Torvalds { 10841da177e4SLinus Torvalds int mtu = IPV6_MIN_MTU; 10851da177e4SLinus Torvalds struct inet6_dev *idev; 10861da177e4SLinus Torvalds 1087*c68f24ccSEric Dumazet rcu_read_lock(); 1088*c68f24ccSEric Dumazet idev = __in6_dev_get(dev); 1089*c68f24ccSEric Dumazet if (idev) 10901da177e4SLinus Torvalds mtu = idev->cnf.mtu6; 1091*c68f24ccSEric Dumazet rcu_read_unlock(); 10921da177e4SLinus Torvalds return mtu; 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds 10956b75d090SYOSHIFUJI Hideaki int ip6_dst_hoplimit(struct dst_entry *dst) 10961da177e4SLinus Torvalds { 10976b75d090SYOSHIFUJI Hideaki int hoplimit = dst_metric(dst, RTAX_HOPLIMIT); 10986b75d090SYOSHIFUJI Hideaki if (hoplimit < 0) { 10996b75d090SYOSHIFUJI Hideaki struct net_device *dev = dst->dev; 1100*c68f24ccSEric Dumazet struct inet6_dev *idev; 1101*c68f24ccSEric Dumazet 1102*c68f24ccSEric Dumazet rcu_read_lock(); 1103*c68f24ccSEric Dumazet idev = __in6_dev_get(dev); 1104*c68f24ccSEric Dumazet if (idev) 11051da177e4SLinus Torvalds hoplimit = idev->cnf.hop_limit; 1106*c68f24ccSEric Dumazet else 110753b7997fSYOSHIFUJI Hideaki hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit; 1108*c68f24ccSEric Dumazet rcu_read_unlock(); 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds return hoplimit; 11111da177e4SLinus Torvalds } 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds /* 11141da177e4SLinus Torvalds * 11151da177e4SLinus Torvalds */ 11161da177e4SLinus Torvalds 111786872cb5SThomas Graf int ip6_route_add(struct fib6_config *cfg) 11181da177e4SLinus Torvalds { 11191da177e4SLinus Torvalds int err; 11205578689aSDaniel Lezcano struct net *net = cfg->fc_nlinfo.nl_net; 11211da177e4SLinus Torvalds struct rt6_info *rt = NULL; 11221da177e4SLinus Torvalds struct net_device *dev = NULL; 11231da177e4SLinus Torvalds struct inet6_dev *idev = NULL; 1124c71099acSThomas Graf struct fib6_table *table; 11251da177e4SLinus Torvalds int addr_type; 11261da177e4SLinus Torvalds 112786872cb5SThomas Graf if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128) 11281da177e4SLinus Torvalds return -EINVAL; 11291da177e4SLinus Torvalds #ifndef CONFIG_IPV6_SUBTREES 113086872cb5SThomas Graf if (cfg->fc_src_len) 11311da177e4SLinus Torvalds return -EINVAL; 11321da177e4SLinus Torvalds #endif 113386872cb5SThomas Graf if (cfg->fc_ifindex) { 11341da177e4SLinus Torvalds err = -ENODEV; 11355578689aSDaniel Lezcano dev = dev_get_by_index(net, cfg->fc_ifindex); 11361da177e4SLinus Torvalds if (!dev) 11371da177e4SLinus Torvalds goto out; 11381da177e4SLinus Torvalds idev = in6_dev_get(dev); 11391da177e4SLinus Torvalds if (!idev) 11401da177e4SLinus Torvalds goto out; 11411da177e4SLinus Torvalds } 11421da177e4SLinus Torvalds 114386872cb5SThomas Graf if (cfg->fc_metric == 0) 114486872cb5SThomas Graf cfg->fc_metric = IP6_RT_PRIO_USER; 11451da177e4SLinus Torvalds 11465578689aSDaniel Lezcano table = fib6_new_table(net, cfg->fc_table); 1147c71099acSThomas Graf if (table == NULL) { 1148c71099acSThomas Graf err = -ENOBUFS; 1149c71099acSThomas Graf goto out; 1150c71099acSThomas Graf } 1151c71099acSThomas Graf 115286393e52SAlexey Dobriyan rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops); 11531da177e4SLinus Torvalds 11541da177e4SLinus Torvalds if (rt == NULL) { 11551da177e4SLinus Torvalds err = -ENOMEM; 11561da177e4SLinus Torvalds goto out; 11571da177e4SLinus Torvalds } 11581da177e4SLinus Torvalds 1159d8d1f30bSChangli Gao rt->dst.obsolete = -1; 11606f704992SYOSHIFUJI Hideaki rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ? 11616f704992SYOSHIFUJI Hideaki jiffies + clock_t_to_jiffies(cfg->fc_expires) : 11626f704992SYOSHIFUJI Hideaki 0; 11631da177e4SLinus Torvalds 116486872cb5SThomas Graf if (cfg->fc_protocol == RTPROT_UNSPEC) 116586872cb5SThomas Graf cfg->fc_protocol = RTPROT_BOOT; 116686872cb5SThomas Graf rt->rt6i_protocol = cfg->fc_protocol; 116786872cb5SThomas Graf 116886872cb5SThomas Graf addr_type = ipv6_addr_type(&cfg->fc_dst); 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds if (addr_type & IPV6_ADDR_MULTICAST) 1171d8d1f30bSChangli Gao rt->dst.input = ip6_mc_input; 11721da177e4SLinus Torvalds else 1173d8d1f30bSChangli Gao rt->dst.input = ip6_forward; 11741da177e4SLinus Torvalds 1175d8d1f30bSChangli Gao rt->dst.output = ip6_output; 11761da177e4SLinus Torvalds 117786872cb5SThomas Graf ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len); 117886872cb5SThomas Graf rt->rt6i_dst.plen = cfg->fc_dst_len; 11791da177e4SLinus Torvalds if (rt->rt6i_dst.plen == 128) 1180d8d1f30bSChangli Gao rt->dst.flags = DST_HOST; 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES 118386872cb5SThomas Graf ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len); 118486872cb5SThomas Graf rt->rt6i_src.plen = cfg->fc_src_len; 11851da177e4SLinus Torvalds #endif 11861da177e4SLinus Torvalds 118786872cb5SThomas Graf rt->rt6i_metric = cfg->fc_metric; 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds /* We cannot add true routes via loopback here, 11901da177e4SLinus Torvalds they would result in kernel looping; promote them to reject routes 11911da177e4SLinus Torvalds */ 119286872cb5SThomas Graf if ((cfg->fc_flags & RTF_REJECT) || 11931da177e4SLinus Torvalds (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) { 11941da177e4SLinus Torvalds /* hold loopback dev/idev if we haven't done so. */ 11955578689aSDaniel Lezcano if (dev != net->loopback_dev) { 11961da177e4SLinus Torvalds if (dev) { 11971da177e4SLinus Torvalds dev_put(dev); 11981da177e4SLinus Torvalds in6_dev_put(idev); 11991da177e4SLinus Torvalds } 12005578689aSDaniel Lezcano dev = net->loopback_dev; 12011da177e4SLinus Torvalds dev_hold(dev); 12021da177e4SLinus Torvalds idev = in6_dev_get(dev); 12031da177e4SLinus Torvalds if (!idev) { 12041da177e4SLinus Torvalds err = -ENODEV; 12051da177e4SLinus Torvalds goto out; 12061da177e4SLinus Torvalds } 12071da177e4SLinus Torvalds } 1208d8d1f30bSChangli Gao rt->dst.output = ip6_pkt_discard_out; 1209d8d1f30bSChangli Gao rt->dst.input = ip6_pkt_discard; 1210d8d1f30bSChangli Gao rt->dst.error = -ENETUNREACH; 12111da177e4SLinus Torvalds rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP; 12121da177e4SLinus Torvalds goto install_route; 12131da177e4SLinus Torvalds } 12141da177e4SLinus Torvalds 121586872cb5SThomas Graf if (cfg->fc_flags & RTF_GATEWAY) { 12161da177e4SLinus Torvalds struct in6_addr *gw_addr; 12171da177e4SLinus Torvalds int gwa_type; 12181da177e4SLinus Torvalds 121986872cb5SThomas Graf gw_addr = &cfg->fc_gateway; 122086872cb5SThomas Graf ipv6_addr_copy(&rt->rt6i_gateway, gw_addr); 12211da177e4SLinus Torvalds gwa_type = ipv6_addr_type(gw_addr); 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) { 12241da177e4SLinus Torvalds struct rt6_info *grt; 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds /* IPv6 strictly inhibits using not link-local 12271da177e4SLinus Torvalds addresses as nexthop address. 12281da177e4SLinus Torvalds Otherwise, router will not able to send redirects. 12291da177e4SLinus Torvalds It is very good, but in some (rare!) circumstances 12301da177e4SLinus Torvalds (SIT, PtP, NBMA NOARP links) it is handy to allow 12311da177e4SLinus Torvalds some exceptions. --ANK 12321da177e4SLinus Torvalds */ 12331da177e4SLinus Torvalds err = -EINVAL; 12341da177e4SLinus Torvalds if (!(gwa_type&IPV6_ADDR_UNICAST)) 12351da177e4SLinus Torvalds goto out; 12361da177e4SLinus Torvalds 12375578689aSDaniel Lezcano grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1); 12381da177e4SLinus Torvalds 12391da177e4SLinus Torvalds err = -EHOSTUNREACH; 12401da177e4SLinus Torvalds if (grt == NULL) 12411da177e4SLinus Torvalds goto out; 12421da177e4SLinus Torvalds if (dev) { 12431da177e4SLinus Torvalds if (dev != grt->rt6i_dev) { 1244d8d1f30bSChangli Gao dst_release(&grt->dst); 12451da177e4SLinus Torvalds goto out; 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds } else { 12481da177e4SLinus Torvalds dev = grt->rt6i_dev; 12491da177e4SLinus Torvalds idev = grt->rt6i_idev; 12501da177e4SLinus Torvalds dev_hold(dev); 12511da177e4SLinus Torvalds in6_dev_hold(grt->rt6i_idev); 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds if (!(grt->rt6i_flags&RTF_GATEWAY)) 12541da177e4SLinus Torvalds err = 0; 1255d8d1f30bSChangli Gao dst_release(&grt->dst); 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds if (err) 12581da177e4SLinus Torvalds goto out; 12591da177e4SLinus Torvalds } 12601da177e4SLinus Torvalds err = -EINVAL; 12611da177e4SLinus Torvalds if (dev == NULL || (dev->flags&IFF_LOOPBACK)) 12621da177e4SLinus Torvalds goto out; 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds err = -ENODEV; 12661da177e4SLinus Torvalds if (dev == NULL) 12671da177e4SLinus Torvalds goto out; 12681da177e4SLinus Torvalds 126986872cb5SThomas Graf if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) { 12701da177e4SLinus Torvalds rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev); 12711da177e4SLinus Torvalds if (IS_ERR(rt->rt6i_nexthop)) { 12721da177e4SLinus Torvalds err = PTR_ERR(rt->rt6i_nexthop); 12731da177e4SLinus Torvalds rt->rt6i_nexthop = NULL; 12741da177e4SLinus Torvalds goto out; 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds } 12771da177e4SLinus Torvalds 127886872cb5SThomas Graf rt->rt6i_flags = cfg->fc_flags; 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds install_route: 128186872cb5SThomas Graf if (cfg->fc_mx) { 128286872cb5SThomas Graf struct nlattr *nla; 128386872cb5SThomas Graf int remaining; 12841da177e4SLinus Torvalds 128586872cb5SThomas Graf nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) { 12868f4c1f9bSThomas Graf int type = nla_type(nla); 128786872cb5SThomas Graf 128886872cb5SThomas Graf if (type) { 128986872cb5SThomas Graf if (type > RTAX_MAX) { 12901da177e4SLinus Torvalds err = -EINVAL; 12911da177e4SLinus Torvalds goto out; 12921da177e4SLinus Torvalds } 129386872cb5SThomas Graf 1294d8d1f30bSChangli Gao rt->dst.metrics[type - 1] = nla_get_u32(nla); 12951da177e4SLinus Torvalds } 12961da177e4SLinus Torvalds } 12971da177e4SLinus Torvalds } 12981da177e4SLinus Torvalds 1299d8d1f30bSChangli Gao if (dst_metric(&rt->dst, RTAX_HOPLIMIT) == 0) 1300d8d1f30bSChangli Gao rt->dst.metrics[RTAX_HOPLIMIT-1] = -1; 1301d8d1f30bSChangli Gao if (!dst_mtu(&rt->dst)) 1302d8d1f30bSChangli Gao rt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev); 1303d8d1f30bSChangli Gao if (!dst_metric(&rt->dst, RTAX_ADVMSS)) 1304d8d1f30bSChangli Gao rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->dst)); 1305d8d1f30bSChangli Gao rt->dst.dev = dev; 13061da177e4SLinus Torvalds rt->rt6i_idev = idev; 1307c71099acSThomas Graf rt->rt6i_table = table; 130863152fc0SDaniel Lezcano 1309c346dca1SYOSHIFUJI Hideaki cfg->fc_nlinfo.nl_net = dev_net(dev); 131063152fc0SDaniel Lezcano 131186872cb5SThomas Graf return __ip6_ins_rt(rt, &cfg->fc_nlinfo); 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds out: 13141da177e4SLinus Torvalds if (dev) 13151da177e4SLinus Torvalds dev_put(dev); 13161da177e4SLinus Torvalds if (idev) 13171da177e4SLinus Torvalds in6_dev_put(idev); 13181da177e4SLinus Torvalds if (rt) 1319d8d1f30bSChangli Gao dst_free(&rt->dst); 13201da177e4SLinus Torvalds return err; 13211da177e4SLinus Torvalds } 13221da177e4SLinus Torvalds 132386872cb5SThomas Graf static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info) 13241da177e4SLinus Torvalds { 13251da177e4SLinus Torvalds int err; 1326c71099acSThomas Graf struct fib6_table *table; 1327c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(rt->rt6i_dev); 13281da177e4SLinus Torvalds 13298ed67789SDaniel Lezcano if (rt == net->ipv6.ip6_null_entry) 13306c813a72SPatrick McHardy return -ENOENT; 13316c813a72SPatrick McHardy 1332c71099acSThomas Graf table = rt->rt6i_table; 1333c71099acSThomas Graf write_lock_bh(&table->tb6_lock); 13341da177e4SLinus Torvalds 133586872cb5SThomas Graf err = fib6_del(rt, info); 1336d8d1f30bSChangli Gao dst_release(&rt->dst); 13371da177e4SLinus Torvalds 1338c71099acSThomas Graf write_unlock_bh(&table->tb6_lock); 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds return err; 13411da177e4SLinus Torvalds } 13421da177e4SLinus Torvalds 1343e0a1ad73SThomas Graf int ip6_del_rt(struct rt6_info *rt) 1344e0a1ad73SThomas Graf { 13454d1169c1SDenis V. Lunev struct nl_info info = { 1346c346dca1SYOSHIFUJI Hideaki .nl_net = dev_net(rt->rt6i_dev), 13474d1169c1SDenis V. Lunev }; 1348528c4cebSDenis V. Lunev return __ip6_del_rt(rt, &info); 1349e0a1ad73SThomas Graf } 1350e0a1ad73SThomas Graf 135186872cb5SThomas Graf static int ip6_route_del(struct fib6_config *cfg) 13521da177e4SLinus Torvalds { 1353c71099acSThomas Graf struct fib6_table *table; 13541da177e4SLinus Torvalds struct fib6_node *fn; 13551da177e4SLinus Torvalds struct rt6_info *rt; 13561da177e4SLinus Torvalds int err = -ESRCH; 13571da177e4SLinus Torvalds 13585578689aSDaniel Lezcano table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table); 1359c71099acSThomas Graf if (table == NULL) 1360c71099acSThomas Graf return err; 13611da177e4SLinus Torvalds 1362c71099acSThomas Graf read_lock_bh(&table->tb6_lock); 1363c71099acSThomas Graf 1364c71099acSThomas Graf fn = fib6_locate(&table->tb6_root, 136586872cb5SThomas Graf &cfg->fc_dst, cfg->fc_dst_len, 136686872cb5SThomas Graf &cfg->fc_src, cfg->fc_src_len); 13671da177e4SLinus Torvalds 13681da177e4SLinus Torvalds if (fn) { 1369d8d1f30bSChangli Gao for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) { 137086872cb5SThomas Graf if (cfg->fc_ifindex && 13711da177e4SLinus Torvalds (rt->rt6i_dev == NULL || 137286872cb5SThomas Graf rt->rt6i_dev->ifindex != cfg->fc_ifindex)) 13731da177e4SLinus Torvalds continue; 137486872cb5SThomas Graf if (cfg->fc_flags & RTF_GATEWAY && 137586872cb5SThomas Graf !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway)) 13761da177e4SLinus Torvalds continue; 137786872cb5SThomas Graf if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric) 13781da177e4SLinus Torvalds continue; 1379d8d1f30bSChangli Gao dst_hold(&rt->dst); 1380c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 13811da177e4SLinus Torvalds 138286872cb5SThomas Graf return __ip6_del_rt(rt, &cfg->fc_nlinfo); 13831da177e4SLinus Torvalds } 13841da177e4SLinus Torvalds } 1385c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 13861da177e4SLinus Torvalds 13871da177e4SLinus Torvalds return err; 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds /* 13911da177e4SLinus Torvalds * Handle redirects 13921da177e4SLinus Torvalds */ 1393a6279458SYOSHIFUJI Hideaki struct ip6rd_flowi { 1394a6279458SYOSHIFUJI Hideaki struct flowi fl; 1395a6279458SYOSHIFUJI Hideaki struct in6_addr gateway; 1396a6279458SYOSHIFUJI Hideaki }; 13971da177e4SLinus Torvalds 13988ed67789SDaniel Lezcano static struct rt6_info *__ip6_route_redirect(struct net *net, 13998ed67789SDaniel Lezcano struct fib6_table *table, 1400a6279458SYOSHIFUJI Hideaki struct flowi *fl, 1401a6279458SYOSHIFUJI Hideaki int flags) 1402a6279458SYOSHIFUJI Hideaki { 1403a6279458SYOSHIFUJI Hideaki struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl; 1404a6279458SYOSHIFUJI Hideaki struct rt6_info *rt; 1405a6279458SYOSHIFUJI Hideaki struct fib6_node *fn; 1406c71099acSThomas Graf 1407e843b9e1SYOSHIFUJI Hideaki /* 1408e843b9e1SYOSHIFUJI Hideaki * Get the "current" route for this destination and 1409e843b9e1SYOSHIFUJI Hideaki * check if the redirect has come from approriate router. 1410e843b9e1SYOSHIFUJI Hideaki * 1411e843b9e1SYOSHIFUJI Hideaki * RFC 2461 specifies that redirects should only be 1412e843b9e1SYOSHIFUJI Hideaki * accepted if they come from the nexthop to the target. 1413e843b9e1SYOSHIFUJI Hideaki * Due to the way the routes are chosen, this notion 1414e843b9e1SYOSHIFUJI Hideaki * is a bit fuzzy and one might need to check all possible 1415e843b9e1SYOSHIFUJI Hideaki * routes. 1416e843b9e1SYOSHIFUJI Hideaki */ 14171da177e4SLinus Torvalds 1418c71099acSThomas Graf read_lock_bh(&table->tb6_lock); 1419a6279458SYOSHIFUJI Hideaki fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src); 1420e843b9e1SYOSHIFUJI Hideaki restart: 1421d8d1f30bSChangli Gao for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) { 14221da177e4SLinus Torvalds /* 14231da177e4SLinus Torvalds * Current route is on-link; redirect is always invalid. 14241da177e4SLinus Torvalds * 14251da177e4SLinus Torvalds * Seems, previous statement is not true. It could 14261da177e4SLinus Torvalds * be node, which looks for us as on-link (f.e. proxy ndisc) 14271da177e4SLinus Torvalds * But then router serving it might decide, that we should 14281da177e4SLinus Torvalds * know truth 8)8) --ANK (980726). 14291da177e4SLinus Torvalds */ 1430e843b9e1SYOSHIFUJI Hideaki if (rt6_check_expired(rt)) 1431e843b9e1SYOSHIFUJI Hideaki continue; 14321da177e4SLinus Torvalds if (!(rt->rt6i_flags & RTF_GATEWAY)) 1433e843b9e1SYOSHIFUJI Hideaki continue; 1434a6279458SYOSHIFUJI Hideaki if (fl->oif != rt->rt6i_dev->ifindex) 1435e843b9e1SYOSHIFUJI Hideaki continue; 1436a6279458SYOSHIFUJI Hideaki if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway)) 1437e843b9e1SYOSHIFUJI Hideaki continue; 1438e843b9e1SYOSHIFUJI Hideaki break; 1439e843b9e1SYOSHIFUJI Hideaki } 1440a6279458SYOSHIFUJI Hideaki 1441cb15d9c2SYOSHIFUJI Hideaki if (!rt) 14428ed67789SDaniel Lezcano rt = net->ipv6.ip6_null_entry; 14438ed67789SDaniel Lezcano BACKTRACK(net, &fl->fl6_src); 1444cb15d9c2SYOSHIFUJI Hideaki out: 1445d8d1f30bSChangli Gao dst_hold(&rt->dst); 1446a6279458SYOSHIFUJI Hideaki 1447c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 14481da177e4SLinus Torvalds 1449a6279458SYOSHIFUJI Hideaki return rt; 1450a6279458SYOSHIFUJI Hideaki }; 1451a6279458SYOSHIFUJI Hideaki 1452a6279458SYOSHIFUJI Hideaki static struct rt6_info *ip6_route_redirect(struct in6_addr *dest, 1453a6279458SYOSHIFUJI Hideaki struct in6_addr *src, 1454a6279458SYOSHIFUJI Hideaki struct in6_addr *gateway, 1455a6279458SYOSHIFUJI Hideaki struct net_device *dev) 1456a6279458SYOSHIFUJI Hideaki { 1457adaa70bbSThomas Graf int flags = RT6_LOOKUP_F_HAS_SADDR; 1458c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 1459a6279458SYOSHIFUJI Hideaki struct ip6rd_flowi rdfl = { 1460a6279458SYOSHIFUJI Hideaki .fl = { 1461a6279458SYOSHIFUJI Hideaki .oif = dev->ifindex, 1462a6279458SYOSHIFUJI Hideaki .nl_u = { 1463a6279458SYOSHIFUJI Hideaki .ip6_u = { 1464a6279458SYOSHIFUJI Hideaki .daddr = *dest, 1465a6279458SYOSHIFUJI Hideaki .saddr = *src, 1466a6279458SYOSHIFUJI Hideaki }, 1467a6279458SYOSHIFUJI Hideaki }, 1468a6279458SYOSHIFUJI Hideaki }, 1469a6279458SYOSHIFUJI Hideaki }; 1470adaa70bbSThomas Graf 147186c36ce4SBrian Haley ipv6_addr_copy(&rdfl.gateway, gateway); 147286c36ce4SBrian Haley 1473adaa70bbSThomas Graf if (rt6_need_strict(dest)) 1474adaa70bbSThomas Graf flags |= RT6_LOOKUP_F_IFACE; 1475a6279458SYOSHIFUJI Hideaki 14765578689aSDaniel Lezcano return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl, 147758f09b78SDaniel Lezcano flags, __ip6_route_redirect); 1478a6279458SYOSHIFUJI Hideaki } 1479a6279458SYOSHIFUJI Hideaki 1480a6279458SYOSHIFUJI Hideaki void rt6_redirect(struct in6_addr *dest, struct in6_addr *src, 1481a6279458SYOSHIFUJI Hideaki struct in6_addr *saddr, 1482a6279458SYOSHIFUJI Hideaki struct neighbour *neigh, u8 *lladdr, int on_link) 1483a6279458SYOSHIFUJI Hideaki { 1484a6279458SYOSHIFUJI Hideaki struct rt6_info *rt, *nrt = NULL; 1485a6279458SYOSHIFUJI Hideaki struct netevent_redirect netevent; 1486c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(neigh->dev); 1487a6279458SYOSHIFUJI Hideaki 1488a6279458SYOSHIFUJI Hideaki rt = ip6_route_redirect(dest, src, saddr, neigh->dev); 1489a6279458SYOSHIFUJI Hideaki 14908ed67789SDaniel Lezcano if (rt == net->ipv6.ip6_null_entry) { 14911da177e4SLinus Torvalds if (net_ratelimit()) 14921da177e4SLinus Torvalds printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop " 14931da177e4SLinus Torvalds "for redirect target\n"); 1494a6279458SYOSHIFUJI Hideaki goto out; 14951da177e4SLinus Torvalds } 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds /* 14981da177e4SLinus Torvalds * We have finally decided to accept it. 14991da177e4SLinus Torvalds */ 15001da177e4SLinus Torvalds 15011da177e4SLinus Torvalds neigh_update(neigh, lladdr, NUD_STALE, 15021da177e4SLinus Torvalds NEIGH_UPDATE_F_WEAK_OVERRIDE| 15031da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE| 15041da177e4SLinus Torvalds (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 15051da177e4SLinus Torvalds NEIGH_UPDATE_F_ISROUTER)) 15061da177e4SLinus Torvalds ); 15071da177e4SLinus Torvalds 15081da177e4SLinus Torvalds /* 15091da177e4SLinus Torvalds * Redirect received -> path was valid. 15101da177e4SLinus Torvalds * Look, redirects are sent only in response to data packets, 15111da177e4SLinus Torvalds * so that this nexthop apparently is reachable. --ANK 15121da177e4SLinus Torvalds */ 1513d8d1f30bSChangli Gao dst_confirm(&rt->dst); 15141da177e4SLinus Torvalds 15151da177e4SLinus Torvalds /* Duplicate redirect: silently ignore. */ 1516d8d1f30bSChangli Gao if (neigh == rt->dst.neighbour) 15171da177e4SLinus Torvalds goto out; 15181da177e4SLinus Torvalds 15191da177e4SLinus Torvalds nrt = ip6_rt_copy(rt); 15201da177e4SLinus Torvalds if (nrt == NULL) 15211da177e4SLinus Torvalds goto out; 15221da177e4SLinus Torvalds 15231da177e4SLinus Torvalds nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE; 15241da177e4SLinus Torvalds if (on_link) 15251da177e4SLinus Torvalds nrt->rt6i_flags &= ~RTF_GATEWAY; 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds ipv6_addr_copy(&nrt->rt6i_dst.addr, dest); 15281da177e4SLinus Torvalds nrt->rt6i_dst.plen = 128; 1529d8d1f30bSChangli Gao nrt->dst.flags |= DST_HOST; 15301da177e4SLinus Torvalds 15311da177e4SLinus Torvalds ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key); 15321da177e4SLinus Torvalds nrt->rt6i_nexthop = neigh_clone(neigh); 15331da177e4SLinus Torvalds /* Reset pmtu, it may be better */ 1534d8d1f30bSChangli Gao nrt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev); 1535d8d1f30bSChangli Gao nrt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dev_net(neigh->dev), 1536d8d1f30bSChangli Gao dst_mtu(&nrt->dst)); 15371da177e4SLinus Torvalds 153840e22e8fSThomas Graf if (ip6_ins_rt(nrt)) 15391da177e4SLinus Torvalds goto out; 15401da177e4SLinus Torvalds 1541d8d1f30bSChangli Gao netevent.old = &rt->dst; 1542d8d1f30bSChangli Gao netevent.new = &nrt->dst; 15438d71740cSTom Tucker call_netevent_notifiers(NETEVENT_REDIRECT, &netevent); 15448d71740cSTom Tucker 15451da177e4SLinus Torvalds if (rt->rt6i_flags&RTF_CACHE) { 1546e0a1ad73SThomas Graf ip6_del_rt(rt); 15471da177e4SLinus Torvalds return; 15481da177e4SLinus Torvalds } 15491da177e4SLinus Torvalds 15501da177e4SLinus Torvalds out: 1551d8d1f30bSChangli Gao dst_release(&rt->dst); 15521da177e4SLinus Torvalds } 15531da177e4SLinus Torvalds 15541da177e4SLinus Torvalds /* 15551da177e4SLinus Torvalds * Handle ICMP "packet too big" messages 15561da177e4SLinus Torvalds * i.e. Path MTU discovery 15571da177e4SLinus Torvalds */ 15581da177e4SLinus Torvalds 15591da177e4SLinus Torvalds void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr, 15601da177e4SLinus Torvalds struct net_device *dev, u32 pmtu) 15611da177e4SLinus Torvalds { 15621da177e4SLinus Torvalds struct rt6_info *rt, *nrt; 1563c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 15641da177e4SLinus Torvalds int allfrag = 0; 15651da177e4SLinus Torvalds 15665578689aSDaniel Lezcano rt = rt6_lookup(net, daddr, saddr, dev->ifindex, 0); 15671da177e4SLinus Torvalds if (rt == NULL) 15681da177e4SLinus Torvalds return; 15691da177e4SLinus Torvalds 1570d8d1f30bSChangli Gao if (pmtu >= dst_mtu(&rt->dst)) 15711da177e4SLinus Torvalds goto out; 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds if (pmtu < IPV6_MIN_MTU) { 15741da177e4SLinus Torvalds /* 15751da177e4SLinus Torvalds * According to RFC2460, PMTU is set to the IPv6 Minimum Link 15761da177e4SLinus Torvalds * MTU (1280) and a fragment header should always be included 15771da177e4SLinus Torvalds * after a node receiving Too Big message reporting PMTU is 15781da177e4SLinus Torvalds * less than the IPv6 Minimum Link MTU. 15791da177e4SLinus Torvalds */ 15801da177e4SLinus Torvalds pmtu = IPV6_MIN_MTU; 15811da177e4SLinus Torvalds allfrag = 1; 15821da177e4SLinus Torvalds } 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds /* New mtu received -> path was valid. 15851da177e4SLinus Torvalds They are sent only in response to data packets, 15861da177e4SLinus Torvalds so that this nexthop apparently is reachable. --ANK 15871da177e4SLinus Torvalds */ 1588d8d1f30bSChangli Gao dst_confirm(&rt->dst); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds /* Host route. If it is static, it would be better 15911da177e4SLinus Torvalds not to override it, but add new one, so that 15921da177e4SLinus Torvalds when cache entry will expire old pmtu 15931da177e4SLinus Torvalds would return automatically. 15941da177e4SLinus Torvalds */ 15951da177e4SLinus Torvalds if (rt->rt6i_flags & RTF_CACHE) { 1596d8d1f30bSChangli Gao rt->dst.metrics[RTAX_MTU-1] = pmtu; 15971da177e4SLinus Torvalds if (allfrag) 1598d8d1f30bSChangli Gao rt->dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG; 1599d8d1f30bSChangli Gao dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires); 16001da177e4SLinus Torvalds rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES; 16011da177e4SLinus Torvalds goto out; 16021da177e4SLinus Torvalds } 16031da177e4SLinus Torvalds 16041da177e4SLinus Torvalds /* Network route. 16051da177e4SLinus Torvalds Two cases are possible: 16061da177e4SLinus Torvalds 1. It is connected route. Action: COW 16071da177e4SLinus Torvalds 2. It is gatewayed route or NONEXTHOP route. Action: clone it. 16081da177e4SLinus Torvalds */ 1609d5315b50SYOSHIFUJI Hideaki if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP)) 1610a1e78363SYOSHIFUJI Hideaki nrt = rt6_alloc_cow(rt, daddr, saddr); 1611d5315b50SYOSHIFUJI Hideaki else 1612d5315b50SYOSHIFUJI Hideaki nrt = rt6_alloc_clone(rt, daddr); 1613a1e78363SYOSHIFUJI Hideaki 1614d5315b50SYOSHIFUJI Hideaki if (nrt) { 1615d8d1f30bSChangli Gao nrt->dst.metrics[RTAX_MTU-1] = pmtu; 16161da177e4SLinus Torvalds if (allfrag) 1617d8d1f30bSChangli Gao nrt->dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG; 1618a1e78363SYOSHIFUJI Hideaki 16191da177e4SLinus Torvalds /* According to RFC 1981, detecting PMTU increase shouldn't be 1620a1e78363SYOSHIFUJI Hideaki * happened within 5 mins, the recommended timer is 10 mins. 1621a1e78363SYOSHIFUJI Hideaki * Here this route expiration time is set to ip6_rt_mtu_expires 1622a1e78363SYOSHIFUJI Hideaki * which is 10 mins. After 10 mins the decreased pmtu is expired 1623a1e78363SYOSHIFUJI Hideaki * and detecting PMTU increase will be automatically happened. 16241da177e4SLinus Torvalds */ 1625d8d1f30bSChangli Gao dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires); 16261da177e4SLinus Torvalds nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES; 1627a1e78363SYOSHIFUJI Hideaki 162840e22e8fSThomas Graf ip6_ins_rt(nrt); 16291da177e4SLinus Torvalds } 16301da177e4SLinus Torvalds out: 1631d8d1f30bSChangli Gao dst_release(&rt->dst); 16321da177e4SLinus Torvalds } 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds /* 16351da177e4SLinus Torvalds * Misc support functions 16361da177e4SLinus Torvalds */ 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds static struct rt6_info * ip6_rt_copy(struct rt6_info *ort) 16391da177e4SLinus Torvalds { 1640c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(ort->rt6i_dev); 164186393e52SAlexey Dobriyan struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops); 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds if (rt) { 1644d8d1f30bSChangli Gao rt->dst.input = ort->dst.input; 1645d8d1f30bSChangli Gao rt->dst.output = ort->dst.output; 16461da177e4SLinus Torvalds 1647d8d1f30bSChangli Gao memcpy(rt->dst.metrics, ort->dst.metrics, RTAX_MAX*sizeof(u32)); 1648d8d1f30bSChangli Gao rt->dst.error = ort->dst.error; 1649d8d1f30bSChangli Gao rt->dst.dev = ort->dst.dev; 1650d8d1f30bSChangli Gao if (rt->dst.dev) 1651d8d1f30bSChangli Gao dev_hold(rt->dst.dev); 16521da177e4SLinus Torvalds rt->rt6i_idev = ort->rt6i_idev; 16531da177e4SLinus Torvalds if (rt->rt6i_idev) 16541da177e4SLinus Torvalds in6_dev_hold(rt->rt6i_idev); 1655d8d1f30bSChangli Gao rt->dst.lastuse = jiffies; 16561da177e4SLinus Torvalds rt->rt6i_expires = 0; 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway); 16591da177e4SLinus Torvalds rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES; 16601da177e4SLinus Torvalds rt->rt6i_metric = 0; 16611da177e4SLinus Torvalds 16621da177e4SLinus Torvalds memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key)); 16631da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES 16641da177e4SLinus Torvalds memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key)); 16651da177e4SLinus Torvalds #endif 1666c71099acSThomas Graf rt->rt6i_table = ort->rt6i_table; 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds return rt; 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 167170ceb4f5SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO 1672efa2cea0SDaniel Lezcano static struct rt6_info *rt6_get_route_info(struct net *net, 1673efa2cea0SDaniel Lezcano struct in6_addr *prefix, int prefixlen, 167470ceb4f5SYOSHIFUJI Hideaki struct in6_addr *gwaddr, int ifindex) 167570ceb4f5SYOSHIFUJI Hideaki { 167670ceb4f5SYOSHIFUJI Hideaki struct fib6_node *fn; 167770ceb4f5SYOSHIFUJI Hideaki struct rt6_info *rt = NULL; 1678c71099acSThomas Graf struct fib6_table *table; 167970ceb4f5SYOSHIFUJI Hideaki 1680efa2cea0SDaniel Lezcano table = fib6_get_table(net, RT6_TABLE_INFO); 1681c71099acSThomas Graf if (table == NULL) 1682c71099acSThomas Graf return NULL; 1683c71099acSThomas Graf 1684c71099acSThomas Graf write_lock_bh(&table->tb6_lock); 1685c71099acSThomas Graf fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0); 168670ceb4f5SYOSHIFUJI Hideaki if (!fn) 168770ceb4f5SYOSHIFUJI Hideaki goto out; 168870ceb4f5SYOSHIFUJI Hideaki 1689d8d1f30bSChangli Gao for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) { 169070ceb4f5SYOSHIFUJI Hideaki if (rt->rt6i_dev->ifindex != ifindex) 169170ceb4f5SYOSHIFUJI Hideaki continue; 169270ceb4f5SYOSHIFUJI Hideaki if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY)) 169370ceb4f5SYOSHIFUJI Hideaki continue; 169470ceb4f5SYOSHIFUJI Hideaki if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr)) 169570ceb4f5SYOSHIFUJI Hideaki continue; 1696d8d1f30bSChangli Gao dst_hold(&rt->dst); 169770ceb4f5SYOSHIFUJI Hideaki break; 169870ceb4f5SYOSHIFUJI Hideaki } 169970ceb4f5SYOSHIFUJI Hideaki out: 1700c71099acSThomas Graf write_unlock_bh(&table->tb6_lock); 170170ceb4f5SYOSHIFUJI Hideaki return rt; 170270ceb4f5SYOSHIFUJI Hideaki } 170370ceb4f5SYOSHIFUJI Hideaki 1704efa2cea0SDaniel Lezcano static struct rt6_info *rt6_add_route_info(struct net *net, 1705efa2cea0SDaniel Lezcano struct in6_addr *prefix, int prefixlen, 170670ceb4f5SYOSHIFUJI Hideaki struct in6_addr *gwaddr, int ifindex, 170770ceb4f5SYOSHIFUJI Hideaki unsigned pref) 170870ceb4f5SYOSHIFUJI Hideaki { 170986872cb5SThomas Graf struct fib6_config cfg = { 171086872cb5SThomas Graf .fc_table = RT6_TABLE_INFO, 1711238fc7eaSRami Rosen .fc_metric = IP6_RT_PRIO_USER, 171286872cb5SThomas Graf .fc_ifindex = ifindex, 171386872cb5SThomas Graf .fc_dst_len = prefixlen, 171486872cb5SThomas Graf .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO | 171586872cb5SThomas Graf RTF_UP | RTF_PREF(pref), 1716efa2cea0SDaniel Lezcano .fc_nlinfo.pid = 0, 1717efa2cea0SDaniel Lezcano .fc_nlinfo.nlh = NULL, 1718efa2cea0SDaniel Lezcano .fc_nlinfo.nl_net = net, 171986872cb5SThomas Graf }; 172070ceb4f5SYOSHIFUJI Hideaki 172186872cb5SThomas Graf ipv6_addr_copy(&cfg.fc_dst, prefix); 172286872cb5SThomas Graf ipv6_addr_copy(&cfg.fc_gateway, gwaddr); 172386872cb5SThomas Graf 1724e317da96SYOSHIFUJI Hideaki /* We should treat it as a default route if prefix length is 0. */ 1725e317da96SYOSHIFUJI Hideaki if (!prefixlen) 172686872cb5SThomas Graf cfg.fc_flags |= RTF_DEFAULT; 172770ceb4f5SYOSHIFUJI Hideaki 172886872cb5SThomas Graf ip6_route_add(&cfg); 172970ceb4f5SYOSHIFUJI Hideaki 1730efa2cea0SDaniel Lezcano return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex); 173170ceb4f5SYOSHIFUJI Hideaki } 173270ceb4f5SYOSHIFUJI Hideaki #endif 173370ceb4f5SYOSHIFUJI Hideaki 17341da177e4SLinus Torvalds struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev) 17351da177e4SLinus Torvalds { 17361da177e4SLinus Torvalds struct rt6_info *rt; 1737c71099acSThomas Graf struct fib6_table *table; 17381da177e4SLinus Torvalds 1739c346dca1SYOSHIFUJI Hideaki table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT); 1740c71099acSThomas Graf if (table == NULL) 1741c71099acSThomas Graf return NULL; 17421da177e4SLinus Torvalds 1743c71099acSThomas Graf write_lock_bh(&table->tb6_lock); 1744d8d1f30bSChangli Gao for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) { 17451da177e4SLinus Torvalds if (dev == rt->rt6i_dev && 1746045927ffSYOSHIFUJI Hideaki ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) && 17471da177e4SLinus Torvalds ipv6_addr_equal(&rt->rt6i_gateway, addr)) 17481da177e4SLinus Torvalds break; 17491da177e4SLinus Torvalds } 17501da177e4SLinus Torvalds if (rt) 1751d8d1f30bSChangli Gao dst_hold(&rt->dst); 1752c71099acSThomas Graf write_unlock_bh(&table->tb6_lock); 17531da177e4SLinus Torvalds return rt; 17541da177e4SLinus Torvalds } 17551da177e4SLinus Torvalds 17561da177e4SLinus Torvalds struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr, 1757ebacaaa0SYOSHIFUJI Hideaki struct net_device *dev, 1758ebacaaa0SYOSHIFUJI Hideaki unsigned int pref) 17591da177e4SLinus Torvalds { 176086872cb5SThomas Graf struct fib6_config cfg = { 176186872cb5SThomas Graf .fc_table = RT6_TABLE_DFLT, 1762238fc7eaSRami Rosen .fc_metric = IP6_RT_PRIO_USER, 176386872cb5SThomas Graf .fc_ifindex = dev->ifindex, 176486872cb5SThomas Graf .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT | 176586872cb5SThomas Graf RTF_UP | RTF_EXPIRES | RTF_PREF(pref), 17665578689aSDaniel Lezcano .fc_nlinfo.pid = 0, 17675578689aSDaniel Lezcano .fc_nlinfo.nlh = NULL, 1768c346dca1SYOSHIFUJI Hideaki .fc_nlinfo.nl_net = dev_net(dev), 176986872cb5SThomas Graf }; 17701da177e4SLinus Torvalds 177186872cb5SThomas Graf ipv6_addr_copy(&cfg.fc_gateway, gwaddr); 17721da177e4SLinus Torvalds 177386872cb5SThomas Graf ip6_route_add(&cfg); 17741da177e4SLinus Torvalds 17751da177e4SLinus Torvalds return rt6_get_dflt_router(gwaddr, dev); 17761da177e4SLinus Torvalds } 17771da177e4SLinus Torvalds 17787b4da532SDaniel Lezcano void rt6_purge_dflt_routers(struct net *net) 17791da177e4SLinus Torvalds { 17801da177e4SLinus Torvalds struct rt6_info *rt; 1781c71099acSThomas Graf struct fib6_table *table; 1782c71099acSThomas Graf 1783c71099acSThomas Graf /* NOTE: Keep consistent with rt6_get_dflt_router */ 17847b4da532SDaniel Lezcano table = fib6_get_table(net, RT6_TABLE_DFLT); 1785c71099acSThomas Graf if (table == NULL) 1786c71099acSThomas Graf return; 17871da177e4SLinus Torvalds 17881da177e4SLinus Torvalds restart: 1789c71099acSThomas Graf read_lock_bh(&table->tb6_lock); 1790d8d1f30bSChangli Gao for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) { 17911da177e4SLinus Torvalds if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) { 1792d8d1f30bSChangli Gao dst_hold(&rt->dst); 1793c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 1794e0a1ad73SThomas Graf ip6_del_rt(rt); 17951da177e4SLinus Torvalds goto restart; 17961da177e4SLinus Torvalds } 17971da177e4SLinus Torvalds } 1798c71099acSThomas Graf read_unlock_bh(&table->tb6_lock); 17991da177e4SLinus Torvalds } 18001da177e4SLinus Torvalds 18015578689aSDaniel Lezcano static void rtmsg_to_fib6_config(struct net *net, 18025578689aSDaniel Lezcano struct in6_rtmsg *rtmsg, 180386872cb5SThomas Graf struct fib6_config *cfg) 180486872cb5SThomas Graf { 180586872cb5SThomas Graf memset(cfg, 0, sizeof(*cfg)); 180686872cb5SThomas Graf 180786872cb5SThomas Graf cfg->fc_table = RT6_TABLE_MAIN; 180886872cb5SThomas Graf cfg->fc_ifindex = rtmsg->rtmsg_ifindex; 180986872cb5SThomas Graf cfg->fc_metric = rtmsg->rtmsg_metric; 181086872cb5SThomas Graf cfg->fc_expires = rtmsg->rtmsg_info; 181186872cb5SThomas Graf cfg->fc_dst_len = rtmsg->rtmsg_dst_len; 181286872cb5SThomas Graf cfg->fc_src_len = rtmsg->rtmsg_src_len; 181386872cb5SThomas Graf cfg->fc_flags = rtmsg->rtmsg_flags; 181486872cb5SThomas Graf 18155578689aSDaniel Lezcano cfg->fc_nlinfo.nl_net = net; 1816f1243c2dSBenjamin Thery 181786872cb5SThomas Graf ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst); 181886872cb5SThomas Graf ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src); 181986872cb5SThomas Graf ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway); 182086872cb5SThomas Graf } 182186872cb5SThomas Graf 18225578689aSDaniel Lezcano int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg) 18231da177e4SLinus Torvalds { 182486872cb5SThomas Graf struct fib6_config cfg; 18251da177e4SLinus Torvalds struct in6_rtmsg rtmsg; 18261da177e4SLinus Torvalds int err; 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds switch(cmd) { 18291da177e4SLinus Torvalds case SIOCADDRT: /* Add a route */ 18301da177e4SLinus Torvalds case SIOCDELRT: /* Delete a route */ 18311da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 18321da177e4SLinus Torvalds return -EPERM; 18331da177e4SLinus Torvalds err = copy_from_user(&rtmsg, arg, 18341da177e4SLinus Torvalds sizeof(struct in6_rtmsg)); 18351da177e4SLinus Torvalds if (err) 18361da177e4SLinus Torvalds return -EFAULT; 18371da177e4SLinus Torvalds 18385578689aSDaniel Lezcano rtmsg_to_fib6_config(net, &rtmsg, &cfg); 183986872cb5SThomas Graf 18401da177e4SLinus Torvalds rtnl_lock(); 18411da177e4SLinus Torvalds switch (cmd) { 18421da177e4SLinus Torvalds case SIOCADDRT: 184386872cb5SThomas Graf err = ip6_route_add(&cfg); 18441da177e4SLinus Torvalds break; 18451da177e4SLinus Torvalds case SIOCDELRT: 184686872cb5SThomas Graf err = ip6_route_del(&cfg); 18471da177e4SLinus Torvalds break; 18481da177e4SLinus Torvalds default: 18491da177e4SLinus Torvalds err = -EINVAL; 18501da177e4SLinus Torvalds } 18511da177e4SLinus Torvalds rtnl_unlock(); 18521da177e4SLinus Torvalds 18531da177e4SLinus Torvalds return err; 18543ff50b79SStephen Hemminger } 18551da177e4SLinus Torvalds 18561da177e4SLinus Torvalds return -EINVAL; 18571da177e4SLinus Torvalds } 18581da177e4SLinus Torvalds 18591da177e4SLinus Torvalds /* 18601da177e4SLinus Torvalds * Drop the packet on the floor 18611da177e4SLinus Torvalds */ 18621da177e4SLinus Torvalds 1863d5fdd6baSBrian Haley static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes) 18641da177e4SLinus Torvalds { 1865612f09e8SYOSHIFUJI Hideaki int type; 1866adf30907SEric Dumazet struct dst_entry *dst = skb_dst(skb); 1867612f09e8SYOSHIFUJI Hideaki switch (ipstats_mib_noroutes) { 1868612f09e8SYOSHIFUJI Hideaki case IPSTATS_MIB_INNOROUTES: 18690660e03fSArnaldo Carvalho de Melo type = ipv6_addr_type(&ipv6_hdr(skb)->daddr); 187045bb0060SUlrich Weber if (type == IPV6_ADDR_ANY) { 18713bd653c8SDenis V. Lunev IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst), 18723bd653c8SDenis V. Lunev IPSTATS_MIB_INADDRERRORS); 1873612f09e8SYOSHIFUJI Hideaki break; 1874612f09e8SYOSHIFUJI Hideaki } 1875612f09e8SYOSHIFUJI Hideaki /* FALLTHROUGH */ 1876612f09e8SYOSHIFUJI Hideaki case IPSTATS_MIB_OUTNOROUTES: 18773bd653c8SDenis V. Lunev IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst), 18783bd653c8SDenis V. Lunev ipstats_mib_noroutes); 1879612f09e8SYOSHIFUJI Hideaki break; 1880612f09e8SYOSHIFUJI Hideaki } 18813ffe533cSAlexey Dobriyan icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0); 18821da177e4SLinus Torvalds kfree_skb(skb); 18831da177e4SLinus Torvalds return 0; 18841da177e4SLinus Torvalds } 18851da177e4SLinus Torvalds 18869ce8ade0SThomas Graf static int ip6_pkt_discard(struct sk_buff *skb) 18879ce8ade0SThomas Graf { 1888612f09e8SYOSHIFUJI Hideaki return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES); 18899ce8ade0SThomas Graf } 18909ce8ade0SThomas Graf 189120380731SArnaldo Carvalho de Melo static int ip6_pkt_discard_out(struct sk_buff *skb) 18921da177e4SLinus Torvalds { 1893adf30907SEric Dumazet skb->dev = skb_dst(skb)->dev; 1894612f09e8SYOSHIFUJI Hideaki return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES); 18951da177e4SLinus Torvalds } 18961da177e4SLinus Torvalds 18976723ab54SDavid S. Miller #ifdef CONFIG_IPV6_MULTIPLE_TABLES 18986723ab54SDavid S. Miller 18999ce8ade0SThomas Graf static int ip6_pkt_prohibit(struct sk_buff *skb) 19009ce8ade0SThomas Graf { 1901612f09e8SYOSHIFUJI Hideaki return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES); 19029ce8ade0SThomas Graf } 19039ce8ade0SThomas Graf 19049ce8ade0SThomas Graf static int ip6_pkt_prohibit_out(struct sk_buff *skb) 19059ce8ade0SThomas Graf { 1906adf30907SEric Dumazet skb->dev = skb_dst(skb)->dev; 1907612f09e8SYOSHIFUJI Hideaki return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES); 19089ce8ade0SThomas Graf } 19099ce8ade0SThomas Graf 19106723ab54SDavid S. Miller #endif 19116723ab54SDavid S. Miller 19121da177e4SLinus Torvalds /* 19131da177e4SLinus Torvalds * Allocate a dst for local (unicast / anycast) address. 19141da177e4SLinus Torvalds */ 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev, 19171da177e4SLinus Torvalds const struct in6_addr *addr, 19181da177e4SLinus Torvalds int anycast) 19191da177e4SLinus Torvalds { 1920c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(idev->dev); 192186393e52SAlexey Dobriyan struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops); 192214deae41SDavid S. Miller struct neighbour *neigh; 19231da177e4SLinus Torvalds 19241da177e4SLinus Torvalds if (rt == NULL) 19251da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 19261da177e4SLinus Torvalds 19275578689aSDaniel Lezcano dev_hold(net->loopback_dev); 19281da177e4SLinus Torvalds in6_dev_hold(idev); 19291da177e4SLinus Torvalds 1930d8d1f30bSChangli Gao rt->dst.flags = DST_HOST; 1931d8d1f30bSChangli Gao rt->dst.input = ip6_input; 1932d8d1f30bSChangli Gao rt->dst.output = ip6_output; 19335578689aSDaniel Lezcano rt->rt6i_dev = net->loopback_dev; 19341da177e4SLinus Torvalds rt->rt6i_idev = idev; 1935d8d1f30bSChangli Gao rt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev); 1936d8d1f30bSChangli Gao rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->dst)); 1937d8d1f30bSChangli Gao rt->dst.metrics[RTAX_HOPLIMIT-1] = -1; 1938d8d1f30bSChangli Gao rt->dst.obsolete = -1; 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP; 194158c4fb86SYOSHIFUJI Hideaki if (anycast) 194258c4fb86SYOSHIFUJI Hideaki rt->rt6i_flags |= RTF_ANYCAST; 194358c4fb86SYOSHIFUJI Hideaki else 19441da177e4SLinus Torvalds rt->rt6i_flags |= RTF_LOCAL; 194514deae41SDavid S. Miller neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway); 194614deae41SDavid S. Miller if (IS_ERR(neigh)) { 1947d8d1f30bSChangli Gao dst_free(&rt->dst); 194814deae41SDavid S. Miller 194914deae41SDavid S. Miller /* We are casting this because that is the return 195014deae41SDavid S. Miller * value type. But an errno encoded pointer is the 195114deae41SDavid S. Miller * same regardless of the underlying pointer type, 195214deae41SDavid S. Miller * and that's what we are returning. So this is OK. 195314deae41SDavid S. Miller */ 195414deae41SDavid S. Miller return (struct rt6_info *) neigh; 19551da177e4SLinus Torvalds } 195614deae41SDavid S. Miller rt->rt6i_nexthop = neigh; 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds ipv6_addr_copy(&rt->rt6i_dst.addr, addr); 19591da177e4SLinus Torvalds rt->rt6i_dst.plen = 128; 19605578689aSDaniel Lezcano rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL); 19611da177e4SLinus Torvalds 1962d8d1f30bSChangli Gao atomic_set(&rt->dst.__refcnt, 1); 19631da177e4SLinus Torvalds 19641da177e4SLinus Torvalds return rt; 19651da177e4SLinus Torvalds } 19661da177e4SLinus Torvalds 19678ed67789SDaniel Lezcano struct arg_dev_net { 19688ed67789SDaniel Lezcano struct net_device *dev; 19698ed67789SDaniel Lezcano struct net *net; 19708ed67789SDaniel Lezcano }; 19718ed67789SDaniel Lezcano 19721da177e4SLinus Torvalds static int fib6_ifdown(struct rt6_info *rt, void *arg) 19731da177e4SLinus Torvalds { 19748ed67789SDaniel Lezcano struct net_device *dev = ((struct arg_dev_net *)arg)->dev; 19758ed67789SDaniel Lezcano struct net *net = ((struct arg_dev_net *)arg)->net; 19768ed67789SDaniel Lezcano 19778ed67789SDaniel Lezcano if (((void *)rt->rt6i_dev == dev || dev == NULL) && 19788ed67789SDaniel Lezcano rt != net->ipv6.ip6_null_entry) { 19791da177e4SLinus Torvalds RT6_TRACE("deleted by ifdown %p\n", rt); 19801da177e4SLinus Torvalds return -1; 19811da177e4SLinus Torvalds } 19821da177e4SLinus Torvalds return 0; 19831da177e4SLinus Torvalds } 19841da177e4SLinus Torvalds 1985f3db4851SDaniel Lezcano void rt6_ifdown(struct net *net, struct net_device *dev) 19861da177e4SLinus Torvalds { 19878ed67789SDaniel Lezcano struct arg_dev_net adn = { 19888ed67789SDaniel Lezcano .dev = dev, 19898ed67789SDaniel Lezcano .net = net, 19908ed67789SDaniel Lezcano }; 19918ed67789SDaniel Lezcano 19928ed67789SDaniel Lezcano fib6_clean_all(net, fib6_ifdown, 0, &adn); 19931e493d19SDavid S. Miller icmp6_clean_all(fib6_ifdown, &adn); 19941da177e4SLinus Torvalds } 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds struct rt6_mtu_change_arg 19971da177e4SLinus Torvalds { 19981da177e4SLinus Torvalds struct net_device *dev; 19991da177e4SLinus Torvalds unsigned mtu; 20001da177e4SLinus Torvalds }; 20011da177e4SLinus Torvalds 20021da177e4SLinus Torvalds static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg) 20031da177e4SLinus Torvalds { 20041da177e4SLinus Torvalds struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg; 20051da177e4SLinus Torvalds struct inet6_dev *idev; 2006c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(arg->dev); 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds /* In IPv6 pmtu discovery is not optional, 20091da177e4SLinus Torvalds so that RTAX_MTU lock cannot disable it. 20101da177e4SLinus Torvalds We still use this lock to block changes 20111da177e4SLinus Torvalds caused by addrconf/ndisc. 20121da177e4SLinus Torvalds */ 20131da177e4SLinus Torvalds 20141da177e4SLinus Torvalds idev = __in6_dev_get(arg->dev); 20151da177e4SLinus Torvalds if (idev == NULL) 20161da177e4SLinus Torvalds return 0; 20171da177e4SLinus Torvalds 20181da177e4SLinus Torvalds /* For administrative MTU increase, there is no way to discover 20191da177e4SLinus Torvalds IPv6 PMTU increase, so PMTU increase should be updated here. 20201da177e4SLinus Torvalds Since RFC 1981 doesn't include administrative MTU increase 20211da177e4SLinus Torvalds update PMTU increase is a MUST. (i.e. jumbo frame) 20221da177e4SLinus Torvalds */ 20231da177e4SLinus Torvalds /* 20241da177e4SLinus Torvalds If new MTU is less than route PMTU, this new MTU will be the 20251da177e4SLinus Torvalds lowest MTU in the path, update the route PMTU to reflect PMTU 20261da177e4SLinus Torvalds decreases; if new MTU is greater than route PMTU, and the 20271da177e4SLinus Torvalds old MTU is the lowest MTU in the path, update the route PMTU 20281da177e4SLinus Torvalds to reflect the increase. In this case if the other nodes' MTU 20291da177e4SLinus Torvalds also have the lowest MTU, TOO BIG MESSAGE will be lead to 20301da177e4SLinus Torvalds PMTU discouvery. 20311da177e4SLinus Torvalds */ 20321da177e4SLinus Torvalds if (rt->rt6i_dev == arg->dev && 2033d8d1f30bSChangli Gao !dst_metric_locked(&rt->dst, RTAX_MTU) && 2034d8d1f30bSChangli Gao (dst_mtu(&rt->dst) >= arg->mtu || 2035d8d1f30bSChangli Gao (dst_mtu(&rt->dst) < arg->mtu && 2036d8d1f30bSChangli Gao dst_mtu(&rt->dst) == idev->cnf.mtu6))) { 2037d8d1f30bSChangli Gao rt->dst.metrics[RTAX_MTU-1] = arg->mtu; 2038d8d1f30bSChangli Gao rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, arg->mtu); 2039566cfd8fSSimon Arlott } 20401da177e4SLinus Torvalds return 0; 20411da177e4SLinus Torvalds } 20421da177e4SLinus Torvalds 20431da177e4SLinus Torvalds void rt6_mtu_change(struct net_device *dev, unsigned mtu) 20441da177e4SLinus Torvalds { 2045c71099acSThomas Graf struct rt6_mtu_change_arg arg = { 2046c71099acSThomas Graf .dev = dev, 2047c71099acSThomas Graf .mtu = mtu, 2048c71099acSThomas Graf }; 20491da177e4SLinus Torvalds 2050c346dca1SYOSHIFUJI Hideaki fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg); 20511da177e4SLinus Torvalds } 20521da177e4SLinus Torvalds 2053ef7c79edSPatrick McHardy static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = { 20545176f91eSThomas Graf [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) }, 205586872cb5SThomas Graf [RTA_OIF] = { .type = NLA_U32 }, 2056ab364a6fSThomas Graf [RTA_IIF] = { .type = NLA_U32 }, 205786872cb5SThomas Graf [RTA_PRIORITY] = { .type = NLA_U32 }, 205886872cb5SThomas Graf [RTA_METRICS] = { .type = NLA_NESTED }, 205986872cb5SThomas Graf }; 206086872cb5SThomas Graf 206186872cb5SThomas Graf static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh, 206286872cb5SThomas Graf struct fib6_config *cfg) 20631da177e4SLinus Torvalds { 206486872cb5SThomas Graf struct rtmsg *rtm; 206586872cb5SThomas Graf struct nlattr *tb[RTA_MAX+1]; 206686872cb5SThomas Graf int err; 20671da177e4SLinus Torvalds 206886872cb5SThomas Graf err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy); 206986872cb5SThomas Graf if (err < 0) 207086872cb5SThomas Graf goto errout; 20711da177e4SLinus Torvalds 207286872cb5SThomas Graf err = -EINVAL; 207386872cb5SThomas Graf rtm = nlmsg_data(nlh); 207486872cb5SThomas Graf memset(cfg, 0, sizeof(*cfg)); 207586872cb5SThomas Graf 207686872cb5SThomas Graf cfg->fc_table = rtm->rtm_table; 207786872cb5SThomas Graf cfg->fc_dst_len = rtm->rtm_dst_len; 207886872cb5SThomas Graf cfg->fc_src_len = rtm->rtm_src_len; 207986872cb5SThomas Graf cfg->fc_flags = RTF_UP; 208086872cb5SThomas Graf cfg->fc_protocol = rtm->rtm_protocol; 208186872cb5SThomas Graf 208286872cb5SThomas Graf if (rtm->rtm_type == RTN_UNREACHABLE) 208386872cb5SThomas Graf cfg->fc_flags |= RTF_REJECT; 208486872cb5SThomas Graf 208586872cb5SThomas Graf cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid; 208686872cb5SThomas Graf cfg->fc_nlinfo.nlh = nlh; 20873b1e0a65SYOSHIFUJI Hideaki cfg->fc_nlinfo.nl_net = sock_net(skb->sk); 208886872cb5SThomas Graf 208986872cb5SThomas Graf if (tb[RTA_GATEWAY]) { 209086872cb5SThomas Graf nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16); 209186872cb5SThomas Graf cfg->fc_flags |= RTF_GATEWAY; 20921da177e4SLinus Torvalds } 209386872cb5SThomas Graf 209486872cb5SThomas Graf if (tb[RTA_DST]) { 209586872cb5SThomas Graf int plen = (rtm->rtm_dst_len + 7) >> 3; 209686872cb5SThomas Graf 209786872cb5SThomas Graf if (nla_len(tb[RTA_DST]) < plen) 209886872cb5SThomas Graf goto errout; 209986872cb5SThomas Graf 210086872cb5SThomas Graf nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen); 21011da177e4SLinus Torvalds } 210286872cb5SThomas Graf 210386872cb5SThomas Graf if (tb[RTA_SRC]) { 210486872cb5SThomas Graf int plen = (rtm->rtm_src_len + 7) >> 3; 210586872cb5SThomas Graf 210686872cb5SThomas Graf if (nla_len(tb[RTA_SRC]) < plen) 210786872cb5SThomas Graf goto errout; 210886872cb5SThomas Graf 210986872cb5SThomas Graf nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen); 21101da177e4SLinus Torvalds } 211186872cb5SThomas Graf 211286872cb5SThomas Graf if (tb[RTA_OIF]) 211386872cb5SThomas Graf cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]); 211486872cb5SThomas Graf 211586872cb5SThomas Graf if (tb[RTA_PRIORITY]) 211686872cb5SThomas Graf cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]); 211786872cb5SThomas Graf 211886872cb5SThomas Graf if (tb[RTA_METRICS]) { 211986872cb5SThomas Graf cfg->fc_mx = nla_data(tb[RTA_METRICS]); 212086872cb5SThomas Graf cfg->fc_mx_len = nla_len(tb[RTA_METRICS]); 21211da177e4SLinus Torvalds } 212286872cb5SThomas Graf 212386872cb5SThomas Graf if (tb[RTA_TABLE]) 212486872cb5SThomas Graf cfg->fc_table = nla_get_u32(tb[RTA_TABLE]); 212586872cb5SThomas Graf 212686872cb5SThomas Graf err = 0; 212786872cb5SThomas Graf errout: 212886872cb5SThomas Graf return err; 21291da177e4SLinus Torvalds } 21301da177e4SLinus Torvalds 2131c127ea2cSThomas Graf static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg) 21321da177e4SLinus Torvalds { 213386872cb5SThomas Graf struct fib6_config cfg; 213486872cb5SThomas Graf int err; 21351da177e4SLinus Torvalds 213686872cb5SThomas Graf err = rtm_to_fib6_config(skb, nlh, &cfg); 213786872cb5SThomas Graf if (err < 0) 213886872cb5SThomas Graf return err; 213986872cb5SThomas Graf 214086872cb5SThomas Graf return ip6_route_del(&cfg); 21411da177e4SLinus Torvalds } 21421da177e4SLinus Torvalds 2143c127ea2cSThomas Graf static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg) 21441da177e4SLinus Torvalds { 214586872cb5SThomas Graf struct fib6_config cfg; 214686872cb5SThomas Graf int err; 21471da177e4SLinus Torvalds 214886872cb5SThomas Graf err = rtm_to_fib6_config(skb, nlh, &cfg); 214986872cb5SThomas Graf if (err < 0) 215086872cb5SThomas Graf return err; 215186872cb5SThomas Graf 215286872cb5SThomas Graf return ip6_route_add(&cfg); 21531da177e4SLinus Torvalds } 21541da177e4SLinus Torvalds 2155339bf98fSThomas Graf static inline size_t rt6_nlmsg_size(void) 2156339bf98fSThomas Graf { 2157339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct rtmsg)) 2158339bf98fSThomas Graf + nla_total_size(16) /* RTA_SRC */ 2159339bf98fSThomas Graf + nla_total_size(16) /* RTA_DST */ 2160339bf98fSThomas Graf + nla_total_size(16) /* RTA_GATEWAY */ 2161339bf98fSThomas Graf + nla_total_size(16) /* RTA_PREFSRC */ 2162339bf98fSThomas Graf + nla_total_size(4) /* RTA_TABLE */ 2163339bf98fSThomas Graf + nla_total_size(4) /* RTA_IIF */ 2164339bf98fSThomas Graf + nla_total_size(4) /* RTA_OIF */ 2165339bf98fSThomas Graf + nla_total_size(4) /* RTA_PRIORITY */ 21666a2b9ce0SNoriaki TAKAMIYA + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */ 2167339bf98fSThomas Graf + nla_total_size(sizeof(struct rta_cacheinfo)); 2168339bf98fSThomas Graf } 2169339bf98fSThomas Graf 2170191cd582SBrian Haley static int rt6_fill_node(struct net *net, 2171191cd582SBrian Haley struct sk_buff *skb, struct rt6_info *rt, 21720d51aa80SJamal Hadi Salim struct in6_addr *dst, struct in6_addr *src, 21730d51aa80SJamal Hadi Salim int iif, int type, u32 pid, u32 seq, 21747bc570c8SYOSHIFUJI Hideaki int prefix, int nowait, unsigned int flags) 21751da177e4SLinus Torvalds { 21761da177e4SLinus Torvalds struct rtmsg *rtm; 21771da177e4SLinus Torvalds struct nlmsghdr *nlh; 2178e3703b3dSThomas Graf long expires; 21799e762a4aSPatrick McHardy u32 table; 21801da177e4SLinus Torvalds 21811da177e4SLinus Torvalds if (prefix) { /* user wants prefix routes only */ 21821da177e4SLinus Torvalds if (!(rt->rt6i_flags & RTF_PREFIX_RT)) { 21831da177e4SLinus Torvalds /* success since this is not a prefix route */ 21841da177e4SLinus Torvalds return 1; 21851da177e4SLinus Torvalds } 21861da177e4SLinus Torvalds } 21871da177e4SLinus Torvalds 21882d7202bfSThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags); 21892d7202bfSThomas Graf if (nlh == NULL) 219026932566SPatrick McHardy return -EMSGSIZE; 21912d7202bfSThomas Graf 21922d7202bfSThomas Graf rtm = nlmsg_data(nlh); 21931da177e4SLinus Torvalds rtm->rtm_family = AF_INET6; 21941da177e4SLinus Torvalds rtm->rtm_dst_len = rt->rt6i_dst.plen; 21951da177e4SLinus Torvalds rtm->rtm_src_len = rt->rt6i_src.plen; 21961da177e4SLinus Torvalds rtm->rtm_tos = 0; 2197c71099acSThomas Graf if (rt->rt6i_table) 21989e762a4aSPatrick McHardy table = rt->rt6i_table->tb6_id; 2199c71099acSThomas Graf else 22009e762a4aSPatrick McHardy table = RT6_TABLE_UNSPEC; 22019e762a4aSPatrick McHardy rtm->rtm_table = table; 22022d7202bfSThomas Graf NLA_PUT_U32(skb, RTA_TABLE, table); 22031da177e4SLinus Torvalds if (rt->rt6i_flags&RTF_REJECT) 22041da177e4SLinus Torvalds rtm->rtm_type = RTN_UNREACHABLE; 22051da177e4SLinus Torvalds else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK)) 22061da177e4SLinus Torvalds rtm->rtm_type = RTN_LOCAL; 22071da177e4SLinus Torvalds else 22081da177e4SLinus Torvalds rtm->rtm_type = RTN_UNICAST; 22091da177e4SLinus Torvalds rtm->rtm_flags = 0; 22101da177e4SLinus Torvalds rtm->rtm_scope = RT_SCOPE_UNIVERSE; 22111da177e4SLinus Torvalds rtm->rtm_protocol = rt->rt6i_protocol; 22121da177e4SLinus Torvalds if (rt->rt6i_flags&RTF_DYNAMIC) 22131da177e4SLinus Torvalds rtm->rtm_protocol = RTPROT_REDIRECT; 22141da177e4SLinus Torvalds else if (rt->rt6i_flags & RTF_ADDRCONF) 22151da177e4SLinus Torvalds rtm->rtm_protocol = RTPROT_KERNEL; 22161da177e4SLinus Torvalds else if (rt->rt6i_flags&RTF_DEFAULT) 22171da177e4SLinus Torvalds rtm->rtm_protocol = RTPROT_RA; 22181da177e4SLinus Torvalds 22191da177e4SLinus Torvalds if (rt->rt6i_flags&RTF_CACHE) 22201da177e4SLinus Torvalds rtm->rtm_flags |= RTM_F_CLONED; 22211da177e4SLinus Torvalds 22221da177e4SLinus Torvalds if (dst) { 22232d7202bfSThomas Graf NLA_PUT(skb, RTA_DST, 16, dst); 22241da177e4SLinus Torvalds rtm->rtm_dst_len = 128; 22251da177e4SLinus Torvalds } else if (rtm->rtm_dst_len) 22262d7202bfSThomas Graf NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr); 22271da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES 22281da177e4SLinus Torvalds if (src) { 22292d7202bfSThomas Graf NLA_PUT(skb, RTA_SRC, 16, src); 22301da177e4SLinus Torvalds rtm->rtm_src_len = 128; 22311da177e4SLinus Torvalds } else if (rtm->rtm_src_len) 22322d7202bfSThomas Graf NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr); 22331da177e4SLinus Torvalds #endif 22347bc570c8SYOSHIFUJI Hideaki if (iif) { 22357bc570c8SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_MROUTE 22367bc570c8SYOSHIFUJI Hideaki if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) { 22378229efdaSBenjamin Thery int err = ip6mr_get_route(net, skb, rtm, nowait); 22387bc570c8SYOSHIFUJI Hideaki if (err <= 0) { 22397bc570c8SYOSHIFUJI Hideaki if (!nowait) { 22407bc570c8SYOSHIFUJI Hideaki if (err == 0) 22417bc570c8SYOSHIFUJI Hideaki return 0; 22427bc570c8SYOSHIFUJI Hideaki goto nla_put_failure; 22437bc570c8SYOSHIFUJI Hideaki } else { 22447bc570c8SYOSHIFUJI Hideaki if (err == -EMSGSIZE) 22457bc570c8SYOSHIFUJI Hideaki goto nla_put_failure; 22467bc570c8SYOSHIFUJI Hideaki } 22477bc570c8SYOSHIFUJI Hideaki } 22487bc570c8SYOSHIFUJI Hideaki } else 22497bc570c8SYOSHIFUJI Hideaki #endif 22502d7202bfSThomas Graf NLA_PUT_U32(skb, RTA_IIF, iif); 22517bc570c8SYOSHIFUJI Hideaki } else if (dst) { 2252d8d1f30bSChangli Gao struct inet6_dev *idev = ip6_dst_idev(&rt->dst); 22531da177e4SLinus Torvalds struct in6_addr saddr_buf; 2254191cd582SBrian Haley if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL, 22557cbca67cSYOSHIFUJI Hideaki dst, 0, &saddr_buf) == 0) 22562d7202bfSThomas Graf NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf); 22571da177e4SLinus Torvalds } 22582d7202bfSThomas Graf 2259d8d1f30bSChangli Gao if (rtnetlink_put_metrics(skb, rt->dst.metrics) < 0) 22602d7202bfSThomas Graf goto nla_put_failure; 22612d7202bfSThomas Graf 2262d8d1f30bSChangli Gao if (rt->dst.neighbour) 2263d8d1f30bSChangli Gao NLA_PUT(skb, RTA_GATEWAY, 16, &rt->dst.neighbour->primary_key); 22642d7202bfSThomas Graf 2265d8d1f30bSChangli Gao if (rt->dst.dev) 22662d7202bfSThomas Graf NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex); 22672d7202bfSThomas Graf 22682d7202bfSThomas Graf NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric); 2269e3703b3dSThomas Graf 227036e3deaeSYOSHIFUJI Hideaki if (!(rt->rt6i_flags & RTF_EXPIRES)) 227136e3deaeSYOSHIFUJI Hideaki expires = 0; 227236e3deaeSYOSHIFUJI Hideaki else if (rt->rt6i_expires - jiffies < INT_MAX) 227336e3deaeSYOSHIFUJI Hideaki expires = rt->rt6i_expires - jiffies; 227436e3deaeSYOSHIFUJI Hideaki else 227536e3deaeSYOSHIFUJI Hideaki expires = INT_MAX; 227669cdf8f9SYOSHIFUJI Hideaki 2277d8d1f30bSChangli Gao if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0, 2278d8d1f30bSChangli Gao expires, rt->dst.error) < 0) 2279e3703b3dSThomas Graf goto nla_put_failure; 22801da177e4SLinus Torvalds 22812d7202bfSThomas Graf return nlmsg_end(skb, nlh); 22822d7202bfSThomas Graf 22832d7202bfSThomas Graf nla_put_failure: 228426932566SPatrick McHardy nlmsg_cancel(skb, nlh); 228526932566SPatrick McHardy return -EMSGSIZE; 22861da177e4SLinus Torvalds } 22871da177e4SLinus Torvalds 22881b43af54SPatrick McHardy int rt6_dump_route(struct rt6_info *rt, void *p_arg) 22891da177e4SLinus Torvalds { 22901da177e4SLinus Torvalds struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg; 22911da177e4SLinus Torvalds int prefix; 22921da177e4SLinus Torvalds 22932d7202bfSThomas Graf if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) { 22942d7202bfSThomas Graf struct rtmsg *rtm = nlmsg_data(arg->cb->nlh); 22951da177e4SLinus Torvalds prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0; 22961da177e4SLinus Torvalds } else 22971da177e4SLinus Torvalds prefix = 0; 22981da177e4SLinus Torvalds 2299191cd582SBrian Haley return rt6_fill_node(arg->net, 2300191cd582SBrian Haley arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE, 23011da177e4SLinus Torvalds NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq, 23027bc570c8SYOSHIFUJI Hideaki prefix, 0, NLM_F_MULTI); 23031da177e4SLinus Torvalds } 23041da177e4SLinus Torvalds 2305c127ea2cSThomas Graf static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg) 23061da177e4SLinus Torvalds { 23073b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(in_skb->sk); 2308ab364a6fSThomas Graf struct nlattr *tb[RTA_MAX+1]; 23091da177e4SLinus Torvalds struct rt6_info *rt; 2310ab364a6fSThomas Graf struct sk_buff *skb; 2311ab364a6fSThomas Graf struct rtmsg *rtm; 2312ab364a6fSThomas Graf struct flowi fl; 2313ab364a6fSThomas Graf int err, iif = 0; 2314ab364a6fSThomas Graf 2315ab364a6fSThomas Graf err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy); 2316ab364a6fSThomas Graf if (err < 0) 2317ab364a6fSThomas Graf goto errout; 2318ab364a6fSThomas Graf 2319ab364a6fSThomas Graf err = -EINVAL; 2320ab364a6fSThomas Graf memset(&fl, 0, sizeof(fl)); 2321ab364a6fSThomas Graf 2322ab364a6fSThomas Graf if (tb[RTA_SRC]) { 2323ab364a6fSThomas Graf if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr)) 2324ab364a6fSThomas Graf goto errout; 2325ab364a6fSThomas Graf 2326ab364a6fSThomas Graf ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC])); 2327ab364a6fSThomas Graf } 2328ab364a6fSThomas Graf 2329ab364a6fSThomas Graf if (tb[RTA_DST]) { 2330ab364a6fSThomas Graf if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr)) 2331ab364a6fSThomas Graf goto errout; 2332ab364a6fSThomas Graf 2333ab364a6fSThomas Graf ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST])); 2334ab364a6fSThomas Graf } 2335ab364a6fSThomas Graf 2336ab364a6fSThomas Graf if (tb[RTA_IIF]) 2337ab364a6fSThomas Graf iif = nla_get_u32(tb[RTA_IIF]); 2338ab364a6fSThomas Graf 2339ab364a6fSThomas Graf if (tb[RTA_OIF]) 2340ab364a6fSThomas Graf fl.oif = nla_get_u32(tb[RTA_OIF]); 2341ab364a6fSThomas Graf 2342ab364a6fSThomas Graf if (iif) { 2343ab364a6fSThomas Graf struct net_device *dev; 23445578689aSDaniel Lezcano dev = __dev_get_by_index(net, iif); 2345ab364a6fSThomas Graf if (!dev) { 2346ab364a6fSThomas Graf err = -ENODEV; 2347ab364a6fSThomas Graf goto errout; 2348ab364a6fSThomas Graf } 2349ab364a6fSThomas Graf } 23501da177e4SLinus Torvalds 23511da177e4SLinus Torvalds skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 2352ab364a6fSThomas Graf if (skb == NULL) { 2353ab364a6fSThomas Graf err = -ENOBUFS; 2354ab364a6fSThomas Graf goto errout; 2355ab364a6fSThomas Graf } 23561da177e4SLinus Torvalds 23571da177e4SLinus Torvalds /* Reserve room for dummy headers, this skb can pass 23581da177e4SLinus Torvalds through good chunk of routing engine. 23591da177e4SLinus Torvalds */ 2360459a98edSArnaldo Carvalho de Melo skb_reset_mac_header(skb); 23611da177e4SLinus Torvalds skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr)); 23621da177e4SLinus Torvalds 23638a3edd80SDaniel Lezcano rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl); 2364d8d1f30bSChangli Gao skb_dst_set(skb, &rt->dst); 23651da177e4SLinus Torvalds 2366191cd582SBrian Haley err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif, 23671da177e4SLinus Torvalds RTM_NEWROUTE, NETLINK_CB(in_skb).pid, 23687bc570c8SYOSHIFUJI Hideaki nlh->nlmsg_seq, 0, 0, 0); 23691da177e4SLinus Torvalds if (err < 0) { 2370ab364a6fSThomas Graf kfree_skb(skb); 2371ab364a6fSThomas Graf goto errout; 23721da177e4SLinus Torvalds } 23731da177e4SLinus Torvalds 23745578689aSDaniel Lezcano err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid); 2375ab364a6fSThomas Graf errout: 23761da177e4SLinus Torvalds return err; 23771da177e4SLinus Torvalds } 23781da177e4SLinus Torvalds 237986872cb5SThomas Graf void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info) 23801da177e4SLinus Torvalds { 23811da177e4SLinus Torvalds struct sk_buff *skb; 23825578689aSDaniel Lezcano struct net *net = info->nl_net; 2383528c4cebSDenis V. Lunev u32 seq; 2384528c4cebSDenis V. Lunev int err; 23850d51aa80SJamal Hadi Salim 2386528c4cebSDenis V. Lunev err = -ENOBUFS; 2387528c4cebSDenis V. Lunev seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0; 238886872cb5SThomas Graf 2389339bf98fSThomas Graf skb = nlmsg_new(rt6_nlmsg_size(), gfp_any()); 239021713ebcSThomas Graf if (skb == NULL) 239121713ebcSThomas Graf goto errout; 23921da177e4SLinus Torvalds 2393191cd582SBrian Haley err = rt6_fill_node(net, skb, rt, NULL, NULL, 0, 23947bc570c8SYOSHIFUJI Hideaki event, info->pid, seq, 0, 0, 0); 239526932566SPatrick McHardy if (err < 0) { 239626932566SPatrick McHardy /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */ 239726932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 239826932566SPatrick McHardy kfree_skb(skb); 239926932566SPatrick McHardy goto errout; 240026932566SPatrick McHardy } 24011ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE, 24025578689aSDaniel Lezcano info->nlh, gfp_any()); 24031ce85fe4SPablo Neira Ayuso return; 240421713ebcSThomas Graf errout: 240521713ebcSThomas Graf if (err < 0) 24065578689aSDaniel Lezcano rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err); 24071da177e4SLinus Torvalds } 24081da177e4SLinus Torvalds 24098ed67789SDaniel Lezcano static int ip6_route_dev_notify(struct notifier_block *this, 24108ed67789SDaniel Lezcano unsigned long event, void *data) 24118ed67789SDaniel Lezcano { 24128ed67789SDaniel Lezcano struct net_device *dev = (struct net_device *)data; 2413c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 24148ed67789SDaniel Lezcano 24158ed67789SDaniel Lezcano if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) { 2416d8d1f30bSChangli Gao net->ipv6.ip6_null_entry->dst.dev = dev; 24178ed67789SDaniel Lezcano net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev); 24188ed67789SDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES 2419d8d1f30bSChangli Gao net->ipv6.ip6_prohibit_entry->dst.dev = dev; 24208ed67789SDaniel Lezcano net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev); 2421d8d1f30bSChangli Gao net->ipv6.ip6_blk_hole_entry->dst.dev = dev; 24228ed67789SDaniel Lezcano net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev); 24238ed67789SDaniel Lezcano #endif 24248ed67789SDaniel Lezcano } 24258ed67789SDaniel Lezcano 24268ed67789SDaniel Lezcano return NOTIFY_OK; 24278ed67789SDaniel Lezcano } 24288ed67789SDaniel Lezcano 24291da177e4SLinus Torvalds /* 24301da177e4SLinus Torvalds * /proc 24311da177e4SLinus Torvalds */ 24321da177e4SLinus Torvalds 24331da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 24341da177e4SLinus Torvalds 24351da177e4SLinus Torvalds #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1) 24361da177e4SLinus Torvalds 24371da177e4SLinus Torvalds struct rt6_proc_arg 24381da177e4SLinus Torvalds { 24391da177e4SLinus Torvalds char *buffer; 24401da177e4SLinus Torvalds int offset; 24411da177e4SLinus Torvalds int length; 24421da177e4SLinus Torvalds int skip; 24431da177e4SLinus Torvalds int len; 24441da177e4SLinus Torvalds }; 24451da177e4SLinus Torvalds 24461da177e4SLinus Torvalds static int rt6_info_route(struct rt6_info *rt, void *p_arg) 24471da177e4SLinus Torvalds { 244833120b30SAlexey Dobriyan struct seq_file *m = p_arg; 24491da177e4SLinus Torvalds 24504b7a4274SHarvey Harrison seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen); 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES 24534b7a4274SHarvey Harrison seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen); 24541da177e4SLinus Torvalds #else 245533120b30SAlexey Dobriyan seq_puts(m, "00000000000000000000000000000000 00 "); 24561da177e4SLinus Torvalds #endif 24571da177e4SLinus Torvalds 24581da177e4SLinus Torvalds if (rt->rt6i_nexthop) { 24594b7a4274SHarvey Harrison seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key); 24601da177e4SLinus Torvalds } else { 246133120b30SAlexey Dobriyan seq_puts(m, "00000000000000000000000000000000"); 24621da177e4SLinus Torvalds } 246333120b30SAlexey Dobriyan seq_printf(m, " %08x %08x %08x %08x %8s\n", 2464d8d1f30bSChangli Gao rt->rt6i_metric, atomic_read(&rt->dst.__refcnt), 2465d8d1f30bSChangli Gao rt->dst.__use, rt->rt6i_flags, 24661da177e4SLinus Torvalds rt->rt6i_dev ? rt->rt6i_dev->name : ""); 24671da177e4SLinus Torvalds return 0; 24681da177e4SLinus Torvalds } 24691da177e4SLinus Torvalds 247033120b30SAlexey Dobriyan static int ipv6_route_show(struct seq_file *m, void *v) 24711da177e4SLinus Torvalds { 2472f3db4851SDaniel Lezcano struct net *net = (struct net *)m->private; 2473f3db4851SDaniel Lezcano fib6_clean_all(net, rt6_info_route, 0, m); 247433120b30SAlexey Dobriyan return 0; 24751da177e4SLinus Torvalds } 24761da177e4SLinus Torvalds 247733120b30SAlexey Dobriyan static int ipv6_route_open(struct inode *inode, struct file *file) 247833120b30SAlexey Dobriyan { 2479de05c557SPavel Emelyanov return single_open_net(inode, file, ipv6_route_show); 2480f3db4851SDaniel Lezcano } 2481f3db4851SDaniel Lezcano 248233120b30SAlexey Dobriyan static const struct file_operations ipv6_route_proc_fops = { 248333120b30SAlexey Dobriyan .owner = THIS_MODULE, 248433120b30SAlexey Dobriyan .open = ipv6_route_open, 248533120b30SAlexey Dobriyan .read = seq_read, 248633120b30SAlexey Dobriyan .llseek = seq_lseek, 2487b6fcbdb4SPavel Emelyanov .release = single_release_net, 248833120b30SAlexey Dobriyan }; 248933120b30SAlexey Dobriyan 24901da177e4SLinus Torvalds static int rt6_stats_seq_show(struct seq_file *seq, void *v) 24911da177e4SLinus Torvalds { 249269ddb805SDaniel Lezcano struct net *net = (struct net *)seq->private; 24931da177e4SLinus Torvalds seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n", 249469ddb805SDaniel Lezcano net->ipv6.rt6_stats->fib_nodes, 249569ddb805SDaniel Lezcano net->ipv6.rt6_stats->fib_route_nodes, 249669ddb805SDaniel Lezcano net->ipv6.rt6_stats->fib_rt_alloc, 249769ddb805SDaniel Lezcano net->ipv6.rt6_stats->fib_rt_entries, 249869ddb805SDaniel Lezcano net->ipv6.rt6_stats->fib_rt_cache, 249986393e52SAlexey Dobriyan atomic_read(&net->ipv6.ip6_dst_ops.entries), 250069ddb805SDaniel Lezcano net->ipv6.rt6_stats->fib_discarded_routes); 25011da177e4SLinus Torvalds 25021da177e4SLinus Torvalds return 0; 25031da177e4SLinus Torvalds } 25041da177e4SLinus Torvalds 25051da177e4SLinus Torvalds static int rt6_stats_seq_open(struct inode *inode, struct file *file) 25061da177e4SLinus Torvalds { 2507de05c557SPavel Emelyanov return single_open_net(inode, file, rt6_stats_seq_show); 250869ddb805SDaniel Lezcano } 250969ddb805SDaniel Lezcano 25109a32144eSArjan van de Ven static const struct file_operations rt6_stats_seq_fops = { 25111da177e4SLinus Torvalds .owner = THIS_MODULE, 25121da177e4SLinus Torvalds .open = rt6_stats_seq_open, 25131da177e4SLinus Torvalds .read = seq_read, 25141da177e4SLinus Torvalds .llseek = seq_lseek, 2515b6fcbdb4SPavel Emelyanov .release = single_release_net, 25161da177e4SLinus Torvalds }; 25171da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 25181da177e4SLinus Torvalds 25191da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 25201da177e4SLinus Torvalds 25211da177e4SLinus Torvalds static 25228d65af78SAlexey Dobriyan int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, 25231da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 25241da177e4SLinus Torvalds { 25255b7c931dSDaniel Lezcano struct net *net = current->nsproxy->net_ns; 25265b7c931dSDaniel Lezcano int delay = net->ipv6.sysctl.flush_delay; 25271da177e4SLinus Torvalds if (write) { 25288d65af78SAlexey Dobriyan proc_dointvec(ctl, write, buffer, lenp, ppos); 25295b7c931dSDaniel Lezcano fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net); 25301da177e4SLinus Torvalds return 0; 25311da177e4SLinus Torvalds } else 25321da177e4SLinus Torvalds return -EINVAL; 25331da177e4SLinus Torvalds } 25341da177e4SLinus Torvalds 2535760f2d01SDaniel Lezcano ctl_table ipv6_route_table_template[] = { 25361da177e4SLinus Torvalds { 25371da177e4SLinus Torvalds .procname = "flush", 25384990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.flush_delay, 25391da177e4SLinus Torvalds .maxlen = sizeof(int), 254089c8b3a1SDave Jones .mode = 0200, 25416d9f239aSAlexey Dobriyan .proc_handler = ipv6_sysctl_rtcache_flush 25421da177e4SLinus Torvalds }, 25431da177e4SLinus Torvalds { 25441da177e4SLinus Torvalds .procname = "gc_thresh", 25459a7ec3a9SDaniel Lezcano .data = &ip6_dst_ops_template.gc_thresh, 25461da177e4SLinus Torvalds .maxlen = sizeof(int), 25471da177e4SLinus Torvalds .mode = 0644, 25486d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 25491da177e4SLinus Torvalds }, 25501da177e4SLinus Torvalds { 25511da177e4SLinus Torvalds .procname = "max_size", 25524990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_max_size, 25531da177e4SLinus Torvalds .maxlen = sizeof(int), 25541da177e4SLinus Torvalds .mode = 0644, 25556d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 25561da177e4SLinus Torvalds }, 25571da177e4SLinus Torvalds { 25581da177e4SLinus Torvalds .procname = "gc_min_interval", 25594990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval, 25601da177e4SLinus Torvalds .maxlen = sizeof(int), 25611da177e4SLinus Torvalds .mode = 0644, 25626d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 25631da177e4SLinus Torvalds }, 25641da177e4SLinus Torvalds { 25651da177e4SLinus Torvalds .procname = "gc_timeout", 25664990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout, 25671da177e4SLinus Torvalds .maxlen = sizeof(int), 25681da177e4SLinus Torvalds .mode = 0644, 25696d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 25701da177e4SLinus Torvalds }, 25711da177e4SLinus Torvalds { 25721da177e4SLinus Torvalds .procname = "gc_interval", 25734990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval, 25741da177e4SLinus Torvalds .maxlen = sizeof(int), 25751da177e4SLinus Torvalds .mode = 0644, 25766d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 25771da177e4SLinus Torvalds }, 25781da177e4SLinus Torvalds { 25791da177e4SLinus Torvalds .procname = "gc_elasticity", 25804990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity, 25811da177e4SLinus Torvalds .maxlen = sizeof(int), 25821da177e4SLinus Torvalds .mode = 0644, 25836d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 25841da177e4SLinus Torvalds }, 25851da177e4SLinus Torvalds { 25861da177e4SLinus Torvalds .procname = "mtu_expires", 25874990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires, 25881da177e4SLinus Torvalds .maxlen = sizeof(int), 25891da177e4SLinus Torvalds .mode = 0644, 25906d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 25911da177e4SLinus Torvalds }, 25921da177e4SLinus Torvalds { 25931da177e4SLinus Torvalds .procname = "min_adv_mss", 25944990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss, 25951da177e4SLinus Torvalds .maxlen = sizeof(int), 25961da177e4SLinus Torvalds .mode = 0644, 25976d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 25981da177e4SLinus Torvalds }, 25991da177e4SLinus Torvalds { 26001da177e4SLinus Torvalds .procname = "gc_min_interval_ms", 26014990509fSDaniel Lezcano .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval, 26021da177e4SLinus Torvalds .maxlen = sizeof(int), 26031da177e4SLinus Torvalds .mode = 0644, 26046d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_ms_jiffies, 26051da177e4SLinus Torvalds }, 2606f8572d8fSEric W. Biederman { } 26071da177e4SLinus Torvalds }; 26081da177e4SLinus Torvalds 26092c8c1e72SAlexey Dobriyan struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net) 2610760f2d01SDaniel Lezcano { 2611760f2d01SDaniel Lezcano struct ctl_table *table; 2612760f2d01SDaniel Lezcano 2613760f2d01SDaniel Lezcano table = kmemdup(ipv6_route_table_template, 2614760f2d01SDaniel Lezcano sizeof(ipv6_route_table_template), 2615760f2d01SDaniel Lezcano GFP_KERNEL); 26165ee09105SYOSHIFUJI Hideaki 26175ee09105SYOSHIFUJI Hideaki if (table) { 26185ee09105SYOSHIFUJI Hideaki table[0].data = &net->ipv6.sysctl.flush_delay; 261986393e52SAlexey Dobriyan table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh; 26205ee09105SYOSHIFUJI Hideaki table[2].data = &net->ipv6.sysctl.ip6_rt_max_size; 26215ee09105SYOSHIFUJI Hideaki table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval; 26225ee09105SYOSHIFUJI Hideaki table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout; 26235ee09105SYOSHIFUJI Hideaki table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval; 26245ee09105SYOSHIFUJI Hideaki table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity; 26255ee09105SYOSHIFUJI Hideaki table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires; 26265ee09105SYOSHIFUJI Hideaki table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss; 26279c69fabeSAlexey Dobriyan table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval; 26285ee09105SYOSHIFUJI Hideaki } 26295ee09105SYOSHIFUJI Hideaki 2630760f2d01SDaniel Lezcano return table; 2631760f2d01SDaniel Lezcano } 26321da177e4SLinus Torvalds #endif 26331da177e4SLinus Torvalds 26342c8c1e72SAlexey Dobriyan static int __net_init ip6_route_net_init(struct net *net) 2635cdb18761SDaniel Lezcano { 2636633d424bSPavel Emelyanov int ret = -ENOMEM; 26378ed67789SDaniel Lezcano 263886393e52SAlexey Dobriyan memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template, 263986393e52SAlexey Dobriyan sizeof(net->ipv6.ip6_dst_ops)); 2640f2fc6a54SBenjamin Thery 26418ed67789SDaniel Lezcano net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template, 26428ed67789SDaniel Lezcano sizeof(*net->ipv6.ip6_null_entry), 26438ed67789SDaniel Lezcano GFP_KERNEL); 26448ed67789SDaniel Lezcano if (!net->ipv6.ip6_null_entry) 2645f2fc6a54SBenjamin Thery goto out_ip6_dst_ops; 2646d8d1f30bSChangli Gao net->ipv6.ip6_null_entry->dst.path = 26478ed67789SDaniel Lezcano (struct dst_entry *)net->ipv6.ip6_null_entry; 2648d8d1f30bSChangli Gao net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops; 26498ed67789SDaniel Lezcano 26508ed67789SDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES 26518ed67789SDaniel Lezcano net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template, 26528ed67789SDaniel Lezcano sizeof(*net->ipv6.ip6_prohibit_entry), 26538ed67789SDaniel Lezcano GFP_KERNEL); 265468fffc67SPeter Zijlstra if (!net->ipv6.ip6_prohibit_entry) 265568fffc67SPeter Zijlstra goto out_ip6_null_entry; 2656d8d1f30bSChangli Gao net->ipv6.ip6_prohibit_entry->dst.path = 26578ed67789SDaniel Lezcano (struct dst_entry *)net->ipv6.ip6_prohibit_entry; 2658d8d1f30bSChangli Gao net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops; 26598ed67789SDaniel Lezcano 26608ed67789SDaniel Lezcano net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template, 26618ed67789SDaniel Lezcano sizeof(*net->ipv6.ip6_blk_hole_entry), 26628ed67789SDaniel Lezcano GFP_KERNEL); 266368fffc67SPeter Zijlstra if (!net->ipv6.ip6_blk_hole_entry) 266468fffc67SPeter Zijlstra goto out_ip6_prohibit_entry; 2665d8d1f30bSChangli Gao net->ipv6.ip6_blk_hole_entry->dst.path = 26668ed67789SDaniel Lezcano (struct dst_entry *)net->ipv6.ip6_blk_hole_entry; 2667d8d1f30bSChangli Gao net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops; 26688ed67789SDaniel Lezcano #endif 26698ed67789SDaniel Lezcano 2670b339a47cSPeter Zijlstra net->ipv6.sysctl.flush_delay = 0; 2671b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_max_size = 4096; 2672b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2; 2673b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ; 2674b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ; 2675b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_gc_elasticity = 9; 2676b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ; 2677b339a47cSPeter Zijlstra net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40; 2678b339a47cSPeter Zijlstra 2679cdb18761SDaniel Lezcano #ifdef CONFIG_PROC_FS 2680cdb18761SDaniel Lezcano proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops); 2681cdb18761SDaniel Lezcano proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops); 2682cdb18761SDaniel Lezcano #endif 26836891a346SBenjamin Thery net->ipv6.ip6_rt_gc_expire = 30*HZ; 26846891a346SBenjamin Thery 26858ed67789SDaniel Lezcano ret = 0; 26868ed67789SDaniel Lezcano out: 26878ed67789SDaniel Lezcano return ret; 2688f2fc6a54SBenjamin Thery 268968fffc67SPeter Zijlstra #ifdef CONFIG_IPV6_MULTIPLE_TABLES 269068fffc67SPeter Zijlstra out_ip6_prohibit_entry: 269168fffc67SPeter Zijlstra kfree(net->ipv6.ip6_prohibit_entry); 269268fffc67SPeter Zijlstra out_ip6_null_entry: 269368fffc67SPeter Zijlstra kfree(net->ipv6.ip6_null_entry); 269468fffc67SPeter Zijlstra #endif 2695f2fc6a54SBenjamin Thery out_ip6_dst_ops: 2696f2fc6a54SBenjamin Thery goto out; 2697cdb18761SDaniel Lezcano } 2698cdb18761SDaniel Lezcano 26992c8c1e72SAlexey Dobriyan static void __net_exit ip6_route_net_exit(struct net *net) 2700cdb18761SDaniel Lezcano { 2701cdb18761SDaniel Lezcano #ifdef CONFIG_PROC_FS 2702cdb18761SDaniel Lezcano proc_net_remove(net, "ipv6_route"); 2703cdb18761SDaniel Lezcano proc_net_remove(net, "rt6_stats"); 2704cdb18761SDaniel Lezcano #endif 27058ed67789SDaniel Lezcano kfree(net->ipv6.ip6_null_entry); 27068ed67789SDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES 27078ed67789SDaniel Lezcano kfree(net->ipv6.ip6_prohibit_entry); 27088ed67789SDaniel Lezcano kfree(net->ipv6.ip6_blk_hole_entry); 27098ed67789SDaniel Lezcano #endif 2710cdb18761SDaniel Lezcano } 2711cdb18761SDaniel Lezcano 2712cdb18761SDaniel Lezcano static struct pernet_operations ip6_route_net_ops = { 2713cdb18761SDaniel Lezcano .init = ip6_route_net_init, 2714cdb18761SDaniel Lezcano .exit = ip6_route_net_exit, 2715cdb18761SDaniel Lezcano }; 2716cdb18761SDaniel Lezcano 27178ed67789SDaniel Lezcano static struct notifier_block ip6_route_dev_notifier = { 27188ed67789SDaniel Lezcano .notifier_call = ip6_route_dev_notify, 27198ed67789SDaniel Lezcano .priority = 0, 27208ed67789SDaniel Lezcano }; 27218ed67789SDaniel Lezcano 2722433d49c3SDaniel Lezcano int __init ip6_route_init(void) 27231da177e4SLinus Torvalds { 2724433d49c3SDaniel Lezcano int ret; 2725433d49c3SDaniel Lezcano 27269a7ec3a9SDaniel Lezcano ret = -ENOMEM; 27279a7ec3a9SDaniel Lezcano ip6_dst_ops_template.kmem_cachep = 27289a7ec3a9SDaniel Lezcano kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0, 27299a7ec3a9SDaniel Lezcano SLAB_HWCACHE_ALIGN, NULL); 27309a7ec3a9SDaniel Lezcano if (!ip6_dst_ops_template.kmem_cachep) 2731c19a28e1SFernando Carrijo goto out; 273214e50e57SDavid S. Miller 27338ed67789SDaniel Lezcano ret = register_pernet_subsys(&ip6_route_net_ops); 27348ed67789SDaniel Lezcano if (ret) 2735bdb3289fSDaniel Lezcano goto out_kmem_cache; 2736bdb3289fSDaniel Lezcano 27375dc121e9SArnaud Ebalard ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep; 27385dc121e9SArnaud Ebalard 27398ed67789SDaniel Lezcano /* Registering of the loopback is done before this portion of code, 27408ed67789SDaniel Lezcano * the loopback reference in rt6_info will not be taken, do it 27418ed67789SDaniel Lezcano * manually for init_net */ 2742d8d1f30bSChangli Gao init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev; 27438ed67789SDaniel Lezcano init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev); 2744bdb3289fSDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES 2745d8d1f30bSChangli Gao init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev; 27468ed67789SDaniel Lezcano init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev); 2747d8d1f30bSChangli Gao init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev; 27488ed67789SDaniel Lezcano init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev); 2749bdb3289fSDaniel Lezcano #endif 2750433d49c3SDaniel Lezcano ret = fib6_init(); 2751433d49c3SDaniel Lezcano if (ret) 27528ed67789SDaniel Lezcano goto out_register_subsys; 2753433d49c3SDaniel Lezcano 2754433d49c3SDaniel Lezcano ret = xfrm6_init(); 2755433d49c3SDaniel Lezcano if (ret) 2756cdb18761SDaniel Lezcano goto out_fib6_init; 2757c35b7e72SDaniel Lezcano 2758433d49c3SDaniel Lezcano ret = fib6_rules_init(); 2759433d49c3SDaniel Lezcano if (ret) 2760433d49c3SDaniel Lezcano goto xfrm6_init; 27617e5449c2SDaniel Lezcano 2762433d49c3SDaniel Lezcano ret = -ENOBUFS; 2763433d49c3SDaniel Lezcano if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) || 2764433d49c3SDaniel Lezcano __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) || 2765433d49c3SDaniel Lezcano __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL)) 2766433d49c3SDaniel Lezcano goto fib6_rules_init; 2767433d49c3SDaniel Lezcano 27688ed67789SDaniel Lezcano ret = register_netdevice_notifier(&ip6_route_dev_notifier); 2769cdb18761SDaniel Lezcano if (ret) 2770cdb18761SDaniel Lezcano goto fib6_rules_init; 27718ed67789SDaniel Lezcano 2772433d49c3SDaniel Lezcano out: 2773433d49c3SDaniel Lezcano return ret; 2774433d49c3SDaniel Lezcano 2775433d49c3SDaniel Lezcano fib6_rules_init: 2776433d49c3SDaniel Lezcano fib6_rules_cleanup(); 2777433d49c3SDaniel Lezcano xfrm6_init: 2778433d49c3SDaniel Lezcano xfrm6_fini(); 2779433d49c3SDaniel Lezcano out_fib6_init: 2780433d49c3SDaniel Lezcano fib6_gc_cleanup(); 27818ed67789SDaniel Lezcano out_register_subsys: 27828ed67789SDaniel Lezcano unregister_pernet_subsys(&ip6_route_net_ops); 2783433d49c3SDaniel Lezcano out_kmem_cache: 2784f2fc6a54SBenjamin Thery kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep); 2785433d49c3SDaniel Lezcano goto out; 27861da177e4SLinus Torvalds } 27871da177e4SLinus Torvalds 27881da177e4SLinus Torvalds void ip6_route_cleanup(void) 27891da177e4SLinus Torvalds { 27908ed67789SDaniel Lezcano unregister_netdevice_notifier(&ip6_route_dev_notifier); 2791101367c2SThomas Graf fib6_rules_cleanup(); 27921da177e4SLinus Torvalds xfrm6_fini(); 27931da177e4SLinus Torvalds fib6_gc_cleanup(); 27948ed67789SDaniel Lezcano unregister_pernet_subsys(&ip6_route_net_ops); 2795f2fc6a54SBenjamin Thery kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep); 27961da177e4SLinus Torvalds } 2797