11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * IPv6 Address [auto]configuration 31da177e4SLinus Torvalds * Linux INET6 implementation 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Authors: 61da177e4SLinus Torvalds * Pedro Roque <roque@di.fc.ul.pt> 71da177e4SLinus Torvalds * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 101da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 111da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 121da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 131da177e4SLinus Torvalds */ 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds /* 161da177e4SLinus Torvalds * Changes: 171da177e4SLinus Torvalds * 181da177e4SLinus Torvalds * Janos Farkas : delete timer on ifdown 191da177e4SLinus Torvalds * <chexum@bankinf.banki.hu> 201da177e4SLinus Torvalds * Andi Kleen : kill double kfree on module 211da177e4SLinus Torvalds * unload. 221da177e4SLinus Torvalds * Maciej W. Rozycki : FDDI support 231da177e4SLinus Torvalds * sekiya@USAGI : Don't send too many RS 241da177e4SLinus Torvalds * packets. 251da177e4SLinus Torvalds * yoshfuji@USAGI : Fixed interval between DAD 261da177e4SLinus Torvalds * packets. 271da177e4SLinus Torvalds * YOSHIFUJI Hideaki @USAGI : improved accuracy of 281da177e4SLinus Torvalds * address validation timer. 291da177e4SLinus Torvalds * YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041) 301da177e4SLinus Torvalds * support. 311da177e4SLinus Torvalds * Yuji SEKIYA @USAGI : Don't assign a same IPv6 321da177e4SLinus Torvalds * address on a same interface. 331da177e4SLinus Torvalds * YOSHIFUJI Hideaki @USAGI : ARCnet support 341da177e4SLinus Torvalds * YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to 351da177e4SLinus Torvalds * seq_file. 36b1cacb68SYOSHIFUJI Hideaki * YOSHIFUJI Hideaki @USAGI : improved source address 37b1cacb68SYOSHIFUJI Hideaki * selection; consider scope, 38b1cacb68SYOSHIFUJI Hideaki * status etc. 391da177e4SLinus Torvalds */ 401da177e4SLinus Torvalds 41f3213831SJoe Perches #define pr_fmt(fmt) "IPv6: " fmt 42f3213831SJoe Perches 431da177e4SLinus Torvalds #include <linux/errno.h> 441da177e4SLinus Torvalds #include <linux/types.h> 45a0bffffcSIlpo Järvinen #include <linux/kernel.h> 461da177e4SLinus Torvalds #include <linux/socket.h> 471da177e4SLinus Torvalds #include <linux/sockios.h> 481da177e4SLinus Torvalds #include <linux/net.h> 493d1bec99SHannes Frederic Sowa #include <linux/inet.h> 501da177e4SLinus Torvalds #include <linux/in6.h> 511da177e4SLinus Torvalds #include <linux/netdevice.h> 521823730fSThomas Graf #include <linux/if_addr.h> 531da177e4SLinus Torvalds #include <linux/if_arp.h> 541da177e4SLinus Torvalds #include <linux/if_arcnet.h> 551da177e4SLinus Torvalds #include <linux/if_infiniband.h> 561da177e4SLinus Torvalds #include <linux/route.h> 571da177e4SLinus Torvalds #include <linux/inetdevice.h> 581da177e4SLinus Torvalds #include <linux/init.h> 595a0e3ad6STejun Heo #include <linux/slab.h> 601da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 611da177e4SLinus Torvalds #include <linux/sysctl.h> 621da177e4SLinus Torvalds #endif 634fc268d2SRandy Dunlap #include <linux/capability.h> 641da177e4SLinus Torvalds #include <linux/delay.h> 651da177e4SLinus Torvalds #include <linux/notifier.h> 66543537bdSPaulo Marques #include <linux/string.h> 67ddbe5032SEric Dumazet #include <linux/hash.h> 681da177e4SLinus Torvalds 69457c4cbcSEric W. Biederman #include <net/net_namespace.h> 701da177e4SLinus Torvalds #include <net/sock.h> 711da177e4SLinus Torvalds #include <net/snmp.h> 721da177e4SLinus Torvalds 735241c2d7SAlexander Aring #include <net/6lowpan.h> 74cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 #include <net/firewire.h> 751da177e4SLinus Torvalds #include <net/ipv6.h> 761da177e4SLinus Torvalds #include <net/protocol.h> 771da177e4SLinus Torvalds #include <net/ndisc.h> 781da177e4SLinus Torvalds #include <net/ip6_route.h> 791da177e4SLinus Torvalds #include <net/addrconf.h> 801da177e4SLinus Torvalds #include <net/tcp.h> 811da177e4SLinus Torvalds #include <net/ip.h> 825d620266SThomas Graf #include <net/netlink.h> 83f24e3d65SMitsuru Chinen #include <net/pkt_sched.h> 84ca254490SDavid Ahern #include <net/l3mdev.h> 851da177e4SLinus Torvalds #include <linux/if_tunnel.h> 861da177e4SLinus Torvalds #include <linux/rtnetlink.h> 87f3a1bfb1SNicolas Dichtel #include <linux/netconf.h> 881da177e4SLinus Torvalds #include <linux/random.h> 89e21e8467SStephen Hemminger #include <linux/uaccess.h> 907f7d9a6bSHerbert Xu #include <asm/unaligned.h> 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds #include <linux/proc_fs.h> 931da177e4SLinus Torvalds #include <linux/seq_file.h> 94bc3b2d7fSPaul Gortmaker #include <linux/export.h> 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds /* Set to 3 to get tracing... */ 971da177e4SLinus Torvalds #define ACONF_DEBUG 2 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds #if ACONF_DEBUG >= 3 100ba3542e1Sdingtianhong #define ADBG(fmt, ...) printk(fmt, ##__VA_ARGS__) 1011da177e4SLinus Torvalds #else 102ba3542e1Sdingtianhong #define ADBG(fmt, ...) do { if (0) printk(fmt, ##__VA_ARGS__); } while (0) 1031da177e4SLinus Torvalds #endif 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds #define INFINITY_LIFE_TIME 0xFFFFFFFF 10618a31e1eSThomas Graf 1073d1bec99SHannes Frederic Sowa #define IPV6_MAX_STRLEN \ 1083d1bec99SHannes Frederic Sowa sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255") 1093d1bec99SHannes Frederic Sowa 11018a31e1eSThomas Graf static inline u32 cstamp_delta(unsigned long cstamp) 11118a31e1eSThomas Graf { 11218a31e1eSThomas Graf return (cstamp - INITIAL_JIFFIES) * 100UL / HZ; 11318a31e1eSThomas Graf } 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 116a317a2f1SWANG Cong static int addrconf_sysctl_register(struct inet6_dev *idev); 117408c4768SPavel Emelyanov static void addrconf_sysctl_unregister(struct inet6_dev *idev); 118408c4768SPavel Emelyanov #else 119a317a2f1SWANG Cong static inline int addrconf_sysctl_register(struct inet6_dev *idev) 120408c4768SPavel Emelyanov { 121a317a2f1SWANG Cong return 0; 122408c4768SPavel Emelyanov } 123408c4768SPavel Emelyanov 124408c4768SPavel Emelyanov static inline void addrconf_sysctl_unregister(struct inet6_dev *idev) 125408c4768SPavel Emelyanov { 126408c4768SPavel Emelyanov } 1271da177e4SLinus Torvalds #endif 1281da177e4SLinus Torvalds 129eb7e0575SSorin Dumitru static void __ipv6_regen_rndid(struct inet6_dev *idev); 130eb7e0575SSorin Dumitru static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr); 1311da177e4SLinus Torvalds static void ipv6_regen_rndid(unsigned long data); 1321da177e4SLinus Torvalds 1331b34be74SYOSHIFUJI Hideaki static int ipv6_generate_eui64(u8 *eui, struct net_device *dev); 1341da177e4SLinus Torvalds static int ipv6_count_addresses(struct inet6_dev *idev); 135622c81d5SHannes Frederic Sowa static int ipv6_generate_stable_address(struct in6_addr *addr, 136622c81d5SHannes Frederic Sowa u8 dad_count, 137622c81d5SHannes Frederic Sowa const struct inet6_dev *idev); 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds /* 1401da177e4SLinus Torvalds * Configured unicast address hash table 1411da177e4SLinus Torvalds */ 142c2e21293Sstephen hemminger static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE]; 1435c578aedSstephen hemminger static DEFINE_SPINLOCK(addrconf_hash_lock); 1441da177e4SLinus Torvalds 145c15b1ccaSHannes Frederic Sowa static void addrconf_verify(void); 146c15b1ccaSHannes Frederic Sowa static void addrconf_verify_rtnl(void); 147c15b1ccaSHannes Frederic Sowa static void addrconf_verify_work(struct work_struct *); 1481da177e4SLinus Torvalds 149c15b1ccaSHannes Frederic Sowa static struct workqueue_struct *addrconf_wq; 150c15b1ccaSHannes Frederic Sowa static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work); 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds static void addrconf_join_anycast(struct inet6_ifaddr *ifp); 1531da177e4SLinus Torvalds static void addrconf_leave_anycast(struct inet6_ifaddr *ifp); 1541da177e4SLinus Torvalds 15593d9b7d7SJiri Pirko static void addrconf_type_change(struct net_device *dev, 15675c78500SMoni Shoua unsigned long event); 1571da177e4SLinus Torvalds static int addrconf_ifdown(struct net_device *dev, int how); 1581da177e4SLinus Torvalds 15921caa662SRomain Kuntz static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx, 16021caa662SRomain Kuntz int plen, 16121caa662SRomain Kuntz const struct net_device *dev, 16221caa662SRomain Kuntz u32 flags, u32 noflags); 16321caa662SRomain Kuntz 164cf22f9a2SDavid S. Miller static void addrconf_dad_start(struct inet6_ifaddr *ifp); 165c15b1ccaSHannes Frederic Sowa static void addrconf_dad_work(struct work_struct *w); 1661da177e4SLinus Torvalds static void addrconf_dad_completed(struct inet6_ifaddr *ifp); 167c5e33bddSYOSHIFUJI Hideaki static void addrconf_dad_run(struct inet6_dev *idev); 1681da177e4SLinus Torvalds static void addrconf_rs_timer(unsigned long data); 1691da177e4SLinus Torvalds static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa); 1701da177e4SLinus Torvalds static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa); 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds static void inet6_prefix_notify(int event, struct inet6_dev *idev, 1731da177e4SLinus Torvalds struct prefix_info *pinfo); 1743e81c6daSDavid S. Miller static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr, 17506bfe655SDaniel Lezcano struct net_device *dev); 1761da177e4SLinus Torvalds 177888c848eSAdrian Bunk static struct ipv6_devconf ipv6_devconf __read_mostly = { 1781da177e4SLinus Torvalds .forwarding = 0, 1791da177e4SLinus Torvalds .hop_limit = IPV6_DEFAULT_HOPLIMIT, 1801da177e4SLinus Torvalds .mtu6 = IPV6_MIN_MTU, 1811da177e4SLinus Torvalds .accept_ra = 1, 1821da177e4SLinus Torvalds .accept_redirects = 1, 1831da177e4SLinus Torvalds .autoconf = 1, 1841da177e4SLinus Torvalds .force_mld_version = 0, 185fc4eba58SHannes Frederic Sowa .mldv1_unsolicited_report_interval = 10 * HZ, 186fc4eba58SHannes Frederic Sowa .mldv2_unsolicited_report_interval = HZ, 1871da177e4SLinus Torvalds .dad_transmits = 1, 1881da177e4SLinus Torvalds .rtr_solicits = MAX_RTR_SOLICITATIONS, 1891da177e4SLinus Torvalds .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL, 1901da177e4SLinus Torvalds .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY, 1911da177e4SLinus Torvalds .use_tempaddr = 0, 1921da177e4SLinus Torvalds .temp_valid_lft = TEMP_VALID_LIFETIME, 1931da177e4SLinus Torvalds .temp_prefered_lft = TEMP_PREFERRED_LIFETIME, 1941da177e4SLinus Torvalds .regen_max_retry = REGEN_MAX_RETRY, 1951da177e4SLinus Torvalds .max_desync_factor = MAX_DESYNC_FACTOR, 1961da177e4SLinus Torvalds .max_addresses = IPV6_MAX_ADDRESSES, 19765f5c7c1SYOSHIFUJI Hideaki .accept_ra_defrtr = 1, 198d9333196SBen Greear .accept_ra_from_local = 0, 1998013d1d7SHangbin Liu .accept_ra_min_hop_limit= 1, 200c4fd30ebSYOSHIFUJI Hideaki .accept_ra_pinfo = 1, 201930d6ff2SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 202930d6ff2SYOSHIFUJI Hideaki .accept_ra_rtr_pref = 1, 20352e16356SYOSHIFUJI Hideaki .rtr_probe_interval = 60 * HZ, 20409c884d4SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO 20509c884d4SYOSHIFUJI Hideaki .accept_ra_rt_info_max_plen = 0, 20609c884d4SYOSHIFUJI Hideaki #endif 207930d6ff2SYOSHIFUJI Hideaki #endif 208fbea49e1SYOSHIFUJI Hideaki .proxy_ndp = 0, 2090bcbc926SYOSHIFUJI Hideaki .accept_source_route = 0, /* we do not accept RH0 by default. */ 210778d80beSYOSHIFUJI Hideaki .disable_ipv6 = 0, 2111b34be74SYOSHIFUJI Hideaki .accept_dad = 1, 212b800c3b9SHannes Frederic Sowa .suppress_frag_ndisc = 1, 213c2943f14SHarout Hedeshian .accept_ra_mtu = 1, 2143d1bec99SHannes Frederic Sowa .stable_secret = { 2153d1bec99SHannes Frederic Sowa .initialized = false, 2163985e8a3SErik Kline }, 2173985e8a3SErik Kline .use_oif_addrs_only = 0, 21835103d11SAndy Gospodarek .ignore_routes_with_linkdown = 0, 219f1705ec1SDavid Ahern .keep_addr_on_down = 0, 2201da177e4SLinus Torvalds }; 2211da177e4SLinus Torvalds 222ab32ea5dSBrian Haley static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = { 2231da177e4SLinus Torvalds .forwarding = 0, 2241da177e4SLinus Torvalds .hop_limit = IPV6_DEFAULT_HOPLIMIT, 2251da177e4SLinus Torvalds .mtu6 = IPV6_MIN_MTU, 2261da177e4SLinus Torvalds .accept_ra = 1, 2271da177e4SLinus Torvalds .accept_redirects = 1, 2281da177e4SLinus Torvalds .autoconf = 1, 229fc4eba58SHannes Frederic Sowa .force_mld_version = 0, 230fc4eba58SHannes Frederic Sowa .mldv1_unsolicited_report_interval = 10 * HZ, 231fc4eba58SHannes Frederic Sowa .mldv2_unsolicited_report_interval = HZ, 2321da177e4SLinus Torvalds .dad_transmits = 1, 2331da177e4SLinus Torvalds .rtr_solicits = MAX_RTR_SOLICITATIONS, 2341da177e4SLinus Torvalds .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL, 2351da177e4SLinus Torvalds .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY, 2361da177e4SLinus Torvalds .use_tempaddr = 0, 2371da177e4SLinus Torvalds .temp_valid_lft = TEMP_VALID_LIFETIME, 2381da177e4SLinus Torvalds .temp_prefered_lft = TEMP_PREFERRED_LIFETIME, 2391da177e4SLinus Torvalds .regen_max_retry = REGEN_MAX_RETRY, 2401da177e4SLinus Torvalds .max_desync_factor = MAX_DESYNC_FACTOR, 2411da177e4SLinus Torvalds .max_addresses = IPV6_MAX_ADDRESSES, 24265f5c7c1SYOSHIFUJI Hideaki .accept_ra_defrtr = 1, 243d9333196SBen Greear .accept_ra_from_local = 0, 2448013d1d7SHangbin Liu .accept_ra_min_hop_limit= 1, 245c4fd30ebSYOSHIFUJI Hideaki .accept_ra_pinfo = 1, 246930d6ff2SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 247930d6ff2SYOSHIFUJI Hideaki .accept_ra_rtr_pref = 1, 24852e16356SYOSHIFUJI Hideaki .rtr_probe_interval = 60 * HZ, 24909c884d4SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO 25009c884d4SYOSHIFUJI Hideaki .accept_ra_rt_info_max_plen = 0, 25109c884d4SYOSHIFUJI Hideaki #endif 252930d6ff2SYOSHIFUJI Hideaki #endif 253fbea49e1SYOSHIFUJI Hideaki .proxy_ndp = 0, 2540bcbc926SYOSHIFUJI Hideaki .accept_source_route = 0, /* we do not accept RH0 by default. */ 255778d80beSYOSHIFUJI Hideaki .disable_ipv6 = 0, 2561b34be74SYOSHIFUJI Hideaki .accept_dad = 1, 257b800c3b9SHannes Frederic Sowa .suppress_frag_ndisc = 1, 258c2943f14SHarout Hedeshian .accept_ra_mtu = 1, 2593d1bec99SHannes Frederic Sowa .stable_secret = { 2603d1bec99SHannes Frederic Sowa .initialized = false, 2613d1bec99SHannes Frederic Sowa }, 2623985e8a3SErik Kline .use_oif_addrs_only = 0, 26335103d11SAndy Gospodarek .ignore_routes_with_linkdown = 0, 264f1705ec1SDavid Ahern .keep_addr_on_down = 0, 2651da177e4SLinus Torvalds }; 2661da177e4SLinus Torvalds 267f24e3d65SMitsuru Chinen /* Check if a valid qdisc is available */ 26805297949SDavid S. Miller static inline bool addrconf_qdisc_ok(const struct net_device *dev) 269f24e3d65SMitsuru Chinen { 27005297949SDavid S. Miller return !qdisc_tx_is_noop(dev); 271f24e3d65SMitsuru Chinen } 272f24e3d65SMitsuru Chinen 273b7b1bfceSHannes Frederic Sowa static void addrconf_del_rs_timer(struct inet6_dev *idev) 2741da177e4SLinus Torvalds { 275b7b1bfceSHannes Frederic Sowa if (del_timer(&idev->rs_timer)) 276b7b1bfceSHannes Frederic Sowa __in6_dev_put(idev); 277b7b1bfceSHannes Frederic Sowa } 278b7b1bfceSHannes Frederic Sowa 279c15b1ccaSHannes Frederic Sowa static void addrconf_del_dad_work(struct inet6_ifaddr *ifp) 280b7b1bfceSHannes Frederic Sowa { 281c15b1ccaSHannes Frederic Sowa if (cancel_delayed_work(&ifp->dad_work)) 2821da177e4SLinus Torvalds __in6_ifa_put(ifp); 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds 285b7b1bfceSHannes Frederic Sowa static void addrconf_mod_rs_timer(struct inet6_dev *idev, 2861da177e4SLinus Torvalds unsigned long when) 2871da177e4SLinus Torvalds { 288b7b1bfceSHannes Frederic Sowa if (!timer_pending(&idev->rs_timer)) 289b7b1bfceSHannes Frederic Sowa in6_dev_hold(idev); 290b7b1bfceSHannes Frederic Sowa mod_timer(&idev->rs_timer, jiffies + when); 2911da177e4SLinus Torvalds } 292b7b1bfceSHannes Frederic Sowa 293c15b1ccaSHannes Frederic Sowa static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp, 294c15b1ccaSHannes Frederic Sowa unsigned long delay) 295b7b1bfceSHannes Frederic Sowa { 296c15b1ccaSHannes Frederic Sowa if (!delayed_work_pending(&ifp->dad_work)) 297b7b1bfceSHannes Frederic Sowa in6_ifa_hold(ifp); 298c15b1ccaSHannes Frederic Sowa mod_delayed_work(addrconf_wq, &ifp->dad_work, delay); 2991da177e4SLinus Torvalds } 3001da177e4SLinus Torvalds 3017f7d9a6bSHerbert Xu static int snmp6_alloc_dev(struct inet6_dev *idev) 3027f7d9a6bSHerbert Xu { 303827da44cSJohn Stultz int i; 304827da44cSJohn Stultz 305698365faSWANG Cong idev->stats.ipv6 = alloc_percpu(struct ipstats_mib); 306698365faSWANG Cong if (!idev->stats.ipv6) 3077f7d9a6bSHerbert Xu goto err_ip; 308827da44cSJohn Stultz 309827da44cSJohn Stultz for_each_possible_cpu(i) { 310827da44cSJohn Stultz struct ipstats_mib *addrconf_stats; 311698365faSWANG Cong addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i); 312827da44cSJohn Stultz u64_stats_init(&addrconf_stats->syncp); 313827da44cSJohn Stultz } 314827da44cSJohn Stultz 315827da44cSJohn Stultz 316be281e55SEric Dumazet idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device), 317be281e55SEric Dumazet GFP_KERNEL); 318be281e55SEric Dumazet if (!idev->stats.icmpv6dev) 3197f7d9a6bSHerbert Xu goto err_icmp; 320be281e55SEric Dumazet idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device), 321be281e55SEric Dumazet GFP_KERNEL); 322be281e55SEric Dumazet if (!idev->stats.icmpv6msgdev) 32314878f75SDavid L Stevens goto err_icmpmsg; 3247f7d9a6bSHerbert Xu 3257f7d9a6bSHerbert Xu return 0; 3267f7d9a6bSHerbert Xu 32714878f75SDavid L Stevens err_icmpmsg: 328be281e55SEric Dumazet kfree(idev->stats.icmpv6dev); 3297f7d9a6bSHerbert Xu err_icmp: 330698365faSWANG Cong free_percpu(idev->stats.ipv6); 3317f7d9a6bSHerbert Xu err_ip: 332aaf70ec7SPavel Emelyanov return -ENOMEM; 3337f7d9a6bSHerbert Xu } 3347f7d9a6bSHerbert Xu 3351da177e4SLinus Torvalds static struct inet6_dev *ipv6_add_dev(struct net_device *dev) 3361da177e4SLinus Torvalds { 3371da177e4SLinus Torvalds struct inet6_dev *ndev; 338a317a2f1SWANG Cong int err = -ENOMEM; 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds ASSERT_RTNL(); 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds if (dev->mtu < IPV6_MIN_MTU) 343a317a2f1SWANG Cong return ERR_PTR(-EINVAL); 3441da177e4SLinus Torvalds 345322f74a4SIngo Oeser ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL); 34663159f29SIan Morris if (!ndev) 347a317a2f1SWANG Cong return ERR_PTR(err); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds rwlock_init(&ndev->lock); 3501da177e4SLinus Torvalds ndev->dev = dev; 351502a2ffdSstephen hemminger INIT_LIST_HEAD(&ndev->addr_list); 352b7b1bfceSHannes Frederic Sowa setup_timer(&ndev->rs_timer, addrconf_rs_timer, 353b7b1bfceSHannes Frederic Sowa (unsigned long)ndev); 354c346dca1SYOSHIFUJI Hideaki memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf)); 3559b29c696SHannes Frederic Sowa 3569b29c696SHannes Frederic Sowa if (ndev->cnf.stable_secret.initialized) 3579b29c696SHannes Frederic Sowa ndev->addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY; 3589b29c696SHannes Frederic Sowa else 3599b29c696SHannes Frederic Sowa ndev->addr_gen_mode = IN6_ADDR_GEN_MODE_EUI64; 3609b29c696SHannes Frederic Sowa 3611da177e4SLinus Torvalds ndev->cnf.mtu6 = dev->mtu; 3621da177e4SLinus Torvalds ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl); 36363159f29SIan Morris if (!ndev->nd_parms) { 3641da177e4SLinus Torvalds kfree(ndev); 365a317a2f1SWANG Cong return ERR_PTR(err); 3661da177e4SLinus Torvalds } 3670187bdfbSBen Hutchings if (ndev->cnf.forwarding) 3680187bdfbSBen Hutchings dev_disable_lro(dev); 3691da177e4SLinus Torvalds /* We refer to the device */ 3701da177e4SLinus Torvalds dev_hold(dev); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds if (snmp6_alloc_dev(ndev) < 0) { 373ba3542e1Sdingtianhong ADBG(KERN_WARNING 374f3213831SJoe Perches "%s: cannot allocate memory for statistics; dev=%s.\n", 375ba3542e1Sdingtianhong __func__, dev->name); 3761da177e4SLinus Torvalds neigh_parms_release(&nd_tbl, ndev->nd_parms); 3778603e33dSRoy Li dev_put(dev); 3788603e33dSRoy Li kfree(ndev); 379a317a2f1SWANG Cong return ERR_PTR(err); 3801da177e4SLinus Torvalds } 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds if (snmp6_register_dev(ndev) < 0) { 383ba3542e1Sdingtianhong ADBG(KERN_WARNING 384f3213831SJoe Perches "%s: cannot create /proc/net/dev_snmp6/%s\n", 385ba3542e1Sdingtianhong __func__, dev->name); 386a317a2f1SWANG Cong goto err_release; 3871da177e4SLinus Torvalds } 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds /* One reference from device. We must do this before 3901da177e4SLinus Torvalds * we invoke __ipv6_regen_rndid(). 3911da177e4SLinus Torvalds */ 3921da177e4SLinus Torvalds in6_dev_hold(ndev); 3931da177e4SLinus Torvalds 3941b34be74SYOSHIFUJI Hideaki if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) 3951b34be74SYOSHIFUJI Hideaki ndev->cnf.accept_dad = -1; 3961b34be74SYOSHIFUJI Hideaki 39707a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_SIT) 398c7dc89c0SFred L. Templin if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) { 399f3213831SJoe Perches pr_info("%s: Disabled Multicast RS\n", dev->name); 400c7dc89c0SFred L. Templin ndev->cnf.rtr_solicits = 0; 401c7dc89c0SFred L. Templin } 402b077d7abSYOSHIFUJI Hideaki #endif 403b077d7abSYOSHIFUJI Hideaki 404372e6c8fSstephen hemminger INIT_LIST_HEAD(&ndev->tempaddr_list); 4051da177e4SLinus Torvalds setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev); 4061da177e4SLinus Torvalds if ((dev->flags&IFF_LOOPBACK) || 4071da177e4SLinus Torvalds dev->type == ARPHRD_TUNNEL || 4089625ed72SYOSHIFUJI Hideaki dev->type == ARPHRD_TUNNEL6 || 4091da177e4SLinus Torvalds dev->type == ARPHRD_SIT || 4101da177e4SLinus Torvalds dev->type == ARPHRD_NONE) { 4110be669bbSJoerg Roedel ndev->cnf.use_tempaddr = -1; 4121da177e4SLinus Torvalds } else { 4131da177e4SLinus Torvalds in6_dev_hold(ndev); 4141da177e4SLinus Torvalds ipv6_regen_rndid((unsigned long) ndev); 4151da177e4SLinus Torvalds } 4165d9efa7eSDavid S. Miller 417914faa14SDaniel Borkmann ndev->token = in6addr_any; 4181da177e4SLinus Torvalds 419f24e3d65SMitsuru Chinen if (netif_running(dev) && addrconf_qdisc_ok(dev)) 42053aadcc9SHerbert Xu ndev->if_flags |= IF_READY; 42153aadcc9SHerbert Xu 4221da177e4SLinus Torvalds ipv6_mc_init_dev(ndev); 4231da177e4SLinus Torvalds ndev->tstamp = jiffies; 424a317a2f1SWANG Cong err = addrconf_sysctl_register(ndev); 425a317a2f1SWANG Cong if (err) { 426a317a2f1SWANG Cong ipv6_mc_destroy_dev(ndev); 427a317a2f1SWANG Cong del_timer(&ndev->regen_timer); 4282a189f9eSSabrina Dubroca snmp6_unregister_dev(ndev); 429a317a2f1SWANG Cong goto err_release; 430a317a2f1SWANG Cong } 43130c4cf57SDavid L Stevens /* protected by rtnl_lock */ 432cf778b00SEric Dumazet rcu_assign_pointer(dev->ip6_ptr, ndev); 433d88ae4ccSYOSHIFUJI Hideaki 4342c5e8933SHannes Frederic Sowa /* Join interface-local all-node multicast group */ 4352c5e8933SHannes Frederic Sowa ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes); 4362c5e8933SHannes Frederic Sowa 437d88ae4ccSYOSHIFUJI Hideaki /* Join all-node multicast group */ 438f3ee4010SYOSHIFUJI Hideaki ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes); 439d88ae4ccSYOSHIFUJI Hideaki 440d6ddef9eSLi Wei /* Join all-router multicast group if forwarding is set */ 4418b2aaedeSLi Wei if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST)) 442d6ddef9eSLi Wei ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters); 443d6ddef9eSLi Wei 4441da177e4SLinus Torvalds return ndev; 445a317a2f1SWANG Cong 446a317a2f1SWANG Cong err_release: 447a317a2f1SWANG Cong neigh_parms_release(&nd_tbl, ndev->nd_parms); 448a317a2f1SWANG Cong ndev->dead = 1; 449a317a2f1SWANG Cong in6_dev_finish_destroy(ndev); 450a317a2f1SWANG Cong return ERR_PTR(err); 4511da177e4SLinus Torvalds } 4521da177e4SLinus Torvalds 453cee89473SYOSHIFUJI Hideaki static struct inet6_dev *ipv6_find_idev(struct net_device *dev) 4541da177e4SLinus Torvalds { 4551da177e4SLinus Torvalds struct inet6_dev *idev; 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds ASSERT_RTNL(); 4581da177e4SLinus Torvalds 459e21e8467SStephen Hemminger idev = __in6_dev_get(dev); 460e21e8467SStephen Hemminger if (!idev) { 461e21e8467SStephen Hemminger idev = ipv6_add_dev(dev); 462a317a2f1SWANG Cong if (IS_ERR(idev)) 4631da177e4SLinus Torvalds return NULL; 4641da177e4SLinus Torvalds } 465c5e33bddSYOSHIFUJI Hideaki 4661da177e4SLinus Torvalds if (dev->flags&IFF_UP) 4671da177e4SLinus Torvalds ipv6_mc_up(idev); 4681da177e4SLinus Torvalds return idev; 4691da177e4SLinus Torvalds } 4701da177e4SLinus Torvalds 471f3a1bfb1SNicolas Dichtel static int inet6_netconf_msgsize_devconf(int type) 472f3a1bfb1SNicolas Dichtel { 473f3a1bfb1SNicolas Dichtel int size = NLMSG_ALIGN(sizeof(struct netconfmsg)) 474f3a1bfb1SNicolas Dichtel + nla_total_size(4); /* NETCONFA_IFINDEX */ 475136ba622SZhang Shengju bool all = false; 476f3a1bfb1SNicolas Dichtel 477136ba622SZhang Shengju if (type == NETCONFA_ALL) 478136ba622SZhang Shengju all = true; 479136ba622SZhang Shengju 480136ba622SZhang Shengju if (all || type == NETCONFA_FORWARDING) 481f3a1bfb1SNicolas Dichtel size += nla_total_size(4); 482b1afce95SDavid S. Miller #ifdef CONFIG_IPV6_MROUTE 483136ba622SZhang Shengju if (all || type == NETCONFA_MC_FORWARDING) 484d67b8c61SNicolas Dichtel size += nla_total_size(4); 485b1afce95SDavid S. Miller #endif 486136ba622SZhang Shengju if (all || type == NETCONFA_PROXY_NEIGH) 487c92d5491Sstephen hemminger size += nla_total_size(4); 488f3a1bfb1SNicolas Dichtel 489136ba622SZhang Shengju if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) 49035103d11SAndy Gospodarek size += nla_total_size(4); 49135103d11SAndy Gospodarek 492f3a1bfb1SNicolas Dichtel return size; 493f3a1bfb1SNicolas Dichtel } 494f3a1bfb1SNicolas Dichtel 495f3a1bfb1SNicolas Dichtel static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex, 496f3a1bfb1SNicolas Dichtel struct ipv6_devconf *devconf, u32 portid, 497f3a1bfb1SNicolas Dichtel u32 seq, int event, unsigned int flags, 498f3a1bfb1SNicolas Dichtel int type) 499f3a1bfb1SNicolas Dichtel { 500f3a1bfb1SNicolas Dichtel struct nlmsghdr *nlh; 501f3a1bfb1SNicolas Dichtel struct netconfmsg *ncm; 502136ba622SZhang Shengju bool all = false; 503f3a1bfb1SNicolas Dichtel 504f3a1bfb1SNicolas Dichtel nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg), 505f3a1bfb1SNicolas Dichtel flags); 50663159f29SIan Morris if (!nlh) 507f3a1bfb1SNicolas Dichtel return -EMSGSIZE; 508f3a1bfb1SNicolas Dichtel 509136ba622SZhang Shengju if (type == NETCONFA_ALL) 510136ba622SZhang Shengju all = true; 511136ba622SZhang Shengju 512f3a1bfb1SNicolas Dichtel ncm = nlmsg_data(nlh); 513f3a1bfb1SNicolas Dichtel ncm->ncm_family = AF_INET6; 514f3a1bfb1SNicolas Dichtel 515f3a1bfb1SNicolas Dichtel if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0) 516f3a1bfb1SNicolas Dichtel goto nla_put_failure; 517f3a1bfb1SNicolas Dichtel 518136ba622SZhang Shengju if ((all || type == NETCONFA_FORWARDING) && 519f3a1bfb1SNicolas Dichtel nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0) 520f3a1bfb1SNicolas Dichtel goto nla_put_failure; 521b1afce95SDavid S. Miller #ifdef CONFIG_IPV6_MROUTE 522136ba622SZhang Shengju if ((all || type == NETCONFA_MC_FORWARDING) && 523d67b8c61SNicolas Dichtel nla_put_s32(skb, NETCONFA_MC_FORWARDING, 524d67b8c61SNicolas Dichtel devconf->mc_forwarding) < 0) 525d67b8c61SNicolas Dichtel goto nla_put_failure; 526b1afce95SDavid S. Miller #endif 527136ba622SZhang Shengju if ((all || type == NETCONFA_PROXY_NEIGH) && 528c92d5491Sstephen hemminger nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0) 529c92d5491Sstephen hemminger goto nla_put_failure; 530c92d5491Sstephen hemminger 531136ba622SZhang Shengju if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) && 53235103d11SAndy Gospodarek nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN, 53335103d11SAndy Gospodarek devconf->ignore_routes_with_linkdown) < 0) 53435103d11SAndy Gospodarek goto nla_put_failure; 53535103d11SAndy Gospodarek 536053c095aSJohannes Berg nlmsg_end(skb, nlh); 537053c095aSJohannes Berg return 0; 538f3a1bfb1SNicolas Dichtel 539f3a1bfb1SNicolas Dichtel nla_put_failure: 540f3a1bfb1SNicolas Dichtel nlmsg_cancel(skb, nlh); 541f3a1bfb1SNicolas Dichtel return -EMSGSIZE; 542f3a1bfb1SNicolas Dichtel } 543f3a1bfb1SNicolas Dichtel 544d67b8c61SNicolas Dichtel void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex, 545f3a1bfb1SNicolas Dichtel struct ipv6_devconf *devconf) 546f3a1bfb1SNicolas Dichtel { 547f3a1bfb1SNicolas Dichtel struct sk_buff *skb; 548f3a1bfb1SNicolas Dichtel int err = -ENOBUFS; 549f3a1bfb1SNicolas Dichtel 550927265bcSEric Dumazet skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_KERNEL); 55163159f29SIan Morris if (!skb) 552f3a1bfb1SNicolas Dichtel goto errout; 553f3a1bfb1SNicolas Dichtel 554f3a1bfb1SNicolas Dichtel err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0, 555f3a1bfb1SNicolas Dichtel RTM_NEWNETCONF, 0, type); 556f3a1bfb1SNicolas Dichtel if (err < 0) { 557f3a1bfb1SNicolas Dichtel /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */ 558f3a1bfb1SNicolas Dichtel WARN_ON(err == -EMSGSIZE); 559f3a1bfb1SNicolas Dichtel kfree_skb(skb); 560f3a1bfb1SNicolas Dichtel goto errout; 561f3a1bfb1SNicolas Dichtel } 562927265bcSEric Dumazet rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_KERNEL); 563f3a1bfb1SNicolas Dichtel return; 564f3a1bfb1SNicolas Dichtel errout: 565f3a1bfb1SNicolas Dichtel rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err); 566f3a1bfb1SNicolas Dichtel } 567f3a1bfb1SNicolas Dichtel 56876f8f6cbSNicolas Dichtel static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = { 56976f8f6cbSNicolas Dichtel [NETCONFA_IFINDEX] = { .len = sizeof(int) }, 57076f8f6cbSNicolas Dichtel [NETCONFA_FORWARDING] = { .len = sizeof(int) }, 571c92d5491Sstephen hemminger [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) }, 57235103d11SAndy Gospodarek [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) }, 57376f8f6cbSNicolas Dichtel }; 57476f8f6cbSNicolas Dichtel 57576f8f6cbSNicolas Dichtel static int inet6_netconf_get_devconf(struct sk_buff *in_skb, 576661d2967SThomas Graf struct nlmsghdr *nlh) 57776f8f6cbSNicolas Dichtel { 57876f8f6cbSNicolas Dichtel struct net *net = sock_net(in_skb->sk); 57976f8f6cbSNicolas Dichtel struct nlattr *tb[NETCONFA_MAX+1]; 58076f8f6cbSNicolas Dichtel struct netconfmsg *ncm; 58176f8f6cbSNicolas Dichtel struct sk_buff *skb; 58276f8f6cbSNicolas Dichtel struct ipv6_devconf *devconf; 58376f8f6cbSNicolas Dichtel struct inet6_dev *in6_dev; 58476f8f6cbSNicolas Dichtel struct net_device *dev; 58576f8f6cbSNicolas Dichtel int ifindex; 58676f8f6cbSNicolas Dichtel int err; 58776f8f6cbSNicolas Dichtel 58876f8f6cbSNicolas Dichtel err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, 58976f8f6cbSNicolas Dichtel devconf_ipv6_policy); 59076f8f6cbSNicolas Dichtel if (err < 0) 59176f8f6cbSNicolas Dichtel goto errout; 59276f8f6cbSNicolas Dichtel 593a97eb33fSAnton Protopopov err = -EINVAL; 59476f8f6cbSNicolas Dichtel if (!tb[NETCONFA_IFINDEX]) 59576f8f6cbSNicolas Dichtel goto errout; 59676f8f6cbSNicolas Dichtel 59776f8f6cbSNicolas Dichtel ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]); 59876f8f6cbSNicolas Dichtel switch (ifindex) { 59976f8f6cbSNicolas Dichtel case NETCONFA_IFINDEX_ALL: 60076f8f6cbSNicolas Dichtel devconf = net->ipv6.devconf_all; 60176f8f6cbSNicolas Dichtel break; 60276f8f6cbSNicolas Dichtel case NETCONFA_IFINDEX_DEFAULT: 60376f8f6cbSNicolas Dichtel devconf = net->ipv6.devconf_dflt; 60476f8f6cbSNicolas Dichtel break; 60576f8f6cbSNicolas Dichtel default: 60676f8f6cbSNicolas Dichtel dev = __dev_get_by_index(net, ifindex); 60763159f29SIan Morris if (!dev) 60876f8f6cbSNicolas Dichtel goto errout; 60976f8f6cbSNicolas Dichtel in6_dev = __in6_dev_get(dev); 61063159f29SIan Morris if (!in6_dev) 61176f8f6cbSNicolas Dichtel goto errout; 61276f8f6cbSNicolas Dichtel devconf = &in6_dev->cnf; 61376f8f6cbSNicolas Dichtel break; 61476f8f6cbSNicolas Dichtel } 61576f8f6cbSNicolas Dichtel 61676f8f6cbSNicolas Dichtel err = -ENOBUFS; 617136ba622SZhang Shengju skb = nlmsg_new(inet6_netconf_msgsize_devconf(NETCONFA_ALL), GFP_ATOMIC); 61863159f29SIan Morris if (!skb) 61976f8f6cbSNicolas Dichtel goto errout; 62076f8f6cbSNicolas Dichtel 62176f8f6cbSNicolas Dichtel err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 62276f8f6cbSNicolas Dichtel NETLINK_CB(in_skb).portid, 62376f8f6cbSNicolas Dichtel nlh->nlmsg_seq, RTM_NEWNETCONF, 0, 624136ba622SZhang Shengju NETCONFA_ALL); 62576f8f6cbSNicolas Dichtel if (err < 0) { 62676f8f6cbSNicolas Dichtel /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */ 62776f8f6cbSNicolas Dichtel WARN_ON(err == -EMSGSIZE); 62876f8f6cbSNicolas Dichtel kfree_skb(skb); 62976f8f6cbSNicolas Dichtel goto errout; 63076f8f6cbSNicolas Dichtel } 63176f8f6cbSNicolas Dichtel err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 63276f8f6cbSNicolas Dichtel errout: 63376f8f6cbSNicolas Dichtel return err; 63476f8f6cbSNicolas Dichtel } 63576f8f6cbSNicolas Dichtel 6367a674200SNicolas Dichtel static int inet6_netconf_dump_devconf(struct sk_buff *skb, 6377a674200SNicolas Dichtel struct netlink_callback *cb) 6387a674200SNicolas Dichtel { 6397a674200SNicolas Dichtel struct net *net = sock_net(skb->sk); 6407a674200SNicolas Dichtel int h, s_h; 6417a674200SNicolas Dichtel int idx, s_idx; 6427a674200SNicolas Dichtel struct net_device *dev; 6437a674200SNicolas Dichtel struct inet6_dev *idev; 6447a674200SNicolas Dichtel struct hlist_head *head; 6457a674200SNicolas Dichtel 6467a674200SNicolas Dichtel s_h = cb->args[0]; 6477a674200SNicolas Dichtel s_idx = idx = cb->args[1]; 6487a674200SNicolas Dichtel 6497a674200SNicolas Dichtel for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 6507a674200SNicolas Dichtel idx = 0; 6517a674200SNicolas Dichtel head = &net->dev_index_head[h]; 6527a674200SNicolas Dichtel rcu_read_lock(); 65363998ac2SNicolas Dichtel cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ 65463998ac2SNicolas Dichtel net->dev_base_seq; 6557a674200SNicolas Dichtel hlist_for_each_entry_rcu(dev, head, index_hlist) { 6567a674200SNicolas Dichtel if (idx < s_idx) 6577a674200SNicolas Dichtel goto cont; 6587a674200SNicolas Dichtel idev = __in6_dev_get(dev); 6597a674200SNicolas Dichtel if (!idev) 6607a674200SNicolas Dichtel goto cont; 6617a674200SNicolas Dichtel 6627a674200SNicolas Dichtel if (inet6_netconf_fill_devconf(skb, dev->ifindex, 6637a674200SNicolas Dichtel &idev->cnf, 6647a674200SNicolas Dichtel NETLINK_CB(cb->skb).portid, 6657a674200SNicolas Dichtel cb->nlh->nlmsg_seq, 6667a674200SNicolas Dichtel RTM_NEWNETCONF, 6677a674200SNicolas Dichtel NLM_F_MULTI, 668136ba622SZhang Shengju NETCONFA_ALL) < 0) { 6697a674200SNicolas Dichtel rcu_read_unlock(); 6707a674200SNicolas Dichtel goto done; 6717a674200SNicolas Dichtel } 67263998ac2SNicolas Dichtel nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 6737a674200SNicolas Dichtel cont: 6747a674200SNicolas Dichtel idx++; 6757a674200SNicolas Dichtel } 6767a674200SNicolas Dichtel rcu_read_unlock(); 6777a674200SNicolas Dichtel } 6787a674200SNicolas Dichtel if (h == NETDEV_HASHENTRIES) { 6797a674200SNicolas Dichtel if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL, 6807a674200SNicolas Dichtel net->ipv6.devconf_all, 6817a674200SNicolas Dichtel NETLINK_CB(cb->skb).portid, 6827a674200SNicolas Dichtel cb->nlh->nlmsg_seq, 6837a674200SNicolas Dichtel RTM_NEWNETCONF, NLM_F_MULTI, 684136ba622SZhang Shengju NETCONFA_ALL) < 0) 6857a674200SNicolas Dichtel goto done; 6867a674200SNicolas Dichtel else 6877a674200SNicolas Dichtel h++; 6887a674200SNicolas Dichtel } 6897a674200SNicolas Dichtel if (h == NETDEV_HASHENTRIES + 1) { 6907a674200SNicolas Dichtel if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT, 6917a674200SNicolas Dichtel net->ipv6.devconf_dflt, 6927a674200SNicolas Dichtel NETLINK_CB(cb->skb).portid, 6937a674200SNicolas Dichtel cb->nlh->nlmsg_seq, 6947a674200SNicolas Dichtel RTM_NEWNETCONF, NLM_F_MULTI, 695136ba622SZhang Shengju NETCONFA_ALL) < 0) 6967a674200SNicolas Dichtel goto done; 6977a674200SNicolas Dichtel else 6987a674200SNicolas Dichtel h++; 6997a674200SNicolas Dichtel } 7007a674200SNicolas Dichtel done: 7017a674200SNicolas Dichtel cb->args[0] = h; 7027a674200SNicolas Dichtel cb->args[1] = idx; 7037a674200SNicolas Dichtel 7047a674200SNicolas Dichtel return skb->len; 7057a674200SNicolas Dichtel } 7067a674200SNicolas Dichtel 7071da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 7081da177e4SLinus Torvalds static void dev_forward_change(struct inet6_dev *idev) 7091da177e4SLinus Torvalds { 7101da177e4SLinus Torvalds struct net_device *dev; 7111da177e4SLinus Torvalds struct inet6_ifaddr *ifa; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds if (!idev) 7141da177e4SLinus Torvalds return; 7151da177e4SLinus Torvalds dev = idev->dev; 7160187bdfbSBen Hutchings if (idev->cnf.forwarding) 7170187bdfbSBen Hutchings dev_disable_lro(dev); 7181a940835SAmerigo Wang if (dev->flags & IFF_MULTICAST) { 7192c5e8933SHannes Frederic Sowa if (idev->cnf.forwarding) { 720f3ee4010SYOSHIFUJI Hideaki ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters); 7212c5e8933SHannes Frederic Sowa ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters); 7222c5e8933SHannes Frederic Sowa ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters); 7232c5e8933SHannes Frederic Sowa } else { 724f3ee4010SYOSHIFUJI Hideaki ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters); 7252c5e8933SHannes Frederic Sowa ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters); 7262c5e8933SHannes Frederic Sowa ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters); 7272c5e8933SHannes Frederic Sowa } 7281da177e4SLinus Torvalds } 729502a2ffdSstephen hemminger 730502a2ffdSstephen hemminger list_for_each_entry(ifa, &idev->addr_list, if_list) { 7312c12a74cSMichal Wrobel if (ifa->flags&IFA_F_TENTATIVE) 7322c12a74cSMichal Wrobel continue; 7331da177e4SLinus Torvalds if (idev->cnf.forwarding) 7341da177e4SLinus Torvalds addrconf_join_anycast(ifa); 7351da177e4SLinus Torvalds else 7361da177e4SLinus Torvalds addrconf_leave_anycast(ifa); 7371da177e4SLinus Torvalds } 738f3a1bfb1SNicolas Dichtel inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING, 739f3a1bfb1SNicolas Dichtel dev->ifindex, &idev->cnf); 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds 743e186932bSPavel Emelyanov static void addrconf_forward_change(struct net *net, __s32 newf) 7441da177e4SLinus Torvalds { 7451da177e4SLinus Torvalds struct net_device *dev; 7461da177e4SLinus Torvalds struct inet6_dev *idev; 7471da177e4SLinus Torvalds 7484acd4945SBen Hutchings for_each_netdev(net, dev) { 7491da177e4SLinus Torvalds idev = __in6_dev_get(dev); 7501da177e4SLinus Torvalds if (idev) { 751e186932bSPavel Emelyanov int changed = (!idev->cnf.forwarding) ^ (!newf); 752e186932bSPavel Emelyanov idev->cnf.forwarding = newf; 7531da177e4SLinus Torvalds if (changed) 7541da177e4SLinus Torvalds dev_forward_change(idev); 7551da177e4SLinus Torvalds } 7561da177e4SLinus Torvalds } 7571da177e4SLinus Torvalds } 758c8fecf22SPavel Emelyanov 759013d97e9SFrancesco Ruggeri static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf) 760c8fecf22SPavel Emelyanov { 761bff16c2fSPavel Emelyanov struct net *net; 762013d97e9SFrancesco Ruggeri int old; 763013d97e9SFrancesco Ruggeri 764013d97e9SFrancesco Ruggeri if (!rtnl_trylock()) 765013d97e9SFrancesco Ruggeri return restart_syscall(); 766bff16c2fSPavel Emelyanov 767bff16c2fSPavel Emelyanov net = (struct net *)table->extra2; 768013d97e9SFrancesco Ruggeri old = *p; 769013d97e9SFrancesco Ruggeri *p = newf; 770c8fecf22SPavel Emelyanov 771013d97e9SFrancesco Ruggeri if (p == &net->ipv6.devconf_dflt->forwarding) { 772f3a1bfb1SNicolas Dichtel if ((!newf) ^ (!old)) 773f3a1bfb1SNicolas Dichtel inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING, 774f3a1bfb1SNicolas Dichtel NETCONFA_IFINDEX_DEFAULT, 775f3a1bfb1SNicolas Dichtel net->ipv6.devconf_dflt); 776013d97e9SFrancesco Ruggeri rtnl_unlock(); 777013d97e9SFrancesco Ruggeri return 0; 77888af182eSEric W. Biederman } 779b325fddbSStephen Hemminger 780e186932bSPavel Emelyanov if (p == &net->ipv6.devconf_all->forwarding) { 781e186932bSPavel Emelyanov net->ipv6.devconf_dflt->forwarding = newf; 782e186932bSPavel Emelyanov addrconf_forward_change(net, newf); 783f3a1bfb1SNicolas Dichtel if ((!newf) ^ (!old)) 784f3a1bfb1SNicolas Dichtel inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING, 785f3a1bfb1SNicolas Dichtel NETCONFA_IFINDEX_ALL, 786f3a1bfb1SNicolas Dichtel net->ipv6.devconf_all); 787013d97e9SFrancesco Ruggeri } else if ((!newf) ^ (!old)) 788c8fecf22SPavel Emelyanov dev_forward_change((struct inet6_dev *)table->extra1); 7890187bdfbSBen Hutchings rtnl_unlock(); 790c8fecf22SPavel Emelyanov 791013d97e9SFrancesco Ruggeri if (newf) 7927b4da532SDaniel Lezcano rt6_purge_dflt_routers(net); 793b325fddbSStephen Hemminger return 1; 794c8fecf22SPavel Emelyanov } 79535103d11SAndy Gospodarek 79635103d11SAndy Gospodarek static void addrconf_linkdown_change(struct net *net, __s32 newf) 79735103d11SAndy Gospodarek { 79835103d11SAndy Gospodarek struct net_device *dev; 79935103d11SAndy Gospodarek struct inet6_dev *idev; 80035103d11SAndy Gospodarek 80135103d11SAndy Gospodarek for_each_netdev(net, dev) { 80235103d11SAndy Gospodarek idev = __in6_dev_get(dev); 80335103d11SAndy Gospodarek if (idev) { 80435103d11SAndy Gospodarek int changed = (!idev->cnf.ignore_routes_with_linkdown) ^ (!newf); 80535103d11SAndy Gospodarek 80635103d11SAndy Gospodarek idev->cnf.ignore_routes_with_linkdown = newf; 80735103d11SAndy Gospodarek if (changed) 80835103d11SAndy Gospodarek inet6_netconf_notify_devconf(dev_net(dev), 80935103d11SAndy Gospodarek NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN, 81035103d11SAndy Gospodarek dev->ifindex, 81135103d11SAndy Gospodarek &idev->cnf); 81235103d11SAndy Gospodarek } 81335103d11SAndy Gospodarek } 81435103d11SAndy Gospodarek } 81535103d11SAndy Gospodarek 81635103d11SAndy Gospodarek static int addrconf_fixup_linkdown(struct ctl_table *table, int *p, int newf) 81735103d11SAndy Gospodarek { 81835103d11SAndy Gospodarek struct net *net; 81935103d11SAndy Gospodarek int old; 82035103d11SAndy Gospodarek 82135103d11SAndy Gospodarek if (!rtnl_trylock()) 82235103d11SAndy Gospodarek return restart_syscall(); 82335103d11SAndy Gospodarek 82435103d11SAndy Gospodarek net = (struct net *)table->extra2; 82535103d11SAndy Gospodarek old = *p; 82635103d11SAndy Gospodarek *p = newf; 82735103d11SAndy Gospodarek 82835103d11SAndy Gospodarek if (p == &net->ipv6.devconf_dflt->ignore_routes_with_linkdown) { 82935103d11SAndy Gospodarek if ((!newf) ^ (!old)) 83035103d11SAndy Gospodarek inet6_netconf_notify_devconf(net, 83135103d11SAndy Gospodarek NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN, 83235103d11SAndy Gospodarek NETCONFA_IFINDEX_DEFAULT, 83335103d11SAndy Gospodarek net->ipv6.devconf_dflt); 83435103d11SAndy Gospodarek rtnl_unlock(); 83535103d11SAndy Gospodarek return 0; 83635103d11SAndy Gospodarek } 83735103d11SAndy Gospodarek 83835103d11SAndy Gospodarek if (p == &net->ipv6.devconf_all->ignore_routes_with_linkdown) { 83935103d11SAndy Gospodarek net->ipv6.devconf_dflt->ignore_routes_with_linkdown = newf; 84035103d11SAndy Gospodarek addrconf_linkdown_change(net, newf); 84135103d11SAndy Gospodarek if ((!newf) ^ (!old)) 84235103d11SAndy Gospodarek inet6_netconf_notify_devconf(net, 84335103d11SAndy Gospodarek NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN, 84435103d11SAndy Gospodarek NETCONFA_IFINDEX_ALL, 84535103d11SAndy Gospodarek net->ipv6.devconf_all); 84635103d11SAndy Gospodarek } 84735103d11SAndy Gospodarek rtnl_unlock(); 84835103d11SAndy Gospodarek 84935103d11SAndy Gospodarek return 1; 85035103d11SAndy Gospodarek } 85135103d11SAndy Gospodarek 8521da177e4SLinus Torvalds #endif 8531da177e4SLinus Torvalds 8545c578aedSstephen hemminger /* Nobody refers to this ifaddr, destroy it */ 8551da177e4SLinus Torvalds void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp) 8561da177e4SLinus Torvalds { 857c2e21293Sstephen hemminger WARN_ON(!hlist_unhashed(&ifp->addr_lst)); 858547b792cSIlpo Järvinen 8591da177e4SLinus Torvalds #ifdef NET_REFCNT_DEBUG 86091df42beSJoe Perches pr_debug("%s\n", __func__); 8611da177e4SLinus Torvalds #endif 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds in6_dev_put(ifp->idev); 8641da177e4SLinus Torvalds 865c15b1ccaSHannes Frederic Sowa if (cancel_delayed_work(&ifp->dad_work)) 866c15b1ccaSHannes Frederic Sowa pr_notice("delayed DAD work was pending while freeing ifa=%p\n", 867c15b1ccaSHannes Frederic Sowa ifp); 8681da177e4SLinus Torvalds 869e9d3e084SHerbert Xu if (ifp->state != INET6_IFADDR_STATE_DEAD) { 870f3213831SJoe Perches pr_warn("Freeing alive inet6 address %p\n", ifp); 8711da177e4SLinus Torvalds return; 8721da177e4SLinus Torvalds } 87394e187c0SAmerigo Wang ip6_rt_put(ifp->rt); 8741da177e4SLinus Torvalds 875e5785985SLai Jiangshan kfree_rcu(ifp, rcu); 8761da177e4SLinus Torvalds } 8771da177e4SLinus Torvalds 878e55ffac6SBrian Haley static void 879e55ffac6SBrian Haley ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp) 880e55ffac6SBrian Haley { 881502a2ffdSstephen hemminger struct list_head *p; 8828a6ce0c0SYOSHIFUJI Hideaki int ifp_scope = ipv6_addr_src_scope(&ifp->addr); 883e55ffac6SBrian Haley 884e55ffac6SBrian Haley /* 885e55ffac6SBrian Haley * Each device address list is sorted in order of scope - 886e55ffac6SBrian Haley * global before linklocal. 887e55ffac6SBrian Haley */ 888502a2ffdSstephen hemminger list_for_each(p, &idev->addr_list) { 889502a2ffdSstephen hemminger struct inet6_ifaddr *ifa 890502a2ffdSstephen hemminger = list_entry(p, struct inet6_ifaddr, if_list); 8918a6ce0c0SYOSHIFUJI Hideaki if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr)) 892e55ffac6SBrian Haley break; 893e55ffac6SBrian Haley } 894e55ffac6SBrian Haley 895b54c9b98SDavid S. Miller list_add_tail(&ifp->if_list, p); 896e55ffac6SBrian Haley } 897e55ffac6SBrian Haley 898ddbe5032SEric Dumazet static u32 inet6_addr_hash(const struct in6_addr *addr) 8993eb84f49SYOSHIFUJI Hideaki { 900ddbe5032SEric Dumazet return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT); 9013eb84f49SYOSHIFUJI Hideaki } 9023eb84f49SYOSHIFUJI Hideaki 9031da177e4SLinus Torvalds /* On success it returns ifp with increased reference count */ 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds static struct inet6_ifaddr * 9063f8f5298SJiri Pirko ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, 9073f8f5298SJiri Pirko const struct in6_addr *peer_addr, int pfxlen, 9088a226b2cSJiri Benc int scope, u32 flags, u32 valid_lft, u32 prefered_lft) 9091da177e4SLinus Torvalds { 9101da177e4SLinus Torvalds struct inet6_ifaddr *ifa = NULL; 9111da177e4SLinus Torvalds struct rt6_info *rt; 9123a88a81dSstephen hemminger unsigned int hash; 9131da177e4SLinus Torvalds int err = 0; 914d68b8270SYOSHIFUJI Hideaki int addr_type = ipv6_addr_type(addr); 915d68b8270SYOSHIFUJI Hideaki 916d68b8270SYOSHIFUJI Hideaki if (addr_type == IPV6_ADDR_ANY || 917d68b8270SYOSHIFUJI Hideaki addr_type & IPV6_ADDR_MULTICAST || 918d68b8270SYOSHIFUJI Hideaki (!(idev->dev->flags & IFF_LOOPBACK) && 919d68b8270SYOSHIFUJI Hideaki addr_type & IPV6_ADDR_LOOPBACK)) 920d68b8270SYOSHIFUJI Hideaki return ERR_PTR(-EADDRNOTAVAIL); 9211da177e4SLinus Torvalds 9228814c4b5SYOSHIFUJI Hideaki rcu_read_lock_bh(); 9231da177e4SLinus Torvalds if (idev->dead) { 9241da177e4SLinus Torvalds err = -ENODEV; /*XXX*/ 9251da177e4SLinus Torvalds goto out2; 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds 92856d417b1SBrian Haley if (idev->cnf.disable_ipv6) { 9299bdd8d40SBrian Haley err = -EACCES; 9309bdd8d40SBrian Haley goto out2; 9319bdd8d40SBrian Haley } 9329bdd8d40SBrian Haley 9335c578aedSstephen hemminger spin_lock(&addrconf_hash_lock); 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds /* Ignore adding duplicate addresses on an interface */ 936c346dca1SYOSHIFUJI Hideaki if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) { 937ba3542e1Sdingtianhong ADBG("ipv6_add_addr: already assigned\n"); 9381da177e4SLinus Torvalds err = -EEXIST; 9391da177e4SLinus Torvalds goto out; 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds 942322f74a4SIngo Oeser ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC); 9431da177e4SLinus Torvalds 94463159f29SIan Morris if (!ifa) { 945ba3542e1Sdingtianhong ADBG("ipv6_add_addr: malloc failed\n"); 9461da177e4SLinus Torvalds err = -ENOBUFS; 9471da177e4SLinus Torvalds goto out; 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds 9508f031519SDavid S. Miller rt = addrconf_dst_alloc(idev, addr, false); 9511da177e4SLinus Torvalds if (IS_ERR(rt)) { 9521da177e4SLinus Torvalds err = PTR_ERR(rt); 9531da177e4SLinus Torvalds goto out; 9541da177e4SLinus Torvalds } 9551da177e4SLinus Torvalds 956bba24896SJiri Pirko neigh_parms_data_state_setall(idev->nd_parms); 957bba24896SJiri Pirko 9584e3fd7a0SAlexey Dobriyan ifa->addr = *addr; 9593f8f5298SJiri Pirko if (peer_addr) 9603f8f5298SJiri Pirko ifa->peer_addr = *peer_addr; 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds spin_lock_init(&ifa->lock); 963c15b1ccaSHannes Frederic Sowa INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work); 964c2e21293Sstephen hemminger INIT_HLIST_NODE(&ifa->addr_lst); 9651da177e4SLinus Torvalds ifa->scope = scope; 9661da177e4SLinus Torvalds ifa->prefix_len = pfxlen; 9671da177e4SLinus Torvalds ifa->flags = flags | IFA_F_TENTATIVE; 9688a226b2cSJiri Benc ifa->valid_lft = valid_lft; 9698a226b2cSJiri Benc ifa->prefered_lft = prefered_lft; 9701da177e4SLinus Torvalds ifa->cstamp = ifa->tstamp = jiffies; 971617fe29dSDaniel Borkmann ifa->tokenized = false; 9721da177e4SLinus Torvalds 97357f5f544SKeir Fraser ifa->rt = rt; 97457f5f544SKeir Fraser 9751da177e4SLinus Torvalds ifa->idev = idev; 9761da177e4SLinus Torvalds in6_dev_hold(idev); 9771da177e4SLinus Torvalds /* For caller */ 9781da177e4SLinus Torvalds in6_ifa_hold(ifa); 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds /* Add to big hash table */ 981ddbe5032SEric Dumazet hash = inet6_addr_hash(addr); 9821da177e4SLinus Torvalds 9835c578aedSstephen hemminger hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]); 9845c578aedSstephen hemminger spin_unlock(&addrconf_hash_lock); 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds write_lock(&idev->lock); 9871da177e4SLinus Torvalds /* Add to inet6_dev unicast addr list. */ 988e55ffac6SBrian Haley ipv6_link_dev_addr(idev, ifa); 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds if (ifa->flags&IFA_F_TEMPORARY) { 991372e6c8fSstephen hemminger list_add(&ifa->tmp_list, &idev->tempaddr_list); 9921da177e4SLinus Torvalds in6_ifa_hold(ifa); 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds in6_ifa_hold(ifa); 9961da177e4SLinus Torvalds write_unlock(&idev->lock); 9971da177e4SLinus Torvalds out2: 9988814c4b5SYOSHIFUJI Hideaki rcu_read_unlock_bh(); 9991da177e4SLinus Torvalds 1000fd92833aSYOSHIFUJI Hideaki if (likely(err == 0)) 1001f88c91ddSCong Wang inet6addr_notifier_call_chain(NETDEV_UP, ifa); 10021da177e4SLinus Torvalds else { 10031da177e4SLinus Torvalds kfree(ifa); 10041da177e4SLinus Torvalds ifa = ERR_PTR(err); 10051da177e4SLinus Torvalds } 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds return ifa; 10081da177e4SLinus Torvalds out: 10095c578aedSstephen hemminger spin_unlock(&addrconf_hash_lock); 10101da177e4SLinus Torvalds goto out2; 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds 10135b84efecSThomas Haller enum cleanup_prefix_rt_t { 10145b84efecSThomas Haller CLEANUP_PREFIX_RT_NOP, /* no cleanup action for prefix route */ 10155b84efecSThomas Haller CLEANUP_PREFIX_RT_DEL, /* delete the prefix route */ 10165b84efecSThomas Haller CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */ 10175b84efecSThomas Haller }; 10185b84efecSThomas Haller 10195b84efecSThomas Haller /* 10205b84efecSThomas Haller * Check, whether the prefix for ifp would still need a prefix route 10215b84efecSThomas Haller * after deleting ifp. The function returns one of the CLEANUP_PREFIX_RT_* 10225b84efecSThomas Haller * constants. 10235b84efecSThomas Haller * 10245b84efecSThomas Haller * 1) we don't purge prefix if address was not permanent. 10255b84efecSThomas Haller * prefix is managed by its own lifetime. 10265b84efecSThomas Haller * 2) we also don't purge, if the address was IFA_F_NOPREFIXROUTE. 10275b84efecSThomas Haller * 3) if there are no addresses, delete prefix. 10285b84efecSThomas Haller * 4) if there are still other permanent address(es), 10295b84efecSThomas Haller * corresponding prefix is still permanent. 10305b84efecSThomas Haller * 5) if there are still other addresses with IFA_F_NOPREFIXROUTE, 10315b84efecSThomas Haller * don't purge the prefix, assume user space is managing it. 10325b84efecSThomas Haller * 6) otherwise, update prefix lifetime to the 10335b84efecSThomas Haller * longest valid lifetime among the corresponding 10345b84efecSThomas Haller * addresses on the device. 10355b84efecSThomas Haller * Note: subsequent RA will update lifetime. 10365b84efecSThomas Haller **/ 10375b84efecSThomas Haller static enum cleanup_prefix_rt_t 10385b84efecSThomas Haller check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires) 10395b84efecSThomas Haller { 10405b84efecSThomas Haller struct inet6_ifaddr *ifa; 10415b84efecSThomas Haller struct inet6_dev *idev = ifp->idev; 10425b84efecSThomas Haller unsigned long lifetime; 10435b84efecSThomas Haller enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL; 10445b84efecSThomas Haller 10455b84efecSThomas Haller *expires = jiffies; 10465b84efecSThomas Haller 10475b84efecSThomas Haller list_for_each_entry(ifa, &idev->addr_list, if_list) { 10485b84efecSThomas Haller if (ifa == ifp) 10495b84efecSThomas Haller continue; 10505b84efecSThomas Haller if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr, 10515b84efecSThomas Haller ifp->prefix_len)) 10525b84efecSThomas Haller continue; 10535b84efecSThomas Haller if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE)) 10545b84efecSThomas Haller return CLEANUP_PREFIX_RT_NOP; 10555b84efecSThomas Haller 10565b84efecSThomas Haller action = CLEANUP_PREFIX_RT_EXPIRE; 10575b84efecSThomas Haller 10585b84efecSThomas Haller spin_lock(&ifa->lock); 10595b84efecSThomas Haller 10605b84efecSThomas Haller lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ); 10615b84efecSThomas Haller /* 10625b84efecSThomas Haller * Note: Because this address is 10635b84efecSThomas Haller * not permanent, lifetime < 10645b84efecSThomas Haller * LONG_MAX / HZ here. 10655b84efecSThomas Haller */ 10665b84efecSThomas Haller if (time_before(*expires, ifa->tstamp + lifetime * HZ)) 10675b84efecSThomas Haller *expires = ifa->tstamp + lifetime * HZ; 10685b84efecSThomas Haller spin_unlock(&ifa->lock); 10695b84efecSThomas Haller } 10705b84efecSThomas Haller 10715b84efecSThomas Haller return action; 10725b84efecSThomas Haller } 10735b84efecSThomas Haller 10745b84efecSThomas Haller static void 10755b84efecSThomas Haller cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt) 10765b84efecSThomas Haller { 10775b84efecSThomas Haller struct rt6_info *rt; 10785b84efecSThomas Haller 10795b84efecSThomas Haller rt = addrconf_get_prefix_route(&ifp->addr, 10805b84efecSThomas Haller ifp->prefix_len, 10815b84efecSThomas Haller ifp->idev->dev, 10825b84efecSThomas Haller 0, RTF_GATEWAY | RTF_DEFAULT); 10835b84efecSThomas Haller if (rt) { 10845b84efecSThomas Haller if (del_rt) 10855b84efecSThomas Haller ip6_del_rt(rt); 10865b84efecSThomas Haller else { 10875b84efecSThomas Haller if (!(rt->rt6i_flags & RTF_EXPIRES)) 10885b84efecSThomas Haller rt6_set_expires(rt, expires); 10895b84efecSThomas Haller ip6_rt_put(rt); 10905b84efecSThomas Haller } 10915b84efecSThomas Haller } 10925b84efecSThomas Haller } 10935b84efecSThomas Haller 10945b84efecSThomas Haller 10951da177e4SLinus Torvalds /* This function wants to get referenced ifp and releases it before return */ 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds static void ipv6_del_addr(struct inet6_ifaddr *ifp) 10981da177e4SLinus Torvalds { 10994c5ff6a6SHerbert Xu int state; 11005b84efecSThomas Haller enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP; 11015b84efecSThomas Haller unsigned long expires; 11021da177e4SLinus Torvalds 1103c15b1ccaSHannes Frederic Sowa ASSERT_RTNL(); 1104c15b1ccaSHannes Frederic Sowa 11058e8e676dSHannes Frederic Sowa spin_lock_bh(&ifp->lock); 11064c5ff6a6SHerbert Xu state = ifp->state; 1107e9d3e084SHerbert Xu ifp->state = INET6_IFADDR_STATE_DEAD; 11088e8e676dSHannes Frederic Sowa spin_unlock_bh(&ifp->lock); 11094c5ff6a6SHerbert Xu 11104c5ff6a6SHerbert Xu if (state == INET6_IFADDR_STATE_DEAD) 11114c5ff6a6SHerbert Xu goto out; 11121da177e4SLinus Torvalds 11135c578aedSstephen hemminger spin_lock_bh(&addrconf_hash_lock); 11145c578aedSstephen hemminger hlist_del_init_rcu(&ifp->addr_lst); 11155c578aedSstephen hemminger spin_unlock_bh(&addrconf_hash_lock); 11161da177e4SLinus Torvalds 11175b84efecSThomas Haller write_lock_bh(&ifp->idev->lock); 11185d9efa7eSDavid S. Miller 11191da177e4SLinus Torvalds if (ifp->flags&IFA_F_TEMPORARY) { 1120372e6c8fSstephen hemminger list_del(&ifp->tmp_list); 11211da177e4SLinus Torvalds if (ifp->ifpub) { 11221da177e4SLinus Torvalds in6_ifa_put(ifp->ifpub); 11231da177e4SLinus Torvalds ifp->ifpub = NULL; 11241da177e4SLinus Torvalds } 11251da177e4SLinus Torvalds __in6_ifa_put(ifp); 11261da177e4SLinus Torvalds } 11271da177e4SLinus Torvalds 11285b84efecSThomas Haller if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE)) 11295b84efecSThomas Haller action = check_cleanup_prefix_route(ifp, &expires); 11305b84efecSThomas Haller 1131502a2ffdSstephen hemminger list_del_init(&ifp->if_list); 11321da177e4SLinus Torvalds __in6_ifa_put(ifp); 1133502a2ffdSstephen hemminger 11345b84efecSThomas Haller write_unlock_bh(&ifp->idev->lock); 11351da177e4SLinus Torvalds 1136c15b1ccaSHannes Frederic Sowa addrconf_del_dad_work(ifp); 1137b2238566SAndrey Vagin 11381da177e4SLinus Torvalds ipv6_ifa_notify(RTM_DELADDR, ifp); 11391da177e4SLinus Torvalds 1140f88c91ddSCong Wang inet6addr_notifier_call_chain(NETDEV_DOWN, ifp); 11411da177e4SLinus Torvalds 11425b84efecSThomas Haller if (action != CLEANUP_PREFIX_RT_NOP) { 11435b84efecSThomas Haller cleanup_prefix_route(ifp, expires, 11445b84efecSThomas Haller action == CLEANUP_PREFIX_RT_DEL); 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds 1147c3968a85SDaniel Walter /* clean up prefsrc entries */ 1148c3968a85SDaniel Walter rt6_remove_prefsrc(ifp); 11494c5ff6a6SHerbert Xu out: 11501da177e4SLinus Torvalds in6_ifa_put(ifp); 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift) 11541da177e4SLinus Torvalds { 11551da177e4SLinus Torvalds struct inet6_dev *idev = ifp->idev; 11561da177e4SLinus Torvalds struct in6_addr addr, *tmpaddr; 115776f793e3SLorenzo Colitti unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age; 1158eac55bf9SBenoit Boissinot unsigned long regen_advance; 11591da177e4SLinus Torvalds int tmp_plen; 11601da177e4SLinus Torvalds int ret = 0; 116195c385b4SNeil Horman u32 addr_flags; 116276f793e3SLorenzo Colitti unsigned long now = jiffies; 11631da177e4SLinus Torvalds 116453bd6749SJiri Pirko write_lock_bh(&idev->lock); 11651da177e4SLinus Torvalds if (ift) { 11661da177e4SLinus Torvalds spin_lock_bh(&ift->lock); 11671da177e4SLinus Torvalds memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8); 11681da177e4SLinus Torvalds spin_unlock_bh(&ift->lock); 11691da177e4SLinus Torvalds tmpaddr = &addr; 11701da177e4SLinus Torvalds } else { 11711da177e4SLinus Torvalds tmpaddr = NULL; 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds retry: 11741da177e4SLinus Torvalds in6_dev_hold(idev); 11751da177e4SLinus Torvalds if (idev->cnf.use_tempaddr <= 0) { 117653bd6749SJiri Pirko write_unlock_bh(&idev->lock); 1177f3213831SJoe Perches pr_info("%s: use_tempaddr is disabled\n", __func__); 11781da177e4SLinus Torvalds in6_dev_put(idev); 11791da177e4SLinus Torvalds ret = -1; 11801da177e4SLinus Torvalds goto out; 11811da177e4SLinus Torvalds } 11821da177e4SLinus Torvalds spin_lock_bh(&ifp->lock); 11831da177e4SLinus Torvalds if (ifp->regen_count++ >= idev->cnf.regen_max_retry) { 11841da177e4SLinus Torvalds idev->cnf.use_tempaddr = -1; /*XXX*/ 11851da177e4SLinus Torvalds spin_unlock_bh(&ifp->lock); 118653bd6749SJiri Pirko write_unlock_bh(&idev->lock); 1187f3213831SJoe Perches pr_warn("%s: regeneration time exceeded - disabled temporary address support\n", 1188f3213831SJoe Perches __func__); 11891da177e4SLinus Torvalds in6_dev_put(idev); 11901da177e4SLinus Torvalds ret = -1; 11911da177e4SLinus Torvalds goto out; 11921da177e4SLinus Torvalds } 11931da177e4SLinus Torvalds in6_ifa_hold(ifp); 11941da177e4SLinus Torvalds memcpy(addr.s6_addr, ifp->addr.s6_addr, 8); 1195eb7e0575SSorin Dumitru __ipv6_try_regen_rndid(idev, tmpaddr); 11961da177e4SLinus Torvalds memcpy(&addr.s6_addr[8], idev->rndid, 8); 119776f793e3SLorenzo Colitti age = (now - ifp->tstamp) / HZ; 11981da177e4SLinus Torvalds tmp_valid_lft = min_t(__u32, 11991da177e4SLinus Torvalds ifp->valid_lft, 12007a876b0eSGlenn Wurster idev->cnf.temp_valid_lft + age); 12011da177e4SLinus Torvalds tmp_prefered_lft = min_t(__u32, 12021da177e4SLinus Torvalds ifp->prefered_lft, 12037a876b0eSGlenn Wurster idev->cnf.temp_prefered_lft + age - 1204784e2710SBen Hutchings idev->cnf.max_desync_factor); 12051da177e4SLinus Torvalds tmp_plen = ifp->prefix_len; 12061da177e4SLinus Torvalds tmp_tstamp = ifp->tstamp; 12071da177e4SLinus Torvalds spin_unlock_bh(&ifp->lock); 12081da177e4SLinus Torvalds 1209eac55bf9SBenoit Boissinot regen_advance = idev->cnf.regen_max_retry * 1210eac55bf9SBenoit Boissinot idev->cnf.dad_transmits * 12111f9248e5SJiri Pirko NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ; 121253bd6749SJiri Pirko write_unlock_bh(&idev->lock); 121395c385b4SNeil Horman 1214eac55bf9SBenoit Boissinot /* A temporary address is created only if this calculated Preferred 1215eac55bf9SBenoit Boissinot * Lifetime is greater than REGEN_ADVANCE time units. In particular, 1216eac55bf9SBenoit Boissinot * an implementation must not create a temporary address with a zero 1217eac55bf9SBenoit Boissinot * Preferred Lifetime. 1218ecab6701SHeiner Kallweit * Use age calculation as in addrconf_verify to avoid unnecessary 1219ecab6701SHeiner Kallweit * temporary addresses being generated. 1220eac55bf9SBenoit Boissinot */ 1221ecab6701SHeiner Kallweit age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ; 1222ecab6701SHeiner Kallweit if (tmp_prefered_lft <= regen_advance + age) { 1223eac55bf9SBenoit Boissinot in6_ifa_put(ifp); 1224eac55bf9SBenoit Boissinot in6_dev_put(idev); 1225eac55bf9SBenoit Boissinot ret = -1; 1226eac55bf9SBenoit Boissinot goto out; 1227eac55bf9SBenoit Boissinot } 1228eac55bf9SBenoit Boissinot 122995c385b4SNeil Horman addr_flags = IFA_F_TEMPORARY; 123095c385b4SNeil Horman /* set in addrconf_prefix_rcv() */ 123195c385b4SNeil Horman if (ifp->flags & IFA_F_OPTIMISTIC) 123295c385b4SNeil Horman addr_flags |= IFA_F_OPTIMISTIC; 123395c385b4SNeil Horman 12344b08a8f1SHannes Frederic Sowa ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen, 12358a226b2cSJiri Benc ipv6_addr_scope(&addr), addr_flags, 12364b08a8f1SHannes Frederic Sowa tmp_valid_lft, tmp_prefered_lft); 12374b08a8f1SHannes Frederic Sowa if (IS_ERR(ift)) { 12381da177e4SLinus Torvalds in6_ifa_put(ifp); 12391da177e4SLinus Torvalds in6_dev_put(idev); 1240f3213831SJoe Perches pr_info("%s: retry temporary address regeneration\n", __func__); 12411da177e4SLinus Torvalds tmpaddr = &addr; 124253bd6749SJiri Pirko write_lock_bh(&idev->lock); 12431da177e4SLinus Torvalds goto retry; 12441da177e4SLinus Torvalds } 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds spin_lock_bh(&ift->lock); 12471da177e4SLinus Torvalds ift->ifpub = ifp; 124876f793e3SLorenzo Colitti ift->cstamp = now; 12491da177e4SLinus Torvalds ift->tstamp = tmp_tstamp; 12501da177e4SLinus Torvalds spin_unlock_bh(&ift->lock); 12511da177e4SLinus Torvalds 1252cf22f9a2SDavid S. Miller addrconf_dad_start(ift); 12531da177e4SLinus Torvalds in6_ifa_put(ift); 12541da177e4SLinus Torvalds in6_dev_put(idev); 12551da177e4SLinus Torvalds out: 12561da177e4SLinus Torvalds return ret; 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds /* 1260072047e4SYOSHIFUJI Hideaki * Choose an appropriate source address (RFC3484) 12611da177e4SLinus Torvalds */ 1262a9b05723SYOSHIFUJI Hideaki enum { 1263a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_INIT = 0, 1264a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_LOCAL, 1265a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_SCOPE, 1266a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_PREFERRED, 1267a9b05723SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_MIP6 1268a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_HOA, 1269a9b05723SYOSHIFUJI Hideaki #endif 1270a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_OIF, 1271a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_LABEL, 1272a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_PRIVACY, 1273a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_ORCHID, 1274a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_PREFIX, 12757fd2561eSErik Kline #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 12767fd2561eSErik Kline IPV6_SADDR_RULE_NOT_OPTIMISTIC, 12777fd2561eSErik Kline #endif 1278a9b05723SYOSHIFUJI Hideaki IPV6_SADDR_RULE_MAX 1279072047e4SYOSHIFUJI Hideaki }; 1280072047e4SYOSHIFUJI Hideaki 1281a9b05723SYOSHIFUJI Hideaki struct ipv6_saddr_score { 1282a9b05723SYOSHIFUJI Hideaki int rule; 1283a9b05723SYOSHIFUJI Hideaki int addr_type; 1284a9b05723SYOSHIFUJI Hideaki struct inet6_ifaddr *ifa; 1285a9b05723SYOSHIFUJI Hideaki DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX); 1286a9b05723SYOSHIFUJI Hideaki int scopedist; 1287a9b05723SYOSHIFUJI Hideaki int matchlen; 1288a9b05723SYOSHIFUJI Hideaki }; 1289a9b05723SYOSHIFUJI Hideaki 1290a9b05723SYOSHIFUJI Hideaki struct ipv6_saddr_dst { 12919acd9f3aSYOSHIFUJI Hideaki const struct in6_addr *addr; 1292a9b05723SYOSHIFUJI Hideaki int ifindex; 1293a9b05723SYOSHIFUJI Hideaki int scope; 1294a9b05723SYOSHIFUJI Hideaki int label; 12957cbca67cSYOSHIFUJI Hideaki unsigned int prefs; 1296a9b05723SYOSHIFUJI Hideaki }; 1297072047e4SYOSHIFUJI Hideaki 1298b6f99a21SDave Jones static inline int ipv6_saddr_preferred(int type) 12991da177e4SLinus Torvalds { 130045bb0060SUlrich Weber if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK)) 1301072047e4SYOSHIFUJI Hideaki return 1; 1302072047e4SYOSHIFUJI Hideaki return 0; 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 13057fd2561eSErik Kline static inline bool ipv6_use_optimistic_addr(struct inet6_dev *idev) 13067fd2561eSErik Kline { 13077fd2561eSErik Kline #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 13087fd2561eSErik Kline return idev && idev->cnf.optimistic_dad && idev->cnf.use_optimistic; 13097fd2561eSErik Kline #else 13107fd2561eSErik Kline return false; 13117fd2561eSErik Kline #endif 13127fd2561eSErik Kline } 13137fd2561eSErik Kline 13143de23255SBenjamin Thery static int ipv6_get_saddr_eval(struct net *net, 13153de23255SBenjamin Thery struct ipv6_saddr_score *score, 1316a9b05723SYOSHIFUJI Hideaki struct ipv6_saddr_dst *dst, 1317a9b05723SYOSHIFUJI Hideaki int i) 1318a9b05723SYOSHIFUJI Hideaki { 1319a9b05723SYOSHIFUJI Hideaki int ret; 1320a9b05723SYOSHIFUJI Hideaki 1321a9b05723SYOSHIFUJI Hideaki if (i <= score->rule) { 1322a9b05723SYOSHIFUJI Hideaki switch (i) { 1323a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_SCOPE: 1324a9b05723SYOSHIFUJI Hideaki ret = score->scopedist; 1325a9b05723SYOSHIFUJI Hideaki break; 1326a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_PREFIX: 1327a9b05723SYOSHIFUJI Hideaki ret = score->matchlen; 1328a9b05723SYOSHIFUJI Hideaki break; 1329a9b05723SYOSHIFUJI Hideaki default: 1330a9b05723SYOSHIFUJI Hideaki ret = !!test_bit(i, score->scorebits); 1331a9b05723SYOSHIFUJI Hideaki } 1332a9b05723SYOSHIFUJI Hideaki goto out; 1333a9b05723SYOSHIFUJI Hideaki } 1334a9b05723SYOSHIFUJI Hideaki 1335a9b05723SYOSHIFUJI Hideaki switch (i) { 1336a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_INIT: 1337a9b05723SYOSHIFUJI Hideaki /* Rule 0: remember if hiscore is not ready yet */ 1338a9b05723SYOSHIFUJI Hideaki ret = !!score->ifa; 1339a9b05723SYOSHIFUJI Hideaki break; 1340a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_LOCAL: 1341a9b05723SYOSHIFUJI Hideaki /* Rule 1: Prefer same address */ 1342a9b05723SYOSHIFUJI Hideaki ret = ipv6_addr_equal(&score->ifa->addr, dst->addr); 1343a9b05723SYOSHIFUJI Hideaki break; 1344a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_SCOPE: 1345a9b05723SYOSHIFUJI Hideaki /* Rule 2: Prefer appropriate scope 1346a9b05723SYOSHIFUJI Hideaki * 1347a9b05723SYOSHIFUJI Hideaki * ret 1348a9b05723SYOSHIFUJI Hideaki * ^ 1349a9b05723SYOSHIFUJI Hideaki * -1 | d 15 1350a9b05723SYOSHIFUJI Hideaki * ---+--+-+---> scope 1351a9b05723SYOSHIFUJI Hideaki * | 1352a9b05723SYOSHIFUJI Hideaki * | d is scope of the destination. 1353a9b05723SYOSHIFUJI Hideaki * B-d | \ 1354a9b05723SYOSHIFUJI Hideaki * | \ <- smaller scope is better if 1355db9c7c39Sstephen hemminger * B-15 | \ if scope is enough for destination. 1356a9b05723SYOSHIFUJI Hideaki * | ret = B - scope (-1 <= scope >= d <= 15). 1357a9b05723SYOSHIFUJI Hideaki * d-C-1 | / 1358a9b05723SYOSHIFUJI Hideaki * |/ <- greater is better 1359a9b05723SYOSHIFUJI Hideaki * -C / if scope is not enough for destination. 1360a9b05723SYOSHIFUJI Hideaki * /| ret = scope - C (-1 <= d < scope <= 15). 1361a9b05723SYOSHIFUJI Hideaki * 1362a9b05723SYOSHIFUJI Hideaki * d - C - 1 < B -15 (for all -1 <= d <= 15). 1363a9b05723SYOSHIFUJI Hideaki * C > d + 14 - B >= 15 + 14 - B = 29 - B. 1364a9b05723SYOSHIFUJI Hideaki * Assume B = 0 and we get C > 29. 1365a9b05723SYOSHIFUJI Hideaki */ 1366a9b05723SYOSHIFUJI Hideaki ret = __ipv6_addr_src_scope(score->addr_type); 1367a9b05723SYOSHIFUJI Hideaki if (ret >= dst->scope) 1368a9b05723SYOSHIFUJI Hideaki ret = -ret; 1369a9b05723SYOSHIFUJI Hideaki else 1370a9b05723SYOSHIFUJI Hideaki ret -= 128; /* 30 is enough */ 1371a9b05723SYOSHIFUJI Hideaki score->scopedist = ret; 1372a9b05723SYOSHIFUJI Hideaki break; 1373a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_PREFERRED: 13747fd2561eSErik Kline { 1375a9b05723SYOSHIFUJI Hideaki /* Rule 3: Avoid deprecated and optimistic addresses */ 13767fd2561eSErik Kline u8 avoid = IFA_F_DEPRECATED; 13777fd2561eSErik Kline 13787fd2561eSErik Kline if (!ipv6_use_optimistic_addr(score->ifa->idev)) 13797fd2561eSErik Kline avoid |= IFA_F_OPTIMISTIC; 1380a9b05723SYOSHIFUJI Hideaki ret = ipv6_saddr_preferred(score->addr_type) || 13817fd2561eSErik Kline !(score->ifa->flags & avoid); 1382a9b05723SYOSHIFUJI Hideaki break; 13837fd2561eSErik Kline } 1384a9b05723SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_MIP6 1385a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_HOA: 13867cbca67cSYOSHIFUJI Hideaki { 1387a9b05723SYOSHIFUJI Hideaki /* Rule 4: Prefer home address */ 13887cbca67cSYOSHIFUJI Hideaki int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA); 13897cbca67cSYOSHIFUJI Hideaki ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome; 1390a9b05723SYOSHIFUJI Hideaki break; 13917cbca67cSYOSHIFUJI Hideaki } 1392a9b05723SYOSHIFUJI Hideaki #endif 1393a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_OIF: 1394a9b05723SYOSHIFUJI Hideaki /* Rule 5: Prefer outgoing interface */ 1395a9b05723SYOSHIFUJI Hideaki ret = (!dst->ifindex || 1396a9b05723SYOSHIFUJI Hideaki dst->ifindex == score->ifa->idev->dev->ifindex); 1397a9b05723SYOSHIFUJI Hideaki break; 1398a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_LABEL: 1399a9b05723SYOSHIFUJI Hideaki /* Rule 6: Prefer matching label */ 14003de23255SBenjamin Thery ret = ipv6_addr_label(net, 14013de23255SBenjamin Thery &score->ifa->addr, score->addr_type, 1402a9b05723SYOSHIFUJI Hideaki score->ifa->idev->dev->ifindex) == dst->label; 1403a9b05723SYOSHIFUJI Hideaki break; 1404a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_PRIVACY: 14057cbca67cSYOSHIFUJI Hideaki { 1406a9b05723SYOSHIFUJI Hideaki /* Rule 7: Prefer public address 140725985edcSLucas De Marchi * Note: prefer temporary address if use_tempaddr >= 2 1408a9b05723SYOSHIFUJI Hideaki */ 14097cbca67cSYOSHIFUJI Hideaki int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ? 14107cbca67cSYOSHIFUJI Hideaki !!(dst->prefs & IPV6_PREFER_SRC_TMP) : 14117cbca67cSYOSHIFUJI Hideaki score->ifa->idev->cnf.use_tempaddr >= 2; 14127cbca67cSYOSHIFUJI Hideaki ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp; 1413a9b05723SYOSHIFUJI Hideaki break; 14147cbca67cSYOSHIFUJI Hideaki } 1415a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_ORCHID: 1416a9b05723SYOSHIFUJI Hideaki /* Rule 8-: Prefer ORCHID vs ORCHID or 1417a9b05723SYOSHIFUJI Hideaki * non-ORCHID vs non-ORCHID 1418a9b05723SYOSHIFUJI Hideaki */ 1419a9b05723SYOSHIFUJI Hideaki ret = !(ipv6_addr_orchid(&score->ifa->addr) ^ 1420a9b05723SYOSHIFUJI Hideaki ipv6_addr_orchid(dst->addr)); 1421a9b05723SYOSHIFUJI Hideaki break; 1422a9b05723SYOSHIFUJI Hideaki case IPV6_SADDR_RULE_PREFIX: 1423a9b05723SYOSHIFUJI Hideaki /* Rule 8: Use longest matching prefix */ 142491b4b04fSYOSHIFUJI Hideaki / 吉藤英明 ret = ipv6_addr_diff(&score->ifa->addr, dst->addr); 142591b4b04fSYOSHIFUJI Hideaki / 吉藤英明 if (ret > score->ifa->prefix_len) 142691b4b04fSYOSHIFUJI Hideaki / 吉藤英明 ret = score->ifa->prefix_len; 142791b4b04fSYOSHIFUJI Hideaki / 吉藤英明 score->matchlen = ret; 1428a9b05723SYOSHIFUJI Hideaki break; 14297fd2561eSErik Kline #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 14307fd2561eSErik Kline case IPV6_SADDR_RULE_NOT_OPTIMISTIC: 14317fd2561eSErik Kline /* Optimistic addresses still have lower precedence than other 14327fd2561eSErik Kline * preferred addresses. 14337fd2561eSErik Kline */ 14347fd2561eSErik Kline ret = !(score->ifa->flags & IFA_F_OPTIMISTIC); 14357fd2561eSErik Kline break; 14367fd2561eSErik Kline #endif 1437a9b05723SYOSHIFUJI Hideaki default: 1438a9b05723SYOSHIFUJI Hideaki ret = 0; 1439a9b05723SYOSHIFUJI Hideaki } 1440a9b05723SYOSHIFUJI Hideaki 1441a9b05723SYOSHIFUJI Hideaki if (ret) 1442a9b05723SYOSHIFUJI Hideaki __set_bit(i, score->scorebits); 1443a9b05723SYOSHIFUJI Hideaki score->rule = i; 1444a9b05723SYOSHIFUJI Hideaki out: 1445a9b05723SYOSHIFUJI Hideaki return ret; 1446a9b05723SYOSHIFUJI Hideaki } 1447a9b05723SYOSHIFUJI Hideaki 1448c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 static int __ipv6_dev_get_saddr(struct net *net, 14499131f3deSYOSHIFUJI Hideaki/吉藤英明 struct ipv6_saddr_dst *dst, 14509131f3deSYOSHIFUJI Hideaki/吉藤英明 struct inet6_dev *idev, 1451c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 struct ipv6_saddr_score *scores, 1452c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 int hiscore_idx) 14531da177e4SLinus Torvalds { 1454c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx]; 1455072047e4SYOSHIFUJI Hideaki 14561da177e4SLinus Torvalds read_lock_bh(&idev->lock); 1457502a2ffdSstephen hemminger list_for_each_entry(score->ifa, &idev->addr_list, if_list) { 1458a9b05723SYOSHIFUJI Hideaki int i; 1459072047e4SYOSHIFUJI Hideaki 1460a9b05723SYOSHIFUJI Hideaki /* 14616b3ae80aSYOSHIFUJI Hideaki * - Tentative Address (RFC2462 section 5.4) 14626b3ae80aSYOSHIFUJI Hideaki * - A tentative address is not considered 14636b3ae80aSYOSHIFUJI Hideaki * "assigned to an interface" in the traditional 146495c385b4SNeil Horman * sense, unless it is also flagged as optimistic. 14656b3ae80aSYOSHIFUJI Hideaki * - Candidate Source Address (section 4) 1466072047e4SYOSHIFUJI Hideaki * - In any case, anycast addresses, multicast 1467072047e4SYOSHIFUJI Hideaki * addresses, and the unspecified address MUST 1468072047e4SYOSHIFUJI Hideaki * NOT be included in a candidate set. 1469072047e4SYOSHIFUJI Hideaki */ 1470a9b05723SYOSHIFUJI Hideaki if ((score->ifa->flags & IFA_F_TENTATIVE) && 1471a9b05723SYOSHIFUJI Hideaki (!(score->ifa->flags & IFA_F_OPTIMISTIC))) 14726b3ae80aSYOSHIFUJI Hideaki continue; 1473a9b05723SYOSHIFUJI Hideaki 1474a9b05723SYOSHIFUJI Hideaki score->addr_type = __ipv6_addr_type(&score->ifa->addr); 1475a9b05723SYOSHIFUJI Hideaki 1476a9b05723SYOSHIFUJI Hideaki if (unlikely(score->addr_type == IPV6_ADDR_ANY || 1477a9b05723SYOSHIFUJI Hideaki score->addr_type & IPV6_ADDR_MULTICAST)) { 1478ba7a46f1SJoe Perches net_dbg_ratelimited("ADDRCONF: unspecified / multicast address assigned as unicast address on %s", 14799131f3deSYOSHIFUJI Hideaki/吉藤英明 idev->dev->name); 14801da177e4SLinus Torvalds continue; 1481072047e4SYOSHIFUJI Hideaki } 1482072047e4SYOSHIFUJI Hideaki 1483a9b05723SYOSHIFUJI Hideaki score->rule = -1; 1484a9b05723SYOSHIFUJI Hideaki bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX); 1485072047e4SYOSHIFUJI Hideaki 1486a9b05723SYOSHIFUJI Hideaki for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) { 1487a9b05723SYOSHIFUJI Hideaki int minihiscore, miniscore; 1488072047e4SYOSHIFUJI Hideaki 14899131f3deSYOSHIFUJI Hideaki/吉藤英明 minihiscore = ipv6_get_saddr_eval(net, hiscore, dst, i); 14909131f3deSYOSHIFUJI Hideaki/吉藤英明 miniscore = ipv6_get_saddr_eval(net, score, dst, i); 1491072047e4SYOSHIFUJI Hideaki 1492a9b05723SYOSHIFUJI Hideaki if (minihiscore > miniscore) { 1493a9b05723SYOSHIFUJI Hideaki if (i == IPV6_SADDR_RULE_SCOPE && 1494a9b05723SYOSHIFUJI Hideaki score->scopedist > 0) { 1495a9b05723SYOSHIFUJI Hideaki /* 1496a9b05723SYOSHIFUJI Hideaki * special case: 1497a9b05723SYOSHIFUJI Hideaki * each remaining entry 1498a9b05723SYOSHIFUJI Hideaki * has too small (not enough) 1499a9b05723SYOSHIFUJI Hideaki * scope, because ifa entries 1500a9b05723SYOSHIFUJI Hideaki * are sorted by their scope 1501a9b05723SYOSHIFUJI Hideaki * values. 1502072047e4SYOSHIFUJI Hideaki */ 15039131f3deSYOSHIFUJI Hideaki/吉藤英明 goto out; 1504072047e4SYOSHIFUJI Hideaki } 1505a9b05723SYOSHIFUJI Hideaki break; 1506a9b05723SYOSHIFUJI Hideaki } else if (minihiscore < miniscore) { 1507a9b05723SYOSHIFUJI Hideaki if (hiscore->ifa) 1508a9b05723SYOSHIFUJI Hideaki in6_ifa_put(hiscore->ifa); 150999cd07a5SJuha-Matti Tapio 1510a9b05723SYOSHIFUJI Hideaki in6_ifa_hold(score->ifa); 1511072047e4SYOSHIFUJI Hideaki 1512a0bffffcSIlpo Järvinen swap(hiscore, score); 1513c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 hiscore_idx = 1 - hiscore_idx; 1514a9b05723SYOSHIFUJI Hideaki 1515a9b05723SYOSHIFUJI Hideaki /* restore our iterator */ 1516a9b05723SYOSHIFUJI Hideaki score->ifa = hiscore->ifa; 1517a9b05723SYOSHIFUJI Hideaki 1518a9b05723SYOSHIFUJI Hideaki break; 15191da177e4SLinus Torvalds } 1520a9b05723SYOSHIFUJI Hideaki } 1521a9b05723SYOSHIFUJI Hideaki } 15229131f3deSYOSHIFUJI Hideaki/吉藤英明 out: 15231da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 1524c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 return hiscore_idx; 15251da177e4SLinus Torvalds } 15269131f3deSYOSHIFUJI Hideaki/吉藤英明 1527afbac601SDavid Ahern static int ipv6_get_saddr_master(struct net *net, 1528afbac601SDavid Ahern const struct net_device *dst_dev, 1529afbac601SDavid Ahern const struct net_device *master, 1530afbac601SDavid Ahern struct ipv6_saddr_dst *dst, 1531afbac601SDavid Ahern struct ipv6_saddr_score *scores, 1532afbac601SDavid Ahern int hiscore_idx) 1533afbac601SDavid Ahern { 1534afbac601SDavid Ahern struct inet6_dev *idev; 1535afbac601SDavid Ahern 1536afbac601SDavid Ahern idev = __in6_dev_get(dst_dev); 1537afbac601SDavid Ahern if (idev) 1538afbac601SDavid Ahern hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev, 1539afbac601SDavid Ahern scores, hiscore_idx); 1540afbac601SDavid Ahern 1541afbac601SDavid Ahern idev = __in6_dev_get(master); 1542afbac601SDavid Ahern if (idev) 1543afbac601SDavid Ahern hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev, 1544afbac601SDavid Ahern scores, hiscore_idx); 1545afbac601SDavid Ahern 1546afbac601SDavid Ahern return hiscore_idx; 1547afbac601SDavid Ahern } 1548afbac601SDavid Ahern 15499131f3deSYOSHIFUJI Hideaki/吉藤英明 int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev, 15509131f3deSYOSHIFUJI Hideaki/吉藤英明 const struct in6_addr *daddr, unsigned int prefs, 15519131f3deSYOSHIFUJI Hideaki/吉藤英明 struct in6_addr *saddr) 15529131f3deSYOSHIFUJI Hideaki/吉藤英明 { 1553c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 struct ipv6_saddr_score scores[2], *hiscore; 15549131f3deSYOSHIFUJI Hideaki/吉藤英明 struct ipv6_saddr_dst dst; 15559131f3deSYOSHIFUJI Hideaki/吉藤英明 struct inet6_dev *idev; 15569131f3deSYOSHIFUJI Hideaki/吉藤英明 struct net_device *dev; 15579131f3deSYOSHIFUJI Hideaki/吉藤英明 int dst_type; 15589131f3deSYOSHIFUJI Hideaki/吉藤英明 bool use_oif_addr = false; 1559c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 int hiscore_idx = 0; 15609131f3deSYOSHIFUJI Hideaki/吉藤英明 15619131f3deSYOSHIFUJI Hideaki/吉藤英明 dst_type = __ipv6_addr_type(daddr); 15629131f3deSYOSHIFUJI Hideaki/吉藤英明 dst.addr = daddr; 15639131f3deSYOSHIFUJI Hideaki/吉藤英明 dst.ifindex = dst_dev ? dst_dev->ifindex : 0; 15649131f3deSYOSHIFUJI Hideaki/吉藤英明 dst.scope = __ipv6_addr_src_scope(dst_type); 15659131f3deSYOSHIFUJI Hideaki/吉藤英明 dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex); 15669131f3deSYOSHIFUJI Hideaki/吉藤英明 dst.prefs = prefs; 15679131f3deSYOSHIFUJI Hideaki/吉藤英明 1568c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 scores[hiscore_idx].rule = -1; 1569c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 scores[hiscore_idx].ifa = NULL; 15709131f3deSYOSHIFUJI Hideaki/吉藤英明 15719131f3deSYOSHIFUJI Hideaki/吉藤英明 rcu_read_lock(); 15729131f3deSYOSHIFUJI Hideaki/吉藤英明 15739131f3deSYOSHIFUJI Hideaki/吉藤英明 /* Candidate Source Address (section 4) 15749131f3deSYOSHIFUJI Hideaki/吉藤英明 * - multicast and link-local destination address, 15759131f3deSYOSHIFUJI Hideaki/吉藤英明 * the set of candidate source address MUST only 15769131f3deSYOSHIFUJI Hideaki/吉藤英明 * include addresses assigned to interfaces 15779131f3deSYOSHIFUJI Hideaki/吉藤英明 * belonging to the same link as the outgoing 15789131f3deSYOSHIFUJI Hideaki/吉藤英明 * interface. 15799131f3deSYOSHIFUJI Hideaki/吉藤英明 * (- For site-local destination addresses, the 15809131f3deSYOSHIFUJI Hideaki/吉藤英明 * set of candidate source addresses MUST only 15819131f3deSYOSHIFUJI Hideaki/吉藤英明 * include addresses assigned to interfaces 15829131f3deSYOSHIFUJI Hideaki/吉藤英明 * belonging to the same site as the outgoing 15839131f3deSYOSHIFUJI Hideaki/吉藤英明 * interface.) 15843985e8a3SErik Kline * - "It is RECOMMENDED that the candidate source addresses 15853985e8a3SErik Kline * be the set of unicast addresses assigned to the 15863985e8a3SErik Kline * interface that will be used to send to the destination 15873985e8a3SErik Kline * (the 'outgoing' interface)." (RFC 6724) 15889131f3deSYOSHIFUJI Hideaki/吉藤英明 */ 15899131f3deSYOSHIFUJI Hideaki/吉藤英明 if (dst_dev) { 15909131f3deSYOSHIFUJI Hideaki/吉藤英明 idev = __in6_dev_get(dst_dev); 15913985e8a3SErik Kline if ((dst_type & IPV6_ADDR_MULTICAST) || 15923985e8a3SErik Kline dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL || 15933985e8a3SErik Kline (idev && idev->cnf.use_oif_addrs_only)) { 15949131f3deSYOSHIFUJI Hideaki/吉藤英明 use_oif_addr = true; 15959131f3deSYOSHIFUJI Hideaki/吉藤英明 } 15969131f3deSYOSHIFUJI Hideaki/吉藤英明 } 15979131f3deSYOSHIFUJI Hideaki/吉藤英明 15989131f3deSYOSHIFUJI Hideaki/吉藤英明 if (use_oif_addr) { 1599c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 if (idev) 1600c15df306SYOSHIFUJI Hideaki hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx); 16019131f3deSYOSHIFUJI Hideaki/吉藤英明 } else { 1602afbac601SDavid Ahern const struct net_device *master; 1603afbac601SDavid Ahern int master_idx = 0; 1604afbac601SDavid Ahern 1605afbac601SDavid Ahern /* if dst_dev exists and is enslaved to an L3 device, then 1606afbac601SDavid Ahern * prefer addresses from dst_dev and then the master over 1607afbac601SDavid Ahern * any other enslaved devices in the L3 domain. 1608afbac601SDavid Ahern */ 1609afbac601SDavid Ahern master = l3mdev_master_dev_rcu(dst_dev); 1610afbac601SDavid Ahern if (master) { 1611afbac601SDavid Ahern master_idx = master->ifindex; 1612afbac601SDavid Ahern 1613afbac601SDavid Ahern hiscore_idx = ipv6_get_saddr_master(net, dst_dev, 1614afbac601SDavid Ahern master, &dst, 1615afbac601SDavid Ahern scores, hiscore_idx); 1616afbac601SDavid Ahern 1617afbac601SDavid Ahern if (scores[hiscore_idx].ifa) 1618afbac601SDavid Ahern goto out; 1619afbac601SDavid Ahern } 1620afbac601SDavid Ahern 16219131f3deSYOSHIFUJI Hideaki/吉藤英明 for_each_netdev_rcu(net, dev) { 1622afbac601SDavid Ahern /* only consider addresses on devices in the 1623afbac601SDavid Ahern * same L3 domain 1624afbac601SDavid Ahern */ 1625afbac601SDavid Ahern if (l3mdev_master_ifindex_rcu(dev) != master_idx) 1626afbac601SDavid Ahern continue; 16279131f3deSYOSHIFUJI Hideaki/吉藤英明 idev = __in6_dev_get(dev); 16289131f3deSYOSHIFUJI Hideaki/吉藤英明 if (!idev) 16299131f3deSYOSHIFUJI Hideaki/吉藤英明 continue; 1630c15df306SYOSHIFUJI Hideaki hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx); 16319131f3deSYOSHIFUJI Hideaki/吉藤英明 } 16329131f3deSYOSHIFUJI Hideaki/吉藤英明 } 1633afbac601SDavid Ahern 1634afbac601SDavid Ahern out: 16358814c4b5SYOSHIFUJI Hideaki rcu_read_unlock(); 16361da177e4SLinus Torvalds 1637c0b8da1eSYOSHIFUJI Hideaki/吉藤英明 hiscore = &scores[hiscore_idx]; 1638a9b05723SYOSHIFUJI Hideaki if (!hiscore->ifa) 1639072047e4SYOSHIFUJI Hideaki return -EADDRNOTAVAIL; 16401da177e4SLinus Torvalds 16414e3fd7a0SAlexey Dobriyan *saddr = hiscore->ifa->addr; 1642a9b05723SYOSHIFUJI Hideaki in6_ifa_put(hiscore->ifa); 1643072047e4SYOSHIFUJI Hideaki return 0; 16441da177e4SLinus Torvalds } 16455e5f3f0fSYOSHIFUJI Hideaki EXPORT_SYMBOL(ipv6_dev_get_saddr); 16461da177e4SLinus Torvalds 16478965779dSAmerigo Wang int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr, 1648479840ffSJiri Pirko u32 banned_flags) 1649b7b1bfceSHannes Frederic Sowa { 1650b7b1bfceSHannes Frederic Sowa struct inet6_ifaddr *ifp; 1651b7b1bfceSHannes Frederic Sowa int err = -EADDRNOTAVAIL; 1652b7b1bfceSHannes Frederic Sowa 1653602582caSHannes Frederic Sowa list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) { 1654602582caSHannes Frederic Sowa if (ifp->scope > IFA_LINK) 1655602582caSHannes Frederic Sowa break; 1656b7b1bfceSHannes Frederic Sowa if (ifp->scope == IFA_LINK && 1657b7b1bfceSHannes Frederic Sowa !(ifp->flags & banned_flags)) { 1658b7b1bfceSHannes Frederic Sowa *addr = ifp->addr; 1659b7b1bfceSHannes Frederic Sowa err = 0; 1660b7b1bfceSHannes Frederic Sowa break; 1661b7b1bfceSHannes Frederic Sowa } 1662b7b1bfceSHannes Frederic Sowa } 1663b7b1bfceSHannes Frederic Sowa return err; 1664b7b1bfceSHannes Frederic Sowa } 1665b7b1bfceSHannes Frederic Sowa 166695c385b4SNeil Horman int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr, 1667479840ffSJiri Pirko u32 banned_flags) 16681da177e4SLinus Torvalds { 16691da177e4SLinus Torvalds struct inet6_dev *idev; 16701da177e4SLinus Torvalds int err = -EADDRNOTAVAIL; 16711da177e4SLinus Torvalds 16728814c4b5SYOSHIFUJI Hideaki rcu_read_lock(); 1673e21e8467SStephen Hemminger idev = __in6_dev_get(dev); 1674e21e8467SStephen Hemminger if (idev) { 16751da177e4SLinus Torvalds read_lock_bh(&idev->lock); 1676b7b1bfceSHannes Frederic Sowa err = __ipv6_get_lladdr(idev, addr, banned_flags); 16771da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 16781da177e4SLinus Torvalds } 16798814c4b5SYOSHIFUJI Hideaki rcu_read_unlock(); 16801da177e4SLinus Torvalds return err; 16811da177e4SLinus Torvalds } 16821da177e4SLinus Torvalds 16831da177e4SLinus Torvalds static int ipv6_count_addresses(struct inet6_dev *idev) 16841da177e4SLinus Torvalds { 16851da177e4SLinus Torvalds int cnt = 0; 16861da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds read_lock_bh(&idev->lock); 1689502a2ffdSstephen hemminger list_for_each_entry(ifp, &idev->addr_list, if_list) 16901da177e4SLinus Torvalds cnt++; 16911da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 16921da177e4SLinus Torvalds return cnt; 16931da177e4SLinus Torvalds } 16941da177e4SLinus Torvalds 1695b71d1d42SEric Dumazet int ipv6_chk_addr(struct net *net, const struct in6_addr *addr, 16962a7851bfSFlorian Westphal const struct net_device *dev, int strict) 16971da177e4SLinus Torvalds { 1698c58da4c6SErik Kline return ipv6_chk_addr_and_flags(net, addr, dev, strict, IFA_F_TENTATIVE); 1699c58da4c6SErik Kline } 1700c58da4c6SErik Kline EXPORT_SYMBOL(ipv6_chk_addr); 1701c58da4c6SErik Kline 1702c58da4c6SErik Kline int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr, 1703c58da4c6SErik Kline const struct net_device *dev, int strict, 1704c58da4c6SErik Kline u32 banned_flags) 1705c58da4c6SErik Kline { 1706eedf042aSStephen Hemminger struct inet6_ifaddr *ifp; 1707ddbe5032SEric Dumazet unsigned int hash = inet6_addr_hash(addr); 1708c58da4c6SErik Kline u32 ifp_flags; 17091da177e4SLinus Torvalds 17105c578aedSstephen hemminger rcu_read_lock_bh(); 1711b67bfe0dSSasha Levin hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { 1712878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(ifp->idev->dev), net)) 1713bfeade08SDaniel Lezcano continue; 1714c58da4c6SErik Kline /* Decouple optimistic from tentative for evaluation here. 1715c58da4c6SErik Kline * Ban optimistic addresses explicitly, when required. 1716c58da4c6SErik Kline */ 1717c58da4c6SErik Kline ifp_flags = (ifp->flags&IFA_F_OPTIMISTIC) 1718c58da4c6SErik Kline ? (ifp->flags&~IFA_F_TENTATIVE) 1719c58da4c6SErik Kline : ifp->flags; 17201da177e4SLinus Torvalds if (ipv6_addr_equal(&ifp->addr, addr) && 1721c58da4c6SErik Kline !(ifp_flags&banned_flags) && 172263159f29SIan Morris (!dev || ifp->idev->dev == dev || 1723eedf042aSStephen Hemminger !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) { 17245c578aedSstephen hemminger rcu_read_unlock_bh(); 1725eedf042aSStephen Hemminger return 1; 1726eedf042aSStephen Hemminger } 1727eedf042aSStephen Hemminger } 17285c578aedSstephen hemminger 1729eedf042aSStephen Hemminger rcu_read_unlock_bh(); 1730eedf042aSStephen Hemminger return 0; 17311da177e4SLinus Torvalds } 1732c58da4c6SErik Kline EXPORT_SYMBOL(ipv6_chk_addr_and_flags); 17337159039aSYOSHIFUJI Hideaki 17343e81c6daSDavid S. Miller static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr, 173506bfe655SDaniel Lezcano struct net_device *dev) 17361da177e4SLinus Torvalds { 1737ddbe5032SEric Dumazet unsigned int hash = inet6_addr_hash(addr); 17381da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 17391da177e4SLinus Torvalds 1740b67bfe0dSSasha Levin hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) { 1741878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(ifp->idev->dev), net)) 174206bfe655SDaniel Lezcano continue; 17431da177e4SLinus Torvalds if (ipv6_addr_equal(&ifp->addr, addr)) { 174463159f29SIan Morris if (!dev || ifp->idev->dev == dev) 17453e81c6daSDavid S. Miller return true; 17461da177e4SLinus Torvalds } 17471da177e4SLinus Torvalds } 17483e81c6daSDavid S. Miller return false; 17491da177e4SLinus Torvalds } 17501da177e4SLinus Torvalds 17517df37ff3SCatalin\(ux\) M. BOIE /* Compares an address/prefix_len with addresses on device @dev. 17527df37ff3SCatalin\(ux\) M. BOIE * If one is found it returns true. 17537df37ff3SCatalin\(ux\) M. BOIE */ 17547df37ff3SCatalin\(ux\) M. BOIE bool ipv6_chk_custom_prefix(const struct in6_addr *addr, 17557df37ff3SCatalin\(ux\) M. BOIE const unsigned int prefix_len, struct net_device *dev) 17567df37ff3SCatalin\(ux\) M. BOIE { 17577df37ff3SCatalin\(ux\) M. BOIE struct inet6_dev *idev; 17587df37ff3SCatalin\(ux\) M. BOIE struct inet6_ifaddr *ifa; 17597df37ff3SCatalin\(ux\) M. BOIE bool ret = false; 17607df37ff3SCatalin\(ux\) M. BOIE 17617df37ff3SCatalin\(ux\) M. BOIE rcu_read_lock(); 17627df37ff3SCatalin\(ux\) M. BOIE idev = __in6_dev_get(dev); 17637df37ff3SCatalin\(ux\) M. BOIE if (idev) { 17647df37ff3SCatalin\(ux\) M. BOIE read_lock_bh(&idev->lock); 17657df37ff3SCatalin\(ux\) M. BOIE list_for_each_entry(ifa, &idev->addr_list, if_list) { 17667df37ff3SCatalin\(ux\) M. BOIE ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len); 17677df37ff3SCatalin\(ux\) M. BOIE if (ret) 17687df37ff3SCatalin\(ux\) M. BOIE break; 17697df37ff3SCatalin\(ux\) M. BOIE } 17707df37ff3SCatalin\(ux\) M. BOIE read_unlock_bh(&idev->lock); 17717df37ff3SCatalin\(ux\) M. BOIE } 17727df37ff3SCatalin\(ux\) M. BOIE rcu_read_unlock(); 17737df37ff3SCatalin\(ux\) M. BOIE 17747df37ff3SCatalin\(ux\) M. BOIE return ret; 17757df37ff3SCatalin\(ux\) M. BOIE } 17767df37ff3SCatalin\(ux\) M. BOIE EXPORT_SYMBOL(ipv6_chk_custom_prefix); 17777df37ff3SCatalin\(ux\) M. BOIE 1778b71d1d42SEric Dumazet int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev) 177952eeeb84SYOSHIFUJI Hideaki { 178052eeeb84SYOSHIFUJI Hideaki struct inet6_dev *idev; 178152eeeb84SYOSHIFUJI Hideaki struct inet6_ifaddr *ifa; 178252eeeb84SYOSHIFUJI Hideaki int onlink; 178352eeeb84SYOSHIFUJI Hideaki 178452eeeb84SYOSHIFUJI Hideaki onlink = 0; 178552eeeb84SYOSHIFUJI Hideaki rcu_read_lock(); 178652eeeb84SYOSHIFUJI Hideaki idev = __in6_dev_get(dev); 178752eeeb84SYOSHIFUJI Hideaki if (idev) { 178852eeeb84SYOSHIFUJI Hideaki read_lock_bh(&idev->lock); 1789502a2ffdSstephen hemminger list_for_each_entry(ifa, &idev->addr_list, if_list) { 179052eeeb84SYOSHIFUJI Hideaki onlink = ipv6_prefix_equal(addr, &ifa->addr, 179152eeeb84SYOSHIFUJI Hideaki ifa->prefix_len); 179252eeeb84SYOSHIFUJI Hideaki if (onlink) 179352eeeb84SYOSHIFUJI Hideaki break; 179452eeeb84SYOSHIFUJI Hideaki } 179552eeeb84SYOSHIFUJI Hideaki read_unlock_bh(&idev->lock); 179652eeeb84SYOSHIFUJI Hideaki } 179752eeeb84SYOSHIFUJI Hideaki rcu_read_unlock(); 179852eeeb84SYOSHIFUJI Hideaki return onlink; 179952eeeb84SYOSHIFUJI Hideaki } 180052eeeb84SYOSHIFUJI Hideaki EXPORT_SYMBOL(ipv6_chk_prefix); 180152eeeb84SYOSHIFUJI Hideaki 18029acd9f3aSYOSHIFUJI Hideaki struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr, 18031cab3da6SDaniel Lezcano struct net_device *dev, int strict) 18041da177e4SLinus Torvalds { 1805b79d1d54SDavid S. Miller struct inet6_ifaddr *ifp, *result = NULL; 1806ddbe5032SEric Dumazet unsigned int hash = inet6_addr_hash(addr); 18071da177e4SLinus Torvalds 18085c578aedSstephen hemminger rcu_read_lock_bh(); 1809b67bfe0dSSasha Levin hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) { 1810878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(ifp->idev->dev), net)) 18111cab3da6SDaniel Lezcano continue; 18121da177e4SLinus Torvalds if (ipv6_addr_equal(&ifp->addr, addr)) { 181363159f29SIan Morris if (!dev || ifp->idev->dev == dev || 18141da177e4SLinus Torvalds !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) { 1815b79d1d54SDavid S. Miller result = ifp; 18161da177e4SLinus Torvalds in6_ifa_hold(ifp); 18171da177e4SLinus Torvalds break; 18181da177e4SLinus Torvalds } 18191da177e4SLinus Torvalds } 18201da177e4SLinus Torvalds } 18215c578aedSstephen hemminger rcu_read_unlock_bh(); 18221da177e4SLinus Torvalds 1823b79d1d54SDavid S. Miller return result; 18241da177e4SLinus Torvalds } 18251da177e4SLinus Torvalds 18261da177e4SLinus Torvalds /* Gets referenced address, destroys ifaddr */ 18271da177e4SLinus Torvalds 1828cc411d0bSBrian Haley static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed) 18291da177e4SLinus Torvalds { 18303d171f39SLubomir Rintel if (dad_failed) 18313d171f39SLubomir Rintel ifp->flags |= IFA_F_DADFAILED; 18323d171f39SLubomir Rintel 18331da177e4SLinus Torvalds if (ifp->flags&IFA_F_PERMANENT) { 18341da177e4SLinus Torvalds spin_lock_bh(&ifp->lock); 1835c15b1ccaSHannes Frederic Sowa addrconf_del_dad_work(ifp); 18361da177e4SLinus Torvalds ifp->flags |= IFA_F_TENTATIVE; 18371da177e4SLinus Torvalds spin_unlock_bh(&ifp->lock); 1838e2577a06SHerbert Xu if (dad_failed) 1839e2577a06SHerbert Xu ipv6_ifa_notify(0, ifp); 18401da177e4SLinus Torvalds in6_ifa_put(ifp); 18411da177e4SLinus Torvalds } else if (ifp->flags&IFA_F_TEMPORARY) { 18421da177e4SLinus Torvalds struct inet6_ifaddr *ifpub; 18431da177e4SLinus Torvalds spin_lock_bh(&ifp->lock); 18441da177e4SLinus Torvalds ifpub = ifp->ifpub; 18451da177e4SLinus Torvalds if (ifpub) { 18461da177e4SLinus Torvalds in6_ifa_hold(ifpub); 18471da177e4SLinus Torvalds spin_unlock_bh(&ifp->lock); 18481da177e4SLinus Torvalds ipv6_create_tempaddr(ifpub, ifp); 18491da177e4SLinus Torvalds in6_ifa_put(ifpub); 18501da177e4SLinus Torvalds } else { 18511da177e4SLinus Torvalds spin_unlock_bh(&ifp->lock); 18521da177e4SLinus Torvalds } 18531da177e4SLinus Torvalds ipv6_del_addr(ifp); 1854c15b1ccaSHannes Frederic Sowa } else { 18551da177e4SLinus Torvalds ipv6_del_addr(ifp); 18561da177e4SLinus Torvalds } 1857c15b1ccaSHannes Frederic Sowa } 18581da177e4SLinus Torvalds 1859f2344a13SHerbert Xu static int addrconf_dad_end(struct inet6_ifaddr *ifp) 1860f2344a13SHerbert Xu { 1861f2344a13SHerbert Xu int err = -ENOENT; 1862f2344a13SHerbert Xu 18638e8e676dSHannes Frederic Sowa spin_lock_bh(&ifp->lock); 1864f2344a13SHerbert Xu if (ifp->state == INET6_IFADDR_STATE_DAD) { 1865f2344a13SHerbert Xu ifp->state = INET6_IFADDR_STATE_POSTDAD; 1866f2344a13SHerbert Xu err = 0; 1867f2344a13SHerbert Xu } 18688e8e676dSHannes Frederic Sowa spin_unlock_bh(&ifp->lock); 1869f2344a13SHerbert Xu 1870f2344a13SHerbert Xu return err; 1871f2344a13SHerbert Xu } 1872f2344a13SHerbert Xu 18733c21edbdSYOSHIFUJI Hideaki void addrconf_dad_failure(struct inet6_ifaddr *ifp) 18743c21edbdSYOSHIFUJI Hideaki { 18751b34be74SYOSHIFUJI Hideaki struct inet6_dev *idev = ifp->idev; 18761855b7c3SHannes Frederic Sowa struct net *net = dev_net(ifp->idev->dev); 18779bdd8d40SBrian Haley 1878853dc2e0SUrsula Braun if (addrconf_dad_end(ifp)) { 1879853dc2e0SUrsula Braun in6_ifa_put(ifp); 1880f2344a13SHerbert Xu return; 1881853dc2e0SUrsula Braun } 1882f2344a13SHerbert Xu 1883e87cc472SJoe Perches net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n", 18840522fea6SJens Rosenboom ifp->idev->dev->name, &ifp->addr); 18859bdd8d40SBrian Haley 18865f40ef77SHannes Frederic Sowa spin_lock_bh(&ifp->lock); 18871b34be74SYOSHIFUJI Hideaki 18885f40ef77SHannes Frederic Sowa if (ifp->flags & IFA_F_STABLE_PRIVACY) { 18895f40ef77SHannes Frederic Sowa int scope = ifp->scope; 18905f40ef77SHannes Frederic Sowa u32 flags = ifp->flags; 18915f40ef77SHannes Frederic Sowa struct in6_addr new_addr; 18925f40ef77SHannes Frederic Sowa struct inet6_ifaddr *ifp2; 18935f40ef77SHannes Frederic Sowa u32 valid_lft, preferred_lft; 18945f40ef77SHannes Frederic Sowa int pfxlen = ifp->prefix_len; 18955f40ef77SHannes Frederic Sowa int retries = ifp->stable_privacy_retry + 1; 18965f40ef77SHannes Frederic Sowa 18971855b7c3SHannes Frederic Sowa if (retries > net->ipv6.sysctl.idgen_retries) { 18985f40ef77SHannes Frederic Sowa net_info_ratelimited("%s: privacy stable address generation failed because of DAD conflicts!\n", 18995f40ef77SHannes Frederic Sowa ifp->idev->dev->name); 19005f40ef77SHannes Frederic Sowa goto errdad; 19015f40ef77SHannes Frederic Sowa } 19025f40ef77SHannes Frederic Sowa 19035f40ef77SHannes Frederic Sowa new_addr = ifp->addr; 19045f40ef77SHannes Frederic Sowa if (ipv6_generate_stable_address(&new_addr, retries, 19055f40ef77SHannes Frederic Sowa idev)) 19065f40ef77SHannes Frederic Sowa goto errdad; 19075f40ef77SHannes Frederic Sowa 19085f40ef77SHannes Frederic Sowa valid_lft = ifp->valid_lft; 19095f40ef77SHannes Frederic Sowa preferred_lft = ifp->prefered_lft; 19105f40ef77SHannes Frederic Sowa 19115f40ef77SHannes Frederic Sowa spin_unlock_bh(&ifp->lock); 19125f40ef77SHannes Frederic Sowa 19135f40ef77SHannes Frederic Sowa if (idev->cnf.max_addresses && 19145f40ef77SHannes Frederic Sowa ipv6_count_addresses(idev) >= 19155f40ef77SHannes Frederic Sowa idev->cnf.max_addresses) 19165f40ef77SHannes Frederic Sowa goto lock_errdad; 19175f40ef77SHannes Frederic Sowa 19185f40ef77SHannes Frederic Sowa net_info_ratelimited("%s: generating new stable privacy address because of DAD conflict\n", 19195f40ef77SHannes Frederic Sowa ifp->idev->dev->name); 19205f40ef77SHannes Frederic Sowa 19215f40ef77SHannes Frederic Sowa ifp2 = ipv6_add_addr(idev, &new_addr, NULL, pfxlen, 19225f40ef77SHannes Frederic Sowa scope, flags, valid_lft, 19235f40ef77SHannes Frederic Sowa preferred_lft); 19245f40ef77SHannes Frederic Sowa if (IS_ERR(ifp2)) 19255f40ef77SHannes Frederic Sowa goto lock_errdad; 19265f40ef77SHannes Frederic Sowa 19275f40ef77SHannes Frederic Sowa spin_lock_bh(&ifp2->lock); 19285f40ef77SHannes Frederic Sowa ifp2->stable_privacy_retry = retries; 19295f40ef77SHannes Frederic Sowa ifp2->state = INET6_IFADDR_STATE_PREDAD; 19305f40ef77SHannes Frederic Sowa spin_unlock_bh(&ifp2->lock); 19315f40ef77SHannes Frederic Sowa 19321855b7c3SHannes Frederic Sowa addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay); 19335f40ef77SHannes Frederic Sowa in6_ifa_put(ifp2); 19345f40ef77SHannes Frederic Sowa lock_errdad: 19355f40ef77SHannes Frederic Sowa spin_lock_bh(&ifp->lock); 19361b34be74SYOSHIFUJI Hideaki } 19371b34be74SYOSHIFUJI Hideaki 19385f40ef77SHannes Frederic Sowa errdad: 1939c15b1ccaSHannes Frederic Sowa /* transition from _POSTDAD to _ERRDAD */ 1940c15b1ccaSHannes Frederic Sowa ifp->state = INET6_IFADDR_STATE_ERRDAD; 19418e8e676dSHannes Frederic Sowa spin_unlock_bh(&ifp->lock); 1942c15b1ccaSHannes Frederic Sowa 1943c15b1ccaSHannes Frederic Sowa addrconf_mod_dad_work(ifp, 0); 19443c21edbdSYOSHIFUJI Hideaki } 19451da177e4SLinus Torvalds 1946a9ed4a29SSabrina Dubroca /* Join to solicited addr multicast group. 1947a9ed4a29SSabrina Dubroca * caller must hold RTNL */ 1948b71d1d42SEric Dumazet void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr) 19491da177e4SLinus Torvalds { 19501da177e4SLinus Torvalds struct in6_addr maddr; 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds if (dev->flags&(IFF_LOOPBACK|IFF_NOARP)) 19531da177e4SLinus Torvalds return; 19541da177e4SLinus Torvalds 19551da177e4SLinus Torvalds addrconf_addr_solict_mult(addr, &maddr); 19561da177e4SLinus Torvalds ipv6_dev_mc_inc(dev, &maddr); 19571da177e4SLinus Torvalds } 19581da177e4SLinus Torvalds 1959a9ed4a29SSabrina Dubroca /* caller must hold RTNL */ 1960b71d1d42SEric Dumazet void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr) 19611da177e4SLinus Torvalds { 19621da177e4SLinus Torvalds struct in6_addr maddr; 19631da177e4SLinus Torvalds 19641da177e4SLinus Torvalds if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP)) 19651da177e4SLinus Torvalds return; 19661da177e4SLinus Torvalds 19671da177e4SLinus Torvalds addrconf_addr_solict_mult(addr, &maddr); 19681da177e4SLinus Torvalds __ipv6_dev_mc_dec(idev, &maddr); 19691da177e4SLinus Torvalds } 19701da177e4SLinus Torvalds 1971a9ed4a29SSabrina Dubroca /* caller must hold RTNL */ 197220380731SArnaldo Carvalho de Melo static void addrconf_join_anycast(struct inet6_ifaddr *ifp) 19731da177e4SLinus Torvalds { 19741da177e4SLinus Torvalds struct in6_addr addr; 1975c15b1ccaSHannes Frederic Sowa 197688ad3149SHannes Frederic Sowa if (ifp->prefix_len >= 127) /* RFC 6164 */ 19772bda8a0cSBjørn Mork return; 19781da177e4SLinus Torvalds ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 19791da177e4SLinus Torvalds if (ipv6_addr_any(&addr)) 19801da177e4SLinus Torvalds return; 1981013b4d90SWANG Cong __ipv6_dev_ac_inc(ifp->idev, &addr); 19821da177e4SLinus Torvalds } 19831da177e4SLinus Torvalds 1984a9ed4a29SSabrina Dubroca /* caller must hold RTNL */ 198520380731SArnaldo Carvalho de Melo static void addrconf_leave_anycast(struct inet6_ifaddr *ifp) 19861da177e4SLinus Torvalds { 19871da177e4SLinus Torvalds struct in6_addr addr; 1988c15b1ccaSHannes Frederic Sowa 198988ad3149SHannes Frederic Sowa if (ifp->prefix_len >= 127) /* RFC 6164 */ 199032019e65SYOSHIFUJI Hideaki return; 19911da177e4SLinus Torvalds ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 19921da177e4SLinus Torvalds if (ipv6_addr_any(&addr)) 19931da177e4SLinus Torvalds return; 19941da177e4SLinus Torvalds __ipv6_dev_ac_dec(ifp->idev, &addr); 19951da177e4SLinus Torvalds } 19961da177e4SLinus Torvalds 199706a4c1c5Salex.bluesman.smirnov@gmail.com static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev) 199806a4c1c5Salex.bluesman.smirnov@gmail.com { 19995241c2d7SAlexander Aring if (dev->addr_len != EUI64_ADDR_LEN) 200006a4c1c5Salex.bluesman.smirnov@gmail.com return -1; 20015241c2d7SAlexander Aring memcpy(eui, dev->dev_addr, EUI64_ADDR_LEN); 20025e98a36eSYOSHIFUJI Hideaki / 吉藤英明 eui[0] ^= 2; 200306a4c1c5Salex.bluesman.smirnov@gmail.com return 0; 200406a4c1c5Salex.bluesman.smirnov@gmail.com } 200506a4c1c5Salex.bluesman.smirnov@gmail.com 2006cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev) 2007cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 { 2008cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 union fwnet_hwaddr *ha; 2009cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 2010cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 if (dev->addr_len != FWNET_ALEN) 2011cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 return -1; 2012cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 2013cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 ha = (union fwnet_hwaddr *)dev->dev_addr; 2014cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 2015cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id)); 2016cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 eui[0] ^= 2; 2017cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 return 0; 2018cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 } 2019cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 2020073a8e0eSYOSHIFUJI Hideaki static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev) 2021073a8e0eSYOSHIFUJI Hideaki { 20221da177e4SLinus Torvalds /* XXX: inherit EUI-64 from other interface -- yoshfuji */ 20231da177e4SLinus Torvalds if (dev->addr_len != ARCNET_ALEN) 20241da177e4SLinus Torvalds return -1; 20251da177e4SLinus Torvalds memset(eui, 0, 7); 20261da177e4SLinus Torvalds eui[7] = *(u8 *)dev->dev_addr; 20271da177e4SLinus Torvalds return 0; 2028073a8e0eSYOSHIFUJI Hideaki } 2029073a8e0eSYOSHIFUJI Hideaki 2030073a8e0eSYOSHIFUJI Hideaki static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev) 2031073a8e0eSYOSHIFUJI Hideaki { 20321da177e4SLinus Torvalds if (dev->addr_len != INFINIBAND_ALEN) 20331da177e4SLinus Torvalds return -1; 20341da177e4SLinus Torvalds memcpy(eui, dev->dev_addr + 12, 8); 20351da177e4SLinus Torvalds eui[0] |= 2; 20361da177e4SLinus Torvalds return 0; 20371da177e4SLinus Torvalds } 2038073a8e0eSYOSHIFUJI Hideaki 2039c61393eaSstephen hemminger static int __ipv6_isatap_ifid(u8 *eui, __be32 addr) 2040dfd982baSYOSHIFUJI Hideaki { 20419af28511SSascha Hlusiak if (addr == 0) 20429af28511SSascha Hlusiak return -1; 2043dfd982baSYOSHIFUJI Hideaki eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) || 2044dfd982baSYOSHIFUJI Hideaki ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) || 2045dfd982baSYOSHIFUJI Hideaki ipv4_is_private_172(addr) || ipv4_is_test_192(addr) || 2046dfd982baSYOSHIFUJI Hideaki ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) || 2047dfd982baSYOSHIFUJI Hideaki ipv4_is_test_198(addr) || ipv4_is_multicast(addr) || 2048dfd982baSYOSHIFUJI Hideaki ipv4_is_lbcast(addr)) ? 0x00 : 0x02; 2049dfd982baSYOSHIFUJI Hideaki eui[1] = 0; 2050dfd982baSYOSHIFUJI Hideaki eui[2] = 0x5E; 2051dfd982baSYOSHIFUJI Hideaki eui[3] = 0xFE; 2052dfd982baSYOSHIFUJI Hideaki memcpy(eui + 4, &addr, 4); 2053dfd982baSYOSHIFUJI Hideaki return 0; 2054dfd982baSYOSHIFUJI Hideaki } 2055dfd982baSYOSHIFUJI Hideaki 2056dfd982baSYOSHIFUJI Hideaki static int addrconf_ifid_sit(u8 *eui, struct net_device *dev) 2057dfd982baSYOSHIFUJI Hideaki { 2058dfd982baSYOSHIFUJI Hideaki if (dev->priv_flags & IFF_ISATAP) 2059dfd982baSYOSHIFUJI Hideaki return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr); 2060dfd982baSYOSHIFUJI Hideaki return -1; 2061dfd982baSYOSHIFUJI Hideaki } 2062dfd982baSYOSHIFUJI Hideaki 2063aee80b54Sstephen hemminger static int addrconf_ifid_gre(u8 *eui, struct net_device *dev) 2064aee80b54Sstephen hemminger { 2065aee80b54Sstephen hemminger return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr); 2066aee80b54Sstephen hemminger } 2067aee80b54Sstephen hemminger 2068e837735eSNicolas Dichtel static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev) 2069e837735eSNicolas Dichtel { 2070e837735eSNicolas Dichtel memcpy(eui, dev->perm_addr, 3); 2071e837735eSNicolas Dichtel memcpy(eui + 5, dev->perm_addr + 3, 3); 2072e837735eSNicolas Dichtel eui[3] = 0xFF; 2073e837735eSNicolas Dichtel eui[4] = 0xFE; 2074e837735eSNicolas Dichtel eui[0] ^= 2; 2075e837735eSNicolas Dichtel return 0; 2076e837735eSNicolas Dichtel } 2077e837735eSNicolas Dichtel 2078073a8e0eSYOSHIFUJI Hideaki static int ipv6_generate_eui64(u8 *eui, struct net_device *dev) 2079073a8e0eSYOSHIFUJI Hideaki { 2080073a8e0eSYOSHIFUJI Hideaki switch (dev->type) { 2081073a8e0eSYOSHIFUJI Hideaki case ARPHRD_ETHER: 2082073a8e0eSYOSHIFUJI Hideaki case ARPHRD_FDDI: 2083073a8e0eSYOSHIFUJI Hideaki return addrconf_ifid_eui48(eui, dev); 2084073a8e0eSYOSHIFUJI Hideaki case ARPHRD_ARCNET: 2085073a8e0eSYOSHIFUJI Hideaki return addrconf_ifid_arcnet(eui, dev); 2086073a8e0eSYOSHIFUJI Hideaki case ARPHRD_INFINIBAND: 2087073a8e0eSYOSHIFUJI Hideaki return addrconf_ifid_infiniband(eui, dev); 2088c7dc89c0SFred L. Templin case ARPHRD_SIT: 2089dfd982baSYOSHIFUJI Hideaki return addrconf_ifid_sit(eui, dev); 2090aee80b54Sstephen hemminger case ARPHRD_IPGRE: 2091aee80b54Sstephen hemminger return addrconf_ifid_gre(eui, dev); 2092e74bccb8SJukka Rissanen case ARPHRD_6LOWPAN: 209306a4c1c5Salex.bluesman.smirnov@gmail.com return addrconf_ifid_eui64(eui, dev); 2094cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 case ARPHRD_IEEE1394: 2095cb6bf355SYOSHIFUJI Hideaki / 吉藤英明 return addrconf_ifid_ieee1394(eui, dev); 2096e837735eSNicolas Dichtel case ARPHRD_TUNNEL6: 2097e837735eSNicolas Dichtel return addrconf_ifid_ip6tnl(eui, dev); 2098073a8e0eSYOSHIFUJI Hideaki } 20991da177e4SLinus Torvalds return -1; 21001da177e4SLinus Torvalds } 21011da177e4SLinus Torvalds 21021da177e4SLinus Torvalds static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev) 21031da177e4SLinus Torvalds { 21041da177e4SLinus Torvalds int err = -1; 21051da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 21061da177e4SLinus Torvalds 21071da177e4SLinus Torvalds read_lock_bh(&idev->lock); 2108602582caSHannes Frederic Sowa list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) { 2109602582caSHannes Frederic Sowa if (ifp->scope > IFA_LINK) 2110602582caSHannes Frederic Sowa break; 21111da177e4SLinus Torvalds if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) { 21121da177e4SLinus Torvalds memcpy(eui, ifp->addr.s6_addr+8, 8); 21131da177e4SLinus Torvalds err = 0; 21141da177e4SLinus Torvalds break; 21151da177e4SLinus Torvalds } 21161da177e4SLinus Torvalds } 21171da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 21181da177e4SLinus Torvalds return err; 21191da177e4SLinus Torvalds } 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */ 2122eb7e0575SSorin Dumitru static void __ipv6_regen_rndid(struct inet6_dev *idev) 21231da177e4SLinus Torvalds { 21241da177e4SLinus Torvalds regen: 2125955189efSYOSHIFUJI Hideaki get_random_bytes(idev->rndid, sizeof(idev->rndid)); 21261da177e4SLinus Torvalds idev->rndid[0] &= ~0x02; 21271da177e4SLinus Torvalds 21281da177e4SLinus Torvalds /* 21291da177e4SLinus Torvalds * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>: 21301da177e4SLinus Torvalds * check if generated address is not inappropriate 21311da177e4SLinus Torvalds * 21321da177e4SLinus Torvalds * - Reserved subnet anycast (RFC 2526) 21331da177e4SLinus Torvalds * 11111101 11....11 1xxxxxxx 2134c7dc89c0SFred L. Templin * - ISATAP (RFC4214) 6.1 21351da177e4SLinus Torvalds * 00-00-5E-FE-xx-xx-xx-xx 21361da177e4SLinus Torvalds * - value 0 21371da177e4SLinus Torvalds * - XXX: already assigned to an address on the device 21381da177e4SLinus Torvalds */ 21391da177e4SLinus Torvalds if (idev->rndid[0] == 0xfd && 21401da177e4SLinus Torvalds (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff && 21411da177e4SLinus Torvalds (idev->rndid[7]&0x80)) 21421da177e4SLinus Torvalds goto regen; 21431da177e4SLinus Torvalds if ((idev->rndid[0]|idev->rndid[1]) == 0) { 21441da177e4SLinus Torvalds if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe) 21451da177e4SLinus Torvalds goto regen; 21461da177e4SLinus Torvalds if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00) 21471da177e4SLinus Torvalds goto regen; 21481da177e4SLinus Torvalds } 21491da177e4SLinus Torvalds } 21501da177e4SLinus Torvalds 21511da177e4SLinus Torvalds static void ipv6_regen_rndid(unsigned long data) 21521da177e4SLinus Torvalds { 21531da177e4SLinus Torvalds struct inet6_dev *idev = (struct inet6_dev *) data; 21541da177e4SLinus Torvalds unsigned long expires; 21551da177e4SLinus Torvalds 21568814c4b5SYOSHIFUJI Hideaki rcu_read_lock_bh(); 21571da177e4SLinus Torvalds write_lock_bh(&idev->lock); 21581da177e4SLinus Torvalds 21591da177e4SLinus Torvalds if (idev->dead) 21601da177e4SLinus Torvalds goto out; 21611da177e4SLinus Torvalds 2162eb7e0575SSorin Dumitru __ipv6_regen_rndid(idev); 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds expires = jiffies + 21651da177e4SLinus Torvalds idev->cnf.temp_prefered_lft * HZ - 21661f9248e5SJiri Pirko idev->cnf.regen_max_retry * idev->cnf.dad_transmits * 21671f9248e5SJiri Pirko NEIGH_VAR(idev->nd_parms, RETRANS_TIME) - 2168784e2710SBen Hutchings idev->cnf.max_desync_factor * HZ; 21691da177e4SLinus Torvalds if (time_before(expires, jiffies)) { 2170f3213831SJoe Perches pr_warn("%s: too short regeneration interval; timer disabled for %s\n", 2171f3213831SJoe Perches __func__, idev->dev->name); 21721da177e4SLinus Torvalds goto out; 21731da177e4SLinus Torvalds } 21741da177e4SLinus Torvalds 21751da177e4SLinus Torvalds if (!mod_timer(&idev->regen_timer, expires)) 21761da177e4SLinus Torvalds in6_dev_hold(idev); 21771da177e4SLinus Torvalds 21781da177e4SLinus Torvalds out: 21791da177e4SLinus Torvalds write_unlock_bh(&idev->lock); 21808814c4b5SYOSHIFUJI Hideaki rcu_read_unlock_bh(); 21811da177e4SLinus Torvalds in6_dev_put(idev); 21821da177e4SLinus Torvalds } 21831da177e4SLinus Torvalds 2184eb7e0575SSorin Dumitru static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr) 21858e5e8f30SEldad Zack { 21861da177e4SLinus Torvalds if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0) 2187eb7e0575SSorin Dumitru __ipv6_regen_rndid(idev); 21881da177e4SLinus Torvalds } 21891da177e4SLinus Torvalds 21901da177e4SLinus Torvalds /* 21911da177e4SLinus Torvalds * Add prefix route. 21921da177e4SLinus Torvalds */ 21931da177e4SLinus Torvalds 21941da177e4SLinus Torvalds static void 21951da177e4SLinus Torvalds addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev, 2196e431b8c0SJamal Hadi Salim unsigned long expires, u32 flags) 21971da177e4SLinus Torvalds { 219886872cb5SThomas Graf struct fib6_config cfg = { 2199ca254490SDavid Ahern .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX, 220086872cb5SThomas Graf .fc_metric = IP6_RT_PRIO_ADDRCONF, 220186872cb5SThomas Graf .fc_ifindex = dev->ifindex, 220286872cb5SThomas Graf .fc_expires = expires, 220386872cb5SThomas Graf .fc_dst_len = plen, 220486872cb5SThomas Graf .fc_flags = RTF_UP | flags, 2205c346dca1SYOSHIFUJI Hideaki .fc_nlinfo.nl_net = dev_net(dev), 2206f410a1fbSStephen Hemminger .fc_protocol = RTPROT_KERNEL, 220786872cb5SThomas Graf }; 22081da177e4SLinus Torvalds 22094e3fd7a0SAlexey Dobriyan cfg.fc_dst = *pfx; 22101da177e4SLinus Torvalds 22111da177e4SLinus Torvalds /* Prevent useless cloning on PtP SIT. 22121da177e4SLinus Torvalds This thing is done here expecting that the whole 22131da177e4SLinus Torvalds class of non-broadcast devices need not cloning. 22141da177e4SLinus Torvalds */ 221507a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_SIT) 22161da177e4SLinus Torvalds if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT)) 221786872cb5SThomas Graf cfg.fc_flags |= RTF_NONEXTHOP; 22180be669bbSJoerg Roedel #endif 22191da177e4SLinus Torvalds 222086872cb5SThomas Graf ip6_route_add(&cfg); 22211da177e4SLinus Torvalds } 22221da177e4SLinus Torvalds 222314ef37b6SAndreas Hofmeister 222414ef37b6SAndreas Hofmeister static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx, 222514ef37b6SAndreas Hofmeister int plen, 222614ef37b6SAndreas Hofmeister const struct net_device *dev, 222714ef37b6SAndreas Hofmeister u32 flags, u32 noflags) 222814ef37b6SAndreas Hofmeister { 222914ef37b6SAndreas Hofmeister struct fib6_node *fn; 223014ef37b6SAndreas Hofmeister struct rt6_info *rt = NULL; 223114ef37b6SAndreas Hofmeister struct fib6_table *table; 2232ca254490SDavid Ahern u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX; 223314ef37b6SAndreas Hofmeister 2234ca254490SDavid Ahern table = fib6_get_table(dev_net(dev), tb_id); 223563159f29SIan Morris if (!table) 223614ef37b6SAndreas Hofmeister return NULL; 223714ef37b6SAndreas Hofmeister 22385744dd9bSLi RongQing read_lock_bh(&table->tb6_lock); 223914ef37b6SAndreas Hofmeister fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0); 224014ef37b6SAndreas Hofmeister if (!fn) 224114ef37b6SAndreas Hofmeister goto out; 22421f56a01fSMartin KaFai Lau 22431f56a01fSMartin KaFai Lau noflags |= RTF_CACHE; 224414ef37b6SAndreas Hofmeister for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) { 2245d1918542SDavid S. Miller if (rt->dst.dev->ifindex != dev->ifindex) 224614ef37b6SAndreas Hofmeister continue; 224714ef37b6SAndreas Hofmeister if ((rt->rt6i_flags & flags) != flags) 224814ef37b6SAndreas Hofmeister continue; 224985da53bfSRomain Kuntz if ((rt->rt6i_flags & noflags) != 0) 225014ef37b6SAndreas Hofmeister continue; 225114ef37b6SAndreas Hofmeister dst_hold(&rt->dst); 225214ef37b6SAndreas Hofmeister break; 225314ef37b6SAndreas Hofmeister } 225414ef37b6SAndreas Hofmeister out: 22555744dd9bSLi RongQing read_unlock_bh(&table->tb6_lock); 225614ef37b6SAndreas Hofmeister return rt; 225714ef37b6SAndreas Hofmeister } 225814ef37b6SAndreas Hofmeister 225914ef37b6SAndreas Hofmeister 22601da177e4SLinus Torvalds /* Create "default" multicast route to the interface */ 22611da177e4SLinus Torvalds 22621da177e4SLinus Torvalds static void addrconf_add_mroute(struct net_device *dev) 22631da177e4SLinus Torvalds { 226486872cb5SThomas Graf struct fib6_config cfg = { 2265ca254490SDavid Ahern .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_LOCAL, 226686872cb5SThomas Graf .fc_metric = IP6_RT_PRIO_ADDRCONF, 226786872cb5SThomas Graf .fc_ifindex = dev->ifindex, 226886872cb5SThomas Graf .fc_dst_len = 8, 226986872cb5SThomas Graf .fc_flags = RTF_UP, 2270c346dca1SYOSHIFUJI Hideaki .fc_nlinfo.nl_net = dev_net(dev), 227186872cb5SThomas Graf }; 22721da177e4SLinus Torvalds 227386872cb5SThomas Graf ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0); 227486872cb5SThomas Graf 227586872cb5SThomas Graf ip6_route_add(&cfg); 22761da177e4SLinus Torvalds } 22771da177e4SLinus Torvalds 22781da177e4SLinus Torvalds static struct inet6_dev *addrconf_add_dev(struct net_device *dev) 22791da177e4SLinus Torvalds { 22801da177e4SLinus Torvalds struct inet6_dev *idev; 22811da177e4SLinus Torvalds 22821da177e4SLinus Torvalds ASSERT_RTNL(); 22831da177e4SLinus Torvalds 2284e21e8467SStephen Hemminger idev = ipv6_find_idev(dev); 2285e21e8467SStephen Hemminger if (!idev) 228664e724f6SBrian Haley return ERR_PTR(-ENOBUFS); 228764e724f6SBrian Haley 228864e724f6SBrian Haley if (idev->cnf.disable_ipv6) 228964e724f6SBrian Haley return ERR_PTR(-EACCES); 22901da177e4SLinus Torvalds 22911da177e4SLinus Torvalds /* Add default multicast route */ 2292ba46ee4cSDavid Ahern if (!(dev->flags & IFF_LOOPBACK) && !netif_is_l3_master(dev)) 22931da177e4SLinus Torvalds addrconf_add_mroute(dev); 22941da177e4SLinus Torvalds 22951da177e4SLinus Torvalds return idev; 22961da177e4SLinus Torvalds } 22971da177e4SLinus Torvalds 229853bd6749SJiri Pirko static void manage_tempaddrs(struct inet6_dev *idev, 229953bd6749SJiri Pirko struct inet6_ifaddr *ifp, 230053bd6749SJiri Pirko __u32 valid_lft, __u32 prefered_lft, 230153bd6749SJiri Pirko bool create, unsigned long now) 230253bd6749SJiri Pirko { 230353bd6749SJiri Pirko u32 flags; 230453bd6749SJiri Pirko struct inet6_ifaddr *ift; 230553bd6749SJiri Pirko 230653bd6749SJiri Pirko read_lock_bh(&idev->lock); 230753bd6749SJiri Pirko /* update all temporary addresses in the list */ 230853bd6749SJiri Pirko list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) { 230953bd6749SJiri Pirko int age, max_valid, max_prefered; 231053bd6749SJiri Pirko 231153bd6749SJiri Pirko if (ifp != ift->ifpub) 231253bd6749SJiri Pirko continue; 231353bd6749SJiri Pirko 231453bd6749SJiri Pirko /* RFC 4941 section 3.3: 231553bd6749SJiri Pirko * If a received option will extend the lifetime of a public 231653bd6749SJiri Pirko * address, the lifetimes of temporary addresses should 231753bd6749SJiri Pirko * be extended, subject to the overall constraint that no 231853bd6749SJiri Pirko * temporary addresses should ever remain "valid" or "preferred" 231953bd6749SJiri Pirko * for a time longer than (TEMP_VALID_LIFETIME) or 232053bd6749SJiri Pirko * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR), respectively. 232153bd6749SJiri Pirko */ 232253bd6749SJiri Pirko age = (now - ift->cstamp) / HZ; 232353bd6749SJiri Pirko max_valid = idev->cnf.temp_valid_lft - age; 232453bd6749SJiri Pirko if (max_valid < 0) 232553bd6749SJiri Pirko max_valid = 0; 232653bd6749SJiri Pirko 232753bd6749SJiri Pirko max_prefered = idev->cnf.temp_prefered_lft - 232853bd6749SJiri Pirko idev->cnf.max_desync_factor - age; 232953bd6749SJiri Pirko if (max_prefered < 0) 233053bd6749SJiri Pirko max_prefered = 0; 233153bd6749SJiri Pirko 233253bd6749SJiri Pirko if (valid_lft > max_valid) 233353bd6749SJiri Pirko valid_lft = max_valid; 233453bd6749SJiri Pirko 233553bd6749SJiri Pirko if (prefered_lft > max_prefered) 233653bd6749SJiri Pirko prefered_lft = max_prefered; 233753bd6749SJiri Pirko 233853bd6749SJiri Pirko spin_lock(&ift->lock); 233953bd6749SJiri Pirko flags = ift->flags; 234053bd6749SJiri Pirko ift->valid_lft = valid_lft; 234153bd6749SJiri Pirko ift->prefered_lft = prefered_lft; 234253bd6749SJiri Pirko ift->tstamp = now; 234353bd6749SJiri Pirko if (prefered_lft > 0) 234453bd6749SJiri Pirko ift->flags &= ~IFA_F_DEPRECATED; 234553bd6749SJiri Pirko 234653bd6749SJiri Pirko spin_unlock(&ift->lock); 234753bd6749SJiri Pirko if (!(flags&IFA_F_TENTATIVE)) 234853bd6749SJiri Pirko ipv6_ifa_notify(0, ift); 234953bd6749SJiri Pirko } 235053bd6749SJiri Pirko 235153bd6749SJiri Pirko if ((create || list_empty(&idev->tempaddr_list)) && 235253bd6749SJiri Pirko idev->cnf.use_tempaddr > 0) { 235353bd6749SJiri Pirko /* When a new public address is created as described 235453bd6749SJiri Pirko * in [ADDRCONF], also create a new temporary address. 235553bd6749SJiri Pirko * Also create a temporary address if it's enabled but 235653bd6749SJiri Pirko * no temporary address currently exists. 235753bd6749SJiri Pirko */ 235853bd6749SJiri Pirko read_unlock_bh(&idev->lock); 235953bd6749SJiri Pirko ipv6_create_tempaddr(ifp, NULL); 236053bd6749SJiri Pirko } else { 236153bd6749SJiri Pirko read_unlock_bh(&idev->lock); 236253bd6749SJiri Pirko } 236353bd6749SJiri Pirko } 236453bd6749SJiri Pirko 2365cc9da6ccSBjørn Mork static bool is_addr_mode_generate_stable(struct inet6_dev *idev) 2366cc9da6ccSBjørn Mork { 2367cc9da6ccSBjørn Mork return idev->addr_gen_mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY || 2368cc9da6ccSBjørn Mork idev->addr_gen_mode == IN6_ADDR_GEN_MODE_RANDOM; 2369cc9da6ccSBjørn Mork } 2370cc9da6ccSBjørn Mork 2371cc84b3c6SAlexander Aring int addrconf_prefix_rcv_add_addr(struct net *net, struct net_device *dev, 23724f672235SAlexander Aring const struct prefix_info *pinfo, 23734f672235SAlexander Aring struct inet6_dev *in6_dev, 2374cc84b3c6SAlexander Aring const struct in6_addr *addr, int addr_type, 2375cc84b3c6SAlexander Aring u32 addr_flags, bool sllao, bool tokenized, 23764f672235SAlexander Aring __u32 valid_lft, u32 prefered_lft) 23774f672235SAlexander Aring { 23784f672235SAlexander Aring struct inet6_ifaddr *ifp = ipv6_get_ifaddr(net, addr, dev, 1); 23794f672235SAlexander Aring int create = 0, update_lft = 0; 23804f672235SAlexander Aring 23814f672235SAlexander Aring if (!ifp && valid_lft) { 23824f672235SAlexander Aring int max_addresses = in6_dev->cnf.max_addresses; 23834f672235SAlexander Aring 23844f672235SAlexander Aring #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 23854f672235SAlexander Aring if (in6_dev->cnf.optimistic_dad && 23864f672235SAlexander Aring !net->ipv6.devconf_all->forwarding && sllao) 23874f672235SAlexander Aring addr_flags |= IFA_F_OPTIMISTIC; 23884f672235SAlexander Aring #endif 23894f672235SAlexander Aring 23904f672235SAlexander Aring /* Do not allow to create too much of autoconfigured 23914f672235SAlexander Aring * addresses; this would be too easy way to crash kernel. 23924f672235SAlexander Aring */ 23934f672235SAlexander Aring if (!max_addresses || 23944f672235SAlexander Aring ipv6_count_addresses(in6_dev) < max_addresses) 23954f672235SAlexander Aring ifp = ipv6_add_addr(in6_dev, addr, NULL, 23964f672235SAlexander Aring pinfo->prefix_len, 23974f672235SAlexander Aring addr_type&IPV6_ADDR_SCOPE_MASK, 23984f672235SAlexander Aring addr_flags, valid_lft, 23994f672235SAlexander Aring prefered_lft); 24004f672235SAlexander Aring 24014f672235SAlexander Aring if (IS_ERR_OR_NULL(ifp)) 24024f672235SAlexander Aring return -1; 24034f672235SAlexander Aring 24044f672235SAlexander Aring update_lft = 0; 24054f672235SAlexander Aring create = 1; 24064f672235SAlexander Aring spin_lock_bh(&ifp->lock); 24074f672235SAlexander Aring ifp->flags |= IFA_F_MANAGETEMPADDR; 24084f672235SAlexander Aring ifp->cstamp = jiffies; 24094f672235SAlexander Aring ifp->tokenized = tokenized; 24104f672235SAlexander Aring spin_unlock_bh(&ifp->lock); 24114f672235SAlexander Aring addrconf_dad_start(ifp); 24124f672235SAlexander Aring } 24134f672235SAlexander Aring 24144f672235SAlexander Aring if (ifp) { 24154f672235SAlexander Aring u32 flags; 24164f672235SAlexander Aring unsigned long now; 24174f672235SAlexander Aring u32 stored_lft; 24184f672235SAlexander Aring 24194f672235SAlexander Aring /* update lifetime (RFC2462 5.5.3 e) */ 24204f672235SAlexander Aring spin_lock_bh(&ifp->lock); 24214f672235SAlexander Aring now = jiffies; 24224f672235SAlexander Aring if (ifp->valid_lft > (now - ifp->tstamp) / HZ) 24234f672235SAlexander Aring stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ; 24244f672235SAlexander Aring else 24254f672235SAlexander Aring stored_lft = 0; 24264f672235SAlexander Aring if (!update_lft && !create && stored_lft) { 24274f672235SAlexander Aring const u32 minimum_lft = min_t(u32, 24284f672235SAlexander Aring stored_lft, MIN_VALID_LIFETIME); 24294f672235SAlexander Aring valid_lft = max(valid_lft, minimum_lft); 24304f672235SAlexander Aring 24314f672235SAlexander Aring /* RFC4862 Section 5.5.3e: 24324f672235SAlexander Aring * "Note that the preferred lifetime of the 24334f672235SAlexander Aring * corresponding address is always reset to 24344f672235SAlexander Aring * the Preferred Lifetime in the received 24354f672235SAlexander Aring * Prefix Information option, regardless of 24364f672235SAlexander Aring * whether the valid lifetime is also reset or 24374f672235SAlexander Aring * ignored." 24384f672235SAlexander Aring * 24394f672235SAlexander Aring * So we should always update prefered_lft here. 24404f672235SAlexander Aring */ 24414f672235SAlexander Aring update_lft = 1; 24424f672235SAlexander Aring } 24434f672235SAlexander Aring 24444f672235SAlexander Aring if (update_lft) { 24454f672235SAlexander Aring ifp->valid_lft = valid_lft; 24464f672235SAlexander Aring ifp->prefered_lft = prefered_lft; 24474f672235SAlexander Aring ifp->tstamp = now; 24484f672235SAlexander Aring flags = ifp->flags; 24494f672235SAlexander Aring ifp->flags &= ~IFA_F_DEPRECATED; 24504f672235SAlexander Aring spin_unlock_bh(&ifp->lock); 24514f672235SAlexander Aring 24524f672235SAlexander Aring if (!(flags&IFA_F_TENTATIVE)) 24534f672235SAlexander Aring ipv6_ifa_notify(0, ifp); 24544f672235SAlexander Aring } else 24554f672235SAlexander Aring spin_unlock_bh(&ifp->lock); 24564f672235SAlexander Aring 24574f672235SAlexander Aring manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft, 24584f672235SAlexander Aring create, now); 24594f672235SAlexander Aring 24604f672235SAlexander Aring in6_ifa_put(ifp); 24614f672235SAlexander Aring addrconf_verify(); 24624f672235SAlexander Aring } 24634f672235SAlexander Aring 24644f672235SAlexander Aring return 0; 24654f672235SAlexander Aring } 2466cc84b3c6SAlexander Aring EXPORT_SYMBOL_GPL(addrconf_prefix_rcv_add_addr); 24674f672235SAlexander Aring 2468e6bff995SNeil Horman void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao) 24691da177e4SLinus Torvalds { 24701da177e4SLinus Torvalds struct prefix_info *pinfo; 24711da177e4SLinus Torvalds __u32 valid_lft; 24721da177e4SLinus Torvalds __u32 prefered_lft; 24734f672235SAlexander Aring int addr_type, err; 247464236f3fSHannes Frederic Sowa u32 addr_flags = 0; 24751da177e4SLinus Torvalds struct inet6_dev *in6_dev; 247656d417b1SBrian Haley struct net *net = dev_net(dev); 24771da177e4SLinus Torvalds 24781da177e4SLinus Torvalds pinfo = (struct prefix_info *) opt; 24791da177e4SLinus Torvalds 24801da177e4SLinus Torvalds if (len < sizeof(struct prefix_info)) { 2481ba3542e1Sdingtianhong ADBG("addrconf: prefix option too short\n"); 24821da177e4SLinus Torvalds return; 24831da177e4SLinus Torvalds } 24841da177e4SLinus Torvalds 24851da177e4SLinus Torvalds /* 24861da177e4SLinus Torvalds * Validation checks ([ADDRCONF], page 19) 24871da177e4SLinus Torvalds */ 24881da177e4SLinus Torvalds 24891da177e4SLinus Torvalds addr_type = ipv6_addr_type(&pinfo->prefix); 24901da177e4SLinus Torvalds 24911da177e4SLinus Torvalds if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL)) 24921da177e4SLinus Torvalds return; 24931da177e4SLinus Torvalds 24941da177e4SLinus Torvalds valid_lft = ntohl(pinfo->valid); 24951da177e4SLinus Torvalds prefered_lft = ntohl(pinfo->prefered); 24961da177e4SLinus Torvalds 24971da177e4SLinus Torvalds if (prefered_lft > valid_lft) { 2498e87cc472SJoe Perches net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n"); 24991da177e4SLinus Torvalds return; 25001da177e4SLinus Torvalds } 25011da177e4SLinus Torvalds 25021da177e4SLinus Torvalds in6_dev = in6_dev_get(dev); 25031da177e4SLinus Torvalds 250463159f29SIan Morris if (!in6_dev) { 2505e87cc472SJoe Perches net_dbg_ratelimited("addrconf: device %s not configured\n", 2506e87cc472SJoe Perches dev->name); 25071da177e4SLinus Torvalds return; 25081da177e4SLinus Torvalds } 25091da177e4SLinus Torvalds 25101da177e4SLinus Torvalds /* 25111da177e4SLinus Torvalds * Two things going on here: 25121da177e4SLinus Torvalds * 1) Add routes for on-link prefixes 25131da177e4SLinus Torvalds * 2) Configure prefixes with the auto flag set 25141da177e4SLinus Torvalds */ 25151da177e4SLinus Torvalds 25164bed72e4SYOSHIFUJI Hideaki if (pinfo->onlink) { 25174bed72e4SYOSHIFUJI Hideaki struct rt6_info *rt; 25184bed72e4SYOSHIFUJI Hideaki unsigned long rt_expires; 25194bed72e4SYOSHIFUJI Hideaki 25201da177e4SLinus Torvalds /* Avoid arithmetic overflow. Really, we could 25216f704992SYOSHIFUJI Hideaki * save rt_expires in seconds, likely valid_lft, 25226f704992SYOSHIFUJI Hideaki * but it would require division in fib gc, that it 25236f704992SYOSHIFUJI Hideaki * not good. 25241da177e4SLinus Torvalds */ 25254bed72e4SYOSHIFUJI Hideaki if (HZ > USER_HZ) 25264bed72e4SYOSHIFUJI Hideaki rt_expires = addrconf_timeout_fixup(valid_lft, HZ); 25274bed72e4SYOSHIFUJI Hideaki else 25284bed72e4SYOSHIFUJI Hideaki rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ); 25293dd4bc68SYOSHIFUJI Hideaki 25304bed72e4SYOSHIFUJI Hideaki if (addrconf_finite_timeout(rt_expires)) 25314bed72e4SYOSHIFUJI Hideaki rt_expires *= HZ; 25321da177e4SLinus Torvalds 253314ef37b6SAndreas Hofmeister rt = addrconf_get_prefix_route(&pinfo->prefix, 253414ef37b6SAndreas Hofmeister pinfo->prefix_len, 253514ef37b6SAndreas Hofmeister dev, 253614ef37b6SAndreas Hofmeister RTF_ADDRCONF | RTF_PREFIX_RT, 253714ef37b6SAndreas Hofmeister RTF_GATEWAY | RTF_DEFAULT); 25381da177e4SLinus Torvalds 253914ef37b6SAndreas Hofmeister if (rt) { 25406f704992SYOSHIFUJI Hideaki /* Autoconf prefix route */ 25411da177e4SLinus Torvalds if (valid_lft == 0) { 2542e0a1ad73SThomas Graf ip6_del_rt(rt); 25431da177e4SLinus Torvalds rt = NULL; 25444bed72e4SYOSHIFUJI Hideaki } else if (addrconf_finite_timeout(rt_expires)) { 25456f704992SYOSHIFUJI Hideaki /* not infinity */ 25461716a961SGao feng rt6_set_expires(rt, jiffies + rt_expires); 25476f704992SYOSHIFUJI Hideaki } else { 25481716a961SGao feng rt6_clean_expires(rt); 25491da177e4SLinus Torvalds } 25501da177e4SLinus Torvalds } else if (valid_lft) { 25516f704992SYOSHIFUJI Hideaki clock_t expires = 0; 25524bed72e4SYOSHIFUJI Hideaki int flags = RTF_ADDRCONF | RTF_PREFIX_RT; 25534bed72e4SYOSHIFUJI Hideaki if (addrconf_finite_timeout(rt_expires)) { 25546f704992SYOSHIFUJI Hideaki /* not infinity */ 25556f704992SYOSHIFUJI Hideaki flags |= RTF_EXPIRES; 25566f704992SYOSHIFUJI Hideaki expires = jiffies_to_clock_t(rt_expires); 25576f704992SYOSHIFUJI Hideaki } 25581da177e4SLinus Torvalds addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len, 25596f704992SYOSHIFUJI Hideaki dev, expires, flags); 25601da177e4SLinus Torvalds } 256194e187c0SAmerigo Wang ip6_rt_put(rt); 25621da177e4SLinus Torvalds } 25631da177e4SLinus Torvalds 25641da177e4SLinus Torvalds /* Try to figure out our local address for this prefix */ 25651da177e4SLinus Torvalds 25661da177e4SLinus Torvalds if (pinfo->autoconf && in6_dev->cnf.autoconf) { 25671da177e4SLinus Torvalds struct in6_addr addr; 2568f997c55cSAlexander Aring bool tokenized = false, dev_addr_generated = false; 25691da177e4SLinus Torvalds 25701da177e4SLinus Torvalds if (pinfo->prefix_len == 64) { 25711da177e4SLinus Torvalds memcpy(&addr, &pinfo->prefix, 8); 2572f53adae4SDaniel Borkmann 2573f53adae4SDaniel Borkmann if (!ipv6_addr_any(&in6_dev->token)) { 2574f53adae4SDaniel Borkmann read_lock_bh(&in6_dev->lock); 2575f53adae4SDaniel Borkmann memcpy(addr.s6_addr + 8, 2576f53adae4SDaniel Borkmann in6_dev->token.s6_addr + 8, 8); 2577f53adae4SDaniel Borkmann read_unlock_bh(&in6_dev->lock); 2578617fe29dSDaniel Borkmann tokenized = true; 2579cc9da6ccSBjørn Mork } else if (is_addr_mode_generate_stable(in6_dev) && 2580622c81d5SHannes Frederic Sowa !ipv6_generate_stable_address(&addr, 0, 2581622c81d5SHannes Frederic Sowa in6_dev)) { 258264236f3fSHannes Frederic Sowa addr_flags |= IFA_F_STABLE_PRIVACY; 2583622c81d5SHannes Frederic Sowa goto ok; 2584f53adae4SDaniel Borkmann } else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) && 25851da177e4SLinus Torvalds ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) { 25864f672235SAlexander Aring goto put; 2587f997c55cSAlexander Aring } else { 2588f997c55cSAlexander Aring dev_addr_generated = true; 25891da177e4SLinus Torvalds } 25901da177e4SLinus Torvalds goto ok; 25911da177e4SLinus Torvalds } 2592e87cc472SJoe Perches net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n", 25931da177e4SLinus Torvalds pinfo->prefix_len); 25944f672235SAlexander Aring goto put; 25951da177e4SLinus Torvalds 25961da177e4SLinus Torvalds ok: 25974f672235SAlexander Aring err = addrconf_prefix_rcv_add_addr(net, dev, pinfo, in6_dev, 25984f672235SAlexander Aring &addr, addr_type, 25994f672235SAlexander Aring addr_flags, sllao, 26004f672235SAlexander Aring tokenized, valid_lft, 26018a226b2cSJiri Benc prefered_lft); 26024f672235SAlexander Aring if (err) 26034f672235SAlexander Aring goto put; 2604f997c55cSAlexander Aring 2605f997c55cSAlexander Aring /* Ignore error case here because previous prefix add addr was 2606f997c55cSAlexander Aring * successful which will be notified. 2607f997c55cSAlexander Aring */ 2608f997c55cSAlexander Aring ndisc_ops_prefix_rcv_add_addr(net, dev, pinfo, in6_dev, &addr, 2609f997c55cSAlexander Aring addr_type, addr_flags, sllao, 2610f997c55cSAlexander Aring tokenized, valid_lft, 2611f997c55cSAlexander Aring prefered_lft, 2612f997c55cSAlexander Aring dev_addr_generated); 26131da177e4SLinus Torvalds } 26141da177e4SLinus Torvalds inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo); 26154f672235SAlexander Aring put: 26161da177e4SLinus Torvalds in6_dev_put(in6_dev); 26171da177e4SLinus Torvalds } 26181da177e4SLinus Torvalds 26191da177e4SLinus Torvalds /* 26201da177e4SLinus Torvalds * Set destination address. 26211da177e4SLinus Torvalds * Special case for SIT interfaces where we create a new "virtual" 26221da177e4SLinus Torvalds * device. 26231da177e4SLinus Torvalds */ 2624af284937SDaniel Lezcano int addrconf_set_dstaddr(struct net *net, void __user *arg) 26251da177e4SLinus Torvalds { 26261da177e4SLinus Torvalds struct in6_ifreq ireq; 26271da177e4SLinus Torvalds struct net_device *dev; 26281da177e4SLinus Torvalds int err = -EINVAL; 26291da177e4SLinus Torvalds 26301da177e4SLinus Torvalds rtnl_lock(); 26311da177e4SLinus Torvalds 26321da177e4SLinus Torvalds err = -EFAULT; 26331da177e4SLinus Torvalds if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 26341da177e4SLinus Torvalds goto err_exit; 26351da177e4SLinus Torvalds 2636af284937SDaniel Lezcano dev = __dev_get_by_index(net, ireq.ifr6_ifindex); 26371da177e4SLinus Torvalds 26381da177e4SLinus Torvalds err = -ENODEV; 263963159f29SIan Morris if (!dev) 26401da177e4SLinus Torvalds goto err_exit; 26411da177e4SLinus Torvalds 264207a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_SIT) 26431da177e4SLinus Torvalds if (dev->type == ARPHRD_SIT) { 26445bc3eb7eSStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 26451da177e4SLinus Torvalds struct ifreq ifr; 26461da177e4SLinus Torvalds struct ip_tunnel_parm p; 26471da177e4SLinus Torvalds 26481da177e4SLinus Torvalds err = -EADDRNOTAVAIL; 26491da177e4SLinus Torvalds if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4)) 26501da177e4SLinus Torvalds goto err_exit; 26511da177e4SLinus Torvalds 26521da177e4SLinus Torvalds memset(&p, 0, sizeof(p)); 26531da177e4SLinus Torvalds p.iph.daddr = ireq.ifr6_addr.s6_addr32[3]; 26541da177e4SLinus Torvalds p.iph.saddr = 0; 26551da177e4SLinus Torvalds p.iph.version = 4; 26561da177e4SLinus Torvalds p.iph.ihl = 5; 26571da177e4SLinus Torvalds p.iph.protocol = IPPROTO_IPV6; 26581da177e4SLinus Torvalds p.iph.ttl = 64; 2659d20b3109SStephen Hemminger ifr.ifr_ifru.ifru_data = (__force void __user *)&p; 26601da177e4SLinus Torvalds 26615bc3eb7eSStephen Hemminger if (ops->ndo_do_ioctl) { 26625bc3eb7eSStephen Hemminger mm_segment_t oldfs = get_fs(); 26635bc3eb7eSStephen Hemminger 26645bc3eb7eSStephen Hemminger set_fs(KERNEL_DS); 26655bc3eb7eSStephen Hemminger err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL); 26661da177e4SLinus Torvalds set_fs(oldfs); 26675bc3eb7eSStephen Hemminger } else 26685bc3eb7eSStephen Hemminger err = -EOPNOTSUPP; 26691da177e4SLinus Torvalds 26701da177e4SLinus Torvalds if (err == 0) { 26711da177e4SLinus Torvalds err = -ENOBUFS; 2672af284937SDaniel Lezcano dev = __dev_get_by_name(net, p.name); 2673af284937SDaniel Lezcano if (!dev) 26741da177e4SLinus Torvalds goto err_exit; 26751da177e4SLinus Torvalds err = dev_open(dev); 26761da177e4SLinus Torvalds } 26771da177e4SLinus Torvalds } 26780be669bbSJoerg Roedel #endif 26791da177e4SLinus Torvalds 26801da177e4SLinus Torvalds err_exit: 26811da177e4SLinus Torvalds rtnl_unlock(); 26821da177e4SLinus Torvalds return err; 26831da177e4SLinus Torvalds } 26841da177e4SLinus Torvalds 268593a714d6SMadhu Challa static int ipv6_mc_config(struct sock *sk, bool join, 268693a714d6SMadhu Challa const struct in6_addr *addr, int ifindex) 268793a714d6SMadhu Challa { 268893a714d6SMadhu Challa int ret; 268993a714d6SMadhu Challa 269093a714d6SMadhu Challa ASSERT_RTNL(); 269193a714d6SMadhu Challa 269293a714d6SMadhu Challa lock_sock(sk); 269393a714d6SMadhu Challa if (join) 269454ff9ef3SMarcelo Ricardo Leitner ret = ipv6_sock_mc_join(sk, ifindex, addr); 269593a714d6SMadhu Challa else 269654ff9ef3SMarcelo Ricardo Leitner ret = ipv6_sock_mc_drop(sk, ifindex, addr); 269793a714d6SMadhu Challa release_sock(sk); 269893a714d6SMadhu Challa 269993a714d6SMadhu Challa return ret; 270093a714d6SMadhu Challa } 270193a714d6SMadhu Challa 27021da177e4SLinus Torvalds /* 27031da177e4SLinus Torvalds * Manual configuration of address on an interface 27041da177e4SLinus Torvalds */ 2705479840ffSJiri Pirko static int inet6_addr_add(struct net *net, int ifindex, 2706479840ffSJiri Pirko const struct in6_addr *pfx, 2707caeaba79SNicolas Dichtel const struct in6_addr *peer_pfx, 2708479840ffSJiri Pirko unsigned int plen, __u32 ifa_flags, 2709479840ffSJiri Pirko __u32 prefered_lft, __u32 valid_lft) 27101da177e4SLinus Torvalds { 27111da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 27121da177e4SLinus Torvalds struct inet6_dev *idev; 27131da177e4SLinus Torvalds struct net_device *dev; 271493a714d6SMadhu Challa unsigned long timeout; 271593a714d6SMadhu Challa clock_t expires; 27161da177e4SLinus Torvalds int scope; 27176f704992SYOSHIFUJI Hideaki u32 flags; 27181da177e4SLinus Torvalds 27191da177e4SLinus Torvalds ASSERT_RTNL(); 27201da177e4SLinus Torvalds 272124ef0da7SThomas Graf if (plen > 128) 272224ef0da7SThomas Graf return -EINVAL; 272324ef0da7SThomas Graf 27240778769dSNoriaki TAKAMIYA /* check the lifetime */ 27250778769dSNoriaki TAKAMIYA if (!valid_lft || prefered_lft > valid_lft) 27260778769dSNoriaki TAKAMIYA return -EINVAL; 27270778769dSNoriaki TAKAMIYA 272853bd6749SJiri Pirko if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64) 272953bd6749SJiri Pirko return -EINVAL; 273053bd6749SJiri Pirko 2731af284937SDaniel Lezcano dev = __dev_get_by_index(net, ifindex); 2732af284937SDaniel Lezcano if (!dev) 27331da177e4SLinus Torvalds return -ENODEV; 27341da177e4SLinus Torvalds 273564e724f6SBrian Haley idev = addrconf_add_dev(dev); 273664e724f6SBrian Haley if (IS_ERR(idev)) 273764e724f6SBrian Haley return PTR_ERR(idev); 27381da177e4SLinus Torvalds 273993a714d6SMadhu Challa if (ifa_flags & IFA_F_MCAUTOJOIN) { 274093a714d6SMadhu Challa int ret = ipv6_mc_config(net->ipv6.mc_autojoin_sk, 274193a714d6SMadhu Challa true, pfx, ifindex); 274293a714d6SMadhu Challa 274393a714d6SMadhu Challa if (ret < 0) 274493a714d6SMadhu Challa return ret; 274593a714d6SMadhu Challa } 274693a714d6SMadhu Challa 27471da177e4SLinus Torvalds scope = ipv6_addr_scope(pfx); 27481da177e4SLinus Torvalds 27494bed72e4SYOSHIFUJI Hideaki timeout = addrconf_timeout_fixup(valid_lft, HZ); 27504bed72e4SYOSHIFUJI Hideaki if (addrconf_finite_timeout(timeout)) { 27514bed72e4SYOSHIFUJI Hideaki expires = jiffies_to_clock_t(timeout * HZ); 27524bed72e4SYOSHIFUJI Hideaki valid_lft = timeout; 27536f704992SYOSHIFUJI Hideaki flags = RTF_EXPIRES; 27544bed72e4SYOSHIFUJI Hideaki } else { 27554bed72e4SYOSHIFUJI Hideaki expires = 0; 27564bed72e4SYOSHIFUJI Hideaki flags = 0; 27574bed72e4SYOSHIFUJI Hideaki ifa_flags |= IFA_F_PERMANENT; 27586f704992SYOSHIFUJI Hideaki } 27590778769dSNoriaki TAKAMIYA 27604bed72e4SYOSHIFUJI Hideaki timeout = addrconf_timeout_fixup(prefered_lft, HZ); 27614bed72e4SYOSHIFUJI Hideaki if (addrconf_finite_timeout(timeout)) { 27624bed72e4SYOSHIFUJI Hideaki if (timeout == 0) 27630778769dSNoriaki TAKAMIYA ifa_flags |= IFA_F_DEPRECATED; 27644bed72e4SYOSHIFUJI Hideaki prefered_lft = timeout; 27654bed72e4SYOSHIFUJI Hideaki } 27660778769dSNoriaki TAKAMIYA 27678a226b2cSJiri Benc ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags, 27688a226b2cSJiri Benc valid_lft, prefered_lft); 27690778769dSNoriaki TAKAMIYA 27701da177e4SLinus Torvalds if (!IS_ERR(ifp)) { 2771761aac73SThomas Haller if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) { 277246d48046SYOSHIFUJI Hideaki addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev, 27736f704992SYOSHIFUJI Hideaki expires, flags); 2774761aac73SThomas Haller } 2775761aac73SThomas Haller 277695c385b4SNeil Horman /* 277795c385b4SNeil Horman * Note that section 3.1 of RFC 4429 indicates 277895c385b4SNeil Horman * that the Optimistic flag should not be set for 277995c385b4SNeil Horman * manually configured addresses 278095c385b4SNeil Horman */ 2781cf22f9a2SDavid S. Miller addrconf_dad_start(ifp); 278253bd6749SJiri Pirko if (ifa_flags & IFA_F_MANAGETEMPADDR) 278353bd6749SJiri Pirko manage_tempaddrs(idev, ifp, valid_lft, prefered_lft, 278453bd6749SJiri Pirko true, jiffies); 27851da177e4SLinus Torvalds in6_ifa_put(ifp); 2786c15b1ccaSHannes Frederic Sowa addrconf_verify_rtnl(); 27871da177e4SLinus Torvalds return 0; 278893a714d6SMadhu Challa } else if (ifa_flags & IFA_F_MCAUTOJOIN) { 278993a714d6SMadhu Challa ipv6_mc_config(net->ipv6.mc_autojoin_sk, 279093a714d6SMadhu Challa false, pfx, ifindex); 27911da177e4SLinus Torvalds } 27921da177e4SLinus Torvalds 27931da177e4SLinus Torvalds return PTR_ERR(ifp); 27941da177e4SLinus Torvalds } 27951da177e4SLinus Torvalds 27966046d5b4SHeiner Kallweit static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags, 27976046d5b4SHeiner Kallweit const struct in6_addr *pfx, unsigned int plen) 27981da177e4SLinus Torvalds { 27991da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 28001da177e4SLinus Torvalds struct inet6_dev *idev; 28011da177e4SLinus Torvalds struct net_device *dev; 28021da177e4SLinus Torvalds 280324ef0da7SThomas Graf if (plen > 128) 280424ef0da7SThomas Graf return -EINVAL; 280524ef0da7SThomas Graf 2806af284937SDaniel Lezcano dev = __dev_get_by_index(net, ifindex); 2807af284937SDaniel Lezcano if (!dev) 28081da177e4SLinus Torvalds return -ENODEV; 28091da177e4SLinus Torvalds 2810e5d08d71SIan Morris idev = __in6_dev_get(dev); 281163159f29SIan Morris if (!idev) 28121da177e4SLinus Torvalds return -ENXIO; 28131da177e4SLinus Torvalds 28141da177e4SLinus Torvalds read_lock_bh(&idev->lock); 2815502a2ffdSstephen hemminger list_for_each_entry(ifp, &idev->addr_list, if_list) { 28161da177e4SLinus Torvalds if (ifp->prefix_len == plen && 28171da177e4SLinus Torvalds ipv6_addr_equal(pfx, &ifp->addr)) { 28181da177e4SLinus Torvalds in6_ifa_hold(ifp); 28191da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 28201da177e4SLinus Torvalds 28216046d5b4SHeiner Kallweit if (!(ifp->flags & IFA_F_TEMPORARY) && 28226046d5b4SHeiner Kallweit (ifa_flags & IFA_F_MANAGETEMPADDR)) 28236046d5b4SHeiner Kallweit manage_tempaddrs(idev, ifp, 0, 0, false, 28246046d5b4SHeiner Kallweit jiffies); 28251da177e4SLinus Torvalds ipv6_del_addr(ifp); 28266046d5b4SHeiner Kallweit addrconf_verify_rtnl(); 282793a714d6SMadhu Challa if (ipv6_addr_is_multicast(pfx)) { 282893a714d6SMadhu Challa ipv6_mc_config(net->ipv6.mc_autojoin_sk, 282993a714d6SMadhu Challa false, pfx, dev->ifindex); 283093a714d6SMadhu Challa } 28311da177e4SLinus Torvalds return 0; 28321da177e4SLinus Torvalds } 28331da177e4SLinus Torvalds } 28341da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 28351da177e4SLinus Torvalds return -EADDRNOTAVAIL; 28361da177e4SLinus Torvalds } 28371da177e4SLinus Torvalds 28381da177e4SLinus Torvalds 2839af284937SDaniel Lezcano int addrconf_add_ifaddr(struct net *net, void __user *arg) 28401da177e4SLinus Torvalds { 28411da177e4SLinus Torvalds struct in6_ifreq ireq; 28421da177e4SLinus Torvalds int err; 28431da177e4SLinus Torvalds 2844af31f412SEric W. Biederman if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 28451da177e4SLinus Torvalds return -EPERM; 28461da177e4SLinus Torvalds 28471da177e4SLinus Torvalds if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 28481da177e4SLinus Torvalds return -EFAULT; 28491da177e4SLinus Torvalds 28501da177e4SLinus Torvalds rtnl_lock(); 2851caeaba79SNicolas Dichtel err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, 2852af284937SDaniel Lezcano ireq.ifr6_prefixlen, IFA_F_PERMANENT, 2853af284937SDaniel Lezcano INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 28541da177e4SLinus Torvalds rtnl_unlock(); 28551da177e4SLinus Torvalds return err; 28561da177e4SLinus Torvalds } 28571da177e4SLinus Torvalds 2858af284937SDaniel Lezcano int addrconf_del_ifaddr(struct net *net, void __user *arg) 28591da177e4SLinus Torvalds { 28601da177e4SLinus Torvalds struct in6_ifreq ireq; 28611da177e4SLinus Torvalds int err; 28621da177e4SLinus Torvalds 2863af31f412SEric W. Biederman if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 28641da177e4SLinus Torvalds return -EPERM; 28651da177e4SLinus Torvalds 28661da177e4SLinus Torvalds if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 28671da177e4SLinus Torvalds return -EFAULT; 28681da177e4SLinus Torvalds 28691da177e4SLinus Torvalds rtnl_lock(); 28706046d5b4SHeiner Kallweit err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, 2871af284937SDaniel Lezcano ireq.ifr6_prefixlen); 28721da177e4SLinus Torvalds rtnl_unlock(); 28731da177e4SLinus Torvalds return err; 28741da177e4SLinus Torvalds } 28751da177e4SLinus Torvalds 2876b5f348e5SIlpo Järvinen static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr, 2877b5f348e5SIlpo Järvinen int plen, int scope) 2878b5f348e5SIlpo Järvinen { 2879b5f348e5SIlpo Järvinen struct inet6_ifaddr *ifp; 2880b5f348e5SIlpo Järvinen 28818a226b2cSJiri Benc ifp = ipv6_add_addr(idev, addr, NULL, plen, 288207edd741SHannes Frederic Sowa scope, IFA_F_PERMANENT, 288307edd741SHannes Frederic Sowa INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 2884b5f348e5SIlpo Järvinen if (!IS_ERR(ifp)) { 2885b5f348e5SIlpo Järvinen spin_lock_bh(&ifp->lock); 2886b5f348e5SIlpo Järvinen ifp->flags &= ~IFA_F_TENTATIVE; 2887b5f348e5SIlpo Järvinen spin_unlock_bh(&ifp->lock); 2888b5f348e5SIlpo Järvinen ipv6_ifa_notify(RTM_NEWADDR, ifp); 2889b5f348e5SIlpo Järvinen in6_ifa_put(ifp); 2890b5f348e5SIlpo Järvinen } 2891b5f348e5SIlpo Järvinen } 2892b5f348e5SIlpo Järvinen 289307a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_SIT) 28941da177e4SLinus Torvalds static void sit_add_v4_addrs(struct inet6_dev *idev) 28951da177e4SLinus Torvalds { 28961da177e4SLinus Torvalds struct in6_addr addr; 28971da177e4SLinus Torvalds struct net_device *dev; 2898c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(idev->dev); 2899929c9cf3SNicolas Dichtel int scope, plen; 2900f0e2acfaSNicolas Dichtel u32 pflags = 0; 29011da177e4SLinus Torvalds 29021da177e4SLinus Torvalds ASSERT_RTNL(); 29031da177e4SLinus Torvalds 29041da177e4SLinus Torvalds memset(&addr, 0, sizeof(struct in6_addr)); 29051da177e4SLinus Torvalds memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4); 29061da177e4SLinus Torvalds 29071da177e4SLinus Torvalds if (idev->dev->flags&IFF_POINTOPOINT) { 29081da177e4SLinus Torvalds addr.s6_addr32[0] = htonl(0xfe800000); 29091da177e4SLinus Torvalds scope = IFA_LINK; 2910929c9cf3SNicolas Dichtel plen = 64; 29111da177e4SLinus Torvalds } else { 29121da177e4SLinus Torvalds scope = IPV6_ADDR_COMPATv4; 2913929c9cf3SNicolas Dichtel plen = 96; 2914f0e2acfaSNicolas Dichtel pflags |= RTF_NONEXTHOP; 29151da177e4SLinus Torvalds } 29161da177e4SLinus Torvalds 29171da177e4SLinus Torvalds if (addr.s6_addr32[3]) { 2918929c9cf3SNicolas Dichtel add_addr(idev, &addr, plen, scope); 2919f0e2acfaSNicolas Dichtel addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags); 29201da177e4SLinus Torvalds return; 29211da177e4SLinus Torvalds } 29221da177e4SLinus Torvalds 29236fda7350SBenjamin Thery for_each_netdev(net, dev) { 2924e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 29251da177e4SLinus Torvalds if (in_dev && (dev->flags & IFF_UP)) { 29261da177e4SLinus Torvalds struct in_ifaddr *ifa; 29271da177e4SLinus Torvalds 29281da177e4SLinus Torvalds int flag = scope; 29291da177e4SLinus Torvalds 29301da177e4SLinus Torvalds for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 29311da177e4SLinus Torvalds 29321da177e4SLinus Torvalds addr.s6_addr32[3] = ifa->ifa_local; 29331da177e4SLinus Torvalds 29341da177e4SLinus Torvalds if (ifa->ifa_scope == RT_SCOPE_LINK) 29351da177e4SLinus Torvalds continue; 29361da177e4SLinus Torvalds if (ifa->ifa_scope >= RT_SCOPE_HOST) { 29371da177e4SLinus Torvalds if (idev->dev->flags&IFF_POINTOPOINT) 29381da177e4SLinus Torvalds continue; 29391da177e4SLinus Torvalds flag |= IFA_HOST; 29401da177e4SLinus Torvalds } 29411da177e4SLinus Torvalds 2942b5f348e5SIlpo Järvinen add_addr(idev, &addr, plen, flag); 2943f0e2acfaSNicolas Dichtel addrconf_prefix_route(&addr, plen, idev->dev, 0, 2944f0e2acfaSNicolas Dichtel pflags); 29451da177e4SLinus Torvalds } 29461da177e4SLinus Torvalds } 29471da177e4SLinus Torvalds } 29481da177e4SLinus Torvalds } 29490be669bbSJoerg Roedel #endif 29501da177e4SLinus Torvalds 29511da177e4SLinus Torvalds static void init_loopback(struct net_device *dev) 29521da177e4SLinus Torvalds { 29531da177e4SLinus Torvalds struct inet6_dev *idev; 295425fb6ca4SBalakumaran Kannan struct net_device *sp_dev; 295525fb6ca4SBalakumaran Kannan struct inet6_ifaddr *sp_ifa; 295625fb6ca4SBalakumaran Kannan struct rt6_info *sp_rt; 29571da177e4SLinus Torvalds 29581da177e4SLinus Torvalds /* ::1 */ 29591da177e4SLinus Torvalds 29601da177e4SLinus Torvalds ASSERT_RTNL(); 29611da177e4SLinus Torvalds 2962e5d08d71SIan Morris idev = ipv6_find_idev(dev); 296363159f29SIan Morris if (!idev) { 296491df42beSJoe Perches pr_debug("%s: add_dev failed\n", __func__); 29651da177e4SLinus Torvalds return; 29661da177e4SLinus Torvalds } 29671da177e4SLinus Torvalds 2968b5f348e5SIlpo Järvinen add_addr(idev, &in6addr_loopback, 128, IFA_HOST); 296925fb6ca4SBalakumaran Kannan 297025fb6ca4SBalakumaran Kannan /* Add routes to other interface's IPv6 addresses */ 297125fb6ca4SBalakumaran Kannan for_each_netdev(dev_net(dev), sp_dev) { 297225fb6ca4SBalakumaran Kannan if (!strcmp(sp_dev->name, dev->name)) 297325fb6ca4SBalakumaran Kannan continue; 297425fb6ca4SBalakumaran Kannan 297525fb6ca4SBalakumaran Kannan idev = __in6_dev_get(sp_dev); 297625fb6ca4SBalakumaran Kannan if (!idev) 297725fb6ca4SBalakumaran Kannan continue; 297825fb6ca4SBalakumaran Kannan 297925fb6ca4SBalakumaran Kannan read_lock_bh(&idev->lock); 298025fb6ca4SBalakumaran Kannan list_for_each_entry(sp_ifa, &idev->addr_list, if_list) { 298125fb6ca4SBalakumaran Kannan 298225fb6ca4SBalakumaran Kannan if (sp_ifa->flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE)) 298325fb6ca4SBalakumaran Kannan continue; 298425fb6ca4SBalakumaran Kannan 298533d99113SGao feng if (sp_ifa->rt) { 298633d99113SGao feng /* This dst has been added to garbage list when 298733d99113SGao feng * lo device down, release this obsolete dst and 298833d99113SGao feng * reallocate a new router for ifa. 298933d99113SGao feng */ 299033d99113SGao feng if (sp_ifa->rt->dst.obsolete > 0) { 299133d99113SGao feng ip6_rt_put(sp_ifa->rt); 299233d99113SGao feng sp_ifa->rt = NULL; 299333d99113SGao feng } else { 2994a881ae1fSGao feng continue; 299533d99113SGao feng } 299633d99113SGao feng } 2997a881ae1fSGao feng 299857ec0afeSFrançois-Xavier Le Bail sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, false); 299925fb6ca4SBalakumaran Kannan 300025fb6ca4SBalakumaran Kannan /* Failure cases are ignored */ 3001534c8779SGao feng if (!IS_ERR(sp_rt)) { 3002534c8779SGao feng sp_ifa->rt = sp_rt; 300325fb6ca4SBalakumaran Kannan ip6_ins_rt(sp_rt); 300425fb6ca4SBalakumaran Kannan } 3005534c8779SGao feng } 300625fb6ca4SBalakumaran Kannan read_unlock_bh(&idev->lock); 300725fb6ca4SBalakumaran Kannan } 30081da177e4SLinus Torvalds } 30091da177e4SLinus Torvalds 30102ad3ed59SAlexander Aring void addrconf_add_linklocal(struct inet6_dev *idev, 301164236f3fSHannes Frederic Sowa const struct in6_addr *addr, u32 flags) 30121da177e4SLinus Torvalds { 30131da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 301464236f3fSHannes Frederic Sowa u32 addr_flags = flags | IFA_F_PERMANENT; 30151da177e4SLinus Torvalds 301695c385b4SNeil Horman #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 301795c385b4SNeil Horman if (idev->cnf.optimistic_dad && 3018702beb87SDavid Miller !dev_net(idev->dev)->ipv6.devconf_all->forwarding) 301995c385b4SNeil Horman addr_flags |= IFA_F_OPTIMISTIC; 302095c385b4SNeil Horman #endif 302195c385b4SNeil Horman 302207edd741SHannes Frederic Sowa ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags, 302307edd741SHannes Frederic Sowa INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 30241da177e4SLinus Torvalds if (!IS_ERR(ifp)) { 302546d48046SYOSHIFUJI Hideaki addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0); 3026cf22f9a2SDavid S. Miller addrconf_dad_start(ifp); 30271da177e4SLinus Torvalds in6_ifa_put(ifp); 30281da177e4SLinus Torvalds } 30291da177e4SLinus Torvalds } 30302ad3ed59SAlexander Aring EXPORT_SYMBOL_GPL(addrconf_add_linklocal); 30311da177e4SLinus Torvalds 3032622c81d5SHannes Frederic Sowa static bool ipv6_reserved_interfaceid(struct in6_addr address) 3033622c81d5SHannes Frederic Sowa { 3034622c81d5SHannes Frederic Sowa if ((address.s6_addr32[2] | address.s6_addr32[3]) == 0) 3035622c81d5SHannes Frederic Sowa return true; 3036622c81d5SHannes Frederic Sowa 3037622c81d5SHannes Frederic Sowa if (address.s6_addr32[2] == htonl(0x02005eff) && 3038622c81d5SHannes Frederic Sowa ((address.s6_addr32[3] & htonl(0xfe000000)) == htonl(0xfe000000))) 3039622c81d5SHannes Frederic Sowa return true; 3040622c81d5SHannes Frederic Sowa 3041622c81d5SHannes Frederic Sowa if (address.s6_addr32[2] == htonl(0xfdffffff) && 3042622c81d5SHannes Frederic Sowa ((address.s6_addr32[3] & htonl(0xffffff80)) == htonl(0xffffff80))) 3043622c81d5SHannes Frederic Sowa return true; 3044622c81d5SHannes Frederic Sowa 3045622c81d5SHannes Frederic Sowa return false; 3046622c81d5SHannes Frederic Sowa } 3047622c81d5SHannes Frederic Sowa 3048622c81d5SHannes Frederic Sowa static int ipv6_generate_stable_address(struct in6_addr *address, 3049622c81d5SHannes Frederic Sowa u8 dad_count, 3050622c81d5SHannes Frederic Sowa const struct inet6_dev *idev) 3051622c81d5SHannes Frederic Sowa { 3052622c81d5SHannes Frederic Sowa static DEFINE_SPINLOCK(lock); 3053622c81d5SHannes Frederic Sowa static __u32 digest[SHA_DIGEST_WORDS]; 3054622c81d5SHannes Frederic Sowa static __u32 workspace[SHA_WORKSPACE_WORDS]; 3055622c81d5SHannes Frederic Sowa 3056622c81d5SHannes Frederic Sowa static union { 3057622c81d5SHannes Frederic Sowa char __data[SHA_MESSAGE_BYTES]; 3058622c81d5SHannes Frederic Sowa struct { 3059622c81d5SHannes Frederic Sowa struct in6_addr secret; 3060ff40217eSHannes Frederic Sowa __be32 prefix[2]; 3061622c81d5SHannes Frederic Sowa unsigned char hwaddr[MAX_ADDR_LEN]; 3062622c81d5SHannes Frederic Sowa u8 dad_count; 3063622c81d5SHannes Frederic Sowa } __packed; 3064622c81d5SHannes Frederic Sowa } data; 3065622c81d5SHannes Frederic Sowa 3066622c81d5SHannes Frederic Sowa struct in6_addr secret; 3067622c81d5SHannes Frederic Sowa struct in6_addr temp; 3068622c81d5SHannes Frederic Sowa struct net *net = dev_net(idev->dev); 3069622c81d5SHannes Frederic Sowa 3070622c81d5SHannes Frederic Sowa BUILD_BUG_ON(sizeof(data.__data) != sizeof(data)); 3071622c81d5SHannes Frederic Sowa 3072622c81d5SHannes Frederic Sowa if (idev->cnf.stable_secret.initialized) 3073622c81d5SHannes Frederic Sowa secret = idev->cnf.stable_secret.secret; 3074622c81d5SHannes Frederic Sowa else if (net->ipv6.devconf_dflt->stable_secret.initialized) 3075622c81d5SHannes Frederic Sowa secret = net->ipv6.devconf_dflt->stable_secret.secret; 3076622c81d5SHannes Frederic Sowa else 3077622c81d5SHannes Frederic Sowa return -1; 3078622c81d5SHannes Frederic Sowa 3079622c81d5SHannes Frederic Sowa retry: 3080622c81d5SHannes Frederic Sowa spin_lock_bh(&lock); 3081622c81d5SHannes Frederic Sowa 3082622c81d5SHannes Frederic Sowa sha_init(digest); 3083622c81d5SHannes Frederic Sowa memset(&data, 0, sizeof(data)); 3084622c81d5SHannes Frederic Sowa memset(workspace, 0, sizeof(workspace)); 3085622c81d5SHannes Frederic Sowa memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len); 3086ff40217eSHannes Frederic Sowa data.prefix[0] = address->s6_addr32[0]; 3087ff40217eSHannes Frederic Sowa data.prefix[1] = address->s6_addr32[1]; 3088622c81d5SHannes Frederic Sowa data.secret = secret; 3089622c81d5SHannes Frederic Sowa data.dad_count = dad_count; 3090622c81d5SHannes Frederic Sowa 3091622c81d5SHannes Frederic Sowa sha_transform(digest, data.__data, workspace); 3092622c81d5SHannes Frederic Sowa 3093622c81d5SHannes Frederic Sowa temp = *address; 3094ff40217eSHannes Frederic Sowa temp.s6_addr32[2] = (__force __be32)digest[0]; 3095ff40217eSHannes Frederic Sowa temp.s6_addr32[3] = (__force __be32)digest[1]; 3096622c81d5SHannes Frederic Sowa 3097622c81d5SHannes Frederic Sowa spin_unlock_bh(&lock); 3098622c81d5SHannes Frederic Sowa 3099622c81d5SHannes Frederic Sowa if (ipv6_reserved_interfaceid(temp)) { 3100622c81d5SHannes Frederic Sowa dad_count++; 31011855b7c3SHannes Frederic Sowa if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries) 3102622c81d5SHannes Frederic Sowa return -1; 3103622c81d5SHannes Frederic Sowa goto retry; 3104622c81d5SHannes Frederic Sowa } 3105622c81d5SHannes Frederic Sowa 3106622c81d5SHannes Frederic Sowa *address = temp; 3107622c81d5SHannes Frederic Sowa return 0; 3108622c81d5SHannes Frederic Sowa } 3109622c81d5SHannes Frederic Sowa 3110cc9da6ccSBjørn Mork static void ipv6_gen_mode_random_init(struct inet6_dev *idev) 3111cc9da6ccSBjørn Mork { 3112cc9da6ccSBjørn Mork struct ipv6_stable_secret *s = &idev->cnf.stable_secret; 3113cc9da6ccSBjørn Mork 3114cc9da6ccSBjørn Mork if (s->initialized) 3115cc9da6ccSBjørn Mork return; 3116cc9da6ccSBjørn Mork s = &idev->cnf.stable_secret; 3117cc9da6ccSBjørn Mork get_random_bytes(&s->secret, sizeof(s->secret)); 3118cc9da6ccSBjørn Mork s->initialized = true; 3119cc9da6ccSBjørn Mork } 3120cc9da6ccSBjørn Mork 3121bc91b0f0SJiri Pirko static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route) 3122bc91b0f0SJiri Pirko { 3123bc91b0f0SJiri Pirko struct in6_addr addr; 3124bc91b0f0SJiri Pirko 3125ca254490SDavid Ahern /* no link local addresses on L3 master devices */ 3126ca254490SDavid Ahern if (netif_is_l3_master(idev->dev)) 3127ca254490SDavid Ahern return; 3128ca254490SDavid Ahern 3129bc91b0f0SJiri Pirko ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0); 3130622c81d5SHannes Frederic Sowa 3131cc9da6ccSBjørn Mork switch (idev->addr_gen_mode) { 3132cc9da6ccSBjørn Mork case IN6_ADDR_GEN_MODE_RANDOM: 3133cc9da6ccSBjørn Mork ipv6_gen_mode_random_init(idev); 3134cc9da6ccSBjørn Mork /* fallthrough */ 3135cc9da6ccSBjørn Mork case IN6_ADDR_GEN_MODE_STABLE_PRIVACY: 3136622c81d5SHannes Frederic Sowa if (!ipv6_generate_stable_address(&addr, 0, idev)) 313764236f3fSHannes Frederic Sowa addrconf_add_linklocal(idev, &addr, 313864236f3fSHannes Frederic Sowa IFA_F_STABLE_PRIVACY); 3139622c81d5SHannes Frederic Sowa else if (prefix_route) 3140622c81d5SHannes Frederic Sowa addrconf_prefix_route(&addr, 64, idev->dev, 0, 0); 3141cc9da6ccSBjørn Mork break; 3142cc9da6ccSBjørn Mork case IN6_ADDR_GEN_MODE_EUI64: 3143bc91b0f0SJiri Pirko /* addrconf_add_linklocal also adds a prefix_route and we 3144bc91b0f0SJiri Pirko * only need to care about prefix routes if ipv6_generate_eui64 3145bc91b0f0SJiri Pirko * couldn't generate one. 3146bc91b0f0SJiri Pirko */ 3147bc91b0f0SJiri Pirko if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0) 314864236f3fSHannes Frederic Sowa addrconf_add_linklocal(idev, &addr, 0); 3149bc91b0f0SJiri Pirko else if (prefix_route) 3150bc91b0f0SJiri Pirko addrconf_prefix_route(&addr, 64, idev->dev, 0, 0); 3151cc9da6ccSBjørn Mork break; 3152cc9da6ccSBjørn Mork case IN6_ADDR_GEN_MODE_NONE: 3153cc9da6ccSBjørn Mork default: 3154cc9da6ccSBjørn Mork /* will not add any link local address */ 3155cc9da6ccSBjørn Mork break; 3156bc91b0f0SJiri Pirko } 3157bc91b0f0SJiri Pirko } 3158bc91b0f0SJiri Pirko 31591da177e4SLinus Torvalds static void addrconf_dev_config(struct net_device *dev) 31601da177e4SLinus Torvalds { 31611da177e4SLinus Torvalds struct inet6_dev *idev; 31621da177e4SLinus Torvalds 31631da177e4SLinus Torvalds ASSERT_RTNL(); 31641da177e4SLinus Torvalds 316574235a25SHerbert Xu if ((dev->type != ARPHRD_ETHER) && 316674235a25SHerbert Xu (dev->type != ARPHRD_FDDI) && 316774235a25SHerbert Xu (dev->type != ARPHRD_ARCNET) && 316806a4c1c5Salex.bluesman.smirnov@gmail.com (dev->type != ARPHRD_INFINIBAND) && 3169e837735eSNicolas Dichtel (dev->type != ARPHRD_IEEE1394) && 3170e74bccb8SJukka Rissanen (dev->type != ARPHRD_TUNNEL6) && 3171cc9da6ccSBjørn Mork (dev->type != ARPHRD_6LOWPAN) && 3172cc9da6ccSBjørn Mork (dev->type != ARPHRD_NONE)) { 317374235a25SHerbert Xu /* Alas, we support only Ethernet autoconfiguration. */ 317474235a25SHerbert Xu return; 317574235a25SHerbert Xu } 317674235a25SHerbert Xu 31771da177e4SLinus Torvalds idev = addrconf_add_dev(dev); 317864e724f6SBrian Haley if (IS_ERR(idev)) 31791da177e4SLinus Torvalds return; 31801da177e4SLinus Torvalds 3181cc9da6ccSBjørn Mork /* this device type has no EUI support */ 3182cc9da6ccSBjørn Mork if (dev->type == ARPHRD_NONE && 3183cc9da6ccSBjørn Mork idev->addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64) 3184cc9da6ccSBjørn Mork idev->addr_gen_mode = IN6_ADDR_GEN_MODE_RANDOM; 3185cc9da6ccSBjørn Mork 3186bc91b0f0SJiri Pirko addrconf_addr_gen(idev, false); 31871da177e4SLinus Torvalds } 31881da177e4SLinus Torvalds 318907a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_SIT) 31901da177e4SLinus Torvalds static void addrconf_sit_config(struct net_device *dev) 31911da177e4SLinus Torvalds { 31921da177e4SLinus Torvalds struct inet6_dev *idev; 31931da177e4SLinus Torvalds 31941da177e4SLinus Torvalds ASSERT_RTNL(); 31951da177e4SLinus Torvalds 31961da177e4SLinus Torvalds /* 31971da177e4SLinus Torvalds * Configure the tunnel with one of our IPv4 31981da177e4SLinus Torvalds * addresses... we should configure all of 31991da177e4SLinus Torvalds * our v4 addrs in the tunnel 32001da177e4SLinus Torvalds */ 32011da177e4SLinus Torvalds 3202e5d08d71SIan Morris idev = ipv6_find_idev(dev); 320363159f29SIan Morris if (!idev) { 320491df42beSJoe Perches pr_debug("%s: add_dev failed\n", __func__); 32051da177e4SLinus Torvalds return; 32061da177e4SLinus Torvalds } 32071da177e4SLinus Torvalds 3208c7dc89c0SFred L. Templin if (dev->priv_flags & IFF_ISATAP) { 3209bc91b0f0SJiri Pirko addrconf_addr_gen(idev, false); 3210c7dc89c0SFred L. Templin return; 3211c7dc89c0SFred L. Templin } 3212c7dc89c0SFred L. Templin 32131da177e4SLinus Torvalds sit_add_v4_addrs(idev); 32141da177e4SLinus Torvalds 321562b54dd9SNicolas Dichtel if (dev->flags&IFF_POINTOPOINT) 32161da177e4SLinus Torvalds addrconf_add_mroute(dev); 32171da177e4SLinus Torvalds } 32180be669bbSJoerg Roedel #endif 32191da177e4SLinus Torvalds 322007a93626SAmerigo Wang #if IS_ENABLED(CONFIG_NET_IPGRE) 3221aee80b54Sstephen hemminger static void addrconf_gre_config(struct net_device *dev) 3222aee80b54Sstephen hemminger { 3223aee80b54Sstephen hemminger struct inet6_dev *idev; 3224aee80b54Sstephen hemminger 3225aee80b54Sstephen hemminger ASSERT_RTNL(); 3226aee80b54Sstephen hemminger 3227e5d08d71SIan Morris idev = ipv6_find_idev(dev); 322863159f29SIan Morris if (!idev) { 322991df42beSJoe Perches pr_debug("%s: add_dev failed\n", __func__); 3230aee80b54Sstephen hemminger return; 3231aee80b54Sstephen hemminger } 3232aee80b54Sstephen hemminger 3233bc91b0f0SJiri Pirko addrconf_addr_gen(idev, true); 3234d9e4ce65SHannes Frederic Sowa if (dev->flags & IFF_POINTOPOINT) 3235d9e4ce65SHannes Frederic Sowa addrconf_add_mroute(dev); 3236aee80b54Sstephen hemminger } 3237aee80b54Sstephen hemminger #endif 3238aee80b54Sstephen hemminger 3239f1705ec1SDavid Ahern static int fixup_permanent_addr(struct inet6_dev *idev, 3240f1705ec1SDavid Ahern struct inet6_ifaddr *ifp) 3241f1705ec1SDavid Ahern { 3242f1705ec1SDavid Ahern if (!ifp->rt) { 3243f1705ec1SDavid Ahern struct rt6_info *rt; 3244f1705ec1SDavid Ahern 3245f1705ec1SDavid Ahern rt = addrconf_dst_alloc(idev, &ifp->addr, false); 3246f1705ec1SDavid Ahern if (unlikely(IS_ERR(rt))) 3247f1705ec1SDavid Ahern return PTR_ERR(rt); 3248f1705ec1SDavid Ahern 3249f1705ec1SDavid Ahern ifp->rt = rt; 3250f1705ec1SDavid Ahern } 3251f1705ec1SDavid Ahern 3252f1705ec1SDavid Ahern if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) { 3253f1705ec1SDavid Ahern addrconf_prefix_route(&ifp->addr, ifp->prefix_len, 3254f1705ec1SDavid Ahern idev->dev, 0, 0); 3255f1705ec1SDavid Ahern } 3256f1705ec1SDavid Ahern 3257f1705ec1SDavid Ahern addrconf_dad_start(ifp); 3258f1705ec1SDavid Ahern 3259f1705ec1SDavid Ahern return 0; 3260f1705ec1SDavid Ahern } 3261f1705ec1SDavid Ahern 3262f1705ec1SDavid Ahern static void addrconf_permanent_addr(struct net_device *dev) 3263f1705ec1SDavid Ahern { 3264f1705ec1SDavid Ahern struct inet6_ifaddr *ifp, *tmp; 3265f1705ec1SDavid Ahern struct inet6_dev *idev; 3266f1705ec1SDavid Ahern 3267f1705ec1SDavid Ahern idev = __in6_dev_get(dev); 3268f1705ec1SDavid Ahern if (!idev) 3269f1705ec1SDavid Ahern return; 3270f1705ec1SDavid Ahern 3271f1705ec1SDavid Ahern write_lock_bh(&idev->lock); 3272f1705ec1SDavid Ahern 3273f1705ec1SDavid Ahern list_for_each_entry_safe(ifp, tmp, &idev->addr_list, if_list) { 3274f1705ec1SDavid Ahern if ((ifp->flags & IFA_F_PERMANENT) && 3275f1705ec1SDavid Ahern fixup_permanent_addr(idev, ifp) < 0) { 3276f1705ec1SDavid Ahern write_unlock_bh(&idev->lock); 3277f1705ec1SDavid Ahern ipv6_del_addr(ifp); 3278f1705ec1SDavid Ahern write_lock_bh(&idev->lock); 3279f1705ec1SDavid Ahern 3280f1705ec1SDavid Ahern net_info_ratelimited("%s: Failed to add prefix route for address %pI6c; dropping\n", 3281f1705ec1SDavid Ahern idev->dev->name, &ifp->addr); 3282f1705ec1SDavid Ahern } 3283f1705ec1SDavid Ahern } 3284f1705ec1SDavid Ahern 3285f1705ec1SDavid Ahern write_unlock_bh(&idev->lock); 3286f1705ec1SDavid Ahern } 3287f1705ec1SDavid Ahern 32881da177e4SLinus Torvalds static int addrconf_notify(struct notifier_block *this, unsigned long event, 3289351638e7SJiri Pirko void *ptr) 32901da177e4SLinus Torvalds { 3291351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr); 32924f7f34eaSDavid Ahern struct netdev_notifier_changeupper_info *info; 3293748e2d93SEric Dumazet struct inet6_dev *idev = __in6_dev_get(dev); 3294c5e33bddSYOSHIFUJI Hideaki int run_pending = 0; 3295b217d616SHerbert Xu int err; 32961da177e4SLinus Torvalds 32971da177e4SLinus Torvalds switch (event) { 329845ba9dd2SYOSHIFUJI Hideaki case NETDEV_REGISTER: 329974235a25SHerbert Xu if (!idev && dev->mtu >= IPV6_MIN_MTU) { 330045ba9dd2SYOSHIFUJI Hideaki idev = ipv6_add_dev(dev); 3301a317a2f1SWANG Cong if (IS_ERR(idev)) 3302a317a2f1SWANG Cong return notifier_from_errno(PTR_ERR(idev)); 330345ba9dd2SYOSHIFUJI Hideaki } 330445ba9dd2SYOSHIFUJI Hideaki break; 3305bcdd553fSStephen Hemminger 3306b7b0b1d2SAlexander Duyck case NETDEV_CHANGEMTU: 3307b7b0b1d2SAlexander Duyck /* if MTU under IPV6_MIN_MTU stop IPv6 on this interface. */ 3308b7b0b1d2SAlexander Duyck if (dev->mtu < IPV6_MIN_MTU) { 3309b7b0b1d2SAlexander Duyck addrconf_ifdown(dev, 1); 3310b7b0b1d2SAlexander Duyck break; 3311b7b0b1d2SAlexander Duyck } 3312b7b0b1d2SAlexander Duyck 3313b7b0b1d2SAlexander Duyck if (idev) { 3314b7b0b1d2SAlexander Duyck rt6_mtu_change(dev, dev->mtu); 3315b7b0b1d2SAlexander Duyck idev->cnf.mtu6 = dev->mtu; 3316b7b0b1d2SAlexander Duyck break; 3317b7b0b1d2SAlexander Duyck } 3318b7b0b1d2SAlexander Duyck 3319b7b0b1d2SAlexander Duyck /* allocate new idev */ 3320b7b0b1d2SAlexander Duyck idev = ipv6_add_dev(dev); 3321b7b0b1d2SAlexander Duyck if (IS_ERR(idev)) 3322b7b0b1d2SAlexander Duyck break; 3323b7b0b1d2SAlexander Duyck 3324b7b0b1d2SAlexander Duyck /* device is still not ready */ 3325b7b0b1d2SAlexander Duyck if (!(idev->if_flags & IF_READY)) 3326b7b0b1d2SAlexander Duyck break; 3327b7b0b1d2SAlexander Duyck 3328b7b0b1d2SAlexander Duyck run_pending = 1; 3329b7b0b1d2SAlexander Duyck 3330b7b0b1d2SAlexander Duyck /* fall through */ 3331b7b0b1d2SAlexander Duyck 33321da177e4SLinus Torvalds case NETDEV_UP: 33333c21edbdSYOSHIFUJI Hideaki case NETDEV_CHANGE: 3334c2edacf8SJay Vosburgh if (dev->flags & IFF_SLAVE) 3335c2edacf8SJay Vosburgh break; 3336c2edacf8SJay Vosburgh 33373ce62a84SWANG Cong if (idev && idev->cnf.disable_ipv6) 33383ce62a84SWANG Cong break; 33393ce62a84SWANG Cong 33403c21edbdSYOSHIFUJI Hideaki if (event == NETDEV_UP) { 334138bd10c4SDavid Ahern /* restore routes for permanent addresses */ 334238bd10c4SDavid Ahern addrconf_permanent_addr(dev); 334338bd10c4SDavid Ahern 3344f24e3d65SMitsuru Chinen if (!addrconf_qdisc_ok(dev)) { 33453c21edbdSYOSHIFUJI Hideaki /* device is not ready yet. */ 3346f3213831SJoe Perches pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n", 33473c21edbdSYOSHIFUJI Hideaki dev->name); 33483c21edbdSYOSHIFUJI Hideaki break; 33493c21edbdSYOSHIFUJI Hideaki } 335099081049SKristian Slavov 3351d31c7b8fSEvgeniy Polyakov if (!idev && dev->mtu >= IPV6_MIN_MTU) 3352d31c7b8fSEvgeniy Polyakov idev = ipv6_add_dev(dev); 3353d31c7b8fSEvgeniy Polyakov 3354a317a2f1SWANG Cong if (!IS_ERR_OR_NULL(idev)) { 335599081049SKristian Slavov idev->if_flags |= IF_READY; 3356e3ec6cfcSBenjamin Thery run_pending = 1; 3357e3ec6cfcSBenjamin Thery } 3358b7b0b1d2SAlexander Duyck } else if (event == NETDEV_CHANGE) { 3359f24e3d65SMitsuru Chinen if (!addrconf_qdisc_ok(dev)) { 33603c21edbdSYOSHIFUJI Hideaki /* device is still not ready. */ 33613c21edbdSYOSHIFUJI Hideaki break; 33623c21edbdSYOSHIFUJI Hideaki } 33633c21edbdSYOSHIFUJI Hideaki 33643c21edbdSYOSHIFUJI Hideaki if (idev) { 3365bcdd553fSStephen Hemminger if (idev->if_flags & IF_READY) 33663c21edbdSYOSHIFUJI Hideaki /* device is already configured. */ 33673c21edbdSYOSHIFUJI Hideaki break; 33683c21edbdSYOSHIFUJI Hideaki idev->if_flags |= IF_READY; 33693c21edbdSYOSHIFUJI Hideaki } 33703c21edbdSYOSHIFUJI Hideaki 3371f3213831SJoe Perches pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n", 33723c21edbdSYOSHIFUJI Hideaki dev->name); 33733c21edbdSYOSHIFUJI Hideaki 3374c5e33bddSYOSHIFUJI Hideaki run_pending = 1; 33753c21edbdSYOSHIFUJI Hideaki } 33763c21edbdSYOSHIFUJI Hideaki 33771da177e4SLinus Torvalds switch (dev->type) { 337807a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_SIT) 33791da177e4SLinus Torvalds case ARPHRD_SIT: 33801da177e4SLinus Torvalds addrconf_sit_config(dev); 33811da177e4SLinus Torvalds break; 33820be669bbSJoerg Roedel #endif 338307a93626SAmerigo Wang #if IS_ENABLED(CONFIG_NET_IPGRE) 3384aee80b54Sstephen hemminger case ARPHRD_IPGRE: 3385aee80b54Sstephen hemminger addrconf_gre_config(dev); 3386aee80b54Sstephen hemminger break; 3387aee80b54Sstephen hemminger #endif 33881da177e4SLinus Torvalds case ARPHRD_LOOPBACK: 33891da177e4SLinus Torvalds init_loopback(dev); 33901da177e4SLinus Torvalds break; 33911da177e4SLinus Torvalds 33921da177e4SLinus Torvalds default: 33931da177e4SLinus Torvalds addrconf_dev_config(dev); 33941da177e4SLinus Torvalds break; 33953ff50b79SStephen Hemminger } 3396bcdd553fSStephen Hemminger 3397a317a2f1SWANG Cong if (!IS_ERR_OR_NULL(idev)) { 3398c5e33bddSYOSHIFUJI Hideaki if (run_pending) 3399c5e33bddSYOSHIFUJI Hideaki addrconf_dad_run(idev); 3400c5e33bddSYOSHIFUJI Hideaki 3401bcdd553fSStephen Hemminger /* 3402bcdd553fSStephen Hemminger * If the MTU changed during the interface down, 3403bcdd553fSStephen Hemminger * when the interface up, the changed MTU must be 3404bcdd553fSStephen Hemminger * reflected in the idev as well as routers. 34051da177e4SLinus Torvalds */ 3406bcdd553fSStephen Hemminger if (idev->cnf.mtu6 != dev->mtu && 3407bcdd553fSStephen Hemminger dev->mtu >= IPV6_MIN_MTU) { 34081da177e4SLinus Torvalds rt6_mtu_change(dev, dev->mtu); 34091da177e4SLinus Torvalds idev->cnf.mtu6 = dev->mtu; 34101da177e4SLinus Torvalds } 34111da177e4SLinus Torvalds idev->tstamp = jiffies; 34121da177e4SLinus Torvalds inet6_ifinfo_notify(RTM_NEWLINK, idev); 3413bcdd553fSStephen Hemminger 3414bcdd553fSStephen Hemminger /* 3415bcdd553fSStephen Hemminger * If the changed mtu during down is lower than 3416bcdd553fSStephen Hemminger * IPV6_MIN_MTU stop IPv6 on this interface. 34171da177e4SLinus Torvalds */ 34181da177e4SLinus Torvalds if (dev->mtu < IPV6_MIN_MTU) 3419bcdd553fSStephen Hemminger addrconf_ifdown(dev, 1); 34201da177e4SLinus Torvalds } 34211da177e4SLinus Torvalds break; 34221da177e4SLinus Torvalds 34231da177e4SLinus Torvalds case NETDEV_DOWN: 34241da177e4SLinus Torvalds case NETDEV_UNREGISTER: 34251da177e4SLinus Torvalds /* 34261da177e4SLinus Torvalds * Remove all addresses from this interface. 34271da177e4SLinus Torvalds */ 34281da177e4SLinus Torvalds addrconf_ifdown(dev, event != NETDEV_DOWN); 34291da177e4SLinus Torvalds break; 34303c21edbdSYOSHIFUJI Hideaki 34311da177e4SLinus Torvalds case NETDEV_CHANGENAME: 34321da177e4SLinus Torvalds if (idev) { 34335632c515SStephen Hemminger snmp6_unregister_dev(idev); 3434408c4768SPavel Emelyanov addrconf_sysctl_unregister(idev); 3435a317a2f1SWANG Cong err = addrconf_sysctl_register(idev); 3436b217d616SHerbert Xu if (err) 3437b217d616SHerbert Xu return notifier_from_errno(err); 3438a317a2f1SWANG Cong err = snmp6_register_dev(idev); 3439a317a2f1SWANG Cong if (err) { 3440a317a2f1SWANG Cong addrconf_sysctl_unregister(idev); 3441a317a2f1SWANG Cong return notifier_from_errno(err); 3442a317a2f1SWANG Cong } 34435632c515SStephen Hemminger } 34441da177e4SLinus Torvalds break; 3445bcdd553fSStephen Hemminger 344693d9b7d7SJiri Pirko case NETDEV_PRE_TYPE_CHANGE: 344793d9b7d7SJiri Pirko case NETDEV_POST_TYPE_CHANGE: 34483ef0952cSAndrew Lunn if (idev) 344993d9b7d7SJiri Pirko addrconf_type_change(dev, event); 345075c78500SMoni Shoua break; 34514f7f34eaSDavid Ahern 34524f7f34eaSDavid Ahern case NETDEV_CHANGEUPPER: 34534f7f34eaSDavid Ahern info = ptr; 34544f7f34eaSDavid Ahern 34554f7f34eaSDavid Ahern /* flush all routes if dev is linked to or unlinked from 34564f7f34eaSDavid Ahern * an L3 master device (e.g., VRF) 34574f7f34eaSDavid Ahern */ 34584f7f34eaSDavid Ahern if (info->upper_dev && netif_is_l3_master(info->upper_dev)) 34594f7f34eaSDavid Ahern addrconf_ifdown(dev, 0); 34603ff50b79SStephen Hemminger } 34611da177e4SLinus Torvalds 34621da177e4SLinus Torvalds return NOTIFY_OK; 34631da177e4SLinus Torvalds } 34641da177e4SLinus Torvalds 34651da177e4SLinus Torvalds /* 34661da177e4SLinus Torvalds * addrconf module should be notified of a device going up 34671da177e4SLinus Torvalds */ 34681da177e4SLinus Torvalds static struct notifier_block ipv6_dev_notf = { 34691da177e4SLinus Torvalds .notifier_call = addrconf_notify, 34701da177e4SLinus Torvalds }; 34711da177e4SLinus Torvalds 347293d9b7d7SJiri Pirko static void addrconf_type_change(struct net_device *dev, unsigned long event) 347375c78500SMoni Shoua { 347475c78500SMoni Shoua struct inet6_dev *idev; 347575c78500SMoni Shoua ASSERT_RTNL(); 347675c78500SMoni Shoua 347775c78500SMoni Shoua idev = __in6_dev_get(dev); 347875c78500SMoni Shoua 347993d9b7d7SJiri Pirko if (event == NETDEV_POST_TYPE_CHANGE) 348075c78500SMoni Shoua ipv6_mc_remap(idev); 348193d9b7d7SJiri Pirko else if (event == NETDEV_PRE_TYPE_CHANGE) 348275c78500SMoni Shoua ipv6_mc_unmap(idev); 348375c78500SMoni Shoua } 348475c78500SMoni Shoua 348570af921dSDavid Ahern static bool addr_is_local(const struct in6_addr *addr) 348670af921dSDavid Ahern { 348770af921dSDavid Ahern return ipv6_addr_type(addr) & 348870af921dSDavid Ahern (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK); 348970af921dSDavid Ahern } 349070af921dSDavid Ahern 34911da177e4SLinus Torvalds static int addrconf_ifdown(struct net_device *dev, int how) 34921da177e4SLinus Torvalds { 3493c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 3494502a2ffdSstephen hemminger struct inet6_dev *idev; 3495f1705ec1SDavid Ahern struct inet6_ifaddr *ifa, *tmp; 3496f1705ec1SDavid Ahern struct list_head del_list; 3497f1705ec1SDavid Ahern int _keep_addr; 3498f1705ec1SDavid Ahern bool keep_addr; 349973a8bd74SDavid S. Miller int state, i; 35001da177e4SLinus Torvalds 35011da177e4SLinus Torvalds ASSERT_RTNL(); 35021da177e4SLinus Torvalds 3503f3db4851SDaniel Lezcano rt6_ifdown(net, dev); 350473a8bd74SDavid S. Miller neigh_ifdown(&nd_tbl, dev); 35051da177e4SLinus Torvalds 35061da177e4SLinus Torvalds idev = __in6_dev_get(dev); 350763159f29SIan Morris if (!idev) 35081da177e4SLinus Torvalds return -ENODEV; 35091da177e4SLinus Torvalds 3510bcdd553fSStephen Hemminger /* 3511bcdd553fSStephen Hemminger * Step 1: remove reference to ipv6 device from parent device. 3512bcdd553fSStephen Hemminger * Do not dev_put! 35131da177e4SLinus Torvalds */ 3514439e2385SDenis V. Lunev if (how) { 35151da177e4SLinus Torvalds idev->dead = 1; 35168814c4b5SYOSHIFUJI Hideaki 35178814c4b5SYOSHIFUJI Hideaki /* protected by rtnl_lock */ 3518a9b3cd7fSStephen Hemminger RCU_INIT_POINTER(dev->ip6_ptr, NULL); 35191da177e4SLinus Torvalds 35201da177e4SLinus Torvalds /* Step 1.5: remove snmp6 entry */ 35211da177e4SLinus Torvalds snmp6_unregister_dev(idev); 35221da177e4SLinus Torvalds 35231da177e4SLinus Torvalds } 35241da177e4SLinus Torvalds 3525f1705ec1SDavid Ahern /* aggregate the system setting and interface setting */ 3526f1705ec1SDavid Ahern _keep_addr = net->ipv6.devconf_all->keep_addr_on_down; 3527f1705ec1SDavid Ahern if (!_keep_addr) 3528f1705ec1SDavid Ahern _keep_addr = idev->cnf.keep_addr_on_down; 3529f1705ec1SDavid Ahern 3530f1705ec1SDavid Ahern /* combine the user config with event to determine if permanent 3531f1705ec1SDavid Ahern * addresses are to be removed from address hash table 3532f1705ec1SDavid Ahern */ 3533bc561632SMike Manning keep_addr = !(how || _keep_addr <= 0 || idev->cnf.disable_ipv6); 3534f1705ec1SDavid Ahern 353573a8bd74SDavid S. Miller /* Step 2: clear hash table */ 353673a8bd74SDavid S. Miller for (i = 0; i < IN6_ADDR_HSIZE; i++) { 353773a8bd74SDavid S. Miller struct hlist_head *h = &inet6_addr_lst[i]; 353873a8bd74SDavid S. Miller 353973a8bd74SDavid S. Miller spin_lock_bh(&addrconf_hash_lock); 354073a8bd74SDavid S. Miller restart: 3541b67bfe0dSSasha Levin hlist_for_each_entry_rcu(ifa, h, addr_lst) { 354273a8bd74SDavid S. Miller if (ifa->idev == idev) { 3543c15b1ccaSHannes Frederic Sowa addrconf_del_dad_work(ifa); 3544f1705ec1SDavid Ahern /* combined flag + permanent flag decide if 3545f1705ec1SDavid Ahern * address is retained on a down event 3546f1705ec1SDavid Ahern */ 3547f1705ec1SDavid Ahern if (!keep_addr || 354870af921dSDavid Ahern !(ifa->flags & IFA_F_PERMANENT) || 354970af921dSDavid Ahern addr_is_local(&ifa->addr)) { 3550f1705ec1SDavid Ahern hlist_del_init_rcu(&ifa->addr_lst); 355173a8bd74SDavid S. Miller goto restart; 355273a8bd74SDavid S. Miller } 355373a8bd74SDavid S. Miller } 3554f1705ec1SDavid Ahern } 355573a8bd74SDavid S. Miller spin_unlock_bh(&addrconf_hash_lock); 355673a8bd74SDavid S. Miller } 355773a8bd74SDavid S. Miller 35581da177e4SLinus Torvalds write_lock_bh(&idev->lock); 35591da177e4SLinus Torvalds 3560b7b1bfceSHannes Frederic Sowa addrconf_del_rs_timer(idev); 3561b7b1bfceSHannes Frederic Sowa 3562bcdd553fSStephen Hemminger /* Step 2: clear flags for stateless addrconf */ 3563439e2385SDenis V. Lunev if (!how) 35643c21edbdSYOSHIFUJI Hideaki idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY); 35651da177e4SLinus Torvalds 3566439e2385SDenis V. Lunev if (how && del_timer(&idev->regen_timer)) 35671da177e4SLinus Torvalds in6_dev_put(idev); 35681da177e4SLinus Torvalds 3569bcdd553fSStephen Hemminger /* Step 3: clear tempaddr list */ 3570372e6c8fSstephen hemminger while (!list_empty(&idev->tempaddr_list)) { 3571372e6c8fSstephen hemminger ifa = list_first_entry(&idev->tempaddr_list, 3572372e6c8fSstephen hemminger struct inet6_ifaddr, tmp_list); 3573372e6c8fSstephen hemminger list_del(&ifa->tmp_list); 35741da177e4SLinus Torvalds write_unlock_bh(&idev->lock); 35751da177e4SLinus Torvalds spin_lock_bh(&ifa->lock); 35761da177e4SLinus Torvalds 35771da177e4SLinus Torvalds if (ifa->ifpub) { 35781da177e4SLinus Torvalds in6_ifa_put(ifa->ifpub); 35791da177e4SLinus Torvalds ifa->ifpub = NULL; 35801da177e4SLinus Torvalds } 35811da177e4SLinus Torvalds spin_unlock_bh(&ifa->lock); 35821da177e4SLinus Torvalds in6_ifa_put(ifa); 35831da177e4SLinus Torvalds write_lock_bh(&idev->lock); 35841da177e4SLinus Torvalds } 35858f37ada5Sstephen hemminger 3586f1705ec1SDavid Ahern /* re-combine the user config with event to determine if permanent 3587f1705ec1SDavid Ahern * addresses are to be removed from the interface list 3588f1705ec1SDavid Ahern */ 3589bc561632SMike Manning keep_addr = (!how && _keep_addr > 0 && !idev->cnf.disable_ipv6); 3590f1705ec1SDavid Ahern 3591f1705ec1SDavid Ahern INIT_LIST_HEAD(&del_list); 3592f1705ec1SDavid Ahern list_for_each_entry_safe(ifa, tmp, &idev->addr_list, if_list) { 359338bd10c4SDavid Ahern struct rt6_info *rt = NULL; 359438bd10c4SDavid Ahern 3595c15b1ccaSHannes Frederic Sowa addrconf_del_dad_work(ifa); 359684e8b803Sstephen hemminger 35974c5ff6a6SHerbert Xu write_unlock_bh(&idev->lock); 35988e8e676dSHannes Frederic Sowa spin_lock_bh(&ifa->lock); 3599f1705ec1SDavid Ahern 360070af921dSDavid Ahern if (keep_addr && (ifa->flags & IFA_F_PERMANENT) && 360170af921dSDavid Ahern !addr_is_local(&ifa->addr)) { 3602f1705ec1SDavid Ahern /* set state to skip the notifier below */ 3603f1705ec1SDavid Ahern state = INET6_IFADDR_STATE_DEAD; 3604f1705ec1SDavid Ahern ifa->state = 0; 3605f1705ec1SDavid Ahern if (!(ifa->flags & IFA_F_NODAD)) 3606f1705ec1SDavid Ahern ifa->flags |= IFA_F_TENTATIVE; 360738bd10c4SDavid Ahern 360838bd10c4SDavid Ahern rt = ifa->rt; 360938bd10c4SDavid Ahern ifa->rt = NULL; 3610f1705ec1SDavid Ahern } else { 36114c5ff6a6SHerbert Xu state = ifa->state; 36124c5ff6a6SHerbert Xu ifa->state = INET6_IFADDR_STATE_DEAD; 3613f1705ec1SDavid Ahern 3614c882219aSWei Yongjun list_move(&ifa->if_list, &del_list); 3615f1705ec1SDavid Ahern } 3616f1705ec1SDavid Ahern 36178e8e676dSHannes Frederic Sowa spin_unlock_bh(&ifa->lock); 36184c5ff6a6SHerbert Xu 361938bd10c4SDavid Ahern if (rt) 362038bd10c4SDavid Ahern ip6_del_rt(rt); 362138bd10c4SDavid Ahern 36229d82ca98SJohn Fastabend if (state != INET6_IFADDR_STATE_DEAD) { 36231da177e4SLinus Torvalds __ipv6_ifa_notify(RTM_DELADDR, ifa); 3624f88c91ddSCong Wang inet6addr_notifier_call_chain(NETDEV_DOWN, ifa); 3625ea06f717SMike Manning } else { 3626ea06f717SMike Manning if (idev->cnf.forwarding) 3627ea06f717SMike Manning addrconf_leave_anycast(ifa); 3628ea06f717SMike Manning addrconf_leave_solict(ifa->idev, &ifa->addr); 36292de79570SLorenzo Colitti } 363073a8bd74SDavid S. Miller 36311da177e4SLinus Torvalds write_lock_bh(&idev->lock); 36321da177e4SLinus Torvalds } 36338f37ada5Sstephen hemminger 36341da177e4SLinus Torvalds write_unlock_bh(&idev->lock); 36351da177e4SLinus Torvalds 3636f1705ec1SDavid Ahern /* now clean up addresses to be removed */ 3637f1705ec1SDavid Ahern while (!list_empty(&del_list)) { 3638f1705ec1SDavid Ahern ifa = list_first_entry(&del_list, 3639f1705ec1SDavid Ahern struct inet6_ifaddr, if_list); 3640f1705ec1SDavid Ahern list_del(&ifa->if_list); 3641f1705ec1SDavid Ahern 3642f1705ec1SDavid Ahern in6_ifa_put(ifa); 3643f1705ec1SDavid Ahern } 3644f1705ec1SDavid Ahern 3645381f4dcaSSabrina Dubroca /* Step 5: Discard anycast and multicast list */ 3646381f4dcaSSabrina Dubroca if (how) { 3647381f4dcaSSabrina Dubroca ipv6_ac_destroy_dev(idev); 36481da177e4SLinus Torvalds ipv6_mc_destroy_dev(idev); 3649381f4dcaSSabrina Dubroca } else { 36501da177e4SLinus Torvalds ipv6_mc_down(idev); 3651381f4dcaSSabrina Dubroca } 36521da177e4SLinus Torvalds 36531da177e4SLinus Torvalds idev->tstamp = jiffies; 36541da177e4SLinus Torvalds 3655bcdd553fSStephen Hemminger /* Last: Shot the device (if unregistered) */ 3656439e2385SDenis V. Lunev if (how) { 3657408c4768SPavel Emelyanov addrconf_sysctl_unregister(idev); 36581da177e4SLinus Torvalds neigh_parms_release(&nd_tbl, idev->nd_parms); 36591da177e4SLinus Torvalds neigh_ifdown(&nd_tbl, dev); 36601da177e4SLinus Torvalds in6_dev_put(idev); 36611da177e4SLinus Torvalds } 36621da177e4SLinus Torvalds return 0; 36631da177e4SLinus Torvalds } 36641da177e4SLinus Torvalds 36651da177e4SLinus Torvalds static void addrconf_rs_timer(unsigned long data) 36661da177e4SLinus Torvalds { 3667b7b1bfceSHannes Frederic Sowa struct inet6_dev *idev = (struct inet6_dev *)data; 3668caf92bc4SCong Wang struct net_device *dev = idev->dev; 3669b7b1bfceSHannes Frederic Sowa struct in6_addr lladdr; 36701da177e4SLinus Torvalds 3671b7b1bfceSHannes Frederic Sowa write_lock(&idev->lock); 36725b2a1953Sstephen hemminger if (idev->dead || !(idev->if_flags & IF_READY)) 36731da177e4SLinus Torvalds goto out; 36741da177e4SLinus Torvalds 36759ba2add3SShmulik Ladkani if (!ipv6_accept_ra(idev)) 36761da177e4SLinus Torvalds goto out; 36775b2a1953Sstephen hemminger 36785b2a1953Sstephen hemminger /* Announcement received after solicitation was sent */ 36795b2a1953Sstephen hemminger if (idev->if_flags & IF_RA_RCVD) 36805b2a1953Sstephen hemminger goto out; 36811da177e4SLinus Torvalds 3682b7b1bfceSHannes Frederic Sowa if (idev->rs_probes++ < idev->cnf.rtr_solicits) { 3683caf92bc4SCong Wang write_unlock(&idev->lock); 3684caf92bc4SCong Wang if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE)) 3685caf92bc4SCong Wang ndisc_send_rs(dev, &lladdr, 3686b7b1bfceSHannes Frederic Sowa &in6addr_linklocal_allrouters); 3687b7b1bfceSHannes Frederic Sowa else 3688caf92bc4SCong Wang goto put; 3689b7b1bfceSHannes Frederic Sowa 3690caf92bc4SCong Wang write_lock(&idev->lock); 36911da177e4SLinus Torvalds /* The wait after the last probe can be shorter */ 3692b7b1bfceSHannes Frederic Sowa addrconf_mod_rs_timer(idev, (idev->rs_probes == 3693b7b1bfceSHannes Frederic Sowa idev->cnf.rtr_solicits) ? 36945b2a1953Sstephen hemminger idev->cnf.rtr_solicit_delay : 36955b2a1953Sstephen hemminger idev->cnf.rtr_solicit_interval); 36961da177e4SLinus Torvalds } else { 36971da177e4SLinus Torvalds /* 36981da177e4SLinus Torvalds * Note: we do not support deprecated "all on-link" 36991da177e4SLinus Torvalds * assumption any longer. 37001da177e4SLinus Torvalds */ 370191df42beSJoe Perches pr_debug("%s: no IPv6 routers present\n", idev->dev->name); 37021da177e4SLinus Torvalds } 37031da177e4SLinus Torvalds 37041da177e4SLinus Torvalds out: 3705b7b1bfceSHannes Frederic Sowa write_unlock(&idev->lock); 3706caf92bc4SCong Wang put: 3707b7b1bfceSHannes Frederic Sowa in6_dev_put(idev); 37081da177e4SLinus Torvalds } 37091da177e4SLinus Torvalds 37101da177e4SLinus Torvalds /* 37111da177e4SLinus Torvalds * Duplicate Address Detection 37121da177e4SLinus Torvalds */ 37133c21edbdSYOSHIFUJI Hideaki static void addrconf_dad_kick(struct inet6_ifaddr *ifp) 37143c21edbdSYOSHIFUJI Hideaki { 37153c21edbdSYOSHIFUJI Hideaki unsigned long rand_num; 37163c21edbdSYOSHIFUJI Hideaki struct inet6_dev *idev = ifp->idev; 37173c21edbdSYOSHIFUJI Hideaki 371895c385b4SNeil Horman if (ifp->flags & IFA_F_OPTIMISTIC) 371995c385b4SNeil Horman rand_num = 0; 372095c385b4SNeil Horman else 372163862b5bSAruna-Hewapathirane rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1); 372295c385b4SNeil Horman 3723b7b1bfceSHannes Frederic Sowa ifp->dad_probes = idev->cnf.dad_transmits; 3724c15b1ccaSHannes Frederic Sowa addrconf_mod_dad_work(ifp, rand_num); 37253c21edbdSYOSHIFUJI Hideaki } 37263c21edbdSYOSHIFUJI Hideaki 3727c15b1ccaSHannes Frederic Sowa static void addrconf_dad_begin(struct inet6_ifaddr *ifp) 37281da177e4SLinus Torvalds { 37291da177e4SLinus Torvalds struct inet6_dev *idev = ifp->idev; 37301da177e4SLinus Torvalds struct net_device *dev = idev->dev; 373116186a82Ssubashab@codeaurora.org bool notify = false; 37321da177e4SLinus Torvalds 37331da177e4SLinus Torvalds addrconf_join_solict(dev, &ifp->addr); 37341da177e4SLinus Torvalds 373563862b5bSAruna-Hewapathirane prandom_seed((__force u32) ifp->addr.s6_addr32[3]); 37361da177e4SLinus Torvalds 37371da177e4SLinus Torvalds read_lock_bh(&idev->lock); 3738622ccdf1SHerbert Xu spin_lock(&ifp->lock); 3739e9d3e084SHerbert Xu if (ifp->state == INET6_IFADDR_STATE_DEAD) 37401da177e4SLinus Torvalds goto out; 37411da177e4SLinus Torvalds 37421da177e4SLinus Torvalds if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) || 37431b34be74SYOSHIFUJI Hideaki idev->cnf.accept_dad < 1 || 374455ebaef1SNoriaki TAKAMIYA !(ifp->flags&IFA_F_TENTATIVE) || 374555ebaef1SNoriaki TAKAMIYA ifp->flags & IFA_F_NODAD) { 3746cc411d0bSBrian Haley ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED); 374721809fafSstephen hemminger spin_unlock(&ifp->lock); 37481da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 37491da177e4SLinus Torvalds 37501da177e4SLinus Torvalds addrconf_dad_completed(ifp); 37511da177e4SLinus Torvalds return; 37521da177e4SLinus Torvalds } 37531da177e4SLinus Torvalds 37546732badeSYOSHIFUJI Hideaki if (!(idev->if_flags & IF_READY)) { 375521809fafSstephen hemminger spin_unlock(&ifp->lock); 37566732badeSYOSHIFUJI Hideaki read_unlock_bh(&idev->lock); 37573c21edbdSYOSHIFUJI Hideaki /* 3758590a9887SMasatake YAMATO * If the device is not ready: 37593c21edbdSYOSHIFUJI Hideaki * - keep it tentative if it is a permanent address. 37603c21edbdSYOSHIFUJI Hideaki * - otherwise, kill it. 37613c21edbdSYOSHIFUJI Hideaki */ 37623c21edbdSYOSHIFUJI Hideaki in6_ifa_hold(ifp); 3763cc411d0bSBrian Haley addrconf_dad_stop(ifp, 0); 37646732badeSYOSHIFUJI Hideaki return; 37653c21edbdSYOSHIFUJI Hideaki } 376695c385b4SNeil Horman 376795c385b4SNeil Horman /* 376895c385b4SNeil Horman * Optimistic nodes can start receiving 376995c385b4SNeil Horman * Frames right away 377095c385b4SNeil Horman */ 37717fd2561eSErik Kline if (ifp->flags & IFA_F_OPTIMISTIC) { 377295c385b4SNeil Horman ip6_ins_rt(ifp->rt); 37737fd2561eSErik Kline if (ipv6_use_optimistic_addr(idev)) { 37747fd2561eSErik Kline /* Because optimistic nodes can use this address, 37757fd2561eSErik Kline * notify listeners. If DAD fails, RTM_DELADDR is sent. 37767fd2561eSErik Kline */ 377716186a82Ssubashab@codeaurora.org notify = true; 37787fd2561eSErik Kline } 37797fd2561eSErik Kline } 378095c385b4SNeil Horman 37816732badeSYOSHIFUJI Hideaki addrconf_dad_kick(ifp); 37821da177e4SLinus Torvalds out: 3783622ccdf1SHerbert Xu spin_unlock(&ifp->lock); 37841da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 378516186a82Ssubashab@codeaurora.org if (notify) 378616186a82Ssubashab@codeaurora.org ipv6_ifa_notify(RTM_NEWADDR, ifp); 37871da177e4SLinus Torvalds } 37881da177e4SLinus Torvalds 3789c15b1ccaSHannes Frederic Sowa static void addrconf_dad_start(struct inet6_ifaddr *ifp) 37901da177e4SLinus Torvalds { 3791c15b1ccaSHannes Frederic Sowa bool begin_dad = false; 3792c15b1ccaSHannes Frederic Sowa 37938e8e676dSHannes Frederic Sowa spin_lock_bh(&ifp->lock); 3794c15b1ccaSHannes Frederic Sowa if (ifp->state != INET6_IFADDR_STATE_DEAD) { 3795c15b1ccaSHannes Frederic Sowa ifp->state = INET6_IFADDR_STATE_PREDAD; 3796c15b1ccaSHannes Frederic Sowa begin_dad = true; 3797c15b1ccaSHannes Frederic Sowa } 37988e8e676dSHannes Frederic Sowa spin_unlock_bh(&ifp->lock); 3799c15b1ccaSHannes Frederic Sowa 3800c15b1ccaSHannes Frederic Sowa if (begin_dad) 3801c15b1ccaSHannes Frederic Sowa addrconf_mod_dad_work(ifp, 0); 3802c15b1ccaSHannes Frederic Sowa } 3803c15b1ccaSHannes Frederic Sowa 3804c15b1ccaSHannes Frederic Sowa static void addrconf_dad_work(struct work_struct *w) 3805c15b1ccaSHannes Frederic Sowa { 3806c15b1ccaSHannes Frederic Sowa struct inet6_ifaddr *ifp = container_of(to_delayed_work(w), 3807c15b1ccaSHannes Frederic Sowa struct inet6_ifaddr, 3808c15b1ccaSHannes Frederic Sowa dad_work); 38091da177e4SLinus Torvalds struct inet6_dev *idev = ifp->idev; 38101da177e4SLinus Torvalds struct in6_addr mcaddr; 381185b51b12SMike Manning bool disable_ipv6 = false; 38121da177e4SLinus Torvalds 3813c15b1ccaSHannes Frederic Sowa enum { 3814c15b1ccaSHannes Frederic Sowa DAD_PROCESS, 3815c15b1ccaSHannes Frederic Sowa DAD_BEGIN, 3816c15b1ccaSHannes Frederic Sowa DAD_ABORT, 3817c15b1ccaSHannes Frederic Sowa } action = DAD_PROCESS; 3818c15b1ccaSHannes Frederic Sowa 3819c15b1ccaSHannes Frederic Sowa rtnl_lock(); 3820c15b1ccaSHannes Frederic Sowa 38218e8e676dSHannes Frederic Sowa spin_lock_bh(&ifp->lock); 3822c15b1ccaSHannes Frederic Sowa if (ifp->state == INET6_IFADDR_STATE_PREDAD) { 3823c15b1ccaSHannes Frederic Sowa action = DAD_BEGIN; 3824c15b1ccaSHannes Frederic Sowa ifp->state = INET6_IFADDR_STATE_DAD; 3825c15b1ccaSHannes Frederic Sowa } else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) { 3826c15b1ccaSHannes Frederic Sowa action = DAD_ABORT; 3827c15b1ccaSHannes Frederic Sowa ifp->state = INET6_IFADDR_STATE_POSTDAD; 382885b51b12SMike Manning 382985b51b12SMike Manning if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6 && 383085b51b12SMike Manning !(ifp->flags & IFA_F_STABLE_PRIVACY)) { 383185b51b12SMike Manning struct in6_addr addr; 383285b51b12SMike Manning 383385b51b12SMike Manning addr.s6_addr32[0] = htonl(0xfe800000); 383485b51b12SMike Manning addr.s6_addr32[1] = 0; 383585b51b12SMike Manning 383685b51b12SMike Manning if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) && 383785b51b12SMike Manning ipv6_addr_equal(&ifp->addr, &addr)) { 383885b51b12SMike Manning /* DAD failed for link-local based on MAC */ 383985b51b12SMike Manning idev->cnf.disable_ipv6 = 1; 384085b51b12SMike Manning 384185b51b12SMike Manning pr_info("%s: IPv6 being disabled!\n", 384285b51b12SMike Manning ifp->idev->dev->name); 384385b51b12SMike Manning disable_ipv6 = true; 384485b51b12SMike Manning } 384585b51b12SMike Manning } 3846c15b1ccaSHannes Frederic Sowa } 38478e8e676dSHannes Frederic Sowa spin_unlock_bh(&ifp->lock); 3848c15b1ccaSHannes Frederic Sowa 3849c15b1ccaSHannes Frederic Sowa if (action == DAD_BEGIN) { 3850c15b1ccaSHannes Frederic Sowa addrconf_dad_begin(ifp); 3851c15b1ccaSHannes Frederic Sowa goto out; 3852c15b1ccaSHannes Frederic Sowa } else if (action == DAD_ABORT) { 3853c15b1ccaSHannes Frederic Sowa addrconf_dad_stop(ifp, 1); 385485b51b12SMike Manning if (disable_ipv6) 385585b51b12SMike Manning addrconf_ifdown(idev->dev, 0); 3856c15b1ccaSHannes Frederic Sowa goto out; 3857c15b1ccaSHannes Frederic Sowa } 3858c15b1ccaSHannes Frederic Sowa 3859b7b1bfceSHannes Frederic Sowa if (!ifp->dad_probes && addrconf_dad_end(ifp)) 3860f2344a13SHerbert Xu goto out; 3861f2344a13SHerbert Xu 3862c15b1ccaSHannes Frederic Sowa write_lock_bh(&idev->lock); 3863122e4519Sstephen hemminger if (idev->dead || !(idev->if_flags & IF_READY)) { 3864c15b1ccaSHannes Frederic Sowa write_unlock_bh(&idev->lock); 38651da177e4SLinus Torvalds goto out; 38661da177e4SLinus Torvalds } 386721809fafSstephen hemminger 386821809fafSstephen hemminger spin_lock(&ifp->lock); 3869622ccdf1SHerbert Xu if (ifp->state == INET6_IFADDR_STATE_DEAD) { 3870622ccdf1SHerbert Xu spin_unlock(&ifp->lock); 3871c15b1ccaSHannes Frederic Sowa write_unlock_bh(&idev->lock); 3872622ccdf1SHerbert Xu goto out; 3873622ccdf1SHerbert Xu } 3874622ccdf1SHerbert Xu 3875b7b1bfceSHannes Frederic Sowa if (ifp->dad_probes == 0) { 38761da177e4SLinus Torvalds /* 38771da177e4SLinus Torvalds * DAD was successful 38781da177e4SLinus Torvalds */ 38791da177e4SLinus Torvalds 3880cc411d0bSBrian Haley ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED); 388121809fafSstephen hemminger spin_unlock(&ifp->lock); 3882c15b1ccaSHannes Frederic Sowa write_unlock_bh(&idev->lock); 38831da177e4SLinus Torvalds 38841da177e4SLinus Torvalds addrconf_dad_completed(ifp); 38851da177e4SLinus Torvalds 38861da177e4SLinus Torvalds goto out; 38871da177e4SLinus Torvalds } 38881da177e4SLinus Torvalds 3889b7b1bfceSHannes Frederic Sowa ifp->dad_probes--; 3890c15b1ccaSHannes Frederic Sowa addrconf_mod_dad_work(ifp, 38911f9248e5SJiri Pirko NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME)); 389221809fafSstephen hemminger spin_unlock(&ifp->lock); 3893c15b1ccaSHannes Frederic Sowa write_unlock_bh(&idev->lock); 38941da177e4SLinus Torvalds 38951da177e4SLinus Torvalds /* send a neighbour solicitation for our addr */ 38961da177e4SLinus Torvalds addrconf_addr_solict_mult(&ifp->addr, &mcaddr); 3897304d888bSNicolas Dichtel ndisc_send_ns(ifp->idev->dev, &ifp->addr, &mcaddr, &in6addr_any); 38981da177e4SLinus Torvalds out: 38991da177e4SLinus Torvalds in6_ifa_put(ifp); 3900c15b1ccaSHannes Frederic Sowa rtnl_unlock(); 39011da177e4SLinus Torvalds } 39021da177e4SLinus Torvalds 390311ffff75SHannes Frederic Sowa /* ifp->idev must be at least read locked */ 390411ffff75SHannes Frederic Sowa static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp) 390511ffff75SHannes Frederic Sowa { 390611ffff75SHannes Frederic Sowa struct inet6_ifaddr *ifpiter; 390711ffff75SHannes Frederic Sowa struct inet6_dev *idev = ifp->idev; 390811ffff75SHannes Frederic Sowa 3909602582caSHannes Frederic Sowa list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) { 3910602582caSHannes Frederic Sowa if (ifpiter->scope > IFA_LINK) 3911602582caSHannes Frederic Sowa break; 391211ffff75SHannes Frederic Sowa if (ifp != ifpiter && ifpiter->scope == IFA_LINK && 391311ffff75SHannes Frederic Sowa (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE| 391411ffff75SHannes Frederic Sowa IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) == 391511ffff75SHannes Frederic Sowa IFA_F_PERMANENT) 391611ffff75SHannes Frederic Sowa return false; 391711ffff75SHannes Frederic Sowa } 391811ffff75SHannes Frederic Sowa return true; 391911ffff75SHannes Frederic Sowa } 392011ffff75SHannes Frederic Sowa 39211da177e4SLinus Torvalds static void addrconf_dad_completed(struct inet6_ifaddr *ifp) 39221da177e4SLinus Torvalds { 39231da177e4SLinus Torvalds struct net_device *dev = ifp->idev->dev; 3924b7b1bfceSHannes Frederic Sowa struct in6_addr lladdr; 3925b173ee48SHannes Frederic Sowa bool send_rs, send_mld; 3926b7b1bfceSHannes Frederic Sowa 3927c15b1ccaSHannes Frederic Sowa addrconf_del_dad_work(ifp); 39281da177e4SLinus Torvalds 39291da177e4SLinus Torvalds /* 39301da177e4SLinus Torvalds * Configure the address for reception. Now it is valid. 39311da177e4SLinus Torvalds */ 39321da177e4SLinus Torvalds 39331da177e4SLinus Torvalds ipv6_ifa_notify(RTM_NEWADDR, ifp); 39341da177e4SLinus Torvalds 3935026359bcSTore Anderson /* If added prefix is link local and we are prepared to process 3936026359bcSTore Anderson router advertisements, start sending router solicitations. 39371da177e4SLinus Torvalds */ 39381da177e4SLinus Torvalds 39391ec047ebSHannes Frederic Sowa read_lock_bh(&ifp->idev->lock); 394011ffff75SHannes Frederic Sowa send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp); 3941b173ee48SHannes Frederic Sowa send_rs = send_mld && 3942b173ee48SHannes Frederic Sowa ipv6_accept_ra(ifp->idev) && 3943b173ee48SHannes Frederic Sowa ifp->idev->cnf.rtr_solicits > 0 && 3944b173ee48SHannes Frederic Sowa (dev->flags&IFF_LOOPBACK) == 0; 39451ec047ebSHannes Frederic Sowa read_unlock_bh(&ifp->idev->lock); 39461ec047ebSHannes Frederic Sowa 3947b173ee48SHannes Frederic Sowa /* While dad is in progress mld report's source address is in6_addrany. 3948b173ee48SHannes Frederic Sowa * Resend with proper ll now. 3949b173ee48SHannes Frederic Sowa */ 3950b173ee48SHannes Frederic Sowa if (send_mld) 3951b173ee48SHannes Frederic Sowa ipv6_mc_dad_complete(ifp->idev); 3952b173ee48SHannes Frederic Sowa 39531ec047ebSHannes Frederic Sowa if (send_rs) { 39541da177e4SLinus Torvalds /* 39551da177e4SLinus Torvalds * If a host as already performed a random delay 39561da177e4SLinus Torvalds * [...] as part of DAD [...] there is no need 39571da177e4SLinus Torvalds * to delay again before sending the first RS 39581da177e4SLinus Torvalds */ 39591ec047ebSHannes Frederic Sowa if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE)) 3960b7b1bfceSHannes Frederic Sowa return; 39611ec047ebSHannes Frederic Sowa ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters); 39621da177e4SLinus Torvalds 3963b7b1bfceSHannes Frederic Sowa write_lock_bh(&ifp->idev->lock); 3964b7b1bfceSHannes Frederic Sowa spin_lock(&ifp->lock); 3965b7b1bfceSHannes Frederic Sowa ifp->idev->rs_probes = 1; 39661da177e4SLinus Torvalds ifp->idev->if_flags |= IF_RS_SENT; 3967b7b1bfceSHannes Frederic Sowa addrconf_mod_rs_timer(ifp->idev, 3968b7b1bfceSHannes Frederic Sowa ifp->idev->cnf.rtr_solicit_interval); 3969b7b1bfceSHannes Frederic Sowa spin_unlock(&ifp->lock); 3970b7b1bfceSHannes Frederic Sowa write_unlock_bh(&ifp->idev->lock); 39711da177e4SLinus Torvalds } 39721da177e4SLinus Torvalds } 39731da177e4SLinus Torvalds 3974e21e8467SStephen Hemminger static void addrconf_dad_run(struct inet6_dev *idev) 3975e21e8467SStephen Hemminger { 3976c5e33bddSYOSHIFUJI Hideaki struct inet6_ifaddr *ifp; 3977c5e33bddSYOSHIFUJI Hideaki 3978c5e33bddSYOSHIFUJI Hideaki read_lock_bh(&idev->lock); 3979502a2ffdSstephen hemminger list_for_each_entry(ifp, &idev->addr_list, if_list) { 398021809fafSstephen hemminger spin_lock(&ifp->lock); 3981f2344a13SHerbert Xu if (ifp->flags & IFA_F_TENTATIVE && 3982f2344a13SHerbert Xu ifp->state == INET6_IFADDR_STATE_DAD) 3983c5e33bddSYOSHIFUJI Hideaki addrconf_dad_kick(ifp); 3984f2344a13SHerbert Xu spin_unlock(&ifp->lock); 3985c5e33bddSYOSHIFUJI Hideaki } 3986c5e33bddSYOSHIFUJI Hideaki read_unlock_bh(&idev->lock); 3987c5e33bddSYOSHIFUJI Hideaki } 3988c5e33bddSYOSHIFUJI Hideaki 39891da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 39901da177e4SLinus Torvalds struct if6_iter_state { 39913c40090aSDaniel Lezcano struct seq_net_private p; 39921da177e4SLinus Torvalds int bucket; 39931d578303SMihai Maruseac int offset; 39941da177e4SLinus Torvalds }; 39951da177e4SLinus Torvalds 39961d578303SMihai Maruseac static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos) 39971da177e4SLinus Torvalds { 39981da177e4SLinus Torvalds struct inet6_ifaddr *ifa = NULL; 39991da177e4SLinus Torvalds struct if6_iter_state *state = seq->private; 40001218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 40011d578303SMihai Maruseac int p = 0; 40021da177e4SLinus Torvalds 40031d578303SMihai Maruseac /* initial bucket if pos is 0 */ 40041d578303SMihai Maruseac if (pos == 0) { 40051d578303SMihai Maruseac state->bucket = 0; 40061d578303SMihai Maruseac state->offset = 0; 40071d578303SMihai Maruseac } 40081d578303SMihai Maruseac 40091d578303SMihai Maruseac for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) { 4010b67bfe0dSSasha Levin hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket], 40111d578303SMihai Maruseac addr_lst) { 40129f0d3c27SEric Dumazet if (!net_eq(dev_net(ifa->idev->dev), net)) 40139f0d3c27SEric Dumazet continue; 40141d578303SMihai Maruseac /* sync with offset */ 40151d578303SMihai Maruseac if (p < state->offset) { 40161d578303SMihai Maruseac p++; 40171d578303SMihai Maruseac continue; 40181d578303SMihai Maruseac } 40191d578303SMihai Maruseac state->offset++; 40201da177e4SLinus Torvalds return ifa; 40211da177e4SLinus Torvalds } 40221d578303SMihai Maruseac 40231d578303SMihai Maruseac /* prepare for next bucket */ 40241d578303SMihai Maruseac state->offset = 0; 40251d578303SMihai Maruseac p = 0; 40261d578303SMihai Maruseac } 4027c2e21293Sstephen hemminger return NULL; 4028c2e21293Sstephen hemminger } 40291da177e4SLinus Torvalds 4030c2e21293Sstephen hemminger static struct inet6_ifaddr *if6_get_next(struct seq_file *seq, 4031c2e21293Sstephen hemminger struct inet6_ifaddr *ifa) 40321da177e4SLinus Torvalds { 40331da177e4SLinus Torvalds struct if6_iter_state *state = seq->private; 40341218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 40351da177e4SLinus Torvalds 4036b67bfe0dSSasha Levin hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) { 40379f0d3c27SEric Dumazet if (!net_eq(dev_net(ifa->idev->dev), net)) 40389f0d3c27SEric Dumazet continue; 40391d578303SMihai Maruseac state->offset++; 40401da177e4SLinus Torvalds return ifa; 40411d578303SMihai Maruseac } 40421da177e4SLinus Torvalds 4043c2e21293Sstephen hemminger while (++state->bucket < IN6_ADDR_HSIZE) { 40441d578303SMihai Maruseac state->offset = 0; 4045b67bfe0dSSasha Levin hlist_for_each_entry_rcu_bh(ifa, 4046c2e21293Sstephen hemminger &inet6_addr_lst[state->bucket], addr_lst) { 40479f0d3c27SEric Dumazet if (!net_eq(dev_net(ifa->idev->dev), net)) 40489f0d3c27SEric Dumazet continue; 40491d578303SMihai Maruseac state->offset++; 4050c2e21293Sstephen hemminger return ifa; 4051c2e21293Sstephen hemminger } 4052c2e21293Sstephen hemminger } 4053c2e21293Sstephen hemminger 4054c2e21293Sstephen hemminger return NULL; 4055c2e21293Sstephen hemminger } 4056c2e21293Sstephen hemminger 40571da177e4SLinus Torvalds static void *if6_seq_start(struct seq_file *seq, loff_t *pos) 40584f70eccaSEric Dumazet __acquires(rcu_bh) 40591da177e4SLinus Torvalds { 40605c578aedSstephen hemminger rcu_read_lock_bh(); 40611d578303SMihai Maruseac return if6_get_first(seq, *pos); 40621da177e4SLinus Torvalds } 40631da177e4SLinus Torvalds 40641da177e4SLinus Torvalds static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos) 40651da177e4SLinus Torvalds { 40661da177e4SLinus Torvalds struct inet6_ifaddr *ifa; 40671da177e4SLinus Torvalds 40681da177e4SLinus Torvalds ifa = if6_get_next(seq, v); 40691da177e4SLinus Torvalds ++*pos; 40701da177e4SLinus Torvalds return ifa; 40711da177e4SLinus Torvalds } 40721da177e4SLinus Torvalds 40731da177e4SLinus Torvalds static void if6_seq_stop(struct seq_file *seq, void *v) 40744f70eccaSEric Dumazet __releases(rcu_bh) 40751da177e4SLinus Torvalds { 40765c578aedSstephen hemminger rcu_read_unlock_bh(); 40771da177e4SLinus Torvalds } 40781da177e4SLinus Torvalds 40791da177e4SLinus Torvalds static int if6_seq_show(struct seq_file *seq, void *v) 40801da177e4SLinus Torvalds { 40811da177e4SLinus Torvalds struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v; 4082971a351cSJiri Pirko seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n", 4083b071195dSHarvey Harrison &ifp->addr, 40841da177e4SLinus Torvalds ifp->idev->dev->ifindex, 40851da177e4SLinus Torvalds ifp->prefix_len, 40861da177e4SLinus Torvalds ifp->scope, 4087971a351cSJiri Pirko (u8) ifp->flags, 40881da177e4SLinus Torvalds ifp->idev->dev->name); 40891da177e4SLinus Torvalds return 0; 40901da177e4SLinus Torvalds } 40911da177e4SLinus Torvalds 409256b3d975SPhilippe De Muyter static const struct seq_operations if6_seq_ops = { 40931da177e4SLinus Torvalds .start = if6_seq_start, 40941da177e4SLinus Torvalds .next = if6_seq_next, 40951da177e4SLinus Torvalds .show = if6_seq_show, 40961da177e4SLinus Torvalds .stop = if6_seq_stop, 40971da177e4SLinus Torvalds }; 40981da177e4SLinus Torvalds 40991da177e4SLinus Torvalds static int if6_seq_open(struct inode *inode, struct file *file) 41001da177e4SLinus Torvalds { 41013c40090aSDaniel Lezcano return seq_open_net(inode, file, &if6_seq_ops, 4102cf7732e4SPavel Emelyanov sizeof(struct if6_iter_state)); 41031da177e4SLinus Torvalds } 41041da177e4SLinus Torvalds 41059a32144eSArjan van de Ven static const struct file_operations if6_fops = { 41061da177e4SLinus Torvalds .owner = THIS_MODULE, 41071da177e4SLinus Torvalds .open = if6_seq_open, 41081da177e4SLinus Torvalds .read = seq_read, 41091da177e4SLinus Torvalds .llseek = seq_lseek, 41103c40090aSDaniel Lezcano .release = seq_release_net, 41111da177e4SLinus Torvalds }; 41121da177e4SLinus Torvalds 41132c8c1e72SAlexey Dobriyan static int __net_init if6_proc_net_init(struct net *net) 41141da177e4SLinus Torvalds { 4115d4beaa66SGao feng if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops)) 41161da177e4SLinus Torvalds return -ENOMEM; 41171da177e4SLinus Torvalds return 0; 41181da177e4SLinus Torvalds } 41191da177e4SLinus Torvalds 41202c8c1e72SAlexey Dobriyan static void __net_exit if6_proc_net_exit(struct net *net) 41213c40090aSDaniel Lezcano { 4122ece31ffdSGao feng remove_proc_entry("if_inet6", net->proc_net); 41233c40090aSDaniel Lezcano } 41243c40090aSDaniel Lezcano 41253c40090aSDaniel Lezcano static struct pernet_operations if6_proc_net_ops = { 41263c40090aSDaniel Lezcano .init = if6_proc_net_init, 41273c40090aSDaniel Lezcano .exit = if6_proc_net_exit, 41283c40090aSDaniel Lezcano }; 41293c40090aSDaniel Lezcano 41303c40090aSDaniel Lezcano int __init if6_proc_init(void) 41313c40090aSDaniel Lezcano { 41323c40090aSDaniel Lezcano return register_pernet_subsys(&if6_proc_net_ops); 41333c40090aSDaniel Lezcano } 41343c40090aSDaniel Lezcano 41351da177e4SLinus Torvalds void if6_proc_exit(void) 41361da177e4SLinus Torvalds { 41373c40090aSDaniel Lezcano unregister_pernet_subsys(&if6_proc_net_ops); 41381da177e4SLinus Torvalds } 41391da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 41401da177e4SLinus Torvalds 414107a93626SAmerigo Wang #if IS_ENABLED(CONFIG_IPV6_MIP6) 41423b9f9a1cSNoriaki TAKAMIYA /* Check if address is a home address configured on any interface. */ 4143b71d1d42SEric Dumazet int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr) 41443b9f9a1cSNoriaki TAKAMIYA { 41453b9f9a1cSNoriaki TAKAMIYA int ret = 0; 4146c2e21293Sstephen hemminger struct inet6_ifaddr *ifp = NULL; 4147ddbe5032SEric Dumazet unsigned int hash = inet6_addr_hash(addr); 4148c2e21293Sstephen hemminger 41495c578aedSstephen hemminger rcu_read_lock_bh(); 4150b67bfe0dSSasha Levin hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) { 4151878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(ifp->idev->dev), net)) 4152389f6612SDaniel Lezcano continue; 4153caad295fSYOSHIFUJI Hideaki if (ipv6_addr_equal(&ifp->addr, addr) && 41543b9f9a1cSNoriaki TAKAMIYA (ifp->flags & IFA_F_HOMEADDRESS)) { 41553b9f9a1cSNoriaki TAKAMIYA ret = 1; 41563b9f9a1cSNoriaki TAKAMIYA break; 41573b9f9a1cSNoriaki TAKAMIYA } 41583b9f9a1cSNoriaki TAKAMIYA } 41595c578aedSstephen hemminger rcu_read_unlock_bh(); 41603b9f9a1cSNoriaki TAKAMIYA return ret; 41613b9f9a1cSNoriaki TAKAMIYA } 41623b9f9a1cSNoriaki TAKAMIYA #endif 41633b9f9a1cSNoriaki TAKAMIYA 41641da177e4SLinus Torvalds /* 41651da177e4SLinus Torvalds * Periodic address status verification 41661da177e4SLinus Torvalds */ 41671da177e4SLinus Torvalds 4168c15b1ccaSHannes Frederic Sowa static void addrconf_verify_rtnl(void) 41691da177e4SLinus Torvalds { 4170b2db7564SYOSHIFUJI Hideaki unsigned long now, next, next_sec, next_sched; 41711da177e4SLinus Torvalds struct inet6_ifaddr *ifp; 41721da177e4SLinus Torvalds int i; 41731da177e4SLinus Torvalds 4174c15b1ccaSHannes Frederic Sowa ASSERT_RTNL(); 4175c15b1ccaSHannes Frederic Sowa 41765c578aedSstephen hemminger rcu_read_lock_bh(); 41771da177e4SLinus Torvalds now = jiffies; 4178b2db7564SYOSHIFUJI Hideaki next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY); 41791da177e4SLinus Torvalds 4180c15b1ccaSHannes Frederic Sowa cancel_delayed_work(&addr_chk_work); 41811da177e4SLinus Torvalds 41821da177e4SLinus Torvalds for (i = 0; i < IN6_ADDR_HSIZE; i++) { 41831da177e4SLinus Torvalds restart: 4184c15b1ccaSHannes Frederic Sowa hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) { 41851da177e4SLinus Torvalds unsigned long age; 41861da177e4SLinus Torvalds 4187fad8da3eSYasushi Asano /* When setting preferred_lft to a value not zero or 4188fad8da3eSYasushi Asano * infinity, while valid_lft is infinity 4189fad8da3eSYasushi Asano * IFA_F_PERMANENT has a non-infinity life time. 4190fad8da3eSYasushi Asano */ 4191fad8da3eSYasushi Asano if ((ifp->flags & IFA_F_PERMANENT) && 4192fad8da3eSYasushi Asano (ifp->prefered_lft == INFINITY_LIFE_TIME)) 41931da177e4SLinus Torvalds continue; 41941da177e4SLinus Torvalds 41951da177e4SLinus Torvalds spin_lock(&ifp->lock); 4196b2db7564SYOSHIFUJI Hideaki /* We try to batch several events at once. */ 4197b2db7564SYOSHIFUJI Hideaki age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ; 41981da177e4SLinus Torvalds 41998f27ebb9SYOSHIFUJI Hideaki if (ifp->valid_lft != INFINITY_LIFE_TIME && 42008f27ebb9SYOSHIFUJI Hideaki age >= ifp->valid_lft) { 42011da177e4SLinus Torvalds spin_unlock(&ifp->lock); 42021da177e4SLinus Torvalds in6_ifa_hold(ifp); 42031da177e4SLinus Torvalds ipv6_del_addr(ifp); 42041da177e4SLinus Torvalds goto restart; 42058f27ebb9SYOSHIFUJI Hideaki } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) { 42068f27ebb9SYOSHIFUJI Hideaki spin_unlock(&ifp->lock); 42078f27ebb9SYOSHIFUJI Hideaki continue; 42081da177e4SLinus Torvalds } else if (age >= ifp->prefered_lft) { 4209a1ed0526SBrian Haley /* jiffies - ifp->tstamp > age >= ifp->prefered_lft */ 42101da177e4SLinus Torvalds int deprecate = 0; 42111da177e4SLinus Torvalds 42121da177e4SLinus Torvalds if (!(ifp->flags&IFA_F_DEPRECATED)) { 42131da177e4SLinus Torvalds deprecate = 1; 42141da177e4SLinus Torvalds ifp->flags |= IFA_F_DEPRECATED; 42151da177e4SLinus Torvalds } 42161da177e4SLinus Torvalds 4217fad8da3eSYasushi Asano if ((ifp->valid_lft != INFINITY_LIFE_TIME) && 4218fad8da3eSYasushi Asano (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))) 42191da177e4SLinus Torvalds next = ifp->tstamp + ifp->valid_lft * HZ; 42201da177e4SLinus Torvalds 42211da177e4SLinus Torvalds spin_unlock(&ifp->lock); 42221da177e4SLinus Torvalds 42231da177e4SLinus Torvalds if (deprecate) { 42241da177e4SLinus Torvalds in6_ifa_hold(ifp); 42251da177e4SLinus Torvalds 42261da177e4SLinus Torvalds ipv6_ifa_notify(0, ifp); 42271da177e4SLinus Torvalds in6_ifa_put(ifp); 42281da177e4SLinus Torvalds goto restart; 42291da177e4SLinus Torvalds } 42301da177e4SLinus Torvalds } else if ((ifp->flags&IFA_F_TEMPORARY) && 42311da177e4SLinus Torvalds !(ifp->flags&IFA_F_TENTATIVE)) { 423288949cf4Sstephen hemminger unsigned long regen_advance = ifp->idev->cnf.regen_max_retry * 423388949cf4Sstephen hemminger ifp->idev->cnf.dad_transmits * 42341f9248e5SJiri Pirko NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ; 423588949cf4Sstephen hemminger 42361da177e4SLinus Torvalds if (age >= ifp->prefered_lft - regen_advance) { 42371da177e4SLinus Torvalds struct inet6_ifaddr *ifpub = ifp->ifpub; 42381da177e4SLinus Torvalds if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next)) 42391da177e4SLinus Torvalds next = ifp->tstamp + ifp->prefered_lft * HZ; 42401da177e4SLinus Torvalds if (!ifp->regen_count && ifpub) { 42411da177e4SLinus Torvalds ifp->regen_count++; 42421da177e4SLinus Torvalds in6_ifa_hold(ifp); 42431da177e4SLinus Torvalds in6_ifa_hold(ifpub); 42441da177e4SLinus Torvalds spin_unlock(&ifp->lock); 42455c578aedSstephen hemminger 4246291d809bSHiroyuki YAMAMORI spin_lock(&ifpub->lock); 4247291d809bSHiroyuki YAMAMORI ifpub->regen_count = 0; 4248291d809bSHiroyuki YAMAMORI spin_unlock(&ifpub->lock); 42491da177e4SLinus Torvalds ipv6_create_tempaddr(ifpub, ifp); 42501da177e4SLinus Torvalds in6_ifa_put(ifpub); 42511da177e4SLinus Torvalds in6_ifa_put(ifp); 42521da177e4SLinus Torvalds goto restart; 42531da177e4SLinus Torvalds } 42541da177e4SLinus Torvalds } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next)) 42551da177e4SLinus Torvalds next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ; 42561da177e4SLinus Torvalds spin_unlock(&ifp->lock); 42571da177e4SLinus Torvalds } else { 42581da177e4SLinus Torvalds /* ifp->prefered_lft <= ifp->valid_lft */ 42591da177e4SLinus Torvalds if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next)) 42601da177e4SLinus Torvalds next = ifp->tstamp + ifp->prefered_lft * HZ; 42611da177e4SLinus Torvalds spin_unlock(&ifp->lock); 42621da177e4SLinus Torvalds } 42631da177e4SLinus Torvalds } 42641da177e4SLinus Torvalds } 42651da177e4SLinus Torvalds 4266b2db7564SYOSHIFUJI Hideaki next_sec = round_jiffies_up(next); 4267b2db7564SYOSHIFUJI Hideaki next_sched = next; 4268b2db7564SYOSHIFUJI Hideaki 4269b2db7564SYOSHIFUJI Hideaki /* If rounded timeout is accurate enough, accept it. */ 4270b2db7564SYOSHIFUJI Hideaki if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ)) 4271b2db7564SYOSHIFUJI Hideaki next_sched = next_sec; 4272b2db7564SYOSHIFUJI Hideaki 4273b2db7564SYOSHIFUJI Hideaki /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */ 4274b2db7564SYOSHIFUJI Hideaki if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX)) 4275b2db7564SYOSHIFUJI Hideaki next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX; 4276b2db7564SYOSHIFUJI Hideaki 4277ba3542e1Sdingtianhong ADBG(KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n", 4278ba3542e1Sdingtianhong now, next, next_sec, next_sched); 4279c15b1ccaSHannes Frederic Sowa mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now); 42805c578aedSstephen hemminger rcu_read_unlock_bh(); 42811da177e4SLinus Torvalds } 42821da177e4SLinus Torvalds 4283c15b1ccaSHannes Frederic Sowa static void addrconf_verify_work(struct work_struct *w) 4284c15b1ccaSHannes Frederic Sowa { 4285c15b1ccaSHannes Frederic Sowa rtnl_lock(); 4286c15b1ccaSHannes Frederic Sowa addrconf_verify_rtnl(); 4287c15b1ccaSHannes Frederic Sowa rtnl_unlock(); 4288c15b1ccaSHannes Frederic Sowa } 4289c15b1ccaSHannes Frederic Sowa 4290c15b1ccaSHannes Frederic Sowa static void addrconf_verify(void) 4291c15b1ccaSHannes Frederic Sowa { 4292c15b1ccaSHannes Frederic Sowa mod_delayed_work(addrconf_wq, &addr_chk_work, 0); 4293c15b1ccaSHannes Frederic Sowa } 4294c15b1ccaSHannes Frederic Sowa 4295caeaba79SNicolas Dichtel static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local, 4296caeaba79SNicolas Dichtel struct in6_addr **peer_pfx) 4297461d8837SThomas Graf { 4298461d8837SThomas Graf struct in6_addr *pfx = NULL; 4299461d8837SThomas Graf 4300caeaba79SNicolas Dichtel *peer_pfx = NULL; 4301caeaba79SNicolas Dichtel 4302461d8837SThomas Graf if (addr) 4303461d8837SThomas Graf pfx = nla_data(addr); 4304461d8837SThomas Graf 4305461d8837SThomas Graf if (local) { 4306461d8837SThomas Graf if (pfx && nla_memcmp(local, pfx, sizeof(*pfx))) 4307caeaba79SNicolas Dichtel *peer_pfx = pfx; 4308461d8837SThomas Graf pfx = nla_data(local); 4309461d8837SThomas Graf } 4310461d8837SThomas Graf 4311461d8837SThomas Graf return pfx; 4312461d8837SThomas Graf } 4313461d8837SThomas Graf 4314ef7c79edSPatrick McHardy static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = { 4315461d8837SThomas Graf [IFA_ADDRESS] = { .len = sizeof(struct in6_addr) }, 4316461d8837SThomas Graf [IFA_LOCAL] = { .len = sizeof(struct in6_addr) }, 4317461d8837SThomas Graf [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) }, 4318479840ffSJiri Pirko [IFA_FLAGS] = { .len = sizeof(u32) }, 4319461d8837SThomas Graf }; 4320461d8837SThomas Graf 43211da177e4SLinus Torvalds static int 4322661d2967SThomas Graf inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh) 43231da177e4SLinus Torvalds { 43243b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 4325b933f716SThomas Graf struct ifaddrmsg *ifm; 4326b933f716SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4327caeaba79SNicolas Dichtel struct in6_addr *pfx, *peer_pfx; 43286046d5b4SHeiner Kallweit u32 ifa_flags; 4329b933f716SThomas Graf int err; 43301da177e4SLinus Torvalds 4331b933f716SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 4332b933f716SThomas Graf if (err < 0) 4333b933f716SThomas Graf return err; 4334b933f716SThomas Graf 4335b933f716SThomas Graf ifm = nlmsg_data(nlh); 4336caeaba79SNicolas Dichtel pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx); 433763159f29SIan Morris if (!pfx) 43381da177e4SLinus Torvalds return -EINVAL; 43391da177e4SLinus Torvalds 43406046d5b4SHeiner Kallweit ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags; 43416046d5b4SHeiner Kallweit 43426046d5b4SHeiner Kallweit /* We ignore other flags so far. */ 43436046d5b4SHeiner Kallweit ifa_flags &= IFA_F_MANAGETEMPADDR; 43446046d5b4SHeiner Kallweit 43456046d5b4SHeiner Kallweit return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx, 43466046d5b4SHeiner Kallweit ifm->ifa_prefixlen); 43471da177e4SLinus Torvalds } 43481da177e4SLinus Torvalds 4349479840ffSJiri Pirko static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags, 435055ebaef1SNoriaki TAKAMIYA u32 prefered_lft, u32 valid_lft) 4351081bba5bSNoriaki TAKAMIYA { 43526f704992SYOSHIFUJI Hideaki u32 flags; 43536f704992SYOSHIFUJI Hideaki clock_t expires; 43544bed72e4SYOSHIFUJI Hideaki unsigned long timeout; 435553bd6749SJiri Pirko bool was_managetempaddr; 43565b84efecSThomas Haller bool had_prefixroute; 435746d48046SYOSHIFUJI Hideaki 4358c15b1ccaSHannes Frederic Sowa ASSERT_RTNL(); 4359c15b1ccaSHannes Frederic Sowa 4360081bba5bSNoriaki TAKAMIYA if (!valid_lft || (prefered_lft > valid_lft)) 4361081bba5bSNoriaki TAKAMIYA return -EINVAL; 4362081bba5bSNoriaki TAKAMIYA 436353bd6749SJiri Pirko if (ifa_flags & IFA_F_MANAGETEMPADDR && 436453bd6749SJiri Pirko (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64)) 436553bd6749SJiri Pirko return -EINVAL; 436653bd6749SJiri Pirko 43674bed72e4SYOSHIFUJI Hideaki timeout = addrconf_timeout_fixup(valid_lft, HZ); 43684bed72e4SYOSHIFUJI Hideaki if (addrconf_finite_timeout(timeout)) { 43694bed72e4SYOSHIFUJI Hideaki expires = jiffies_to_clock_t(timeout * HZ); 43704bed72e4SYOSHIFUJI Hideaki valid_lft = timeout; 43716f704992SYOSHIFUJI Hideaki flags = RTF_EXPIRES; 43724bed72e4SYOSHIFUJI Hideaki } else { 43734bed72e4SYOSHIFUJI Hideaki expires = 0; 43744bed72e4SYOSHIFUJI Hideaki flags = 0; 43754bed72e4SYOSHIFUJI Hideaki ifa_flags |= IFA_F_PERMANENT; 43766f704992SYOSHIFUJI Hideaki } 4377081bba5bSNoriaki TAKAMIYA 43784bed72e4SYOSHIFUJI Hideaki timeout = addrconf_timeout_fixup(prefered_lft, HZ); 43794bed72e4SYOSHIFUJI Hideaki if (addrconf_finite_timeout(timeout)) { 43804bed72e4SYOSHIFUJI Hideaki if (timeout == 0) 438155ebaef1SNoriaki TAKAMIYA ifa_flags |= IFA_F_DEPRECATED; 43824bed72e4SYOSHIFUJI Hideaki prefered_lft = timeout; 43834bed72e4SYOSHIFUJI Hideaki } 4384081bba5bSNoriaki TAKAMIYA 4385081bba5bSNoriaki TAKAMIYA spin_lock_bh(&ifp->lock); 438653bd6749SJiri Pirko was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR; 43875b84efecSThomas Haller had_prefixroute = ifp->flags & IFA_F_PERMANENT && 43885b84efecSThomas Haller !(ifp->flags & IFA_F_NOPREFIXROUTE); 438953bd6749SJiri Pirko ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | 4390761aac73SThomas Haller IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR | 4391761aac73SThomas Haller IFA_F_NOPREFIXROUTE); 439253bd6749SJiri Pirko ifp->flags |= ifa_flags; 4393081bba5bSNoriaki TAKAMIYA ifp->tstamp = jiffies; 4394081bba5bSNoriaki TAKAMIYA ifp->valid_lft = valid_lft; 4395081bba5bSNoriaki TAKAMIYA ifp->prefered_lft = prefered_lft; 4396081bba5bSNoriaki TAKAMIYA 4397081bba5bSNoriaki TAKAMIYA spin_unlock_bh(&ifp->lock); 4398081bba5bSNoriaki TAKAMIYA if (!(ifp->flags&IFA_F_TENTATIVE)) 4399081bba5bSNoriaki TAKAMIYA ipv6_ifa_notify(0, ifp); 4400081bba5bSNoriaki TAKAMIYA 4401761aac73SThomas Haller if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) { 440246d48046SYOSHIFUJI Hideaki addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev, 44036f704992SYOSHIFUJI Hideaki expires, flags); 44045b84efecSThomas Haller } else if (had_prefixroute) { 44055b84efecSThomas Haller enum cleanup_prefix_rt_t action; 44065b84efecSThomas Haller unsigned long rt_expires; 44075b84efecSThomas Haller 44085b84efecSThomas Haller write_lock_bh(&ifp->idev->lock); 44095b84efecSThomas Haller action = check_cleanup_prefix_route(ifp, &rt_expires); 44105b84efecSThomas Haller write_unlock_bh(&ifp->idev->lock); 44115b84efecSThomas Haller 44125b84efecSThomas Haller if (action != CLEANUP_PREFIX_RT_NOP) { 44135b84efecSThomas Haller cleanup_prefix_route(ifp, rt_expires, 44145b84efecSThomas Haller action == CLEANUP_PREFIX_RT_DEL); 44155b84efecSThomas Haller } 4416761aac73SThomas Haller } 441753bd6749SJiri Pirko 441853bd6749SJiri Pirko if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) { 441953bd6749SJiri Pirko if (was_managetempaddr && !(ifp->flags & IFA_F_MANAGETEMPADDR)) 442053bd6749SJiri Pirko valid_lft = prefered_lft = 0; 442153bd6749SJiri Pirko manage_tempaddrs(ifp->idev, ifp, valid_lft, prefered_lft, 442253bd6749SJiri Pirko !was_managetempaddr, jiffies); 442353bd6749SJiri Pirko } 442453bd6749SJiri Pirko 4425c15b1ccaSHannes Frederic Sowa addrconf_verify_rtnl(); 4426081bba5bSNoriaki TAKAMIYA 4427081bba5bSNoriaki TAKAMIYA return 0; 4428081bba5bSNoriaki TAKAMIYA } 4429081bba5bSNoriaki TAKAMIYA 4430081bba5bSNoriaki TAKAMIYA static int 4431661d2967SThomas Graf inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh) 44321da177e4SLinus Torvalds { 44333b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 4434461d8837SThomas Graf struct ifaddrmsg *ifm; 4435461d8837SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4436caeaba79SNicolas Dichtel struct in6_addr *pfx, *peer_pfx; 44377198f8ceSThomas Graf struct inet6_ifaddr *ifa; 44387198f8ceSThomas Graf struct net_device *dev; 443955ebaef1SNoriaki TAKAMIYA u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; 4440479840ffSJiri Pirko u32 ifa_flags; 4441461d8837SThomas Graf int err; 44421da177e4SLinus Torvalds 4443461d8837SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 4444461d8837SThomas Graf if (err < 0) 4445461d8837SThomas Graf return err; 4446461d8837SThomas Graf 4447461d8837SThomas Graf ifm = nlmsg_data(nlh); 4448caeaba79SNicolas Dichtel pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx); 444963159f29SIan Morris if (!pfx) 44501da177e4SLinus Torvalds return -EINVAL; 44511da177e4SLinus Torvalds 4452461d8837SThomas Graf if (tb[IFA_CACHEINFO]) { 44530778769dSNoriaki TAKAMIYA struct ifa_cacheinfo *ci; 4454461d8837SThomas Graf 4455461d8837SThomas Graf ci = nla_data(tb[IFA_CACHEINFO]); 44560778769dSNoriaki TAKAMIYA valid_lft = ci->ifa_valid; 4457461d8837SThomas Graf preferred_lft = ci->ifa_prefered; 4458461d8837SThomas Graf } else { 4459461d8837SThomas Graf preferred_lft = INFINITY_LIFE_TIME; 4460461d8837SThomas Graf valid_lft = INFINITY_LIFE_TIME; 44610778769dSNoriaki TAKAMIYA } 44620778769dSNoriaki TAKAMIYA 4463af284937SDaniel Lezcano dev = __dev_get_by_index(net, ifm->ifa_index); 446463159f29SIan Morris if (!dev) 44657198f8ceSThomas Graf return -ENODEV; 4466081bba5bSNoriaki TAKAMIYA 4467479840ffSJiri Pirko ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags; 4468479840ffSJiri Pirko 446955ebaef1SNoriaki TAKAMIYA /* We ignore other flags so far. */ 4470761aac73SThomas Haller ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR | 447193a714d6SMadhu Challa IFA_F_NOPREFIXROUTE | IFA_F_MCAUTOJOIN; 447255ebaef1SNoriaki TAKAMIYA 44731cab3da6SDaniel Lezcano ifa = ipv6_get_ifaddr(net, pfx, dev, 1); 447463159f29SIan Morris if (!ifa) { 44757198f8ceSThomas Graf /* 44767198f8ceSThomas Graf * It would be best to check for !NLM_F_CREATE here but 4477db9c7c39Sstephen hemminger * userspace already relies on not having to provide this. 44787198f8ceSThomas Graf */ 4479caeaba79SNicolas Dichtel return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx, 4480af284937SDaniel Lezcano ifm->ifa_prefixlen, ifa_flags, 4481af284937SDaniel Lezcano preferred_lft, valid_lft); 44821da177e4SLinus Torvalds } 44831da177e4SLinus Torvalds 44847198f8ceSThomas Graf if (nlh->nlmsg_flags & NLM_F_EXCL || 44857198f8ceSThomas Graf !(nlh->nlmsg_flags & NLM_F_REPLACE)) 44867198f8ceSThomas Graf err = -EEXIST; 44877198f8ceSThomas Graf else 448855ebaef1SNoriaki TAKAMIYA err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft); 44897198f8ceSThomas Graf 44907198f8ceSThomas Graf in6_ifa_put(ifa); 44917198f8ceSThomas Graf 44927198f8ceSThomas Graf return err; 44937198f8ceSThomas Graf } 44947198f8ceSThomas Graf 4495479840ffSJiri Pirko static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags, 4496101bb229SThomas Graf u8 scope, int ifindex) 4497101bb229SThomas Graf { 4498101bb229SThomas Graf struct ifaddrmsg *ifm; 4499101bb229SThomas Graf 4500101bb229SThomas Graf ifm = nlmsg_data(nlh); 4501101bb229SThomas Graf ifm->ifa_family = AF_INET6; 4502101bb229SThomas Graf ifm->ifa_prefixlen = prefixlen; 4503101bb229SThomas Graf ifm->ifa_flags = flags; 4504101bb229SThomas Graf ifm->ifa_scope = scope; 4505101bb229SThomas Graf ifm->ifa_index = ifindex; 4506101bb229SThomas Graf } 4507101bb229SThomas Graf 450885486af0SThomas Graf static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp, 450985486af0SThomas Graf unsigned long tstamp, u32 preferred, u32 valid) 451085486af0SThomas Graf { 451185486af0SThomas Graf struct ifa_cacheinfo ci; 451285486af0SThomas Graf 451318a31e1eSThomas Graf ci.cstamp = cstamp_delta(cstamp); 451418a31e1eSThomas Graf ci.tstamp = cstamp_delta(tstamp); 451585486af0SThomas Graf ci.ifa_prefered = preferred; 451685486af0SThomas Graf ci.ifa_valid = valid; 451785486af0SThomas Graf 451885486af0SThomas Graf return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci); 451985486af0SThomas Graf } 452085486af0SThomas Graf 4521101bb229SThomas Graf static inline int rt_scope(int ifa_scope) 4522101bb229SThomas Graf { 4523101bb229SThomas Graf if (ifa_scope & IFA_HOST) 4524101bb229SThomas Graf return RT_SCOPE_HOST; 4525101bb229SThomas Graf else if (ifa_scope & IFA_LINK) 4526101bb229SThomas Graf return RT_SCOPE_LINK; 4527101bb229SThomas Graf else if (ifa_scope & IFA_SITE) 4528101bb229SThomas Graf return RT_SCOPE_SITE; 4529101bb229SThomas Graf else 4530101bb229SThomas Graf return RT_SCOPE_UNIVERSE; 4531101bb229SThomas Graf } 4532101bb229SThomas Graf 45330ab6803bSThomas Graf static inline int inet6_ifaddr_msgsize(void) 45340ab6803bSThomas Graf { 4535339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 4536caeaba79SNicolas Dichtel + nla_total_size(16) /* IFA_LOCAL */ 4537339bf98fSThomas Graf + nla_total_size(16) /* IFA_ADDRESS */ 4538479840ffSJiri Pirko + nla_total_size(sizeof(struct ifa_cacheinfo)) 4539479840ffSJiri Pirko + nla_total_size(4) /* IFA_FLAGS */; 45400ab6803bSThomas Graf } 4541c5396a31SYOSHIFUJI Hideaki 45421da177e4SLinus Torvalds static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa, 454315e47304SEric W. Biederman u32 portid, u32 seq, int event, unsigned int flags) 45441da177e4SLinus Torvalds { 45451da177e4SLinus Torvalds struct nlmsghdr *nlh; 454685486af0SThomas Graf u32 preferred, valid; 45471da177e4SLinus Torvalds 454815e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags); 454963159f29SIan Morris if (!nlh) 455026932566SPatrick McHardy return -EMSGSIZE; 45510ab6803bSThomas Graf 4552101bb229SThomas Graf put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope), 4553101bb229SThomas Graf ifa->idev->dev->ifindex); 4554101bb229SThomas Graf 4555fad8da3eSYasushi Asano if (!((ifa->flags&IFA_F_PERMANENT) && 4556fad8da3eSYasushi Asano (ifa->prefered_lft == INFINITY_LIFE_TIME))) { 455785486af0SThomas Graf preferred = ifa->prefered_lft; 455885486af0SThomas Graf valid = ifa->valid_lft; 455985486af0SThomas Graf if (preferred != INFINITY_LIFE_TIME) { 45601da177e4SLinus Torvalds long tval = (jiffies - ifa->tstamp)/HZ; 4561a1faa698SJens Rosenboom if (preferred > tval) 456285486af0SThomas Graf preferred -= tval; 4563a1faa698SJens Rosenboom else 4564a1faa698SJens Rosenboom preferred = 0; 4565f56619fcSBen Hutchings if (valid != INFINITY_LIFE_TIME) { 4566f56619fcSBen Hutchings if (valid > tval) 456785486af0SThomas Graf valid -= tval; 4568f56619fcSBen Hutchings else 4569f56619fcSBen Hutchings valid = 0; 4570f56619fcSBen Hutchings } 45711da177e4SLinus Torvalds } 45721da177e4SLinus Torvalds } else { 457385486af0SThomas Graf preferred = INFINITY_LIFE_TIME; 457485486af0SThomas Graf valid = INFINITY_LIFE_TIME; 45751da177e4SLinus Torvalds } 457685486af0SThomas Graf 45777996c799SCong Wang if (!ipv6_addr_any(&ifa->peer_addr)) { 4578930345eaSJiri Benc if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 || 4579930345eaSJiri Benc nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->peer_addr) < 0) 4580caeaba79SNicolas Dichtel goto error; 4581caeaba79SNicolas Dichtel } else 4582930345eaSJiri Benc if (nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->addr) < 0) 4583caeaba79SNicolas Dichtel goto error; 4584caeaba79SNicolas Dichtel 4585caeaba79SNicolas Dichtel if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0) 4586caeaba79SNicolas Dichtel goto error; 458785486af0SThomas Graf 4588479840ffSJiri Pirko if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0) 4589479840ffSJiri Pirko goto error; 4590479840ffSJiri Pirko 4591053c095aSJohannes Berg nlmsg_end(skb, nlh); 4592053c095aSJohannes Berg return 0; 4593caeaba79SNicolas Dichtel 4594caeaba79SNicolas Dichtel error: 4595caeaba79SNicolas Dichtel nlmsg_cancel(skb, nlh); 4596caeaba79SNicolas Dichtel return -EMSGSIZE; 45971da177e4SLinus Torvalds } 45981da177e4SLinus Torvalds 45991da177e4SLinus Torvalds static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca, 460015e47304SEric W. Biederman u32 portid, u32 seq, int event, u16 flags) 46011da177e4SLinus Torvalds { 46021da177e4SLinus Torvalds struct nlmsghdr *nlh; 4603101bb229SThomas Graf u8 scope = RT_SCOPE_UNIVERSE; 4604101bb229SThomas Graf int ifindex = ifmca->idev->dev->ifindex; 46051da177e4SLinus Torvalds 46061da177e4SLinus Torvalds if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE) 4607101bb229SThomas Graf scope = RT_SCOPE_SITE; 4608101bb229SThomas Graf 460915e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags); 461063159f29SIan Morris if (!nlh) 461126932566SPatrick McHardy return -EMSGSIZE; 46120ab6803bSThomas Graf 4613101bb229SThomas Graf put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex); 4614930345eaSJiri Benc if (nla_put_in6_addr(skb, IFA_MULTICAST, &ifmca->mca_addr) < 0 || 46150ab6803bSThomas Graf put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp, 461626932566SPatrick McHardy INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) { 461726932566SPatrick McHardy nlmsg_cancel(skb, nlh); 461826932566SPatrick McHardy return -EMSGSIZE; 461926932566SPatrick McHardy } 462085486af0SThomas Graf 4621053c095aSJohannes Berg nlmsg_end(skb, nlh); 4622053c095aSJohannes Berg return 0; 46231da177e4SLinus Torvalds } 46241da177e4SLinus Torvalds 46251da177e4SLinus Torvalds static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca, 462615e47304SEric W. Biederman u32 portid, u32 seq, int event, unsigned int flags) 46271da177e4SLinus Torvalds { 46281da177e4SLinus Torvalds struct nlmsghdr *nlh; 4629101bb229SThomas Graf u8 scope = RT_SCOPE_UNIVERSE; 4630101bb229SThomas Graf int ifindex = ifaca->aca_idev->dev->ifindex; 46311da177e4SLinus Torvalds 46321da177e4SLinus Torvalds if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE) 4633101bb229SThomas Graf scope = RT_SCOPE_SITE; 4634101bb229SThomas Graf 463515e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags); 463663159f29SIan Morris if (!nlh) 463726932566SPatrick McHardy return -EMSGSIZE; 46380ab6803bSThomas Graf 4639101bb229SThomas Graf put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex); 4640930345eaSJiri Benc if (nla_put_in6_addr(skb, IFA_ANYCAST, &ifaca->aca_addr) < 0 || 46410ab6803bSThomas Graf put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp, 464226932566SPatrick McHardy INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) { 464326932566SPatrick McHardy nlmsg_cancel(skb, nlh); 464426932566SPatrick McHardy return -EMSGSIZE; 464526932566SPatrick McHardy } 464685486af0SThomas Graf 4647053c095aSJohannes Berg nlmsg_end(skb, nlh); 4648053c095aSJohannes Berg return 0; 46491da177e4SLinus Torvalds } 46501da177e4SLinus Torvalds 4651e21e8467SStephen Hemminger enum addr_type_t { 46521da177e4SLinus Torvalds UNICAST_ADDR, 46531da177e4SLinus Torvalds MULTICAST_ADDR, 46541da177e4SLinus Torvalds ANYCAST_ADDR, 46551da177e4SLinus Torvalds }; 46561da177e4SLinus Torvalds 4657234b27c3SEric Dumazet /* called with rcu_read_lock() */ 4658234b27c3SEric Dumazet static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb, 4659234b27c3SEric Dumazet struct netlink_callback *cb, enum addr_type_t type, 4660234b27c3SEric Dumazet int s_ip_idx, int *p_ip_idx) 46611da177e4SLinus Torvalds { 46621da177e4SLinus Torvalds struct ifmcaddr6 *ifmca; 46631da177e4SLinus Torvalds struct ifacaddr6 *ifaca; 4664234b27c3SEric Dumazet int err = 1; 4665234b27c3SEric Dumazet int ip_idx = *p_ip_idx; 46661da177e4SLinus Torvalds 46671da177e4SLinus Torvalds read_lock_bh(&idev->lock); 46681da177e4SLinus Torvalds switch (type) { 4669502a2ffdSstephen hemminger case UNICAST_ADDR: { 4670502a2ffdSstephen hemminger struct inet6_ifaddr *ifa; 4671502a2ffdSstephen hemminger 4672ae9cda5dSYOSHIFUJI Hideaki /* unicast address incl. temp addr */ 4673502a2ffdSstephen hemminger list_for_each_entry(ifa, &idev->addr_list, if_list) { 4674502a2ffdSstephen hemminger if (++ip_idx < s_ip_idx) 46751da177e4SLinus Torvalds continue; 46765d5619b4SYOSHIFUJI Hideaki err = inet6_fill_ifaddr(skb, ifa, 467715e47304SEric W. Biederman NETLINK_CB(cb->skb).portid, 46785d5619b4SYOSHIFUJI Hideaki cb->nlh->nlmsg_seq, 46795d5619b4SYOSHIFUJI Hideaki RTM_NEWADDR, 46805d5619b4SYOSHIFUJI Hideaki NLM_F_MULTI); 4681053c095aSJohannes Berg if (err < 0) 4682bcd32326SEric Dumazet break; 468363998ac2SNicolas Dichtel nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 46841da177e4SLinus Torvalds } 46851da177e4SLinus Torvalds break; 4686502a2ffdSstephen hemminger } 46871da177e4SLinus Torvalds case MULTICAST_ADDR: 46881da177e4SLinus Torvalds /* multicast address */ 46891da177e4SLinus Torvalds for (ifmca = idev->mc_list; ifmca; 46901da177e4SLinus Torvalds ifmca = ifmca->next, ip_idx++) { 46911da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 46921da177e4SLinus Torvalds continue; 46935d5619b4SYOSHIFUJI Hideaki err = inet6_fill_ifmcaddr(skb, ifmca, 469415e47304SEric W. Biederman NETLINK_CB(cb->skb).portid, 46955d5619b4SYOSHIFUJI Hideaki cb->nlh->nlmsg_seq, 46965d5619b4SYOSHIFUJI Hideaki RTM_GETMULTICAST, 46975d5619b4SYOSHIFUJI Hideaki NLM_F_MULTI); 4698053c095aSJohannes Berg if (err < 0) 4699bcd32326SEric Dumazet break; 47001da177e4SLinus Torvalds } 47011da177e4SLinus Torvalds break; 47021da177e4SLinus Torvalds case ANYCAST_ADDR: 47031da177e4SLinus Torvalds /* anycast address */ 47041da177e4SLinus Torvalds for (ifaca = idev->ac_list; ifaca; 47051da177e4SLinus Torvalds ifaca = ifaca->aca_next, ip_idx++) { 47061da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 47071da177e4SLinus Torvalds continue; 47085d5619b4SYOSHIFUJI Hideaki err = inet6_fill_ifacaddr(skb, ifaca, 470915e47304SEric W. Biederman NETLINK_CB(cb->skb).portid, 47105d5619b4SYOSHIFUJI Hideaki cb->nlh->nlmsg_seq, 47115d5619b4SYOSHIFUJI Hideaki RTM_GETANYCAST, 47125d5619b4SYOSHIFUJI Hideaki NLM_F_MULTI); 4713053c095aSJohannes Berg if (err < 0) 4714bcd32326SEric Dumazet break; 47151da177e4SLinus Torvalds } 47161da177e4SLinus Torvalds break; 47171da177e4SLinus Torvalds default: 47181da177e4SLinus Torvalds break; 47191da177e4SLinus Torvalds } 47201da177e4SLinus Torvalds read_unlock_bh(&idev->lock); 4721234b27c3SEric Dumazet *p_ip_idx = ip_idx; 4722234b27c3SEric Dumazet return err; 4723234b27c3SEric Dumazet } 47245d5619b4SYOSHIFUJI Hideaki 4725234b27c3SEric Dumazet static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb, 4726234b27c3SEric Dumazet enum addr_type_t type) 4727234b27c3SEric Dumazet { 4728234b27c3SEric Dumazet struct net *net = sock_net(skb->sk); 4729234b27c3SEric Dumazet int h, s_h; 4730234b27c3SEric Dumazet int idx, ip_idx; 4731234b27c3SEric Dumazet int s_idx, s_ip_idx; 4732234b27c3SEric Dumazet struct net_device *dev; 4733234b27c3SEric Dumazet struct inet6_dev *idev; 4734234b27c3SEric Dumazet struct hlist_head *head; 4735234b27c3SEric Dumazet 4736234b27c3SEric Dumazet s_h = cb->args[0]; 4737234b27c3SEric Dumazet s_idx = idx = cb->args[1]; 4738234b27c3SEric Dumazet s_ip_idx = ip_idx = cb->args[2]; 4739234b27c3SEric Dumazet 4740234b27c3SEric Dumazet rcu_read_lock(); 474163998ac2SNicolas Dichtel cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq; 4742234b27c3SEric Dumazet for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 4743234b27c3SEric Dumazet idx = 0; 4744234b27c3SEric Dumazet head = &net->dev_index_head[h]; 4745b67bfe0dSSasha Levin hlist_for_each_entry_rcu(dev, head, index_hlist) { 4746234b27c3SEric Dumazet if (idx < s_idx) 4747234b27c3SEric Dumazet goto cont; 47484b97efdfSPatrick McHardy if (h > s_h || idx > s_idx) 4749234b27c3SEric Dumazet s_ip_idx = 0; 4750234b27c3SEric Dumazet ip_idx = 0; 4751e21e8467SStephen Hemminger idev = __in6_dev_get(dev); 4752e21e8467SStephen Hemminger if (!idev) 4753234b27c3SEric Dumazet goto cont; 4754234b27c3SEric Dumazet 4755234b27c3SEric Dumazet if (in6_dump_addrs(idev, skb, cb, type, 47567b46a644SDavid S. Miller s_ip_idx, &ip_idx) < 0) 4757234b27c3SEric Dumazet goto done; 47587562f876SPavel Emelianov cont: 47597562f876SPavel Emelianov idx++; 47601da177e4SLinus Torvalds } 4761234b27c3SEric Dumazet } 4762234b27c3SEric Dumazet done: 4763234b27c3SEric Dumazet rcu_read_unlock(); 4764234b27c3SEric Dumazet cb->args[0] = h; 4765234b27c3SEric Dumazet cb->args[1] = idx; 4766234b27c3SEric Dumazet cb->args[2] = ip_idx; 4767234b27c3SEric Dumazet 47681da177e4SLinus Torvalds return skb->len; 47691da177e4SLinus Torvalds } 47701da177e4SLinus Torvalds 47711da177e4SLinus Torvalds static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 47721da177e4SLinus Torvalds { 47731da177e4SLinus Torvalds enum addr_type_t type = UNICAST_ADDR; 4774b854272bSDenis V. Lunev 47751da177e4SLinus Torvalds return inet6_dump_addr(skb, cb, type); 47761da177e4SLinus Torvalds } 47771da177e4SLinus Torvalds 47781da177e4SLinus Torvalds static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb) 47791da177e4SLinus Torvalds { 47801da177e4SLinus Torvalds enum addr_type_t type = MULTICAST_ADDR; 4781b854272bSDenis V. Lunev 47821da177e4SLinus Torvalds return inet6_dump_addr(skb, cb, type); 47831da177e4SLinus Torvalds } 47841da177e4SLinus Torvalds 47851da177e4SLinus Torvalds 47861da177e4SLinus Torvalds static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb) 47871da177e4SLinus Torvalds { 47881da177e4SLinus Torvalds enum addr_type_t type = ANYCAST_ADDR; 4789b854272bSDenis V. Lunev 47901da177e4SLinus Torvalds return inet6_dump_addr(skb, cb, type); 47911da177e4SLinus Torvalds } 47921da177e4SLinus Torvalds 4793661d2967SThomas Graf static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh) 47946c223828SNoriaki TAKAMIYA { 47953b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(in_skb->sk); 47961b29fc2cSThomas Graf struct ifaddrmsg *ifm; 47971b29fc2cSThomas Graf struct nlattr *tb[IFA_MAX+1]; 4798caeaba79SNicolas Dichtel struct in6_addr *addr = NULL, *peer; 47996c223828SNoriaki TAKAMIYA struct net_device *dev = NULL; 48006c223828SNoriaki TAKAMIYA struct inet6_ifaddr *ifa; 48016c223828SNoriaki TAKAMIYA struct sk_buff *skb; 48026c223828SNoriaki TAKAMIYA int err; 48036c223828SNoriaki TAKAMIYA 48041b29fc2cSThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 48051b29fc2cSThomas Graf if (err < 0) 48061b29fc2cSThomas Graf goto errout; 48076c223828SNoriaki TAKAMIYA 4808caeaba79SNicolas Dichtel addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer); 480963159f29SIan Morris if (!addr) { 48101b29fc2cSThomas Graf err = -EINVAL; 48111b29fc2cSThomas Graf goto errout; 48121b29fc2cSThomas Graf } 48131b29fc2cSThomas Graf 48141b29fc2cSThomas Graf ifm = nlmsg_data(nlh); 48156c223828SNoriaki TAKAMIYA if (ifm->ifa_index) 48166fda7350SBenjamin Thery dev = __dev_get_by_index(net, ifm->ifa_index); 48176c223828SNoriaki TAKAMIYA 4818e21e8467SStephen Hemminger ifa = ipv6_get_ifaddr(net, addr, dev, 1); 4819e21e8467SStephen Hemminger if (!ifa) { 48201b29fc2cSThomas Graf err = -EADDRNOTAVAIL; 48211b29fc2cSThomas Graf goto errout; 48226c223828SNoriaki TAKAMIYA } 48236c223828SNoriaki TAKAMIYA 4824e21e8467SStephen Hemminger skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL); 4825e21e8467SStephen Hemminger if (!skb) { 48261b29fc2cSThomas Graf err = -ENOBUFS; 48271b29fc2cSThomas Graf goto errout_ifa; 48281b29fc2cSThomas Graf } 48291b29fc2cSThomas Graf 483015e47304SEric W. Biederman err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid, 48316c223828SNoriaki TAKAMIYA nlh->nlmsg_seq, RTM_NEWADDR, 0); 483226932566SPatrick McHardy if (err < 0) { 483326932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */ 483426932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 483526932566SPatrick McHardy kfree_skb(skb); 483626932566SPatrick McHardy goto errout_ifa; 483726932566SPatrick McHardy } 483815e47304SEric W. Biederman err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 48391b29fc2cSThomas Graf errout_ifa: 48406c223828SNoriaki TAKAMIYA in6_ifa_put(ifa); 48411b29fc2cSThomas Graf errout: 48426c223828SNoriaki TAKAMIYA return err; 48436c223828SNoriaki TAKAMIYA } 48446c223828SNoriaki TAKAMIYA 48451da177e4SLinus Torvalds static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa) 48461da177e4SLinus Torvalds { 48471da177e4SLinus Torvalds struct sk_buff *skb; 4848c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(ifa->idev->dev); 48495d620266SThomas Graf int err = -ENOBUFS; 48501da177e4SLinus Torvalds 48510ab6803bSThomas Graf skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC); 485263159f29SIan Morris if (!skb) 48535d620266SThomas Graf goto errout; 48545d620266SThomas Graf 48555d620266SThomas Graf err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0); 485626932566SPatrick McHardy if (err < 0) { 485726932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */ 485826932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 485926932566SPatrick McHardy kfree_skb(skb); 486026932566SPatrick McHardy goto errout; 486126932566SPatrick McHardy } 48621ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC); 48631ce85fe4SPablo Neira Ayuso return; 48645d620266SThomas Graf errout: 48655d620266SThomas Graf if (err < 0) 48666fda7350SBenjamin Thery rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err); 48671da177e4SLinus Torvalds } 48681da177e4SLinus Torvalds 4869b6f99a21SDave Jones static inline void ipv6_store_devconf(struct ipv6_devconf *cnf, 48701da177e4SLinus Torvalds __s32 *array, int bytes) 48711da177e4SLinus Torvalds { 487204561c1fSThomas Graf BUG_ON(bytes < (DEVCONF_MAX * 4)); 487304561c1fSThomas Graf 48741da177e4SLinus Torvalds memset(array, 0, bytes); 48751da177e4SLinus Torvalds array[DEVCONF_FORWARDING] = cnf->forwarding; 48761da177e4SLinus Torvalds array[DEVCONF_HOPLIMIT] = cnf->hop_limit; 48771da177e4SLinus Torvalds array[DEVCONF_MTU6] = cnf->mtu6; 48781da177e4SLinus Torvalds array[DEVCONF_ACCEPT_RA] = cnf->accept_ra; 48791da177e4SLinus Torvalds array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects; 48801da177e4SLinus Torvalds array[DEVCONF_AUTOCONF] = cnf->autoconf; 48811da177e4SLinus Torvalds array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits; 48821da177e4SLinus Torvalds array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits; 488393908d19SThomas Graf array[DEVCONF_RTR_SOLICIT_INTERVAL] = 488493908d19SThomas Graf jiffies_to_msecs(cnf->rtr_solicit_interval); 488593908d19SThomas Graf array[DEVCONF_RTR_SOLICIT_DELAY] = 488693908d19SThomas Graf jiffies_to_msecs(cnf->rtr_solicit_delay); 48871da177e4SLinus Torvalds array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version; 4888fc4eba58SHannes Frederic Sowa array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] = 4889fc4eba58SHannes Frederic Sowa jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval); 4890fc4eba58SHannes Frederic Sowa array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] = 4891fc4eba58SHannes Frederic Sowa jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval); 48921da177e4SLinus Torvalds array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr; 48931da177e4SLinus Torvalds array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft; 48941da177e4SLinus Torvalds array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft; 48951da177e4SLinus Torvalds array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry; 48961da177e4SLinus Torvalds array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor; 48971da177e4SLinus Torvalds array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses; 489865f5c7c1SYOSHIFUJI Hideaki array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr; 48998013d1d7SHangbin Liu array[DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT] = cnf->accept_ra_min_hop_limit; 4900c4fd30ebSYOSHIFUJI Hideaki array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo; 4901930d6ff2SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 4902930d6ff2SYOSHIFUJI Hideaki array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref; 490393908d19SThomas Graf array[DEVCONF_RTR_PROBE_INTERVAL] = 490493908d19SThomas Graf jiffies_to_msecs(cnf->rtr_probe_interval); 4905fa03ef38SNeil Horman #ifdef CONFIG_IPV6_ROUTE_INFO 490609c884d4SYOSHIFUJI Hideaki array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen; 490709c884d4SYOSHIFUJI Hideaki #endif 4908930d6ff2SYOSHIFUJI Hideaki #endif 4909fbea49e1SYOSHIFUJI Hideaki array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp; 49100bcbc926SYOSHIFUJI Hideaki array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route; 491195c385b4SNeil Horman #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 491295c385b4SNeil Horman array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad; 49137fd2561eSErik Kline array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic; 491495c385b4SNeil Horman #endif 49157bc570c8SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_MROUTE 49167bc570c8SYOSHIFUJI Hideaki array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding; 49177bc570c8SYOSHIFUJI Hideaki #endif 4918778d80beSYOSHIFUJI Hideaki array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6; 49191b34be74SYOSHIFUJI Hideaki array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad; 4920c3faca05SCosmin Ratiu array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao; 49215cb04436SHannes Frederic Sowa array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify; 4922b800c3b9SHannes Frederic Sowa array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc; 4923d9333196SBen Greear array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local; 4924c2943f14SHarout Hedeshian array[DEVCONF_ACCEPT_RA_MTU] = cnf->accept_ra_mtu; 492535103d11SAndy Gospodarek array[DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN] = cnf->ignore_routes_with_linkdown; 49263d1bec99SHannes Frederic Sowa /* we omit DEVCONF_STABLE_SECRET for now */ 49273985e8a3SErik Kline array[DEVCONF_USE_OIF_ADDRS_ONLY] = cnf->use_oif_addrs_only; 4928abbc3043SJohannes Berg array[DEVCONF_DROP_UNICAST_IN_L2_MULTICAST] = cnf->drop_unicast_in_l2_multicast; 49297a02bf89SJohannes Berg array[DEVCONF_DROP_UNSOLICITED_NA] = cnf->drop_unsolicited_na; 4930f1705ec1SDavid Ahern array[DEVCONF_KEEP_ADDR_ON_DOWN] = cnf->keep_addr_on_down; 49311da177e4SLinus Torvalds } 49321da177e4SLinus Torvalds 4933b382b191SThomas Graf static inline size_t inet6_ifla6_size(void) 4934b382b191SThomas Graf { 4935b382b191SThomas Graf return nla_total_size(4) /* IFLA_INET6_FLAGS */ 4936b382b191SThomas Graf + nla_total_size(sizeof(struct ifla_cacheinfo)) 4937b382b191SThomas Graf + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */ 4938b382b191SThomas Graf + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */ 4939f53adae4SDaniel Borkmann + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */ 4940f53adae4SDaniel Borkmann + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */ 4941b382b191SThomas Graf } 4942b382b191SThomas Graf 4943339bf98fSThomas Graf static inline size_t inet6_if_nlmsg_size(void) 4944339bf98fSThomas Graf { 4945339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 4946339bf98fSThomas Graf + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 4947339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 4948339bf98fSThomas Graf + nla_total_size(4) /* IFLA_MTU */ 4949339bf98fSThomas Graf + nla_total_size(4) /* IFLA_LINK */ 49500344338bSAndy Gospodarek + nla_total_size(1) /* IFLA_OPERSTATE */ 4951b382b191SThomas Graf + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */ 4952339bf98fSThomas Graf } 4953c5396a31SYOSHIFUJI Hideaki 4954be281e55SEric Dumazet static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib, 49557d720c3eSTejun Heo int items, int bytes) 49567f7d9a6bSHerbert Xu { 49577f7d9a6bSHerbert Xu int i; 49587f7d9a6bSHerbert Xu int pad = bytes - sizeof(u64) * items; 49597f7d9a6bSHerbert Xu BUG_ON(pad < 0); 49607f7d9a6bSHerbert Xu 49617f7d9a6bSHerbert Xu /* Use put_unaligned() because stats may not be aligned for u64. */ 49627f7d9a6bSHerbert Xu put_unaligned(items, &stats[0]); 49637f7d9a6bSHerbert Xu for (i = 1; i < items; i++) 4964be281e55SEric Dumazet put_unaligned(atomic_long_read(&mib[i]), &stats[i]); 49657f7d9a6bSHerbert Xu 49667f7d9a6bSHerbert Xu memset(&stats[items], 0, pad); 49677f7d9a6bSHerbert Xu } 49687f7d9a6bSHerbert Xu 4969698365faSWANG Cong static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib, 4970a3a77372SRaghavendra K T int bytes, size_t syncpoff) 49714ce3c183SEric Dumazet { 4972a3a77372SRaghavendra K T int i, c; 4973a3a77372SRaghavendra K T u64 buff[IPSTATS_MIB_MAX]; 4974a3a77372SRaghavendra K T int pad = bytes - sizeof(u64) * IPSTATS_MIB_MAX; 4975a3a77372SRaghavendra K T 49764ce3c183SEric Dumazet BUG_ON(pad < 0); 49774ce3c183SEric Dumazet 4978a3a77372SRaghavendra K T memset(buff, 0, sizeof(buff)); 4979a3a77372SRaghavendra K T buff[0] = IPSTATS_MIB_MAX; 49804ce3c183SEric Dumazet 4981a3a77372SRaghavendra K T for_each_possible_cpu(c) { 4982a3a77372SRaghavendra K T for (i = 1; i < IPSTATS_MIB_MAX; i++) 4983a3a77372SRaghavendra K T buff[i] += snmp_get_cpu_field64(mib, c, i, syncpoff); 4984a3a77372SRaghavendra K T } 4985a3a77372SRaghavendra K T 4986a3a77372SRaghavendra K T memcpy(stats, buff, IPSTATS_MIB_MAX * sizeof(u64)); 4987a3a77372SRaghavendra K T memset(&stats[IPSTATS_MIB_MAX], 0, pad); 49884ce3c183SEric Dumazet } 49894ce3c183SEric Dumazet 49907f7d9a6bSHerbert Xu static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype, 49917f7d9a6bSHerbert Xu int bytes) 49927f7d9a6bSHerbert Xu { 49937f7d9a6bSHerbert Xu switch (attrtype) { 49947f7d9a6bSHerbert Xu case IFLA_INET6_STATS: 4995a3a77372SRaghavendra K T __snmp6_fill_stats64(stats, idev->stats.ipv6, bytes, 4996a3a77372SRaghavendra K T offsetof(struct ipstats_mib, syncp)); 49977f7d9a6bSHerbert Xu break; 49987f7d9a6bSHerbert Xu case IFLA_INET6_ICMP6STATS: 4999be281e55SEric Dumazet __snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes); 50007f7d9a6bSHerbert Xu break; 50017f7d9a6bSHerbert Xu } 50027f7d9a6bSHerbert Xu } 50037f7d9a6bSHerbert Xu 5004d5566fd7SSowmini Varadhan static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev, 5005d5566fd7SSowmini Varadhan u32 ext_filter_mask) 50061da177e4SLinus Torvalds { 5007bf99f1bdSYOSHIFUJI Hideaki struct nlattr *nla; 50081da177e4SLinus Torvalds struct ifla_cacheinfo ci; 50091da177e4SLinus Torvalds 5010c78679e8SDavid S. Miller if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags)) 5011c78679e8SDavid S. Miller goto nla_put_failure; 50121da177e4SLinus Torvalds ci.max_reasm_len = IPV6_MAXPLEN; 501324912420SDavid S. Miller ci.tstamp = cstamp_delta(idev->tstamp); 501424912420SDavid S. Miller ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time); 50151f9248e5SJiri Pirko ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME)); 5016c78679e8SDavid S. Miller if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci)) 5017c78679e8SDavid S. Miller goto nla_put_failure; 5018bf99f1bdSYOSHIFUJI Hideaki nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32)); 501963159f29SIan Morris if (!nla) 502004561c1fSThomas Graf goto nla_put_failure; 5021bf99f1bdSYOSHIFUJI Hideaki ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla)); 50221da177e4SLinus Torvalds 5023bf99f1bdSYOSHIFUJI Hideaki /* XXX - MC not implemented */ 5024bf99f1bdSYOSHIFUJI Hideaki 5025d5566fd7SSowmini Varadhan if (ext_filter_mask & RTEXT_FILTER_SKIP_STATS) 5026d5566fd7SSowmini Varadhan return 0; 5027d5566fd7SSowmini Varadhan 5028bf99f1bdSYOSHIFUJI Hideaki nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64)); 502963159f29SIan Morris if (!nla) 5030bf99f1bdSYOSHIFUJI Hideaki goto nla_put_failure; 5031bf99f1bdSYOSHIFUJI Hideaki snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla)); 5032bf99f1bdSYOSHIFUJI Hideaki 5033bf99f1bdSYOSHIFUJI Hideaki nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64)); 503463159f29SIan Morris if (!nla) 5035bf99f1bdSYOSHIFUJI Hideaki goto nla_put_failure; 5036bf99f1bdSYOSHIFUJI Hideaki snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla)); 50371da177e4SLinus Torvalds 5038f53adae4SDaniel Borkmann nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr)); 503963159f29SIan Morris if (!nla) 5040f53adae4SDaniel Borkmann goto nla_put_failure; 5041bc91b0f0SJiri Pirko 5042bc91b0f0SJiri Pirko if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->addr_gen_mode)) 5043bc91b0f0SJiri Pirko goto nla_put_failure; 5044bc91b0f0SJiri Pirko 5045f53adae4SDaniel Borkmann read_lock_bh(&idev->lock); 5046f53adae4SDaniel Borkmann memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla)); 5047f53adae4SDaniel Borkmann read_unlock_bh(&idev->lock); 5048f53adae4SDaniel Borkmann 5049b382b191SThomas Graf return 0; 5050b382b191SThomas Graf 5051b382b191SThomas Graf nla_put_failure: 5052b382b191SThomas Graf return -EMSGSIZE; 5053b382b191SThomas Graf } 5054b382b191SThomas Graf 5055b1974ed0SArad, Ronen static size_t inet6_get_link_af_size(const struct net_device *dev, 5056b1974ed0SArad, Ronen u32 ext_filter_mask) 5057b382b191SThomas Graf { 5058b382b191SThomas Graf if (!__in6_dev_get(dev)) 5059b382b191SThomas Graf return 0; 5060b382b191SThomas Graf 5061b382b191SThomas Graf return inet6_ifla6_size(); 5062b382b191SThomas Graf } 5063b382b191SThomas Graf 5064d5566fd7SSowmini Varadhan static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev, 5065d5566fd7SSowmini Varadhan u32 ext_filter_mask) 5066b382b191SThomas Graf { 5067b382b191SThomas Graf struct inet6_dev *idev = __in6_dev_get(dev); 5068b382b191SThomas Graf 5069b382b191SThomas Graf if (!idev) 5070b382b191SThomas Graf return -ENODATA; 5071b382b191SThomas Graf 5072d5566fd7SSowmini Varadhan if (inet6_fill_ifla6_attrs(skb, idev, ext_filter_mask) < 0) 5073b382b191SThomas Graf return -EMSGSIZE; 5074b382b191SThomas Graf 5075b382b191SThomas Graf return 0; 5076b382b191SThomas Graf } 5077b382b191SThomas Graf 5078f53adae4SDaniel Borkmann static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token) 5079f53adae4SDaniel Borkmann { 5080f53adae4SDaniel Borkmann struct inet6_ifaddr *ifp; 5081f53adae4SDaniel Borkmann struct net_device *dev = idev->dev; 508247e27d5eSDaniel Borkmann bool clear_token, update_rs = false; 5083dc848292SHannes Frederic Sowa struct in6_addr ll_addr; 5084f53adae4SDaniel Borkmann 5085c15b1ccaSHannes Frederic Sowa ASSERT_RTNL(); 5086c15b1ccaSHannes Frederic Sowa 508763159f29SIan Morris if (!token) 5088f53adae4SDaniel Borkmann return -EINVAL; 5089f53adae4SDaniel Borkmann if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) 5090f53adae4SDaniel Borkmann return -EINVAL; 5091f53adae4SDaniel Borkmann if (!ipv6_accept_ra(idev)) 5092f53adae4SDaniel Borkmann return -EINVAL; 5093f53adae4SDaniel Borkmann if (idev->cnf.rtr_solicits <= 0) 5094f53adae4SDaniel Borkmann return -EINVAL; 5095f53adae4SDaniel Borkmann 5096f53adae4SDaniel Borkmann write_lock_bh(&idev->lock); 5097f53adae4SDaniel Borkmann 5098f53adae4SDaniel Borkmann BUILD_BUG_ON(sizeof(token->s6_addr) != 16); 5099f53adae4SDaniel Borkmann memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8); 5100f53adae4SDaniel Borkmann 5101f53adae4SDaniel Borkmann write_unlock_bh(&idev->lock); 5102f53adae4SDaniel Borkmann 510347e27d5eSDaniel Borkmann clear_token = ipv6_addr_any(token); 510447e27d5eSDaniel Borkmann if (clear_token) 510547e27d5eSDaniel Borkmann goto update_lft; 510647e27d5eSDaniel Borkmann 5107dc848292SHannes Frederic Sowa if (!idev->dead && (idev->if_flags & IF_READY) && 5108dc848292SHannes Frederic Sowa !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE | 5109dc848292SHannes Frederic Sowa IFA_F_OPTIMISTIC)) { 5110fc403832SDaniel Borkmann /* If we're not ready, then normal ifup will take care 5111fc403832SDaniel Borkmann * of this. Otherwise, we need to request our rs here. 5112fc403832SDaniel Borkmann */ 5113f53adae4SDaniel Borkmann ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters); 5114fc403832SDaniel Borkmann update_rs = true; 5115fc403832SDaniel Borkmann } 5116f53adae4SDaniel Borkmann 511747e27d5eSDaniel Borkmann update_lft: 5118f53adae4SDaniel Borkmann write_lock_bh(&idev->lock); 5119fc403832SDaniel Borkmann 512077ecaaceSHannes Frederic Sowa if (update_rs) { 5121f53adae4SDaniel Borkmann idev->if_flags |= IF_RS_SENT; 512277ecaaceSHannes Frederic Sowa idev->rs_probes = 1; 512377ecaaceSHannes Frederic Sowa addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval); 512477ecaaceSHannes Frederic Sowa } 5125f53adae4SDaniel Borkmann 5126f53adae4SDaniel Borkmann /* Well, that's kinda nasty ... */ 5127f53adae4SDaniel Borkmann list_for_each_entry(ifp, &idev->addr_list, if_list) { 5128f53adae4SDaniel Borkmann spin_lock(&ifp->lock); 5129617fe29dSDaniel Borkmann if (ifp->tokenized) { 5130f53adae4SDaniel Borkmann ifp->valid_lft = 0; 5131f53adae4SDaniel Borkmann ifp->prefered_lft = 0; 5132f53adae4SDaniel Borkmann } 5133f53adae4SDaniel Borkmann spin_unlock(&ifp->lock); 5134f53adae4SDaniel Borkmann } 5135f53adae4SDaniel Borkmann 5136f53adae4SDaniel Borkmann write_unlock_bh(&idev->lock); 5137b2ed64a9SLubomir Rintel inet6_ifinfo_notify(RTM_NEWLINK, idev); 5138c15b1ccaSHannes Frederic Sowa addrconf_verify_rtnl(); 5139f53adae4SDaniel Borkmann return 0; 5140f53adae4SDaniel Borkmann } 5141f53adae4SDaniel Borkmann 514211b1f828SDaniel Borkmann static const struct nla_policy inet6_af_policy[IFLA_INET6_MAX + 1] = { 514311b1f828SDaniel Borkmann [IFLA_INET6_ADDR_GEN_MODE] = { .type = NLA_U8 }, 514411b1f828SDaniel Borkmann [IFLA_INET6_TOKEN] = { .len = sizeof(struct in6_addr) }, 514511b1f828SDaniel Borkmann }; 514611b1f828SDaniel Borkmann 514711b1f828SDaniel Borkmann static int inet6_validate_link_af(const struct net_device *dev, 514811b1f828SDaniel Borkmann const struct nlattr *nla) 514911b1f828SDaniel Borkmann { 515011b1f828SDaniel Borkmann struct nlattr *tb[IFLA_INET6_MAX + 1]; 515111b1f828SDaniel Borkmann 515211b1f828SDaniel Borkmann if (dev && !__in6_dev_get(dev)) 515311b1f828SDaniel Borkmann return -EAFNOSUPPORT; 515411b1f828SDaniel Borkmann 515511b1f828SDaniel Borkmann return nla_parse_nested(tb, IFLA_INET6_MAX, nla, inet6_af_policy); 515611b1f828SDaniel Borkmann } 515711b1f828SDaniel Borkmann 5158f53adae4SDaniel Borkmann static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla) 5159f53adae4SDaniel Borkmann { 5160f53adae4SDaniel Borkmann int err = -EINVAL; 5161f53adae4SDaniel Borkmann struct inet6_dev *idev = __in6_dev_get(dev); 5162f53adae4SDaniel Borkmann struct nlattr *tb[IFLA_INET6_MAX + 1]; 5163f53adae4SDaniel Borkmann 5164f53adae4SDaniel Borkmann if (!idev) 5165f53adae4SDaniel Borkmann return -EAFNOSUPPORT; 5166f53adae4SDaniel Borkmann 5167f53adae4SDaniel Borkmann if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL) < 0) 5168f53adae4SDaniel Borkmann BUG(); 5169f53adae4SDaniel Borkmann 5170bc91b0f0SJiri Pirko if (tb[IFLA_INET6_TOKEN]) { 5171f53adae4SDaniel Borkmann err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN])); 5172bc91b0f0SJiri Pirko if (err) 5173bc91b0f0SJiri Pirko return err; 5174bc91b0f0SJiri Pirko } 5175bc91b0f0SJiri Pirko 5176bc91b0f0SJiri Pirko if (tb[IFLA_INET6_ADDR_GEN_MODE]) { 5177bc91b0f0SJiri Pirko u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]); 5178bc91b0f0SJiri Pirko 5179bc91b0f0SJiri Pirko if (mode != IN6_ADDR_GEN_MODE_EUI64 && 5180622c81d5SHannes Frederic Sowa mode != IN6_ADDR_GEN_MODE_NONE && 5181cc9da6ccSBjørn Mork mode != IN6_ADDR_GEN_MODE_STABLE_PRIVACY && 5182cc9da6ccSBjørn Mork mode != IN6_ADDR_GEN_MODE_RANDOM) 5183bc91b0f0SJiri Pirko return -EINVAL; 5184622c81d5SHannes Frederic Sowa 5185622c81d5SHannes Frederic Sowa if (mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY && 5186622c81d5SHannes Frederic Sowa !idev->cnf.stable_secret.initialized && 5187622c81d5SHannes Frederic Sowa !dev_net(dev)->ipv6.devconf_dflt->stable_secret.initialized) 5188622c81d5SHannes Frederic Sowa return -EINVAL; 5189622c81d5SHannes Frederic Sowa 5190bc91b0f0SJiri Pirko idev->addr_gen_mode = mode; 5191bc91b0f0SJiri Pirko err = 0; 5192bc91b0f0SJiri Pirko } 5193f53adae4SDaniel Borkmann 5194f53adae4SDaniel Borkmann return err; 5195f53adae4SDaniel Borkmann } 5196f53adae4SDaniel Borkmann 5197b382b191SThomas Graf static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev, 519815e47304SEric W. Biederman u32 portid, u32 seq, int event, unsigned int flags) 5199b382b191SThomas Graf { 5200b382b191SThomas Graf struct net_device *dev = idev->dev; 5201b382b191SThomas Graf struct ifinfomsg *hdr; 5202b382b191SThomas Graf struct nlmsghdr *nlh; 5203b382b191SThomas Graf void *protoinfo; 5204b382b191SThomas Graf 520515e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags); 520663159f29SIan Morris if (!nlh) 5207b382b191SThomas Graf return -EMSGSIZE; 5208b382b191SThomas Graf 5209b382b191SThomas Graf hdr = nlmsg_data(nlh); 5210b382b191SThomas Graf hdr->ifi_family = AF_INET6; 5211b382b191SThomas Graf hdr->__ifi_pad = 0; 5212b382b191SThomas Graf hdr->ifi_type = dev->type; 5213b382b191SThomas Graf hdr->ifi_index = dev->ifindex; 5214b382b191SThomas Graf hdr->ifi_flags = dev_get_flags(dev); 5215b382b191SThomas Graf hdr->ifi_change = 0; 5216b382b191SThomas Graf 5217c78679e8SDavid S. Miller if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 5218c78679e8SDavid S. Miller (dev->addr_len && 5219c78679e8SDavid S. Miller nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) || 5220c78679e8SDavid S. Miller nla_put_u32(skb, IFLA_MTU, dev->mtu) || 5221a54acb3aSNicolas Dichtel (dev->ifindex != dev_get_iflink(dev) && 52220344338bSAndy Gospodarek nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) || 52230344338bSAndy Gospodarek nla_put_u8(skb, IFLA_OPERSTATE, 52240344338bSAndy Gospodarek netif_running(dev) ? dev->operstate : IF_OPER_DOWN)) 5225c78679e8SDavid S. Miller goto nla_put_failure; 5226b382b191SThomas Graf protoinfo = nla_nest_start(skb, IFLA_PROTINFO); 522763159f29SIan Morris if (!protoinfo) 5228b382b191SThomas Graf goto nla_put_failure; 5229b382b191SThomas Graf 5230d5566fd7SSowmini Varadhan if (inet6_fill_ifla6_attrs(skb, idev, 0) < 0) 5231b382b191SThomas Graf goto nla_put_failure; 5232b382b191SThomas Graf 523304561c1fSThomas Graf nla_nest_end(skb, protoinfo); 5234053c095aSJohannes Berg nlmsg_end(skb, nlh); 5235053c095aSJohannes Berg return 0; 52361da177e4SLinus Torvalds 523704561c1fSThomas Graf nla_put_failure: 523826932566SPatrick McHardy nlmsg_cancel(skb, nlh); 523926932566SPatrick McHardy return -EMSGSIZE; 52401da177e4SLinus Torvalds } 52411da177e4SLinus Torvalds 52421da177e4SLinus Torvalds static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 52431da177e4SLinus Torvalds { 52443b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 524584d2697dSEric Dumazet int h, s_h; 5246434a8a58SDavid S. Miller int idx = 0, s_idx; 52471da177e4SLinus Torvalds struct net_device *dev; 52481da177e4SLinus Torvalds struct inet6_dev *idev; 524984d2697dSEric Dumazet struct hlist_head *head; 52501da177e4SLinus Torvalds 525184d2697dSEric Dumazet s_h = cb->args[0]; 525284d2697dSEric Dumazet s_idx = cb->args[1]; 525384d2697dSEric Dumazet 525484d2697dSEric Dumazet rcu_read_lock(); 525584d2697dSEric Dumazet for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 52567562f876SPavel Emelianov idx = 0; 525784d2697dSEric Dumazet head = &net->dev_index_head[h]; 5258b67bfe0dSSasha Levin hlist_for_each_entry_rcu(dev, head, index_hlist) { 52591da177e4SLinus Torvalds if (idx < s_idx) 52607562f876SPavel Emelianov goto cont; 526184d2697dSEric Dumazet idev = __in6_dev_get(dev); 526284d2697dSEric Dumazet if (!idev) 52637562f876SPavel Emelianov goto cont; 526484d2697dSEric Dumazet if (inet6_fill_ifinfo(skb, idev, 526515e47304SEric W. Biederman NETLINK_CB(cb->skb).portid, 526684d2697dSEric Dumazet cb->nlh->nlmsg_seq, 5267053c095aSJohannes Berg RTM_NEWLINK, NLM_F_MULTI) < 0) 526884d2697dSEric Dumazet goto out; 52697562f876SPavel Emelianov cont: 52707562f876SPavel Emelianov idx++; 52711da177e4SLinus Torvalds } 527284d2697dSEric Dumazet } 527384d2697dSEric Dumazet out: 527484d2697dSEric Dumazet rcu_read_unlock(); 527584d2697dSEric Dumazet cb->args[1] = idx; 527684d2697dSEric Dumazet cb->args[0] = h; 52771da177e4SLinus Torvalds 52781da177e4SLinus Torvalds return skb->len; 52791da177e4SLinus Torvalds } 52801da177e4SLinus Torvalds 52811da177e4SLinus Torvalds void inet6_ifinfo_notify(int event, struct inet6_dev *idev) 52821da177e4SLinus Torvalds { 52831da177e4SLinus Torvalds struct sk_buff *skb; 5284c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(idev->dev); 52858d7a76c9SThomas Graf int err = -ENOBUFS; 52861da177e4SLinus Torvalds 5287339bf98fSThomas Graf skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC); 528863159f29SIan Morris if (!skb) 52898d7a76c9SThomas Graf goto errout; 52908d7a76c9SThomas Graf 52918d7a76c9SThomas Graf err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0); 529226932566SPatrick McHardy if (err < 0) { 529326932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */ 529426932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 529526932566SPatrick McHardy kfree_skb(skb); 529626932566SPatrick McHardy goto errout; 529726932566SPatrick McHardy } 52985f75a104SNicolas Dichtel rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC); 52991ce85fe4SPablo Neira Ayuso return; 53008d7a76c9SThomas Graf errout: 53018d7a76c9SThomas Graf if (err < 0) 53025f75a104SNicolas Dichtel rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err); 53031da177e4SLinus Torvalds } 53041da177e4SLinus Torvalds 5305339bf98fSThomas Graf static inline size_t inet6_prefix_nlmsg_size(void) 5306339bf98fSThomas Graf { 5307339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct prefixmsg)) 5308339bf98fSThomas Graf + nla_total_size(sizeof(struct in6_addr)) 5309339bf98fSThomas Graf + nla_total_size(sizeof(struct prefix_cacheinfo)); 5310339bf98fSThomas Graf } 5311c5396a31SYOSHIFUJI Hideaki 53121da177e4SLinus Torvalds static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev, 531315e47304SEric W. Biederman struct prefix_info *pinfo, u32 portid, u32 seq, 5314b6544c0bSJamal Hadi Salim int event, unsigned int flags) 53151da177e4SLinus Torvalds { 53161da177e4SLinus Torvalds struct prefixmsg *pmsg; 53171da177e4SLinus Torvalds struct nlmsghdr *nlh; 53181da177e4SLinus Torvalds struct prefix_cacheinfo ci; 53191da177e4SLinus Torvalds 532015e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags); 532163159f29SIan Morris if (!nlh) 532226932566SPatrick McHardy return -EMSGSIZE; 53236051e2f4SThomas Graf 53246051e2f4SThomas Graf pmsg = nlmsg_data(nlh); 53251da177e4SLinus Torvalds pmsg->prefix_family = AF_INET6; 53268a47077aSPatrick McHardy pmsg->prefix_pad1 = 0; 53278a47077aSPatrick McHardy pmsg->prefix_pad2 = 0; 53281da177e4SLinus Torvalds pmsg->prefix_ifindex = idev->dev->ifindex; 53291da177e4SLinus Torvalds pmsg->prefix_len = pinfo->prefix_len; 53301da177e4SLinus Torvalds pmsg->prefix_type = pinfo->type; 53318a47077aSPatrick McHardy pmsg->prefix_pad3 = 0; 53321da177e4SLinus Torvalds pmsg->prefix_flags = 0; 53331da177e4SLinus Torvalds if (pinfo->onlink) 53341da177e4SLinus Torvalds pmsg->prefix_flags |= IF_PREFIX_ONLINK; 53351da177e4SLinus Torvalds if (pinfo->autoconf) 53361da177e4SLinus Torvalds pmsg->prefix_flags |= IF_PREFIX_AUTOCONF; 53371da177e4SLinus Torvalds 5338c78679e8SDavid S. Miller if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix)) 5339c78679e8SDavid S. Miller goto nla_put_failure; 53401da177e4SLinus Torvalds ci.preferred_time = ntohl(pinfo->prefered); 53411da177e4SLinus Torvalds ci.valid_time = ntohl(pinfo->valid); 5342c78679e8SDavid S. Miller if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci)) 5343c78679e8SDavid S. Miller goto nla_put_failure; 5344053c095aSJohannes Berg nlmsg_end(skb, nlh); 5345053c095aSJohannes Berg return 0; 53461da177e4SLinus Torvalds 53476051e2f4SThomas Graf nla_put_failure: 534826932566SPatrick McHardy nlmsg_cancel(skb, nlh); 534926932566SPatrick McHardy return -EMSGSIZE; 53501da177e4SLinus Torvalds } 53511da177e4SLinus Torvalds 53521da177e4SLinus Torvalds static void inet6_prefix_notify(int event, struct inet6_dev *idev, 53531da177e4SLinus Torvalds struct prefix_info *pinfo) 53541da177e4SLinus Torvalds { 53551da177e4SLinus Torvalds struct sk_buff *skb; 5356c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(idev->dev); 53578c384bfaSThomas Graf int err = -ENOBUFS; 53581da177e4SLinus Torvalds 5359339bf98fSThomas Graf skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC); 536063159f29SIan Morris if (!skb) 53618c384bfaSThomas Graf goto errout; 53628c384bfaSThomas Graf 53638c384bfaSThomas Graf err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0); 536426932566SPatrick McHardy if (err < 0) { 536526932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */ 536626932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 536726932566SPatrick McHardy kfree_skb(skb); 536826932566SPatrick McHardy goto errout; 536926932566SPatrick McHardy } 53701ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC); 53711ce85fe4SPablo Neira Ayuso return; 53728c384bfaSThomas Graf errout: 53738c384bfaSThomas Graf if (err < 0) 53746fda7350SBenjamin Thery rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err); 53751da177e4SLinus Torvalds } 53761da177e4SLinus Torvalds 53771da177e4SLinus Torvalds static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp) 53781da177e4SLinus Torvalds { 537963998ac2SNicolas Dichtel struct net *net = dev_net(ifp->idev->dev); 538063998ac2SNicolas Dichtel 5381c15b1ccaSHannes Frederic Sowa if (event) 5382c15b1ccaSHannes Frederic Sowa ASSERT_RTNL(); 5383c15b1ccaSHannes Frederic Sowa 53841da177e4SLinus Torvalds inet6_ifa_notify(event ? : RTM_NEWADDR, ifp); 53851da177e4SLinus Torvalds 53861da177e4SLinus Torvalds switch (event) { 53871da177e4SLinus Torvalds case RTM_NEWADDR: 538895c385b4SNeil Horman /* 538995c385b4SNeil Horman * If the address was optimistic 539095c385b4SNeil Horman * we inserted the route at the start of 539195c385b4SNeil Horman * our DAD process, so we don't need 539295c385b4SNeil Horman * to do it again 539395c385b4SNeil Horman */ 539495c385b4SNeil Horman if (!(ifp->rt->rt6i_node)) 539540e22e8fSThomas Graf ip6_ins_rt(ifp->rt); 53961da177e4SLinus Torvalds if (ifp->idev->cnf.forwarding) 53971da177e4SLinus Torvalds addrconf_join_anycast(ifp); 53987996c799SCong Wang if (!ipv6_addr_any(&ifp->peer_addr)) 5399caeaba79SNicolas Dichtel addrconf_prefix_route(&ifp->peer_addr, 128, 5400caeaba79SNicolas Dichtel ifp->idev->dev, 0, 0); 54011da177e4SLinus Torvalds break; 54021da177e4SLinus Torvalds case RTM_DELADDR: 54031da177e4SLinus Torvalds if (ifp->idev->cnf.forwarding) 54041da177e4SLinus Torvalds addrconf_leave_anycast(ifp); 54051da177e4SLinus Torvalds addrconf_leave_solict(ifp->idev, &ifp->addr); 54067996c799SCong Wang if (!ipv6_addr_any(&ifp->peer_addr)) { 5407caeaba79SNicolas Dichtel struct rt6_info *rt; 5408caeaba79SNicolas Dichtel 5409e7478dfcSNicolas Dichtel rt = addrconf_get_prefix_route(&ifp->peer_addr, 128, 5410e7478dfcSNicolas Dichtel ifp->idev->dev, 0, 0); 54118e3d5be7SMartin KaFai Lau if (rt) 54128e3d5be7SMartin KaFai Lau ip6_del_rt(rt); 5413caeaba79SNicolas Dichtel } 541438bd10c4SDavid Ahern if (ifp->rt) { 5415d8d1f30bSChangli Gao dst_hold(&ifp->rt->dst); 54168e3d5be7SMartin KaFai Lau ip6_del_rt(ifp->rt); 541738bd10c4SDavid Ahern } 5418705f1c86SHannes Frederic Sowa rt_genid_bump_ipv6(net); 54191da177e4SLinus Torvalds break; 54201da177e4SLinus Torvalds } 542163998ac2SNicolas Dichtel atomic_inc(&net->ipv6.dev_addr_genid); 54221da177e4SLinus Torvalds } 54231da177e4SLinus Torvalds 54241da177e4SLinus Torvalds static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp) 54251da177e4SLinus Torvalds { 54268814c4b5SYOSHIFUJI Hideaki rcu_read_lock_bh(); 54271da177e4SLinus Torvalds if (likely(ifp->idev->dead == 0)) 54281da177e4SLinus Torvalds __ipv6_ifa_notify(event, ifp); 54298814c4b5SYOSHIFUJI Hideaki rcu_read_unlock_bh(); 54301da177e4SLinus Torvalds } 54311da177e4SLinus Torvalds 54321da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 54331da177e4SLinus Torvalds 54341da177e4SLinus Torvalds static 5435fe2c6338SJoe Perches int addrconf_sysctl_forward(struct ctl_table *ctl, int write, 54361da177e4SLinus Torvalds void __user *buffer, size_t *lenp, loff_t *ppos) 54371da177e4SLinus Torvalds { 54381da177e4SLinus Torvalds int *valp = ctl->data; 54391da177e4SLinus Torvalds int val = *valp; 544088af182eSEric W. Biederman loff_t pos = *ppos; 5441fe2c6338SJoe Perches struct ctl_table lctl; 54421da177e4SLinus Torvalds int ret; 54431da177e4SLinus Torvalds 5444013d97e9SFrancesco Ruggeri /* 5445013d97e9SFrancesco Ruggeri * ctl->data points to idev->cnf.forwarding, we should 5446013d97e9SFrancesco Ruggeri * not modify it until we get the rtnl lock. 5447013d97e9SFrancesco Ruggeri */ 5448013d97e9SFrancesco Ruggeri lctl = *ctl; 5449013d97e9SFrancesco Ruggeri lctl.data = &val; 5450013d97e9SFrancesco Ruggeri 5451013d97e9SFrancesco Ruggeri ret = proc_dointvec(&lctl, write, buffer, lenp, ppos); 54521da177e4SLinus Torvalds 5453c8fecf22SPavel Emelyanov if (write) 5454b325fddbSStephen Hemminger ret = addrconf_fixup_forwarding(ctl, valp, val); 545588af182eSEric W. Biederman if (ret) 545688af182eSEric W. Biederman *ppos = pos; 54571da177e4SLinus Torvalds return ret; 54581da177e4SLinus Torvalds } 54591da177e4SLinus Torvalds 546077751427SMarcelo Leitner static 5461d6df198dSPhil Sutter int addrconf_sysctl_hop_limit(struct ctl_table *ctl, int write, 5462d6df198dSPhil Sutter void __user *buffer, size_t *lenp, loff_t *ppos) 5463d6df198dSPhil Sutter { 5464d6df198dSPhil Sutter struct ctl_table lctl; 5465d6df198dSPhil Sutter int min_hl = 1, max_hl = 255; 5466d6df198dSPhil Sutter 5467d6df198dSPhil Sutter lctl = *ctl; 5468d6df198dSPhil Sutter lctl.extra1 = &min_hl; 5469d6df198dSPhil Sutter lctl.extra2 = &max_hl; 5470d6df198dSPhil Sutter 5471d6df198dSPhil Sutter return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos); 5472d6df198dSPhil Sutter } 5473d6df198dSPhil Sutter 5474d6df198dSPhil Sutter static 547577751427SMarcelo Leitner int addrconf_sysctl_mtu(struct ctl_table *ctl, int write, 547677751427SMarcelo Leitner void __user *buffer, size_t *lenp, loff_t *ppos) 547777751427SMarcelo Leitner { 547877751427SMarcelo Leitner struct inet6_dev *idev = ctl->extra1; 547977751427SMarcelo Leitner int min_mtu = IPV6_MIN_MTU; 548077751427SMarcelo Leitner struct ctl_table lctl; 548177751427SMarcelo Leitner 548277751427SMarcelo Leitner lctl = *ctl; 548377751427SMarcelo Leitner lctl.extra1 = &min_mtu; 548477751427SMarcelo Leitner lctl.extra2 = idev ? &idev->dev->mtu : NULL; 548577751427SMarcelo Leitner 548677751427SMarcelo Leitner return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos); 548777751427SMarcelo Leitner } 548877751427SMarcelo Leitner 548956d417b1SBrian Haley static void dev_disable_change(struct inet6_dev *idev) 549056d417b1SBrian Haley { 549175538c2bSCong Wang struct netdev_notifier_info info; 549275538c2bSCong Wang 549356d417b1SBrian Haley if (!idev || !idev->dev) 549456d417b1SBrian Haley return; 549556d417b1SBrian Haley 549675538c2bSCong Wang netdev_notifier_info_init(&info, idev->dev); 549756d417b1SBrian Haley if (idev->cnf.disable_ipv6) 549875538c2bSCong Wang addrconf_notify(NULL, NETDEV_DOWN, &info); 549956d417b1SBrian Haley else 550075538c2bSCong Wang addrconf_notify(NULL, NETDEV_UP, &info); 550156d417b1SBrian Haley } 550256d417b1SBrian Haley 550356d417b1SBrian Haley static void addrconf_disable_change(struct net *net, __s32 newf) 550456d417b1SBrian Haley { 550556d417b1SBrian Haley struct net_device *dev; 550656d417b1SBrian Haley struct inet6_dev *idev; 550756d417b1SBrian Haley 550856d417b1SBrian Haley rcu_read_lock(); 5509c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 551056d417b1SBrian Haley idev = __in6_dev_get(dev); 551156d417b1SBrian Haley if (idev) { 551256d417b1SBrian Haley int changed = (!idev->cnf.disable_ipv6) ^ (!newf); 551356d417b1SBrian Haley idev->cnf.disable_ipv6 = newf; 551456d417b1SBrian Haley if (changed) 551556d417b1SBrian Haley dev_disable_change(idev); 551656d417b1SBrian Haley } 551756d417b1SBrian Haley } 5518c6d14c84SEric Dumazet rcu_read_unlock(); 551956d417b1SBrian Haley } 552056d417b1SBrian Haley 5521013d97e9SFrancesco Ruggeri static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf) 552256d417b1SBrian Haley { 552356d417b1SBrian Haley struct net *net; 5524013d97e9SFrancesco Ruggeri int old; 5525013d97e9SFrancesco Ruggeri 5526013d97e9SFrancesco Ruggeri if (!rtnl_trylock()) 5527013d97e9SFrancesco Ruggeri return restart_syscall(); 552856d417b1SBrian Haley 552956d417b1SBrian Haley net = (struct net *)table->extra2; 5530013d97e9SFrancesco Ruggeri old = *p; 5531013d97e9SFrancesco Ruggeri *p = newf; 553256d417b1SBrian Haley 5533013d97e9SFrancesco Ruggeri if (p == &net->ipv6.devconf_dflt->disable_ipv6) { 5534013d97e9SFrancesco Ruggeri rtnl_unlock(); 553556d417b1SBrian Haley return 0; 553688af182eSEric W. Biederman } 553756d417b1SBrian Haley 553856d417b1SBrian Haley if (p == &net->ipv6.devconf_all->disable_ipv6) { 553956d417b1SBrian Haley net->ipv6.devconf_dflt->disable_ipv6 = newf; 554056d417b1SBrian Haley addrconf_disable_change(net, newf); 5541013d97e9SFrancesco Ruggeri } else if ((!newf) ^ (!old)) 554256d417b1SBrian Haley dev_disable_change((struct inet6_dev *)table->extra1); 554356d417b1SBrian Haley 554456d417b1SBrian Haley rtnl_unlock(); 554556d417b1SBrian Haley return 0; 554656d417b1SBrian Haley } 554756d417b1SBrian Haley 554856d417b1SBrian Haley static 5549fe2c6338SJoe Perches int addrconf_sysctl_disable(struct ctl_table *ctl, int write, 555056d417b1SBrian Haley void __user *buffer, size_t *lenp, loff_t *ppos) 555156d417b1SBrian Haley { 555256d417b1SBrian Haley int *valp = ctl->data; 555356d417b1SBrian Haley int val = *valp; 555488af182eSEric W. Biederman loff_t pos = *ppos; 5555fe2c6338SJoe Perches struct ctl_table lctl; 555656d417b1SBrian Haley int ret; 555756d417b1SBrian Haley 5558013d97e9SFrancesco Ruggeri /* 5559013d97e9SFrancesco Ruggeri * ctl->data points to idev->cnf.disable_ipv6, we should 5560013d97e9SFrancesco Ruggeri * not modify it until we get the rtnl lock. 5561013d97e9SFrancesco Ruggeri */ 5562013d97e9SFrancesco Ruggeri lctl = *ctl; 5563013d97e9SFrancesco Ruggeri lctl.data = &val; 5564013d97e9SFrancesco Ruggeri 5565013d97e9SFrancesco Ruggeri ret = proc_dointvec(&lctl, write, buffer, lenp, ppos); 556656d417b1SBrian Haley 556756d417b1SBrian Haley if (write) 556856d417b1SBrian Haley ret = addrconf_disable_ipv6(ctl, valp, val); 556988af182eSEric W. Biederman if (ret) 557088af182eSEric W. Biederman *ppos = pos; 557156d417b1SBrian Haley return ret; 557256d417b1SBrian Haley } 557356d417b1SBrian Haley 5574c92d5491Sstephen hemminger static 5575c92d5491Sstephen hemminger int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write, 5576c92d5491Sstephen hemminger void __user *buffer, size_t *lenp, loff_t *ppos) 5577c92d5491Sstephen hemminger { 5578c92d5491Sstephen hemminger int *valp = ctl->data; 5579c92d5491Sstephen hemminger int ret; 5580c92d5491Sstephen hemminger int old, new; 5581c92d5491Sstephen hemminger 5582c92d5491Sstephen hemminger old = *valp; 5583c92d5491Sstephen hemminger ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 5584c92d5491Sstephen hemminger new = *valp; 5585c92d5491Sstephen hemminger 5586c92d5491Sstephen hemminger if (write && old != new) { 5587c92d5491Sstephen hemminger struct net *net = ctl->extra2; 5588c92d5491Sstephen hemminger 5589c92d5491Sstephen hemminger if (!rtnl_trylock()) 5590c92d5491Sstephen hemminger return restart_syscall(); 5591c92d5491Sstephen hemminger 5592c92d5491Sstephen hemminger if (valp == &net->ipv6.devconf_dflt->proxy_ndp) 5593c92d5491Sstephen hemminger inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH, 5594c92d5491Sstephen hemminger NETCONFA_IFINDEX_DEFAULT, 5595c92d5491Sstephen hemminger net->ipv6.devconf_dflt); 5596c92d5491Sstephen hemminger else if (valp == &net->ipv6.devconf_all->proxy_ndp) 5597c92d5491Sstephen hemminger inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH, 5598c92d5491Sstephen hemminger NETCONFA_IFINDEX_ALL, 5599c92d5491Sstephen hemminger net->ipv6.devconf_all); 5600c92d5491Sstephen hemminger else { 5601c92d5491Sstephen hemminger struct inet6_dev *idev = ctl->extra1; 5602c92d5491Sstephen hemminger 5603c92d5491Sstephen hemminger inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH, 5604c92d5491Sstephen hemminger idev->dev->ifindex, 5605c92d5491Sstephen hemminger &idev->cnf); 5606c92d5491Sstephen hemminger } 5607c92d5491Sstephen hemminger rtnl_unlock(); 5608c92d5491Sstephen hemminger } 5609c92d5491Sstephen hemminger 5610c92d5491Sstephen hemminger return ret; 5611c92d5491Sstephen hemminger } 5612c92d5491Sstephen hemminger 56133d1bec99SHannes Frederic Sowa static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write, 56143d1bec99SHannes Frederic Sowa void __user *buffer, size_t *lenp, 56153d1bec99SHannes Frederic Sowa loff_t *ppos) 56163d1bec99SHannes Frederic Sowa { 56173d1bec99SHannes Frederic Sowa int err; 56183d1bec99SHannes Frederic Sowa struct in6_addr addr; 56193d1bec99SHannes Frederic Sowa char str[IPV6_MAX_STRLEN]; 56203d1bec99SHannes Frederic Sowa struct ctl_table lctl = *ctl; 5621622c81d5SHannes Frederic Sowa struct net *net = ctl->extra2; 56223d1bec99SHannes Frederic Sowa struct ipv6_stable_secret *secret = ctl->data; 56233d1bec99SHannes Frederic Sowa 5624622c81d5SHannes Frederic Sowa if (&net->ipv6.devconf_all->stable_secret == ctl->data) 5625622c81d5SHannes Frederic Sowa return -EIO; 5626622c81d5SHannes Frederic Sowa 56273d1bec99SHannes Frederic Sowa lctl.maxlen = IPV6_MAX_STRLEN; 56283d1bec99SHannes Frederic Sowa lctl.data = str; 56293d1bec99SHannes Frederic Sowa 56303d1bec99SHannes Frederic Sowa if (!rtnl_trylock()) 56313d1bec99SHannes Frederic Sowa return restart_syscall(); 56323d1bec99SHannes Frederic Sowa 56333d1bec99SHannes Frederic Sowa if (!write && !secret->initialized) { 56343d1bec99SHannes Frederic Sowa err = -EIO; 56353d1bec99SHannes Frederic Sowa goto out; 56363d1bec99SHannes Frederic Sowa } 56373d1bec99SHannes Frederic Sowa 56385449a5caSWANG Cong err = snprintf(str, sizeof(str), "%pI6", &secret->secret); 56393d1bec99SHannes Frederic Sowa if (err >= sizeof(str)) { 56403d1bec99SHannes Frederic Sowa err = -EIO; 56413d1bec99SHannes Frederic Sowa goto out; 56423d1bec99SHannes Frederic Sowa } 56433d1bec99SHannes Frederic Sowa 56443d1bec99SHannes Frederic Sowa err = proc_dostring(&lctl, write, buffer, lenp, ppos); 56453d1bec99SHannes Frederic Sowa if (err || !write) 56463d1bec99SHannes Frederic Sowa goto out; 56473d1bec99SHannes Frederic Sowa 56483d1bec99SHannes Frederic Sowa if (in6_pton(str, -1, addr.in6_u.u6_addr8, -1, NULL) != 1) { 56493d1bec99SHannes Frederic Sowa err = -EIO; 56503d1bec99SHannes Frederic Sowa goto out; 56513d1bec99SHannes Frederic Sowa } 56523d1bec99SHannes Frederic Sowa 56533d1bec99SHannes Frederic Sowa secret->initialized = true; 56543d1bec99SHannes Frederic Sowa secret->secret = addr; 56553d1bec99SHannes Frederic Sowa 5656622c81d5SHannes Frederic Sowa if (&net->ipv6.devconf_dflt->stable_secret == ctl->data) { 5657622c81d5SHannes Frederic Sowa struct net_device *dev; 5658622c81d5SHannes Frederic Sowa 5659622c81d5SHannes Frederic Sowa for_each_netdev(net, dev) { 5660622c81d5SHannes Frederic Sowa struct inet6_dev *idev = __in6_dev_get(dev); 5661622c81d5SHannes Frederic Sowa 5662622c81d5SHannes Frederic Sowa if (idev) { 5663622c81d5SHannes Frederic Sowa idev->addr_gen_mode = 5664622c81d5SHannes Frederic Sowa IN6_ADDR_GEN_MODE_STABLE_PRIVACY; 5665622c81d5SHannes Frederic Sowa } 5666622c81d5SHannes Frederic Sowa } 5667622c81d5SHannes Frederic Sowa } else { 5668622c81d5SHannes Frederic Sowa struct inet6_dev *idev = ctl->extra1; 5669622c81d5SHannes Frederic Sowa 5670622c81d5SHannes Frederic Sowa idev->addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY; 5671622c81d5SHannes Frederic Sowa } 5672622c81d5SHannes Frederic Sowa 56733d1bec99SHannes Frederic Sowa out: 56743d1bec99SHannes Frederic Sowa rtnl_unlock(); 56753d1bec99SHannes Frederic Sowa 56763d1bec99SHannes Frederic Sowa return err; 56773d1bec99SHannes Frederic Sowa } 5678c92d5491Sstephen hemminger 567935103d11SAndy Gospodarek static 568035103d11SAndy Gospodarek int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl, 568135103d11SAndy Gospodarek int write, 568235103d11SAndy Gospodarek void __user *buffer, 568335103d11SAndy Gospodarek size_t *lenp, 568435103d11SAndy Gospodarek loff_t *ppos) 568535103d11SAndy Gospodarek { 568635103d11SAndy Gospodarek int *valp = ctl->data; 568735103d11SAndy Gospodarek int val = *valp; 568835103d11SAndy Gospodarek loff_t pos = *ppos; 568935103d11SAndy Gospodarek struct ctl_table lctl; 569035103d11SAndy Gospodarek int ret; 569135103d11SAndy Gospodarek 569235103d11SAndy Gospodarek /* ctl->data points to idev->cnf.ignore_routes_when_linkdown 569335103d11SAndy Gospodarek * we should not modify it until we get the rtnl lock. 569435103d11SAndy Gospodarek */ 569535103d11SAndy Gospodarek lctl = *ctl; 569635103d11SAndy Gospodarek lctl.data = &val; 569735103d11SAndy Gospodarek 569835103d11SAndy Gospodarek ret = proc_dointvec(&lctl, write, buffer, lenp, ppos); 569935103d11SAndy Gospodarek 570035103d11SAndy Gospodarek if (write) 570135103d11SAndy Gospodarek ret = addrconf_fixup_linkdown(ctl, valp, val); 570235103d11SAndy Gospodarek if (ret) 570335103d11SAndy Gospodarek *ppos = pos; 570435103d11SAndy Gospodarek return ret; 570535103d11SAndy Gospodarek } 570635103d11SAndy Gospodarek 5707607ea7cdSKonstantin Khlebnikov static const struct ctl_table addrconf_sysctl[] = { 57081da177e4SLinus Torvalds { 57091da177e4SLinus Torvalds .procname = "forwarding", 57101da177e4SLinus Torvalds .data = &ipv6_devconf.forwarding, 57111da177e4SLinus Torvalds .maxlen = sizeof(int), 57121da177e4SLinus Torvalds .mode = 0644, 57136d9f239aSAlexey Dobriyan .proc_handler = addrconf_sysctl_forward, 57141da177e4SLinus Torvalds }, 57151da177e4SLinus Torvalds { 57161da177e4SLinus Torvalds .procname = "hop_limit", 57171da177e4SLinus Torvalds .data = &ipv6_devconf.hop_limit, 57181da177e4SLinus Torvalds .maxlen = sizeof(int), 57191da177e4SLinus Torvalds .mode = 0644, 5720d6df198dSPhil Sutter .proc_handler = addrconf_sysctl_hop_limit, 57211da177e4SLinus Torvalds }, 57221da177e4SLinus Torvalds { 57231da177e4SLinus Torvalds .procname = "mtu", 57241da177e4SLinus Torvalds .data = &ipv6_devconf.mtu6, 57251da177e4SLinus Torvalds .maxlen = sizeof(int), 57261da177e4SLinus Torvalds .mode = 0644, 572777751427SMarcelo Leitner .proc_handler = addrconf_sysctl_mtu, 57281da177e4SLinus Torvalds }, 57291da177e4SLinus Torvalds { 57301da177e4SLinus Torvalds .procname = "accept_ra", 57311da177e4SLinus Torvalds .data = &ipv6_devconf.accept_ra, 57321da177e4SLinus Torvalds .maxlen = sizeof(int), 57331da177e4SLinus Torvalds .mode = 0644, 57346d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 57351da177e4SLinus Torvalds }, 57361da177e4SLinus Torvalds { 57371da177e4SLinus Torvalds .procname = "accept_redirects", 57381da177e4SLinus Torvalds .data = &ipv6_devconf.accept_redirects, 57391da177e4SLinus Torvalds .maxlen = sizeof(int), 57401da177e4SLinus Torvalds .mode = 0644, 57416d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 57421da177e4SLinus Torvalds }, 57431da177e4SLinus Torvalds { 57441da177e4SLinus Torvalds .procname = "autoconf", 57451da177e4SLinus Torvalds .data = &ipv6_devconf.autoconf, 57461da177e4SLinus Torvalds .maxlen = sizeof(int), 57471da177e4SLinus Torvalds .mode = 0644, 57486d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 57491da177e4SLinus Torvalds }, 57501da177e4SLinus Torvalds { 57511da177e4SLinus Torvalds .procname = "dad_transmits", 57521da177e4SLinus Torvalds .data = &ipv6_devconf.dad_transmits, 57531da177e4SLinus Torvalds .maxlen = sizeof(int), 57541da177e4SLinus Torvalds .mode = 0644, 57556d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 57561da177e4SLinus Torvalds }, 57571da177e4SLinus Torvalds { 57581da177e4SLinus Torvalds .procname = "router_solicitations", 57591da177e4SLinus Torvalds .data = &ipv6_devconf.rtr_solicits, 57601da177e4SLinus Torvalds .maxlen = sizeof(int), 57611da177e4SLinus Torvalds .mode = 0644, 57626d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 57631da177e4SLinus Torvalds }, 57641da177e4SLinus Torvalds { 57651da177e4SLinus Torvalds .procname = "router_solicitation_interval", 57661da177e4SLinus Torvalds .data = &ipv6_devconf.rtr_solicit_interval, 57671da177e4SLinus Torvalds .maxlen = sizeof(int), 57681da177e4SLinus Torvalds .mode = 0644, 57696d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 57701da177e4SLinus Torvalds }, 57711da177e4SLinus Torvalds { 57721da177e4SLinus Torvalds .procname = "router_solicitation_delay", 57731da177e4SLinus Torvalds .data = &ipv6_devconf.rtr_solicit_delay, 57741da177e4SLinus Torvalds .maxlen = sizeof(int), 57751da177e4SLinus Torvalds .mode = 0644, 57766d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 57771da177e4SLinus Torvalds }, 57781da177e4SLinus Torvalds { 57791da177e4SLinus Torvalds .procname = "force_mld_version", 57801da177e4SLinus Torvalds .data = &ipv6_devconf.force_mld_version, 57811da177e4SLinus Torvalds .maxlen = sizeof(int), 57821da177e4SLinus Torvalds .mode = 0644, 57836d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 57841da177e4SLinus Torvalds }, 5785fc4eba58SHannes Frederic Sowa { 5786fc4eba58SHannes Frederic Sowa .procname = "mldv1_unsolicited_report_interval", 5787fc4eba58SHannes Frederic Sowa .data = 5788fc4eba58SHannes Frederic Sowa &ipv6_devconf.mldv1_unsolicited_report_interval, 5789fc4eba58SHannes Frederic Sowa .maxlen = sizeof(int), 5790fc4eba58SHannes Frederic Sowa .mode = 0644, 5791fc4eba58SHannes Frederic Sowa .proc_handler = proc_dointvec_ms_jiffies, 5792fc4eba58SHannes Frederic Sowa }, 5793fc4eba58SHannes Frederic Sowa { 5794fc4eba58SHannes Frederic Sowa .procname = "mldv2_unsolicited_report_interval", 5795fc4eba58SHannes Frederic Sowa .data = 5796fc4eba58SHannes Frederic Sowa &ipv6_devconf.mldv2_unsolicited_report_interval, 5797fc4eba58SHannes Frederic Sowa .maxlen = sizeof(int), 5798fc4eba58SHannes Frederic Sowa .mode = 0644, 5799fc4eba58SHannes Frederic Sowa .proc_handler = proc_dointvec_ms_jiffies, 5800fc4eba58SHannes Frederic Sowa }, 58011da177e4SLinus Torvalds { 58021da177e4SLinus Torvalds .procname = "use_tempaddr", 58031da177e4SLinus Torvalds .data = &ipv6_devconf.use_tempaddr, 58041da177e4SLinus Torvalds .maxlen = sizeof(int), 58051da177e4SLinus Torvalds .mode = 0644, 58066d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 58071da177e4SLinus Torvalds }, 58081da177e4SLinus Torvalds { 58091da177e4SLinus Torvalds .procname = "temp_valid_lft", 58101da177e4SLinus Torvalds .data = &ipv6_devconf.temp_valid_lft, 58111da177e4SLinus Torvalds .maxlen = sizeof(int), 58121da177e4SLinus Torvalds .mode = 0644, 58136d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 58141da177e4SLinus Torvalds }, 58151da177e4SLinus Torvalds { 58161da177e4SLinus Torvalds .procname = "temp_prefered_lft", 58171da177e4SLinus Torvalds .data = &ipv6_devconf.temp_prefered_lft, 58181da177e4SLinus Torvalds .maxlen = sizeof(int), 58191da177e4SLinus Torvalds .mode = 0644, 58206d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 58211da177e4SLinus Torvalds }, 58221da177e4SLinus Torvalds { 58231da177e4SLinus Torvalds .procname = "regen_max_retry", 58241da177e4SLinus Torvalds .data = &ipv6_devconf.regen_max_retry, 58251da177e4SLinus Torvalds .maxlen = sizeof(int), 58261da177e4SLinus Torvalds .mode = 0644, 58276d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 58281da177e4SLinus Torvalds }, 58291da177e4SLinus Torvalds { 58301da177e4SLinus Torvalds .procname = "max_desync_factor", 58311da177e4SLinus Torvalds .data = &ipv6_devconf.max_desync_factor, 58321da177e4SLinus Torvalds .maxlen = sizeof(int), 58331da177e4SLinus Torvalds .mode = 0644, 58346d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 58351da177e4SLinus Torvalds }, 58361da177e4SLinus Torvalds { 58371da177e4SLinus Torvalds .procname = "max_addresses", 58381da177e4SLinus Torvalds .data = &ipv6_devconf.max_addresses, 58391da177e4SLinus Torvalds .maxlen = sizeof(int), 58401da177e4SLinus Torvalds .mode = 0644, 58416d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 58421da177e4SLinus Torvalds }, 58431da177e4SLinus Torvalds { 584465f5c7c1SYOSHIFUJI Hideaki .procname = "accept_ra_defrtr", 584565f5c7c1SYOSHIFUJI Hideaki .data = &ipv6_devconf.accept_ra_defrtr, 584665f5c7c1SYOSHIFUJI Hideaki .maxlen = sizeof(int), 584765f5c7c1SYOSHIFUJI Hideaki .mode = 0644, 58486d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 584965f5c7c1SYOSHIFUJI Hideaki }, 585065f5c7c1SYOSHIFUJI Hideaki { 58518013d1d7SHangbin Liu .procname = "accept_ra_min_hop_limit", 58528013d1d7SHangbin Liu .data = &ipv6_devconf.accept_ra_min_hop_limit, 58538013d1d7SHangbin Liu .maxlen = sizeof(int), 58548013d1d7SHangbin Liu .mode = 0644, 58558013d1d7SHangbin Liu .proc_handler = proc_dointvec, 58568013d1d7SHangbin Liu }, 58578013d1d7SHangbin Liu { 5858c4fd30ebSYOSHIFUJI Hideaki .procname = "accept_ra_pinfo", 5859c4fd30ebSYOSHIFUJI Hideaki .data = &ipv6_devconf.accept_ra_pinfo, 5860c4fd30ebSYOSHIFUJI Hideaki .maxlen = sizeof(int), 5861c4fd30ebSYOSHIFUJI Hideaki .mode = 0644, 58626d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 5863c4fd30ebSYOSHIFUJI Hideaki }, 5864930d6ff2SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF 5865930d6ff2SYOSHIFUJI Hideaki { 5866930d6ff2SYOSHIFUJI Hideaki .procname = "accept_ra_rtr_pref", 5867930d6ff2SYOSHIFUJI Hideaki .data = &ipv6_devconf.accept_ra_rtr_pref, 5868930d6ff2SYOSHIFUJI Hideaki .maxlen = sizeof(int), 5869930d6ff2SYOSHIFUJI Hideaki .mode = 0644, 58706d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 5871930d6ff2SYOSHIFUJI Hideaki }, 587252e16356SYOSHIFUJI Hideaki { 587352e16356SYOSHIFUJI Hideaki .procname = "router_probe_interval", 587452e16356SYOSHIFUJI Hideaki .data = &ipv6_devconf.rtr_probe_interval, 587552e16356SYOSHIFUJI Hideaki .maxlen = sizeof(int), 587652e16356SYOSHIFUJI Hideaki .mode = 0644, 58776d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 587852e16356SYOSHIFUJI Hideaki }, 5879fa03ef38SNeil Horman #ifdef CONFIG_IPV6_ROUTE_INFO 588009c884d4SYOSHIFUJI Hideaki { 588109c884d4SYOSHIFUJI Hideaki .procname = "accept_ra_rt_info_max_plen", 588209c884d4SYOSHIFUJI Hideaki .data = &ipv6_devconf.accept_ra_rt_info_max_plen, 588309c884d4SYOSHIFUJI Hideaki .maxlen = sizeof(int), 588409c884d4SYOSHIFUJI Hideaki .mode = 0644, 58856d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 588609c884d4SYOSHIFUJI Hideaki }, 588709c884d4SYOSHIFUJI Hideaki #endif 5888930d6ff2SYOSHIFUJI Hideaki #endif 5889c4fd30ebSYOSHIFUJI Hideaki { 5890fbea49e1SYOSHIFUJI Hideaki .procname = "proxy_ndp", 5891fbea49e1SYOSHIFUJI Hideaki .data = &ipv6_devconf.proxy_ndp, 5892fbea49e1SYOSHIFUJI Hideaki .maxlen = sizeof(int), 5893fbea49e1SYOSHIFUJI Hideaki .mode = 0644, 5894c92d5491Sstephen hemminger .proc_handler = addrconf_sysctl_proxy_ndp, 5895fbea49e1SYOSHIFUJI Hideaki }, 5896fbea49e1SYOSHIFUJI Hideaki { 58970bcbc926SYOSHIFUJI Hideaki .procname = "accept_source_route", 58980bcbc926SYOSHIFUJI Hideaki .data = &ipv6_devconf.accept_source_route, 58990bcbc926SYOSHIFUJI Hideaki .maxlen = sizeof(int), 59000bcbc926SYOSHIFUJI Hideaki .mode = 0644, 59016d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 59020bcbc926SYOSHIFUJI Hideaki }, 590395c385b4SNeil Horman #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 590495c385b4SNeil Horman { 590595c385b4SNeil Horman .procname = "optimistic_dad", 590695c385b4SNeil Horman .data = &ipv6_devconf.optimistic_dad, 590795c385b4SNeil Horman .maxlen = sizeof(int), 590895c385b4SNeil Horman .mode = 0644, 59096d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 591095c385b4SNeil Horman }, 59117fd2561eSErik Kline { 59127fd2561eSErik Kline .procname = "use_optimistic", 59137fd2561eSErik Kline .data = &ipv6_devconf.use_optimistic, 59147fd2561eSErik Kline .maxlen = sizeof(int), 59157fd2561eSErik Kline .mode = 0644, 59167fd2561eSErik Kline .proc_handler = proc_dointvec, 59177fd2561eSErik Kline }, 591895c385b4SNeil Horman #endif 59197bc570c8SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_MROUTE 59207bc570c8SYOSHIFUJI Hideaki { 59217bc570c8SYOSHIFUJI Hideaki .procname = "mc_forwarding", 59227bc570c8SYOSHIFUJI Hideaki .data = &ipv6_devconf.mc_forwarding, 59237bc570c8SYOSHIFUJI Hideaki .maxlen = sizeof(int), 5924a4e6db07SDavid S. Miller .mode = 0444, 59256d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 59267bc570c8SYOSHIFUJI Hideaki }, 59277bc570c8SYOSHIFUJI Hideaki #endif 59280bcbc926SYOSHIFUJI Hideaki { 5929778d80beSYOSHIFUJI Hideaki .procname = "disable_ipv6", 5930778d80beSYOSHIFUJI Hideaki .data = &ipv6_devconf.disable_ipv6, 5931778d80beSYOSHIFUJI Hideaki .maxlen = sizeof(int), 5932778d80beSYOSHIFUJI Hideaki .mode = 0644, 593356d417b1SBrian Haley .proc_handler = addrconf_sysctl_disable, 5934778d80beSYOSHIFUJI Hideaki }, 5935778d80beSYOSHIFUJI Hideaki { 59361b34be74SYOSHIFUJI Hideaki .procname = "accept_dad", 59371b34be74SYOSHIFUJI Hideaki .data = &ipv6_devconf.accept_dad, 59381b34be74SYOSHIFUJI Hideaki .maxlen = sizeof(int), 59391b34be74SYOSHIFUJI Hideaki .mode = 0644, 59406d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec, 59411b34be74SYOSHIFUJI Hideaki }, 59421b34be74SYOSHIFUJI Hideaki { 5943f7734fdfSOctavian Purdila .procname = "force_tllao", 5944f7734fdfSOctavian Purdila .data = &ipv6_devconf.force_tllao, 5945f7734fdfSOctavian Purdila .maxlen = sizeof(int), 5946f7734fdfSOctavian Purdila .mode = 0644, 5947f7734fdfSOctavian Purdila .proc_handler = proc_dointvec 5948f7734fdfSOctavian Purdila }, 5949f7734fdfSOctavian Purdila { 59505cb04436SHannes Frederic Sowa .procname = "ndisc_notify", 59515cb04436SHannes Frederic Sowa .data = &ipv6_devconf.ndisc_notify, 59525cb04436SHannes Frederic Sowa .maxlen = sizeof(int), 59535cb04436SHannes Frederic Sowa .mode = 0644, 59545cb04436SHannes Frederic Sowa .proc_handler = proc_dointvec 59555cb04436SHannes Frederic Sowa }, 59565cb04436SHannes Frederic Sowa { 5957b800c3b9SHannes Frederic Sowa .procname = "suppress_frag_ndisc", 5958b800c3b9SHannes Frederic Sowa .data = &ipv6_devconf.suppress_frag_ndisc, 5959b800c3b9SHannes Frederic Sowa .maxlen = sizeof(int), 5960b800c3b9SHannes Frederic Sowa .mode = 0644, 5961b800c3b9SHannes Frederic Sowa .proc_handler = proc_dointvec 5962b800c3b9SHannes Frederic Sowa }, 5963b800c3b9SHannes Frederic Sowa { 5964d9333196SBen Greear .procname = "accept_ra_from_local", 5965d9333196SBen Greear .data = &ipv6_devconf.accept_ra_from_local, 5966d9333196SBen Greear .maxlen = sizeof(int), 5967d9333196SBen Greear .mode = 0644, 5968d9333196SBen Greear .proc_handler = proc_dointvec, 5969d9333196SBen Greear }, 5970d9333196SBen Greear { 5971c2943f14SHarout Hedeshian .procname = "accept_ra_mtu", 5972c2943f14SHarout Hedeshian .data = &ipv6_devconf.accept_ra_mtu, 5973c2943f14SHarout Hedeshian .maxlen = sizeof(int), 5974c2943f14SHarout Hedeshian .mode = 0644, 5975c2943f14SHarout Hedeshian .proc_handler = proc_dointvec, 5976c2943f14SHarout Hedeshian }, 5977c2943f14SHarout Hedeshian { 59783d1bec99SHannes Frederic Sowa .procname = "stable_secret", 59793d1bec99SHannes Frederic Sowa .data = &ipv6_devconf.stable_secret, 59803d1bec99SHannes Frederic Sowa .maxlen = IPV6_MAX_STRLEN, 59813d1bec99SHannes Frederic Sowa .mode = 0600, 59823d1bec99SHannes Frederic Sowa .proc_handler = addrconf_sysctl_stable_secret, 59833d1bec99SHannes Frederic Sowa }, 59843d1bec99SHannes Frederic Sowa { 59853985e8a3SErik Kline .procname = "use_oif_addrs_only", 59863985e8a3SErik Kline .data = &ipv6_devconf.use_oif_addrs_only, 59873985e8a3SErik Kline .maxlen = sizeof(int), 59883985e8a3SErik Kline .mode = 0644, 59893985e8a3SErik Kline .proc_handler = proc_dointvec, 599035103d11SAndy Gospodarek }, 599135103d11SAndy Gospodarek { 599235103d11SAndy Gospodarek .procname = "ignore_routes_with_linkdown", 599335103d11SAndy Gospodarek .data = &ipv6_devconf.ignore_routes_with_linkdown, 599435103d11SAndy Gospodarek .maxlen = sizeof(int), 599535103d11SAndy Gospodarek .mode = 0644, 599635103d11SAndy Gospodarek .proc_handler = addrconf_sysctl_ignore_routes_with_linkdown, 59973985e8a3SErik Kline }, 59983985e8a3SErik Kline { 5999abbc3043SJohannes Berg .procname = "drop_unicast_in_l2_multicast", 6000abbc3043SJohannes Berg .data = &ipv6_devconf.drop_unicast_in_l2_multicast, 6001abbc3043SJohannes Berg .maxlen = sizeof(int), 6002abbc3043SJohannes Berg .mode = 0644, 6003abbc3043SJohannes Berg .proc_handler = proc_dointvec, 6004abbc3043SJohannes Berg }, 6005abbc3043SJohannes Berg { 60067a02bf89SJohannes Berg .procname = "drop_unsolicited_na", 60077a02bf89SJohannes Berg .data = &ipv6_devconf.drop_unsolicited_na, 60087a02bf89SJohannes Berg .maxlen = sizeof(int), 60097a02bf89SJohannes Berg .mode = 0644, 60107a02bf89SJohannes Berg .proc_handler = proc_dointvec, 60117a02bf89SJohannes Berg }, 60127a02bf89SJohannes Berg { 6013f1705ec1SDavid Ahern .procname = "keep_addr_on_down", 6014f1705ec1SDavid Ahern .data = &ipv6_devconf.keep_addr_on_down, 6015f1705ec1SDavid Ahern .maxlen = sizeof(int), 6016f1705ec1SDavid Ahern .mode = 0644, 6017f1705ec1SDavid Ahern .proc_handler = proc_dointvec, 6018f1705ec1SDavid Ahern 6019f1705ec1SDavid Ahern }, 6020f1705ec1SDavid Ahern { 6021f8572d8fSEric W. Biederman /* sentinel */ 60221da177e4SLinus Torvalds } 60231da177e4SLinus Torvalds }; 60241da177e4SLinus Torvalds 6025bff16c2fSPavel Emelyanov static int __addrconf_sysctl_register(struct net *net, char *dev_name, 6026f8572d8fSEric W. Biederman struct inet6_dev *idev, struct ipv6_devconf *p) 60271da177e4SLinus Torvalds { 60281da177e4SLinus Torvalds int i; 6029607ea7cdSKonstantin Khlebnikov struct ctl_table *table; 60306105e293SEric W. Biederman char path[sizeof("net/ipv6/conf/") + IFNAMSIZ]; 60311dab6222SPavel Emelyanov 6032607ea7cdSKonstantin Khlebnikov table = kmemdup(addrconf_sysctl, sizeof(addrconf_sysctl), GFP_KERNEL); 6033607ea7cdSKonstantin Khlebnikov if (!table) 6034f68635e6SPavel Emelyanov goto out; 6035f68635e6SPavel Emelyanov 6036607ea7cdSKonstantin Khlebnikov for (i = 0; table[i].data; i++) { 6037607ea7cdSKonstantin Khlebnikov table[i].data += (char *)p - (char *)&ipv6_devconf; 6038607ea7cdSKonstantin Khlebnikov table[i].extra1 = idev; /* embedded; no ref */ 6039607ea7cdSKonstantin Khlebnikov table[i].extra2 = net; 60401da177e4SLinus Torvalds } 60411da177e4SLinus Torvalds 60426105e293SEric W. Biederman snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name); 60431da177e4SLinus Torvalds 6044607ea7cdSKonstantin Khlebnikov p->sysctl_header = register_net_sysctl(net, path, table); 6045607ea7cdSKonstantin Khlebnikov if (!p->sysctl_header) 60466105e293SEric W. Biederman goto free; 6047f68635e6SPavel Emelyanov 604895897312SPavel Emelyanov return 0; 60491da177e4SLinus Torvalds 60501da177e4SLinus Torvalds free: 6051607ea7cdSKonstantin Khlebnikov kfree(table); 6052f68635e6SPavel Emelyanov out: 605395897312SPavel Emelyanov return -ENOBUFS; 60541da177e4SLinus Torvalds } 60551da177e4SLinus Torvalds 6056408c4768SPavel Emelyanov static void __addrconf_sysctl_unregister(struct ipv6_devconf *p) 6057f52295a9SPavel Emelyanov { 6058607ea7cdSKonstantin Khlebnikov struct ctl_table *table; 6059f52295a9SPavel Emelyanov 6060607ea7cdSKonstantin Khlebnikov if (!p->sysctl_header) 6061408c4768SPavel Emelyanov return; 6062408c4768SPavel Emelyanov 6063607ea7cdSKonstantin Khlebnikov table = p->sysctl_header->ctl_table_arg; 6064607ea7cdSKonstantin Khlebnikov unregister_net_sysctl_table(p->sysctl_header); 6065607ea7cdSKonstantin Khlebnikov p->sysctl_header = NULL; 6066607ea7cdSKonstantin Khlebnikov kfree(table); 60671da177e4SLinus Torvalds } 6068408c4768SPavel Emelyanov 6069a317a2f1SWANG Cong static int addrconf_sysctl_register(struct inet6_dev *idev) 6070408c4768SPavel Emelyanov { 6071a317a2f1SWANG Cong int err; 6072a317a2f1SWANG Cong 6073a317a2f1SWANG Cong if (!sysctl_dev_name_is_allowed(idev->dev->name)) 6074a317a2f1SWANG Cong return -EINVAL; 6075a317a2f1SWANG Cong 6076a317a2f1SWANG Cong err = neigh_sysctl_register(idev->dev, idev->nd_parms, 6077f8572d8fSEric W. Biederman &ndisc_ifinfo_sysctl_change); 6078a317a2f1SWANG Cong if (err) 6079a317a2f1SWANG Cong return err; 6080a317a2f1SWANG Cong err = __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name, 6081f8572d8fSEric W. Biederman idev, &idev->cnf); 6082a317a2f1SWANG Cong if (err) 6083a317a2f1SWANG Cong neigh_sysctl_unregister(idev->nd_parms); 6084a317a2f1SWANG Cong 6085a317a2f1SWANG Cong return err; 6086408c4768SPavel Emelyanov } 6087408c4768SPavel Emelyanov 6088408c4768SPavel Emelyanov static void addrconf_sysctl_unregister(struct inet6_dev *idev) 6089408c4768SPavel Emelyanov { 6090408c4768SPavel Emelyanov __addrconf_sysctl_unregister(&idev->cnf); 6091408c4768SPavel Emelyanov neigh_sysctl_unregister(idev->nd_parms); 60921da177e4SLinus Torvalds } 60931da177e4SLinus Torvalds 60941da177e4SLinus Torvalds 60951da177e4SLinus Torvalds #endif 60961da177e4SLinus Torvalds 60972c8c1e72SAlexey Dobriyan static int __net_init addrconf_init_net(struct net *net) 6098e0da5a48SPavel Emelyanov { 6099a79ca223SHong Zhiguo int err = -ENOMEM; 6100e0da5a48SPavel Emelyanov struct ipv6_devconf *all, *dflt; 6101e0da5a48SPavel Emelyanov 6102a79ca223SHong Zhiguo all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL); 610363159f29SIan Morris if (!all) 6104e0da5a48SPavel Emelyanov goto err_alloc_all; 6105e0da5a48SPavel Emelyanov 6106a79ca223SHong Zhiguo dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL); 610763159f29SIan Morris if (!dflt) 6108e0da5a48SPavel Emelyanov goto err_alloc_dflt; 6109a79ca223SHong Zhiguo 611056d417b1SBrian Haley /* these will be inherited by all namespaces */ 611156d417b1SBrian Haley dflt->autoconf = ipv6_defaults.autoconf; 611256d417b1SBrian Haley dflt->disable_ipv6 = ipv6_defaults.disable_ipv6; 6113e0da5a48SPavel Emelyanov 61143d1bec99SHannes Frederic Sowa dflt->stable_secret.initialized = false; 61153d1bec99SHannes Frederic Sowa all->stable_secret.initialized = false; 61163d1bec99SHannes Frederic Sowa 6117e0da5a48SPavel Emelyanov net->ipv6.devconf_all = all; 6118e0da5a48SPavel Emelyanov net->ipv6.devconf_dflt = dflt; 6119e0da5a48SPavel Emelyanov 6120e0da5a48SPavel Emelyanov #ifdef CONFIG_SYSCTL 6121f8572d8fSEric W. Biederman err = __addrconf_sysctl_register(net, "all", NULL, all); 6122e0da5a48SPavel Emelyanov if (err < 0) 6123e0da5a48SPavel Emelyanov goto err_reg_all; 6124e0da5a48SPavel Emelyanov 6125f8572d8fSEric W. Biederman err = __addrconf_sysctl_register(net, "default", NULL, dflt); 6126e0da5a48SPavel Emelyanov if (err < 0) 6127e0da5a48SPavel Emelyanov goto err_reg_dflt; 6128e0da5a48SPavel Emelyanov #endif 6129e0da5a48SPavel Emelyanov return 0; 6130e0da5a48SPavel Emelyanov 6131e0da5a48SPavel Emelyanov #ifdef CONFIG_SYSCTL 6132e0da5a48SPavel Emelyanov err_reg_dflt: 6133e0da5a48SPavel Emelyanov __addrconf_sysctl_unregister(all); 6134e0da5a48SPavel Emelyanov err_reg_all: 6135e0da5a48SPavel Emelyanov kfree(dflt); 6136e0da5a48SPavel Emelyanov #endif 6137e0da5a48SPavel Emelyanov err_alloc_dflt: 6138e0da5a48SPavel Emelyanov kfree(all); 6139e0da5a48SPavel Emelyanov err_alloc_all: 6140e0da5a48SPavel Emelyanov return err; 6141e0da5a48SPavel Emelyanov } 6142e0da5a48SPavel Emelyanov 61432c8c1e72SAlexey Dobriyan static void __net_exit addrconf_exit_net(struct net *net) 6144e0da5a48SPavel Emelyanov { 6145e0da5a48SPavel Emelyanov #ifdef CONFIG_SYSCTL 6146e0da5a48SPavel Emelyanov __addrconf_sysctl_unregister(net->ipv6.devconf_dflt); 6147e0da5a48SPavel Emelyanov __addrconf_sysctl_unregister(net->ipv6.devconf_all); 6148e0da5a48SPavel Emelyanov #endif 6149e0da5a48SPavel Emelyanov kfree(net->ipv6.devconf_dflt); 6150e0da5a48SPavel Emelyanov kfree(net->ipv6.devconf_all); 6151e0da5a48SPavel Emelyanov } 6152e0da5a48SPavel Emelyanov 6153e0da5a48SPavel Emelyanov static struct pernet_operations addrconf_ops = { 6154e0da5a48SPavel Emelyanov .init = addrconf_init_net, 6155e0da5a48SPavel Emelyanov .exit = addrconf_exit_net, 6156e0da5a48SPavel Emelyanov }; 6157e0da5a48SPavel Emelyanov 6158207895fdSDaniel Borkmann static struct rtnl_af_ops inet6_ops __read_mostly = { 6159b382b191SThomas Graf .family = AF_INET6, 6160b382b191SThomas Graf .fill_link_af = inet6_fill_link_af, 6161b382b191SThomas Graf .get_link_af_size = inet6_get_link_af_size, 616211b1f828SDaniel Borkmann .validate_link_af = inet6_validate_link_af, 6163f53adae4SDaniel Borkmann .set_link_af = inet6_set_link_af, 6164b382b191SThomas Graf }; 6165b382b191SThomas Graf 61661da177e4SLinus Torvalds /* 61671da177e4SLinus Torvalds * Init / cleanup code 61681da177e4SLinus Torvalds */ 61691da177e4SLinus Torvalds 61701da177e4SLinus Torvalds int __init addrconf_init(void) 61711da177e4SLinus Torvalds { 6172a317a2f1SWANG Cong struct inet6_dev *idev; 6173c2e21293Sstephen hemminger int i, err; 61742a8cc6c8SYOSHIFUJI Hideaki 6175e21e8467SStephen Hemminger err = ipv6_addr_label_init(); 6176e21e8467SStephen Hemminger if (err < 0) { 6177f3213831SJoe Perches pr_crit("%s: cannot initialize default policy table: %d\n", 6178f3213831SJoe Perches __func__, err); 61792cc6d2bfSNeil Horman goto out; 61802a8cc6c8SYOSHIFUJI Hideaki } 61811da177e4SLinus Torvalds 61822cc6d2bfSNeil Horman err = register_pernet_subsys(&addrconf_ops); 61832cc6d2bfSNeil Horman if (err < 0) 61842cc6d2bfSNeil Horman goto out_addrlabel; 6185e0da5a48SPavel Emelyanov 6186c15b1ccaSHannes Frederic Sowa addrconf_wq = create_workqueue("ipv6_addrconf"); 6187c15b1ccaSHannes Frederic Sowa if (!addrconf_wq) { 6188c15b1ccaSHannes Frederic Sowa err = -ENOMEM; 6189c15b1ccaSHannes Frederic Sowa goto out_nowq; 6190c15b1ccaSHannes Frederic Sowa } 6191c15b1ccaSHannes Frederic Sowa 61921da177e4SLinus Torvalds /* The addrconf netdev notifier requires that loopback_dev 61931da177e4SLinus Torvalds * has it's ipv6 private information allocated and setup 61941da177e4SLinus Torvalds * before it can bring up and give link-local addresses 61951da177e4SLinus Torvalds * to other devices which are up. 61961da177e4SLinus Torvalds * 61971da177e4SLinus Torvalds * Unfortunately, loopback_dev is not necessarily the first 61981da177e4SLinus Torvalds * entry in the global dev_base list of net devices. In fact, 61991da177e4SLinus Torvalds * it is likely to be the very last entry on that list. 62001da177e4SLinus Torvalds * So this causes the notifier registry below to try and 62011da177e4SLinus Torvalds * give link-local addresses to all devices besides loopback_dev 62021da177e4SLinus Torvalds * first, then loopback_dev, which cases all the non-loopback_dev 62031da177e4SLinus Torvalds * devices to fail to get a link-local address. 62041da177e4SLinus Torvalds * 62051da177e4SLinus Torvalds * So, as a temporary fix, allocate the ipv6 structure for 62061da177e4SLinus Torvalds * loopback_dev first by hand. 62071da177e4SLinus Torvalds * Longer term, all of the dependencies ipv6 has upon the loopback 62081da177e4SLinus Torvalds * device and it being up should be removed. 62091da177e4SLinus Torvalds */ 62101da177e4SLinus Torvalds rtnl_lock(); 6211a317a2f1SWANG Cong idev = ipv6_add_dev(init_net.loopback_dev); 62121da177e4SLinus Torvalds rtnl_unlock(); 6213a317a2f1SWANG Cong if (IS_ERR(idev)) { 6214a317a2f1SWANG Cong err = PTR_ERR(idev); 6215e0da5a48SPavel Emelyanov goto errlo; 6216a317a2f1SWANG Cong } 62171da177e4SLinus Torvalds 6218c2e21293Sstephen hemminger for (i = 0; i < IN6_ADDR_HSIZE; i++) 6219c2e21293Sstephen hemminger INIT_HLIST_HEAD(&inet6_addr_lst[i]); 6220c2e21293Sstephen hemminger 62211da177e4SLinus Torvalds register_netdevice_notifier(&ipv6_dev_notf); 62221da177e4SLinus Torvalds 6223c15b1ccaSHannes Frederic Sowa addrconf_verify(); 6224c127ea2cSThomas Graf 62253678a9d8Sstephen hemminger rtnl_af_register(&inet6_ops); 6226b382b191SThomas Graf 6227c7ac8679SGreg Rose err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo, 6228c7ac8679SGreg Rose NULL); 6229c127ea2cSThomas Graf if (err < 0) 6230c127ea2cSThomas Graf goto errout; 6231c127ea2cSThomas Graf 6232c127ea2cSThomas Graf /* Only the first call to __rtnl_register can fail */ 6233c7ac8679SGreg Rose __rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL); 6234c7ac8679SGreg Rose __rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL); 6235c7ac8679SGreg Rose __rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr, 6236c7ac8679SGreg Rose inet6_dump_ifaddr, NULL); 6237c7ac8679SGreg Rose __rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL, 6238c7ac8679SGreg Rose inet6_dump_ifmcaddr, NULL); 6239c7ac8679SGreg Rose __rtnl_register(PF_INET6, RTM_GETANYCAST, NULL, 6240c7ac8679SGreg Rose inet6_dump_ifacaddr, NULL); 624176f8f6cbSNicolas Dichtel __rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf, 62427a674200SNicolas Dichtel inet6_netconf_dump_devconf, NULL); 6243c127ea2cSThomas Graf 62442a8cc6c8SYOSHIFUJI Hideaki ipv6_addr_label_rtnl_register(); 62452a8cc6c8SYOSHIFUJI Hideaki 62461da177e4SLinus Torvalds return 0; 6247c127ea2cSThomas Graf errout: 6248b382b191SThomas Graf rtnl_af_unregister(&inet6_ops); 6249c127ea2cSThomas Graf unregister_netdevice_notifier(&ipv6_dev_notf); 6250e0da5a48SPavel Emelyanov errlo: 6251c15b1ccaSHannes Frederic Sowa destroy_workqueue(addrconf_wq); 6252c15b1ccaSHannes Frederic Sowa out_nowq: 6253e0da5a48SPavel Emelyanov unregister_pernet_subsys(&addrconf_ops); 62542cc6d2bfSNeil Horman out_addrlabel: 62552cc6d2bfSNeil Horman ipv6_addr_label_cleanup(); 62562cc6d2bfSNeil Horman out: 6257c127ea2cSThomas Graf return err; 62581da177e4SLinus Torvalds } 62591da177e4SLinus Torvalds 626009f7709fSDaniel Lezcano void addrconf_cleanup(void) 62611da177e4SLinus Torvalds { 6262176c39afSDaniel Lezcano struct net_device *dev; 62631da177e4SLinus Torvalds int i; 62641da177e4SLinus Torvalds 62651da177e4SLinus Torvalds unregister_netdevice_notifier(&ipv6_dev_notf); 6266e0da5a48SPavel Emelyanov unregister_pernet_subsys(&addrconf_ops); 62672cc6d2bfSNeil Horman ipv6_addr_label_cleanup(); 62681da177e4SLinus Torvalds 62691da177e4SLinus Torvalds rtnl_lock(); 62701da177e4SLinus Torvalds 6271b382b191SThomas Graf __rtnl_af_unregister(&inet6_ops); 6272b382b191SThomas Graf 6273176c39afSDaniel Lezcano /* clean dev list */ 6274176c39afSDaniel Lezcano for_each_netdev(&init_net, dev) { 6275176c39afSDaniel Lezcano if (__in6_dev_get(dev) == NULL) 6276176c39afSDaniel Lezcano continue; 6277176c39afSDaniel Lezcano addrconf_ifdown(dev, 1); 6278176c39afSDaniel Lezcano } 6279176c39afSDaniel Lezcano addrconf_ifdown(init_net.loopback_dev, 2); 6280176c39afSDaniel Lezcano 62811da177e4SLinus Torvalds /* 62821da177e4SLinus Torvalds * Check hash table. 62831da177e4SLinus Torvalds */ 62845c578aedSstephen hemminger spin_lock_bh(&addrconf_hash_lock); 6285c2e21293Sstephen hemminger for (i = 0; i < IN6_ADDR_HSIZE; i++) 6286c2e21293Sstephen hemminger WARN_ON(!hlist_empty(&inet6_addr_lst[i])); 62875c578aedSstephen hemminger spin_unlock_bh(&addrconf_hash_lock); 6288c15b1ccaSHannes Frederic Sowa cancel_delayed_work(&addr_chk_work); 62891da177e4SLinus Torvalds rtnl_unlock(); 6290c15b1ccaSHannes Frederic Sowa 6291c15b1ccaSHannes Frederic Sowa destroy_workqueue(addrconf_wq); 62921da177e4SLinus Torvalds } 6293