1 /* 2 * IPv6 Address [auto]configuration 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * as published by the Free Software Foundation; either version 12 * 2 of the License, or (at your option) any later version. 13 */ 14 15 /* 16 * Changes: 17 * 18 * Janos Farkas : delete timer on ifdown 19 * <chexum@bankinf.banki.hu> 20 * Andi Kleen : kill double kfree on module 21 * unload. 22 * Maciej W. Rozycki : FDDI support 23 * sekiya@USAGI : Don't send too many RS 24 * packets. 25 * yoshfuji@USAGI : Fixed interval between DAD 26 * packets. 27 * YOSHIFUJI Hideaki @USAGI : improved accuracy of 28 * address validation timer. 29 * YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041) 30 * support. 31 * Yuji SEKIYA @USAGI : Don't assign a same IPv6 32 * address on a same interface. 33 * YOSHIFUJI Hideaki @USAGI : ARCnet support 34 * YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to 35 * seq_file. 36 * YOSHIFUJI Hideaki @USAGI : improved source address 37 * selection; consider scope, 38 * status etc. 39 */ 40 41 #define pr_fmt(fmt) "IPv6: " fmt 42 43 #include <linux/errno.h> 44 #include <linux/types.h> 45 #include <linux/kernel.h> 46 #include <linux/socket.h> 47 #include <linux/sockios.h> 48 #include <linux/net.h> 49 #include <linux/in6.h> 50 #include <linux/netdevice.h> 51 #include <linux/if_addr.h> 52 #include <linux/if_arp.h> 53 #include <linux/if_arcnet.h> 54 #include <linux/if_infiniband.h> 55 #include <linux/route.h> 56 #include <linux/inetdevice.h> 57 #include <linux/init.h> 58 #include <linux/slab.h> 59 #ifdef CONFIG_SYSCTL 60 #include <linux/sysctl.h> 61 #endif 62 #include <linux/capability.h> 63 #include <linux/delay.h> 64 #include <linux/notifier.h> 65 #include <linux/string.h> 66 #include <linux/hash.h> 67 68 #include <net/net_namespace.h> 69 #include <net/sock.h> 70 #include <net/snmp.h> 71 72 #include <net/af_ieee802154.h> 73 #include <net/firewire.h> 74 #include <net/ipv6.h> 75 #include <net/protocol.h> 76 #include <net/ndisc.h> 77 #include <net/ip6_route.h> 78 #include <net/addrconf.h> 79 #include <net/tcp.h> 80 #include <net/ip.h> 81 #include <net/netlink.h> 82 #include <net/pkt_sched.h> 83 #include <linux/if_tunnel.h> 84 #include <linux/rtnetlink.h> 85 #include <linux/netconf.h> 86 #include <linux/random.h> 87 #include <linux/uaccess.h> 88 #include <asm/unaligned.h> 89 90 #include <linux/proc_fs.h> 91 #include <linux/seq_file.h> 92 #include <linux/export.h> 93 94 /* Set to 3 to get tracing... */ 95 #define ACONF_DEBUG 2 96 97 #if ACONF_DEBUG >= 3 98 #define ADBG(fmt, ...) printk(fmt, ##__VA_ARGS__) 99 #else 100 #define ADBG(fmt, ...) do { if (0) printk(fmt, ##__VA_ARGS__); } while (0) 101 #endif 102 103 #define INFINITY_LIFE_TIME 0xFFFFFFFF 104 105 static inline u32 cstamp_delta(unsigned long cstamp) 106 { 107 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ; 108 } 109 110 #ifdef CONFIG_SYSCTL 111 static void addrconf_sysctl_register(struct inet6_dev *idev); 112 static void addrconf_sysctl_unregister(struct inet6_dev *idev); 113 #else 114 static inline void addrconf_sysctl_register(struct inet6_dev *idev) 115 { 116 } 117 118 static inline void addrconf_sysctl_unregister(struct inet6_dev *idev) 119 { 120 } 121 #endif 122 123 static void __ipv6_regen_rndid(struct inet6_dev *idev); 124 static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr); 125 static void ipv6_regen_rndid(unsigned long data); 126 127 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev); 128 static int ipv6_count_addresses(struct inet6_dev *idev); 129 130 /* 131 * Configured unicast address hash table 132 */ 133 static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE]; 134 static DEFINE_SPINLOCK(addrconf_hash_lock); 135 136 static void addrconf_verify(void); 137 static void addrconf_verify_rtnl(void); 138 static void addrconf_verify_work(struct work_struct *); 139 140 static struct workqueue_struct *addrconf_wq; 141 static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work); 142 143 static void addrconf_join_anycast(struct inet6_ifaddr *ifp); 144 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp); 145 146 static void addrconf_type_change(struct net_device *dev, 147 unsigned long event); 148 static int addrconf_ifdown(struct net_device *dev, int how); 149 150 static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx, 151 int plen, 152 const struct net_device *dev, 153 u32 flags, u32 noflags); 154 155 static void addrconf_dad_start(struct inet6_ifaddr *ifp); 156 static void addrconf_dad_work(struct work_struct *w); 157 static void addrconf_dad_completed(struct inet6_ifaddr *ifp); 158 static void addrconf_dad_run(struct inet6_dev *idev); 159 static void addrconf_rs_timer(unsigned long data); 160 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa); 161 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa); 162 163 static void inet6_prefix_notify(int event, struct inet6_dev *idev, 164 struct prefix_info *pinfo); 165 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr, 166 struct net_device *dev); 167 168 static struct ipv6_devconf ipv6_devconf __read_mostly = { 169 .forwarding = 0, 170 .hop_limit = IPV6_DEFAULT_HOPLIMIT, 171 .mtu6 = IPV6_MIN_MTU, 172 .accept_ra = 1, 173 .accept_redirects = 1, 174 .autoconf = 1, 175 .force_mld_version = 0, 176 .mldv1_unsolicited_report_interval = 10 * HZ, 177 .mldv2_unsolicited_report_interval = HZ, 178 .dad_transmits = 1, 179 .rtr_solicits = MAX_RTR_SOLICITATIONS, 180 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL, 181 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY, 182 .use_tempaddr = 0, 183 .temp_valid_lft = TEMP_VALID_LIFETIME, 184 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME, 185 .regen_max_retry = REGEN_MAX_RETRY, 186 .max_desync_factor = MAX_DESYNC_FACTOR, 187 .max_addresses = IPV6_MAX_ADDRESSES, 188 .accept_ra_defrtr = 1, 189 .accept_ra_pinfo = 1, 190 #ifdef CONFIG_IPV6_ROUTER_PREF 191 .accept_ra_rtr_pref = 1, 192 .rtr_probe_interval = 60 * HZ, 193 #ifdef CONFIG_IPV6_ROUTE_INFO 194 .accept_ra_rt_info_max_plen = 0, 195 #endif 196 #endif 197 .proxy_ndp = 0, 198 .accept_source_route = 0, /* we do not accept RH0 by default. */ 199 .disable_ipv6 = 0, 200 .accept_dad = 1, 201 .suppress_frag_ndisc = 1, 202 }; 203 204 static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = { 205 .forwarding = 0, 206 .hop_limit = IPV6_DEFAULT_HOPLIMIT, 207 .mtu6 = IPV6_MIN_MTU, 208 .accept_ra = 1, 209 .accept_redirects = 1, 210 .autoconf = 1, 211 .force_mld_version = 0, 212 .mldv1_unsolicited_report_interval = 10 * HZ, 213 .mldv2_unsolicited_report_interval = HZ, 214 .dad_transmits = 1, 215 .rtr_solicits = MAX_RTR_SOLICITATIONS, 216 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL, 217 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY, 218 .use_tempaddr = 0, 219 .temp_valid_lft = TEMP_VALID_LIFETIME, 220 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME, 221 .regen_max_retry = REGEN_MAX_RETRY, 222 .max_desync_factor = MAX_DESYNC_FACTOR, 223 .max_addresses = IPV6_MAX_ADDRESSES, 224 .accept_ra_defrtr = 1, 225 .accept_ra_pinfo = 1, 226 #ifdef CONFIG_IPV6_ROUTER_PREF 227 .accept_ra_rtr_pref = 1, 228 .rtr_probe_interval = 60 * HZ, 229 #ifdef CONFIG_IPV6_ROUTE_INFO 230 .accept_ra_rt_info_max_plen = 0, 231 #endif 232 #endif 233 .proxy_ndp = 0, 234 .accept_source_route = 0, /* we do not accept RH0 by default. */ 235 .disable_ipv6 = 0, 236 .accept_dad = 1, 237 .suppress_frag_ndisc = 1, 238 }; 239 240 /* Check if a valid qdisc is available */ 241 static inline bool addrconf_qdisc_ok(const struct net_device *dev) 242 { 243 return !qdisc_tx_is_noop(dev); 244 } 245 246 static void addrconf_del_rs_timer(struct inet6_dev *idev) 247 { 248 if (del_timer(&idev->rs_timer)) 249 __in6_dev_put(idev); 250 } 251 252 static void addrconf_del_dad_work(struct inet6_ifaddr *ifp) 253 { 254 if (cancel_delayed_work(&ifp->dad_work)) 255 __in6_ifa_put(ifp); 256 } 257 258 static void addrconf_mod_rs_timer(struct inet6_dev *idev, 259 unsigned long when) 260 { 261 if (!timer_pending(&idev->rs_timer)) 262 in6_dev_hold(idev); 263 mod_timer(&idev->rs_timer, jiffies + when); 264 } 265 266 static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp, 267 unsigned long delay) 268 { 269 if (!delayed_work_pending(&ifp->dad_work)) 270 in6_ifa_hold(ifp); 271 mod_delayed_work(addrconf_wq, &ifp->dad_work, delay); 272 } 273 274 static int snmp6_alloc_dev(struct inet6_dev *idev) 275 { 276 int i; 277 278 idev->stats.ipv6 = alloc_percpu(struct ipstats_mib); 279 if (!idev->stats.ipv6) 280 goto err_ip; 281 282 for_each_possible_cpu(i) { 283 struct ipstats_mib *addrconf_stats; 284 addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i); 285 u64_stats_init(&addrconf_stats->syncp); 286 } 287 288 289 idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device), 290 GFP_KERNEL); 291 if (!idev->stats.icmpv6dev) 292 goto err_icmp; 293 idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device), 294 GFP_KERNEL); 295 if (!idev->stats.icmpv6msgdev) 296 goto err_icmpmsg; 297 298 return 0; 299 300 err_icmpmsg: 301 kfree(idev->stats.icmpv6dev); 302 err_icmp: 303 free_percpu(idev->stats.ipv6); 304 err_ip: 305 return -ENOMEM; 306 } 307 308 static struct inet6_dev *ipv6_add_dev(struct net_device *dev) 309 { 310 struct inet6_dev *ndev; 311 312 ASSERT_RTNL(); 313 314 if (dev->mtu < IPV6_MIN_MTU) 315 return NULL; 316 317 ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL); 318 319 if (ndev == NULL) 320 return NULL; 321 322 rwlock_init(&ndev->lock); 323 ndev->dev = dev; 324 INIT_LIST_HEAD(&ndev->addr_list); 325 setup_timer(&ndev->rs_timer, addrconf_rs_timer, 326 (unsigned long)ndev); 327 memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf)); 328 ndev->cnf.mtu6 = dev->mtu; 329 ndev->cnf.sysctl = NULL; 330 ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl); 331 if (ndev->nd_parms == NULL) { 332 kfree(ndev); 333 return NULL; 334 } 335 if (ndev->cnf.forwarding) 336 dev_disable_lro(dev); 337 /* We refer to the device */ 338 dev_hold(dev); 339 340 if (snmp6_alloc_dev(ndev) < 0) { 341 ADBG(KERN_WARNING 342 "%s: cannot allocate memory for statistics; dev=%s.\n", 343 __func__, dev->name); 344 neigh_parms_release(&nd_tbl, ndev->nd_parms); 345 dev_put(dev); 346 kfree(ndev); 347 return NULL; 348 } 349 350 if (snmp6_register_dev(ndev) < 0) { 351 ADBG(KERN_WARNING 352 "%s: cannot create /proc/net/dev_snmp6/%s\n", 353 __func__, dev->name); 354 neigh_parms_release(&nd_tbl, ndev->nd_parms); 355 ndev->dead = 1; 356 in6_dev_finish_destroy(ndev); 357 return NULL; 358 } 359 360 /* One reference from device. We must do this before 361 * we invoke __ipv6_regen_rndid(). 362 */ 363 in6_dev_hold(ndev); 364 365 if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) 366 ndev->cnf.accept_dad = -1; 367 368 #if IS_ENABLED(CONFIG_IPV6_SIT) 369 if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) { 370 pr_info("%s: Disabled Multicast RS\n", dev->name); 371 ndev->cnf.rtr_solicits = 0; 372 } 373 #endif 374 375 INIT_LIST_HEAD(&ndev->tempaddr_list); 376 setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev); 377 if ((dev->flags&IFF_LOOPBACK) || 378 dev->type == ARPHRD_TUNNEL || 379 dev->type == ARPHRD_TUNNEL6 || 380 dev->type == ARPHRD_SIT || 381 dev->type == ARPHRD_NONE) { 382 ndev->cnf.use_tempaddr = -1; 383 } else { 384 in6_dev_hold(ndev); 385 ipv6_regen_rndid((unsigned long) ndev); 386 } 387 388 ndev->token = in6addr_any; 389 390 if (netif_running(dev) && addrconf_qdisc_ok(dev)) 391 ndev->if_flags |= IF_READY; 392 393 ipv6_mc_init_dev(ndev); 394 ndev->tstamp = jiffies; 395 addrconf_sysctl_register(ndev); 396 /* protected by rtnl_lock */ 397 rcu_assign_pointer(dev->ip6_ptr, ndev); 398 399 /* Join interface-local all-node multicast group */ 400 ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes); 401 402 /* Join all-node multicast group */ 403 ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes); 404 405 /* Join all-router multicast group if forwarding is set */ 406 if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST)) 407 ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters); 408 409 return ndev; 410 } 411 412 static struct inet6_dev *ipv6_find_idev(struct net_device *dev) 413 { 414 struct inet6_dev *idev; 415 416 ASSERT_RTNL(); 417 418 idev = __in6_dev_get(dev); 419 if (!idev) { 420 idev = ipv6_add_dev(dev); 421 if (!idev) 422 return NULL; 423 } 424 425 if (dev->flags&IFF_UP) 426 ipv6_mc_up(idev); 427 return idev; 428 } 429 430 static int inet6_netconf_msgsize_devconf(int type) 431 { 432 int size = NLMSG_ALIGN(sizeof(struct netconfmsg)) 433 + nla_total_size(4); /* NETCONFA_IFINDEX */ 434 435 /* type -1 is used for ALL */ 436 if (type == -1 || type == NETCONFA_FORWARDING) 437 size += nla_total_size(4); 438 #ifdef CONFIG_IPV6_MROUTE 439 if (type == -1 || type == NETCONFA_MC_FORWARDING) 440 size += nla_total_size(4); 441 #endif 442 if (type == -1 || type == NETCONFA_PROXY_NEIGH) 443 size += nla_total_size(4); 444 445 return size; 446 } 447 448 static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex, 449 struct ipv6_devconf *devconf, u32 portid, 450 u32 seq, int event, unsigned int flags, 451 int type) 452 { 453 struct nlmsghdr *nlh; 454 struct netconfmsg *ncm; 455 456 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg), 457 flags); 458 if (nlh == NULL) 459 return -EMSGSIZE; 460 461 ncm = nlmsg_data(nlh); 462 ncm->ncm_family = AF_INET6; 463 464 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0) 465 goto nla_put_failure; 466 467 /* type -1 is used for ALL */ 468 if ((type == -1 || type == NETCONFA_FORWARDING) && 469 nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0) 470 goto nla_put_failure; 471 #ifdef CONFIG_IPV6_MROUTE 472 if ((type == -1 || type == NETCONFA_MC_FORWARDING) && 473 nla_put_s32(skb, NETCONFA_MC_FORWARDING, 474 devconf->mc_forwarding) < 0) 475 goto nla_put_failure; 476 #endif 477 if ((type == -1 || type == NETCONFA_PROXY_NEIGH) && 478 nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0) 479 goto nla_put_failure; 480 481 return nlmsg_end(skb, nlh); 482 483 nla_put_failure: 484 nlmsg_cancel(skb, nlh); 485 return -EMSGSIZE; 486 } 487 488 void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex, 489 struct ipv6_devconf *devconf) 490 { 491 struct sk_buff *skb; 492 int err = -ENOBUFS; 493 494 skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC); 495 if (skb == NULL) 496 goto errout; 497 498 err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0, 499 RTM_NEWNETCONF, 0, type); 500 if (err < 0) { 501 /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */ 502 WARN_ON(err == -EMSGSIZE); 503 kfree_skb(skb); 504 goto errout; 505 } 506 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_ATOMIC); 507 return; 508 errout: 509 rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err); 510 } 511 512 static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = { 513 [NETCONFA_IFINDEX] = { .len = sizeof(int) }, 514 [NETCONFA_FORWARDING] = { .len = sizeof(int) }, 515 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) }, 516 }; 517 518 static int inet6_netconf_get_devconf(struct sk_buff *in_skb, 519 struct nlmsghdr *nlh) 520 { 521 struct net *net = sock_net(in_skb->sk); 522 struct nlattr *tb[NETCONFA_MAX+1]; 523 struct netconfmsg *ncm; 524 struct sk_buff *skb; 525 struct ipv6_devconf *devconf; 526 struct inet6_dev *in6_dev; 527 struct net_device *dev; 528 int ifindex; 529 int err; 530 531 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, 532 devconf_ipv6_policy); 533 if (err < 0) 534 goto errout; 535 536 err = EINVAL; 537 if (!tb[NETCONFA_IFINDEX]) 538 goto errout; 539 540 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]); 541 switch (ifindex) { 542 case NETCONFA_IFINDEX_ALL: 543 devconf = net->ipv6.devconf_all; 544 break; 545 case NETCONFA_IFINDEX_DEFAULT: 546 devconf = net->ipv6.devconf_dflt; 547 break; 548 default: 549 dev = __dev_get_by_index(net, ifindex); 550 if (dev == NULL) 551 goto errout; 552 in6_dev = __in6_dev_get(dev); 553 if (in6_dev == NULL) 554 goto errout; 555 devconf = &in6_dev->cnf; 556 break; 557 } 558 559 err = -ENOBUFS; 560 skb = nlmsg_new(inet6_netconf_msgsize_devconf(-1), GFP_ATOMIC); 561 if (skb == NULL) 562 goto errout; 563 564 err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 565 NETLINK_CB(in_skb).portid, 566 nlh->nlmsg_seq, RTM_NEWNETCONF, 0, 567 -1); 568 if (err < 0) { 569 /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */ 570 WARN_ON(err == -EMSGSIZE); 571 kfree_skb(skb); 572 goto errout; 573 } 574 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 575 errout: 576 return err; 577 } 578 579 static int inet6_netconf_dump_devconf(struct sk_buff *skb, 580 struct netlink_callback *cb) 581 { 582 struct net *net = sock_net(skb->sk); 583 int h, s_h; 584 int idx, s_idx; 585 struct net_device *dev; 586 struct inet6_dev *idev; 587 struct hlist_head *head; 588 589 s_h = cb->args[0]; 590 s_idx = idx = cb->args[1]; 591 592 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 593 idx = 0; 594 head = &net->dev_index_head[h]; 595 rcu_read_lock(); 596 cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ 597 net->dev_base_seq; 598 hlist_for_each_entry_rcu(dev, head, index_hlist) { 599 if (idx < s_idx) 600 goto cont; 601 idev = __in6_dev_get(dev); 602 if (!idev) 603 goto cont; 604 605 if (inet6_netconf_fill_devconf(skb, dev->ifindex, 606 &idev->cnf, 607 NETLINK_CB(cb->skb).portid, 608 cb->nlh->nlmsg_seq, 609 RTM_NEWNETCONF, 610 NLM_F_MULTI, 611 -1) <= 0) { 612 rcu_read_unlock(); 613 goto done; 614 } 615 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 616 cont: 617 idx++; 618 } 619 rcu_read_unlock(); 620 } 621 if (h == NETDEV_HASHENTRIES) { 622 if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL, 623 net->ipv6.devconf_all, 624 NETLINK_CB(cb->skb).portid, 625 cb->nlh->nlmsg_seq, 626 RTM_NEWNETCONF, NLM_F_MULTI, 627 -1) <= 0) 628 goto done; 629 else 630 h++; 631 } 632 if (h == NETDEV_HASHENTRIES + 1) { 633 if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT, 634 net->ipv6.devconf_dflt, 635 NETLINK_CB(cb->skb).portid, 636 cb->nlh->nlmsg_seq, 637 RTM_NEWNETCONF, NLM_F_MULTI, 638 -1) <= 0) 639 goto done; 640 else 641 h++; 642 } 643 done: 644 cb->args[0] = h; 645 cb->args[1] = idx; 646 647 return skb->len; 648 } 649 650 #ifdef CONFIG_SYSCTL 651 static void dev_forward_change(struct inet6_dev *idev) 652 { 653 struct net_device *dev; 654 struct inet6_ifaddr *ifa; 655 656 if (!idev) 657 return; 658 dev = idev->dev; 659 if (idev->cnf.forwarding) 660 dev_disable_lro(dev); 661 if (dev->flags & IFF_MULTICAST) { 662 if (idev->cnf.forwarding) { 663 ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters); 664 ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters); 665 ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters); 666 } else { 667 ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters); 668 ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters); 669 ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters); 670 } 671 } 672 673 list_for_each_entry(ifa, &idev->addr_list, if_list) { 674 if (ifa->flags&IFA_F_TENTATIVE) 675 continue; 676 if (idev->cnf.forwarding) 677 addrconf_join_anycast(ifa); 678 else 679 addrconf_leave_anycast(ifa); 680 } 681 inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING, 682 dev->ifindex, &idev->cnf); 683 } 684 685 686 static void addrconf_forward_change(struct net *net, __s32 newf) 687 { 688 struct net_device *dev; 689 struct inet6_dev *idev; 690 691 for_each_netdev(net, dev) { 692 idev = __in6_dev_get(dev); 693 if (idev) { 694 int changed = (!idev->cnf.forwarding) ^ (!newf); 695 idev->cnf.forwarding = newf; 696 if (changed) 697 dev_forward_change(idev); 698 } 699 } 700 } 701 702 static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf) 703 { 704 struct net *net; 705 int old; 706 707 if (!rtnl_trylock()) 708 return restart_syscall(); 709 710 net = (struct net *)table->extra2; 711 old = *p; 712 *p = newf; 713 714 if (p == &net->ipv6.devconf_dflt->forwarding) { 715 if ((!newf) ^ (!old)) 716 inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING, 717 NETCONFA_IFINDEX_DEFAULT, 718 net->ipv6.devconf_dflt); 719 rtnl_unlock(); 720 return 0; 721 } 722 723 if (p == &net->ipv6.devconf_all->forwarding) { 724 net->ipv6.devconf_dflt->forwarding = newf; 725 addrconf_forward_change(net, newf); 726 if ((!newf) ^ (!old)) 727 inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING, 728 NETCONFA_IFINDEX_ALL, 729 net->ipv6.devconf_all); 730 } else if ((!newf) ^ (!old)) 731 dev_forward_change((struct inet6_dev *)table->extra1); 732 rtnl_unlock(); 733 734 if (newf) 735 rt6_purge_dflt_routers(net); 736 return 1; 737 } 738 #endif 739 740 /* Nobody refers to this ifaddr, destroy it */ 741 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp) 742 { 743 WARN_ON(!hlist_unhashed(&ifp->addr_lst)); 744 745 #ifdef NET_REFCNT_DEBUG 746 pr_debug("%s\n", __func__); 747 #endif 748 749 in6_dev_put(ifp->idev); 750 751 if (cancel_delayed_work(&ifp->dad_work)) 752 pr_notice("delayed DAD work was pending while freeing ifa=%p\n", 753 ifp); 754 755 if (ifp->state != INET6_IFADDR_STATE_DEAD) { 756 pr_warn("Freeing alive inet6 address %p\n", ifp); 757 return; 758 } 759 ip6_rt_put(ifp->rt); 760 761 kfree_rcu(ifp, rcu); 762 } 763 764 static void 765 ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp) 766 { 767 struct list_head *p; 768 int ifp_scope = ipv6_addr_src_scope(&ifp->addr); 769 770 /* 771 * Each device address list is sorted in order of scope - 772 * global before linklocal. 773 */ 774 list_for_each(p, &idev->addr_list) { 775 struct inet6_ifaddr *ifa 776 = list_entry(p, struct inet6_ifaddr, if_list); 777 if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr)) 778 break; 779 } 780 781 list_add_tail(&ifp->if_list, p); 782 } 783 784 static u32 inet6_addr_hash(const struct in6_addr *addr) 785 { 786 return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT); 787 } 788 789 /* On success it returns ifp with increased reference count */ 790 791 static struct inet6_ifaddr * 792 ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, 793 const struct in6_addr *peer_addr, int pfxlen, 794 int scope, u32 flags, u32 valid_lft, u32 prefered_lft) 795 { 796 struct inet6_ifaddr *ifa = NULL; 797 struct rt6_info *rt; 798 unsigned int hash; 799 int err = 0; 800 int addr_type = ipv6_addr_type(addr); 801 802 if (addr_type == IPV6_ADDR_ANY || 803 addr_type & IPV6_ADDR_MULTICAST || 804 (!(idev->dev->flags & IFF_LOOPBACK) && 805 addr_type & IPV6_ADDR_LOOPBACK)) 806 return ERR_PTR(-EADDRNOTAVAIL); 807 808 rcu_read_lock_bh(); 809 if (idev->dead) { 810 err = -ENODEV; /*XXX*/ 811 goto out2; 812 } 813 814 if (idev->cnf.disable_ipv6) { 815 err = -EACCES; 816 goto out2; 817 } 818 819 spin_lock(&addrconf_hash_lock); 820 821 /* Ignore adding duplicate addresses on an interface */ 822 if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) { 823 ADBG("ipv6_add_addr: already assigned\n"); 824 err = -EEXIST; 825 goto out; 826 } 827 828 ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC); 829 830 if (ifa == NULL) { 831 ADBG("ipv6_add_addr: malloc failed\n"); 832 err = -ENOBUFS; 833 goto out; 834 } 835 836 rt = addrconf_dst_alloc(idev, addr, false); 837 if (IS_ERR(rt)) { 838 err = PTR_ERR(rt); 839 goto out; 840 } 841 842 neigh_parms_data_state_setall(idev->nd_parms); 843 844 ifa->addr = *addr; 845 if (peer_addr) 846 ifa->peer_addr = *peer_addr; 847 848 spin_lock_init(&ifa->lock); 849 spin_lock_init(&ifa->state_lock); 850 INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work); 851 INIT_HLIST_NODE(&ifa->addr_lst); 852 ifa->scope = scope; 853 ifa->prefix_len = pfxlen; 854 ifa->flags = flags | IFA_F_TENTATIVE; 855 ifa->valid_lft = valid_lft; 856 ifa->prefered_lft = prefered_lft; 857 ifa->cstamp = ifa->tstamp = jiffies; 858 ifa->tokenized = false; 859 860 ifa->rt = rt; 861 862 ifa->idev = idev; 863 in6_dev_hold(idev); 864 /* For caller */ 865 in6_ifa_hold(ifa); 866 867 /* Add to big hash table */ 868 hash = inet6_addr_hash(addr); 869 870 hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]); 871 spin_unlock(&addrconf_hash_lock); 872 873 write_lock(&idev->lock); 874 /* Add to inet6_dev unicast addr list. */ 875 ipv6_link_dev_addr(idev, ifa); 876 877 if (ifa->flags&IFA_F_TEMPORARY) { 878 list_add(&ifa->tmp_list, &idev->tempaddr_list); 879 in6_ifa_hold(ifa); 880 } 881 882 in6_ifa_hold(ifa); 883 write_unlock(&idev->lock); 884 out2: 885 rcu_read_unlock_bh(); 886 887 if (likely(err == 0)) 888 inet6addr_notifier_call_chain(NETDEV_UP, ifa); 889 else { 890 kfree(ifa); 891 ifa = ERR_PTR(err); 892 } 893 894 return ifa; 895 out: 896 spin_unlock(&addrconf_hash_lock); 897 goto out2; 898 } 899 900 enum cleanup_prefix_rt_t { 901 CLEANUP_PREFIX_RT_NOP, /* no cleanup action for prefix route */ 902 CLEANUP_PREFIX_RT_DEL, /* delete the prefix route */ 903 CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */ 904 }; 905 906 /* 907 * Check, whether the prefix for ifp would still need a prefix route 908 * after deleting ifp. The function returns one of the CLEANUP_PREFIX_RT_* 909 * constants. 910 * 911 * 1) we don't purge prefix if address was not permanent. 912 * prefix is managed by its own lifetime. 913 * 2) we also don't purge, if the address was IFA_F_NOPREFIXROUTE. 914 * 3) if there are no addresses, delete prefix. 915 * 4) if there are still other permanent address(es), 916 * corresponding prefix is still permanent. 917 * 5) if there are still other addresses with IFA_F_NOPREFIXROUTE, 918 * don't purge the prefix, assume user space is managing it. 919 * 6) otherwise, update prefix lifetime to the 920 * longest valid lifetime among the corresponding 921 * addresses on the device. 922 * Note: subsequent RA will update lifetime. 923 **/ 924 static enum cleanup_prefix_rt_t 925 check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires) 926 { 927 struct inet6_ifaddr *ifa; 928 struct inet6_dev *idev = ifp->idev; 929 unsigned long lifetime; 930 enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL; 931 932 *expires = jiffies; 933 934 list_for_each_entry(ifa, &idev->addr_list, if_list) { 935 if (ifa == ifp) 936 continue; 937 if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr, 938 ifp->prefix_len)) 939 continue; 940 if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE)) 941 return CLEANUP_PREFIX_RT_NOP; 942 943 action = CLEANUP_PREFIX_RT_EXPIRE; 944 945 spin_lock(&ifa->lock); 946 947 lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ); 948 /* 949 * Note: Because this address is 950 * not permanent, lifetime < 951 * LONG_MAX / HZ here. 952 */ 953 if (time_before(*expires, ifa->tstamp + lifetime * HZ)) 954 *expires = ifa->tstamp + lifetime * HZ; 955 spin_unlock(&ifa->lock); 956 } 957 958 return action; 959 } 960 961 static void 962 cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt) 963 { 964 struct rt6_info *rt; 965 966 rt = addrconf_get_prefix_route(&ifp->addr, 967 ifp->prefix_len, 968 ifp->idev->dev, 969 0, RTF_GATEWAY | RTF_DEFAULT); 970 if (rt) { 971 if (del_rt) 972 ip6_del_rt(rt); 973 else { 974 if (!(rt->rt6i_flags & RTF_EXPIRES)) 975 rt6_set_expires(rt, expires); 976 ip6_rt_put(rt); 977 } 978 } 979 } 980 981 982 /* This function wants to get referenced ifp and releases it before return */ 983 984 static void ipv6_del_addr(struct inet6_ifaddr *ifp) 985 { 986 int state; 987 enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP; 988 unsigned long expires; 989 990 ASSERT_RTNL(); 991 992 spin_lock_bh(&ifp->state_lock); 993 state = ifp->state; 994 ifp->state = INET6_IFADDR_STATE_DEAD; 995 spin_unlock_bh(&ifp->state_lock); 996 997 if (state == INET6_IFADDR_STATE_DEAD) 998 goto out; 999 1000 spin_lock_bh(&addrconf_hash_lock); 1001 hlist_del_init_rcu(&ifp->addr_lst); 1002 spin_unlock_bh(&addrconf_hash_lock); 1003 1004 write_lock_bh(&ifp->idev->lock); 1005 1006 if (ifp->flags&IFA_F_TEMPORARY) { 1007 list_del(&ifp->tmp_list); 1008 if (ifp->ifpub) { 1009 in6_ifa_put(ifp->ifpub); 1010 ifp->ifpub = NULL; 1011 } 1012 __in6_ifa_put(ifp); 1013 } 1014 1015 if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE)) 1016 action = check_cleanup_prefix_route(ifp, &expires); 1017 1018 list_del_init(&ifp->if_list); 1019 __in6_ifa_put(ifp); 1020 1021 write_unlock_bh(&ifp->idev->lock); 1022 1023 addrconf_del_dad_work(ifp); 1024 1025 ipv6_ifa_notify(RTM_DELADDR, ifp); 1026 1027 inet6addr_notifier_call_chain(NETDEV_DOWN, ifp); 1028 1029 if (action != CLEANUP_PREFIX_RT_NOP) { 1030 cleanup_prefix_route(ifp, expires, 1031 action == CLEANUP_PREFIX_RT_DEL); 1032 } 1033 1034 /* clean up prefsrc entries */ 1035 rt6_remove_prefsrc(ifp); 1036 out: 1037 in6_ifa_put(ifp); 1038 } 1039 1040 static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift) 1041 { 1042 struct inet6_dev *idev = ifp->idev; 1043 struct in6_addr addr, *tmpaddr; 1044 unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age; 1045 unsigned long regen_advance; 1046 int tmp_plen; 1047 int ret = 0; 1048 u32 addr_flags; 1049 unsigned long now = jiffies; 1050 1051 write_lock_bh(&idev->lock); 1052 if (ift) { 1053 spin_lock_bh(&ift->lock); 1054 memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8); 1055 spin_unlock_bh(&ift->lock); 1056 tmpaddr = &addr; 1057 } else { 1058 tmpaddr = NULL; 1059 } 1060 retry: 1061 in6_dev_hold(idev); 1062 if (idev->cnf.use_tempaddr <= 0) { 1063 write_unlock_bh(&idev->lock); 1064 pr_info("%s: use_tempaddr is disabled\n", __func__); 1065 in6_dev_put(idev); 1066 ret = -1; 1067 goto out; 1068 } 1069 spin_lock_bh(&ifp->lock); 1070 if (ifp->regen_count++ >= idev->cnf.regen_max_retry) { 1071 idev->cnf.use_tempaddr = -1; /*XXX*/ 1072 spin_unlock_bh(&ifp->lock); 1073 write_unlock_bh(&idev->lock); 1074 pr_warn("%s: regeneration time exceeded - disabled temporary address support\n", 1075 __func__); 1076 in6_dev_put(idev); 1077 ret = -1; 1078 goto out; 1079 } 1080 in6_ifa_hold(ifp); 1081 memcpy(addr.s6_addr, ifp->addr.s6_addr, 8); 1082 __ipv6_try_regen_rndid(idev, tmpaddr); 1083 memcpy(&addr.s6_addr[8], idev->rndid, 8); 1084 age = (now - ifp->tstamp) / HZ; 1085 tmp_valid_lft = min_t(__u32, 1086 ifp->valid_lft, 1087 idev->cnf.temp_valid_lft + age); 1088 tmp_prefered_lft = min_t(__u32, 1089 ifp->prefered_lft, 1090 idev->cnf.temp_prefered_lft + age - 1091 idev->cnf.max_desync_factor); 1092 tmp_plen = ifp->prefix_len; 1093 tmp_tstamp = ifp->tstamp; 1094 spin_unlock_bh(&ifp->lock); 1095 1096 regen_advance = idev->cnf.regen_max_retry * 1097 idev->cnf.dad_transmits * 1098 NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ; 1099 write_unlock_bh(&idev->lock); 1100 1101 /* A temporary address is created only if this calculated Preferred 1102 * Lifetime is greater than REGEN_ADVANCE time units. In particular, 1103 * an implementation must not create a temporary address with a zero 1104 * Preferred Lifetime. 1105 * Use age calculation as in addrconf_verify to avoid unnecessary 1106 * temporary addresses being generated. 1107 */ 1108 age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ; 1109 if (tmp_prefered_lft <= regen_advance + age) { 1110 in6_ifa_put(ifp); 1111 in6_dev_put(idev); 1112 ret = -1; 1113 goto out; 1114 } 1115 1116 addr_flags = IFA_F_TEMPORARY; 1117 /* set in addrconf_prefix_rcv() */ 1118 if (ifp->flags & IFA_F_OPTIMISTIC) 1119 addr_flags |= IFA_F_OPTIMISTIC; 1120 1121 ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen, 1122 ipv6_addr_scope(&addr), addr_flags, 1123 tmp_valid_lft, tmp_prefered_lft); 1124 if (IS_ERR(ift)) { 1125 in6_ifa_put(ifp); 1126 in6_dev_put(idev); 1127 pr_info("%s: retry temporary address regeneration\n", __func__); 1128 tmpaddr = &addr; 1129 write_lock_bh(&idev->lock); 1130 goto retry; 1131 } 1132 1133 spin_lock_bh(&ift->lock); 1134 ift->ifpub = ifp; 1135 ift->cstamp = now; 1136 ift->tstamp = tmp_tstamp; 1137 spin_unlock_bh(&ift->lock); 1138 1139 addrconf_dad_start(ift); 1140 in6_ifa_put(ift); 1141 in6_dev_put(idev); 1142 out: 1143 return ret; 1144 } 1145 1146 /* 1147 * Choose an appropriate source address (RFC3484) 1148 */ 1149 enum { 1150 IPV6_SADDR_RULE_INIT = 0, 1151 IPV6_SADDR_RULE_LOCAL, 1152 IPV6_SADDR_RULE_SCOPE, 1153 IPV6_SADDR_RULE_PREFERRED, 1154 #ifdef CONFIG_IPV6_MIP6 1155 IPV6_SADDR_RULE_HOA, 1156 #endif 1157 IPV6_SADDR_RULE_OIF, 1158 IPV6_SADDR_RULE_LABEL, 1159 IPV6_SADDR_RULE_PRIVACY, 1160 IPV6_SADDR_RULE_ORCHID, 1161 IPV6_SADDR_RULE_PREFIX, 1162 IPV6_SADDR_RULE_MAX 1163 }; 1164 1165 struct ipv6_saddr_score { 1166 int rule; 1167 int addr_type; 1168 struct inet6_ifaddr *ifa; 1169 DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX); 1170 int scopedist; 1171 int matchlen; 1172 }; 1173 1174 struct ipv6_saddr_dst { 1175 const struct in6_addr *addr; 1176 int ifindex; 1177 int scope; 1178 int label; 1179 unsigned int prefs; 1180 }; 1181 1182 static inline int ipv6_saddr_preferred(int type) 1183 { 1184 if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK)) 1185 return 1; 1186 return 0; 1187 } 1188 1189 static int ipv6_get_saddr_eval(struct net *net, 1190 struct ipv6_saddr_score *score, 1191 struct ipv6_saddr_dst *dst, 1192 int i) 1193 { 1194 int ret; 1195 1196 if (i <= score->rule) { 1197 switch (i) { 1198 case IPV6_SADDR_RULE_SCOPE: 1199 ret = score->scopedist; 1200 break; 1201 case IPV6_SADDR_RULE_PREFIX: 1202 ret = score->matchlen; 1203 break; 1204 default: 1205 ret = !!test_bit(i, score->scorebits); 1206 } 1207 goto out; 1208 } 1209 1210 switch (i) { 1211 case IPV6_SADDR_RULE_INIT: 1212 /* Rule 0: remember if hiscore is not ready yet */ 1213 ret = !!score->ifa; 1214 break; 1215 case IPV6_SADDR_RULE_LOCAL: 1216 /* Rule 1: Prefer same address */ 1217 ret = ipv6_addr_equal(&score->ifa->addr, dst->addr); 1218 break; 1219 case IPV6_SADDR_RULE_SCOPE: 1220 /* Rule 2: Prefer appropriate scope 1221 * 1222 * ret 1223 * ^ 1224 * -1 | d 15 1225 * ---+--+-+---> scope 1226 * | 1227 * | d is scope of the destination. 1228 * B-d | \ 1229 * | \ <- smaller scope is better if 1230 * B-15 | \ if scope is enough for destination. 1231 * | ret = B - scope (-1 <= scope >= d <= 15). 1232 * d-C-1 | / 1233 * |/ <- greater is better 1234 * -C / if scope is not enough for destination. 1235 * /| ret = scope - C (-1 <= d < scope <= 15). 1236 * 1237 * d - C - 1 < B -15 (for all -1 <= d <= 15). 1238 * C > d + 14 - B >= 15 + 14 - B = 29 - B. 1239 * Assume B = 0 and we get C > 29. 1240 */ 1241 ret = __ipv6_addr_src_scope(score->addr_type); 1242 if (ret >= dst->scope) 1243 ret = -ret; 1244 else 1245 ret -= 128; /* 30 is enough */ 1246 score->scopedist = ret; 1247 break; 1248 case IPV6_SADDR_RULE_PREFERRED: 1249 /* Rule 3: Avoid deprecated and optimistic addresses */ 1250 ret = ipv6_saddr_preferred(score->addr_type) || 1251 !(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC)); 1252 break; 1253 #ifdef CONFIG_IPV6_MIP6 1254 case IPV6_SADDR_RULE_HOA: 1255 { 1256 /* Rule 4: Prefer home address */ 1257 int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA); 1258 ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome; 1259 break; 1260 } 1261 #endif 1262 case IPV6_SADDR_RULE_OIF: 1263 /* Rule 5: Prefer outgoing interface */ 1264 ret = (!dst->ifindex || 1265 dst->ifindex == score->ifa->idev->dev->ifindex); 1266 break; 1267 case IPV6_SADDR_RULE_LABEL: 1268 /* Rule 6: Prefer matching label */ 1269 ret = ipv6_addr_label(net, 1270 &score->ifa->addr, score->addr_type, 1271 score->ifa->idev->dev->ifindex) == dst->label; 1272 break; 1273 case IPV6_SADDR_RULE_PRIVACY: 1274 { 1275 /* Rule 7: Prefer public address 1276 * Note: prefer temporary address if use_tempaddr >= 2 1277 */ 1278 int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ? 1279 !!(dst->prefs & IPV6_PREFER_SRC_TMP) : 1280 score->ifa->idev->cnf.use_tempaddr >= 2; 1281 ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp; 1282 break; 1283 } 1284 case IPV6_SADDR_RULE_ORCHID: 1285 /* Rule 8-: Prefer ORCHID vs ORCHID or 1286 * non-ORCHID vs non-ORCHID 1287 */ 1288 ret = !(ipv6_addr_orchid(&score->ifa->addr) ^ 1289 ipv6_addr_orchid(dst->addr)); 1290 break; 1291 case IPV6_SADDR_RULE_PREFIX: 1292 /* Rule 8: Use longest matching prefix */ 1293 ret = ipv6_addr_diff(&score->ifa->addr, dst->addr); 1294 if (ret > score->ifa->prefix_len) 1295 ret = score->ifa->prefix_len; 1296 score->matchlen = ret; 1297 break; 1298 default: 1299 ret = 0; 1300 } 1301 1302 if (ret) 1303 __set_bit(i, score->scorebits); 1304 score->rule = i; 1305 out: 1306 return ret; 1307 } 1308 1309 int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev, 1310 const struct in6_addr *daddr, unsigned int prefs, 1311 struct in6_addr *saddr) 1312 { 1313 struct ipv6_saddr_score scores[2], 1314 *score = &scores[0], *hiscore = &scores[1]; 1315 struct ipv6_saddr_dst dst; 1316 struct net_device *dev; 1317 int dst_type; 1318 1319 dst_type = __ipv6_addr_type(daddr); 1320 dst.addr = daddr; 1321 dst.ifindex = dst_dev ? dst_dev->ifindex : 0; 1322 dst.scope = __ipv6_addr_src_scope(dst_type); 1323 dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex); 1324 dst.prefs = prefs; 1325 1326 hiscore->rule = -1; 1327 hiscore->ifa = NULL; 1328 1329 rcu_read_lock(); 1330 1331 for_each_netdev_rcu(net, dev) { 1332 struct inet6_dev *idev; 1333 1334 /* Candidate Source Address (section 4) 1335 * - multicast and link-local destination address, 1336 * the set of candidate source address MUST only 1337 * include addresses assigned to interfaces 1338 * belonging to the same link as the outgoing 1339 * interface. 1340 * (- For site-local destination addresses, the 1341 * set of candidate source addresses MUST only 1342 * include addresses assigned to interfaces 1343 * belonging to the same site as the outgoing 1344 * interface.) 1345 */ 1346 if (((dst_type & IPV6_ADDR_MULTICAST) || 1347 dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL) && 1348 dst.ifindex && dev->ifindex != dst.ifindex) 1349 continue; 1350 1351 idev = __in6_dev_get(dev); 1352 if (!idev) 1353 continue; 1354 1355 read_lock_bh(&idev->lock); 1356 list_for_each_entry(score->ifa, &idev->addr_list, if_list) { 1357 int i; 1358 1359 /* 1360 * - Tentative Address (RFC2462 section 5.4) 1361 * - A tentative address is not considered 1362 * "assigned to an interface" in the traditional 1363 * sense, unless it is also flagged as optimistic. 1364 * - Candidate Source Address (section 4) 1365 * - In any case, anycast addresses, multicast 1366 * addresses, and the unspecified address MUST 1367 * NOT be included in a candidate set. 1368 */ 1369 if ((score->ifa->flags & IFA_F_TENTATIVE) && 1370 (!(score->ifa->flags & IFA_F_OPTIMISTIC))) 1371 continue; 1372 1373 score->addr_type = __ipv6_addr_type(&score->ifa->addr); 1374 1375 if (unlikely(score->addr_type == IPV6_ADDR_ANY || 1376 score->addr_type & IPV6_ADDR_MULTICAST)) { 1377 LIMIT_NETDEBUG(KERN_DEBUG 1378 "ADDRCONF: unspecified / multicast address " 1379 "assigned as unicast address on %s", 1380 dev->name); 1381 continue; 1382 } 1383 1384 score->rule = -1; 1385 bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX); 1386 1387 for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) { 1388 int minihiscore, miniscore; 1389 1390 minihiscore = ipv6_get_saddr_eval(net, hiscore, &dst, i); 1391 miniscore = ipv6_get_saddr_eval(net, score, &dst, i); 1392 1393 if (minihiscore > miniscore) { 1394 if (i == IPV6_SADDR_RULE_SCOPE && 1395 score->scopedist > 0) { 1396 /* 1397 * special case: 1398 * each remaining entry 1399 * has too small (not enough) 1400 * scope, because ifa entries 1401 * are sorted by their scope 1402 * values. 1403 */ 1404 goto try_nextdev; 1405 } 1406 break; 1407 } else if (minihiscore < miniscore) { 1408 if (hiscore->ifa) 1409 in6_ifa_put(hiscore->ifa); 1410 1411 in6_ifa_hold(score->ifa); 1412 1413 swap(hiscore, score); 1414 1415 /* restore our iterator */ 1416 score->ifa = hiscore->ifa; 1417 1418 break; 1419 } 1420 } 1421 } 1422 try_nextdev: 1423 read_unlock_bh(&idev->lock); 1424 } 1425 rcu_read_unlock(); 1426 1427 if (!hiscore->ifa) 1428 return -EADDRNOTAVAIL; 1429 1430 *saddr = hiscore->ifa->addr; 1431 in6_ifa_put(hiscore->ifa); 1432 return 0; 1433 } 1434 EXPORT_SYMBOL(ipv6_dev_get_saddr); 1435 1436 int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr, 1437 u32 banned_flags) 1438 { 1439 struct inet6_ifaddr *ifp; 1440 int err = -EADDRNOTAVAIL; 1441 1442 list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) { 1443 if (ifp->scope > IFA_LINK) 1444 break; 1445 if (ifp->scope == IFA_LINK && 1446 !(ifp->flags & banned_flags)) { 1447 *addr = ifp->addr; 1448 err = 0; 1449 break; 1450 } 1451 } 1452 return err; 1453 } 1454 1455 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr, 1456 u32 banned_flags) 1457 { 1458 struct inet6_dev *idev; 1459 int err = -EADDRNOTAVAIL; 1460 1461 rcu_read_lock(); 1462 idev = __in6_dev_get(dev); 1463 if (idev) { 1464 read_lock_bh(&idev->lock); 1465 err = __ipv6_get_lladdr(idev, addr, banned_flags); 1466 read_unlock_bh(&idev->lock); 1467 } 1468 rcu_read_unlock(); 1469 return err; 1470 } 1471 1472 static int ipv6_count_addresses(struct inet6_dev *idev) 1473 { 1474 int cnt = 0; 1475 struct inet6_ifaddr *ifp; 1476 1477 read_lock_bh(&idev->lock); 1478 list_for_each_entry(ifp, &idev->addr_list, if_list) 1479 cnt++; 1480 read_unlock_bh(&idev->lock); 1481 return cnt; 1482 } 1483 1484 int ipv6_chk_addr(struct net *net, const struct in6_addr *addr, 1485 const struct net_device *dev, int strict) 1486 { 1487 struct inet6_ifaddr *ifp; 1488 unsigned int hash = inet6_addr_hash(addr); 1489 1490 rcu_read_lock_bh(); 1491 hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { 1492 if (!net_eq(dev_net(ifp->idev->dev), net)) 1493 continue; 1494 if (ipv6_addr_equal(&ifp->addr, addr) && 1495 !(ifp->flags&IFA_F_TENTATIVE) && 1496 (dev == NULL || ifp->idev->dev == dev || 1497 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) { 1498 rcu_read_unlock_bh(); 1499 return 1; 1500 } 1501 } 1502 1503 rcu_read_unlock_bh(); 1504 return 0; 1505 } 1506 EXPORT_SYMBOL(ipv6_chk_addr); 1507 1508 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr, 1509 struct net_device *dev) 1510 { 1511 unsigned int hash = inet6_addr_hash(addr); 1512 struct inet6_ifaddr *ifp; 1513 1514 hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) { 1515 if (!net_eq(dev_net(ifp->idev->dev), net)) 1516 continue; 1517 if (ipv6_addr_equal(&ifp->addr, addr)) { 1518 if (dev == NULL || ifp->idev->dev == dev) 1519 return true; 1520 } 1521 } 1522 return false; 1523 } 1524 1525 /* Compares an address/prefix_len with addresses on device @dev. 1526 * If one is found it returns true. 1527 */ 1528 bool ipv6_chk_custom_prefix(const struct in6_addr *addr, 1529 const unsigned int prefix_len, struct net_device *dev) 1530 { 1531 struct inet6_dev *idev; 1532 struct inet6_ifaddr *ifa; 1533 bool ret = false; 1534 1535 rcu_read_lock(); 1536 idev = __in6_dev_get(dev); 1537 if (idev) { 1538 read_lock_bh(&idev->lock); 1539 list_for_each_entry(ifa, &idev->addr_list, if_list) { 1540 ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len); 1541 if (ret) 1542 break; 1543 } 1544 read_unlock_bh(&idev->lock); 1545 } 1546 rcu_read_unlock(); 1547 1548 return ret; 1549 } 1550 EXPORT_SYMBOL(ipv6_chk_custom_prefix); 1551 1552 int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev) 1553 { 1554 struct inet6_dev *idev; 1555 struct inet6_ifaddr *ifa; 1556 int onlink; 1557 1558 onlink = 0; 1559 rcu_read_lock(); 1560 idev = __in6_dev_get(dev); 1561 if (idev) { 1562 read_lock_bh(&idev->lock); 1563 list_for_each_entry(ifa, &idev->addr_list, if_list) { 1564 onlink = ipv6_prefix_equal(addr, &ifa->addr, 1565 ifa->prefix_len); 1566 if (onlink) 1567 break; 1568 } 1569 read_unlock_bh(&idev->lock); 1570 } 1571 rcu_read_unlock(); 1572 return onlink; 1573 } 1574 EXPORT_SYMBOL(ipv6_chk_prefix); 1575 1576 struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr, 1577 struct net_device *dev, int strict) 1578 { 1579 struct inet6_ifaddr *ifp, *result = NULL; 1580 unsigned int hash = inet6_addr_hash(addr); 1581 1582 rcu_read_lock_bh(); 1583 hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) { 1584 if (!net_eq(dev_net(ifp->idev->dev), net)) 1585 continue; 1586 if (ipv6_addr_equal(&ifp->addr, addr)) { 1587 if (dev == NULL || ifp->idev->dev == dev || 1588 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) { 1589 result = ifp; 1590 in6_ifa_hold(ifp); 1591 break; 1592 } 1593 } 1594 } 1595 rcu_read_unlock_bh(); 1596 1597 return result; 1598 } 1599 1600 /* Gets referenced address, destroys ifaddr */ 1601 1602 static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed) 1603 { 1604 if (ifp->flags&IFA_F_PERMANENT) { 1605 spin_lock_bh(&ifp->lock); 1606 addrconf_del_dad_work(ifp); 1607 ifp->flags |= IFA_F_TENTATIVE; 1608 if (dad_failed) 1609 ifp->flags |= IFA_F_DADFAILED; 1610 spin_unlock_bh(&ifp->lock); 1611 if (dad_failed) 1612 ipv6_ifa_notify(0, ifp); 1613 in6_ifa_put(ifp); 1614 } else if (ifp->flags&IFA_F_TEMPORARY) { 1615 struct inet6_ifaddr *ifpub; 1616 spin_lock_bh(&ifp->lock); 1617 ifpub = ifp->ifpub; 1618 if (ifpub) { 1619 in6_ifa_hold(ifpub); 1620 spin_unlock_bh(&ifp->lock); 1621 ipv6_create_tempaddr(ifpub, ifp); 1622 in6_ifa_put(ifpub); 1623 } else { 1624 spin_unlock_bh(&ifp->lock); 1625 } 1626 ipv6_del_addr(ifp); 1627 } else { 1628 ipv6_del_addr(ifp); 1629 } 1630 } 1631 1632 static int addrconf_dad_end(struct inet6_ifaddr *ifp) 1633 { 1634 int err = -ENOENT; 1635 1636 spin_lock_bh(&ifp->state_lock); 1637 if (ifp->state == INET6_IFADDR_STATE_DAD) { 1638 ifp->state = INET6_IFADDR_STATE_POSTDAD; 1639 err = 0; 1640 } 1641 spin_unlock_bh(&ifp->state_lock); 1642 1643 return err; 1644 } 1645 1646 void addrconf_dad_failure(struct inet6_ifaddr *ifp) 1647 { 1648 struct inet6_dev *idev = ifp->idev; 1649 1650 if (addrconf_dad_end(ifp)) { 1651 in6_ifa_put(ifp); 1652 return; 1653 } 1654 1655 net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n", 1656 ifp->idev->dev->name, &ifp->addr); 1657 1658 if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) { 1659 struct in6_addr addr; 1660 1661 addr.s6_addr32[0] = htonl(0xfe800000); 1662 addr.s6_addr32[1] = 0; 1663 1664 if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) && 1665 ipv6_addr_equal(&ifp->addr, &addr)) { 1666 /* DAD failed for link-local based on MAC address */ 1667 idev->cnf.disable_ipv6 = 1; 1668 1669 pr_info("%s: IPv6 being disabled!\n", 1670 ifp->idev->dev->name); 1671 } 1672 } 1673 1674 spin_lock_bh(&ifp->state_lock); 1675 /* transition from _POSTDAD to _ERRDAD */ 1676 ifp->state = INET6_IFADDR_STATE_ERRDAD; 1677 spin_unlock_bh(&ifp->state_lock); 1678 1679 addrconf_mod_dad_work(ifp, 0); 1680 } 1681 1682 /* Join to solicited addr multicast group. */ 1683 1684 void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr) 1685 { 1686 struct in6_addr maddr; 1687 1688 ASSERT_RTNL(); 1689 1690 if (dev->flags&(IFF_LOOPBACK|IFF_NOARP)) 1691 return; 1692 1693 addrconf_addr_solict_mult(addr, &maddr); 1694 ipv6_dev_mc_inc(dev, &maddr); 1695 } 1696 1697 void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr) 1698 { 1699 struct in6_addr maddr; 1700 1701 ASSERT_RTNL(); 1702 1703 if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP)) 1704 return; 1705 1706 addrconf_addr_solict_mult(addr, &maddr); 1707 __ipv6_dev_mc_dec(idev, &maddr); 1708 } 1709 1710 static void addrconf_join_anycast(struct inet6_ifaddr *ifp) 1711 { 1712 struct in6_addr addr; 1713 1714 ASSERT_RTNL(); 1715 1716 if (ifp->prefix_len >= 127) /* RFC 6164 */ 1717 return; 1718 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 1719 if (ipv6_addr_any(&addr)) 1720 return; 1721 ipv6_dev_ac_inc(ifp->idev->dev, &addr); 1722 } 1723 1724 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp) 1725 { 1726 struct in6_addr addr; 1727 1728 ASSERT_RTNL(); 1729 1730 if (ifp->prefix_len >= 127) /* RFC 6164 */ 1731 return; 1732 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 1733 if (ipv6_addr_any(&addr)) 1734 return; 1735 __ipv6_dev_ac_dec(ifp->idev, &addr); 1736 } 1737 1738 static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev) 1739 { 1740 if (dev->addr_len != ETH_ALEN) 1741 return -1; 1742 memcpy(eui, dev->dev_addr, 3); 1743 memcpy(eui + 5, dev->dev_addr + 3, 3); 1744 1745 /* 1746 * The zSeries OSA network cards can be shared among various 1747 * OS instances, but the OSA cards have only one MAC address. 1748 * This leads to duplicate address conflicts in conjunction 1749 * with IPv6 if more than one instance uses the same card. 1750 * 1751 * The driver for these cards can deliver a unique 16-bit 1752 * identifier for each instance sharing the same card. It is 1753 * placed instead of 0xFFFE in the interface identifier. The 1754 * "u" bit of the interface identifier is not inverted in this 1755 * case. Hence the resulting interface identifier has local 1756 * scope according to RFC2373. 1757 */ 1758 if (dev->dev_id) { 1759 eui[3] = (dev->dev_id >> 8) & 0xFF; 1760 eui[4] = dev->dev_id & 0xFF; 1761 } else { 1762 eui[3] = 0xFF; 1763 eui[4] = 0xFE; 1764 eui[0] ^= 2; 1765 } 1766 return 0; 1767 } 1768 1769 static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev) 1770 { 1771 if (dev->addr_len != IEEE802154_ADDR_LEN) 1772 return -1; 1773 memcpy(eui, dev->dev_addr, 8); 1774 eui[0] ^= 2; 1775 return 0; 1776 } 1777 1778 static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev) 1779 { 1780 union fwnet_hwaddr *ha; 1781 1782 if (dev->addr_len != FWNET_ALEN) 1783 return -1; 1784 1785 ha = (union fwnet_hwaddr *)dev->dev_addr; 1786 1787 memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id)); 1788 eui[0] ^= 2; 1789 return 0; 1790 } 1791 1792 static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev) 1793 { 1794 /* XXX: inherit EUI-64 from other interface -- yoshfuji */ 1795 if (dev->addr_len != ARCNET_ALEN) 1796 return -1; 1797 memset(eui, 0, 7); 1798 eui[7] = *(u8 *)dev->dev_addr; 1799 return 0; 1800 } 1801 1802 static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev) 1803 { 1804 if (dev->addr_len != INFINIBAND_ALEN) 1805 return -1; 1806 memcpy(eui, dev->dev_addr + 12, 8); 1807 eui[0] |= 2; 1808 return 0; 1809 } 1810 1811 static int __ipv6_isatap_ifid(u8 *eui, __be32 addr) 1812 { 1813 if (addr == 0) 1814 return -1; 1815 eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) || 1816 ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) || 1817 ipv4_is_private_172(addr) || ipv4_is_test_192(addr) || 1818 ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) || 1819 ipv4_is_test_198(addr) || ipv4_is_multicast(addr) || 1820 ipv4_is_lbcast(addr)) ? 0x00 : 0x02; 1821 eui[1] = 0; 1822 eui[2] = 0x5E; 1823 eui[3] = 0xFE; 1824 memcpy(eui + 4, &addr, 4); 1825 return 0; 1826 } 1827 1828 static int addrconf_ifid_sit(u8 *eui, struct net_device *dev) 1829 { 1830 if (dev->priv_flags & IFF_ISATAP) 1831 return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr); 1832 return -1; 1833 } 1834 1835 static int addrconf_ifid_gre(u8 *eui, struct net_device *dev) 1836 { 1837 return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr); 1838 } 1839 1840 static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev) 1841 { 1842 memcpy(eui, dev->perm_addr, 3); 1843 memcpy(eui + 5, dev->perm_addr + 3, 3); 1844 eui[3] = 0xFF; 1845 eui[4] = 0xFE; 1846 eui[0] ^= 2; 1847 return 0; 1848 } 1849 1850 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev) 1851 { 1852 switch (dev->type) { 1853 case ARPHRD_ETHER: 1854 case ARPHRD_FDDI: 1855 return addrconf_ifid_eui48(eui, dev); 1856 case ARPHRD_ARCNET: 1857 return addrconf_ifid_arcnet(eui, dev); 1858 case ARPHRD_INFINIBAND: 1859 return addrconf_ifid_infiniband(eui, dev); 1860 case ARPHRD_SIT: 1861 return addrconf_ifid_sit(eui, dev); 1862 case ARPHRD_IPGRE: 1863 return addrconf_ifid_gre(eui, dev); 1864 case ARPHRD_6LOWPAN: 1865 case ARPHRD_IEEE802154: 1866 return addrconf_ifid_eui64(eui, dev); 1867 case ARPHRD_IEEE1394: 1868 return addrconf_ifid_ieee1394(eui, dev); 1869 case ARPHRD_TUNNEL6: 1870 return addrconf_ifid_ip6tnl(eui, dev); 1871 } 1872 return -1; 1873 } 1874 1875 static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev) 1876 { 1877 int err = -1; 1878 struct inet6_ifaddr *ifp; 1879 1880 read_lock_bh(&idev->lock); 1881 list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) { 1882 if (ifp->scope > IFA_LINK) 1883 break; 1884 if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) { 1885 memcpy(eui, ifp->addr.s6_addr+8, 8); 1886 err = 0; 1887 break; 1888 } 1889 } 1890 read_unlock_bh(&idev->lock); 1891 return err; 1892 } 1893 1894 /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */ 1895 static void __ipv6_regen_rndid(struct inet6_dev *idev) 1896 { 1897 regen: 1898 get_random_bytes(idev->rndid, sizeof(idev->rndid)); 1899 idev->rndid[0] &= ~0x02; 1900 1901 /* 1902 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>: 1903 * check if generated address is not inappropriate 1904 * 1905 * - Reserved subnet anycast (RFC 2526) 1906 * 11111101 11....11 1xxxxxxx 1907 * - ISATAP (RFC4214) 6.1 1908 * 00-00-5E-FE-xx-xx-xx-xx 1909 * - value 0 1910 * - XXX: already assigned to an address on the device 1911 */ 1912 if (idev->rndid[0] == 0xfd && 1913 (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff && 1914 (idev->rndid[7]&0x80)) 1915 goto regen; 1916 if ((idev->rndid[0]|idev->rndid[1]) == 0) { 1917 if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe) 1918 goto regen; 1919 if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00) 1920 goto regen; 1921 } 1922 } 1923 1924 static void ipv6_regen_rndid(unsigned long data) 1925 { 1926 struct inet6_dev *idev = (struct inet6_dev *) data; 1927 unsigned long expires; 1928 1929 rcu_read_lock_bh(); 1930 write_lock_bh(&idev->lock); 1931 1932 if (idev->dead) 1933 goto out; 1934 1935 __ipv6_regen_rndid(idev); 1936 1937 expires = jiffies + 1938 idev->cnf.temp_prefered_lft * HZ - 1939 idev->cnf.regen_max_retry * idev->cnf.dad_transmits * 1940 NEIGH_VAR(idev->nd_parms, RETRANS_TIME) - 1941 idev->cnf.max_desync_factor * HZ; 1942 if (time_before(expires, jiffies)) { 1943 pr_warn("%s: too short regeneration interval; timer disabled for %s\n", 1944 __func__, idev->dev->name); 1945 goto out; 1946 } 1947 1948 if (!mod_timer(&idev->regen_timer, expires)) 1949 in6_dev_hold(idev); 1950 1951 out: 1952 write_unlock_bh(&idev->lock); 1953 rcu_read_unlock_bh(); 1954 in6_dev_put(idev); 1955 } 1956 1957 static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr) 1958 { 1959 if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0) 1960 __ipv6_regen_rndid(idev); 1961 } 1962 1963 /* 1964 * Add prefix route. 1965 */ 1966 1967 static void 1968 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev, 1969 unsigned long expires, u32 flags) 1970 { 1971 struct fib6_config cfg = { 1972 .fc_table = RT6_TABLE_PREFIX, 1973 .fc_metric = IP6_RT_PRIO_ADDRCONF, 1974 .fc_ifindex = dev->ifindex, 1975 .fc_expires = expires, 1976 .fc_dst_len = plen, 1977 .fc_flags = RTF_UP | flags, 1978 .fc_nlinfo.nl_net = dev_net(dev), 1979 .fc_protocol = RTPROT_KERNEL, 1980 }; 1981 1982 cfg.fc_dst = *pfx; 1983 1984 /* Prevent useless cloning on PtP SIT. 1985 This thing is done here expecting that the whole 1986 class of non-broadcast devices need not cloning. 1987 */ 1988 #if IS_ENABLED(CONFIG_IPV6_SIT) 1989 if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT)) 1990 cfg.fc_flags |= RTF_NONEXTHOP; 1991 #endif 1992 1993 ip6_route_add(&cfg); 1994 } 1995 1996 1997 static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx, 1998 int plen, 1999 const struct net_device *dev, 2000 u32 flags, u32 noflags) 2001 { 2002 struct fib6_node *fn; 2003 struct rt6_info *rt = NULL; 2004 struct fib6_table *table; 2005 2006 table = fib6_get_table(dev_net(dev), RT6_TABLE_PREFIX); 2007 if (table == NULL) 2008 return NULL; 2009 2010 read_lock_bh(&table->tb6_lock); 2011 fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0); 2012 if (!fn) 2013 goto out; 2014 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) { 2015 if (rt->dst.dev->ifindex != dev->ifindex) 2016 continue; 2017 if ((rt->rt6i_flags & flags) != flags) 2018 continue; 2019 if ((rt->rt6i_flags & noflags) != 0) 2020 continue; 2021 dst_hold(&rt->dst); 2022 break; 2023 } 2024 out: 2025 read_unlock_bh(&table->tb6_lock); 2026 return rt; 2027 } 2028 2029 2030 /* Create "default" multicast route to the interface */ 2031 2032 static void addrconf_add_mroute(struct net_device *dev) 2033 { 2034 struct fib6_config cfg = { 2035 .fc_table = RT6_TABLE_LOCAL, 2036 .fc_metric = IP6_RT_PRIO_ADDRCONF, 2037 .fc_ifindex = dev->ifindex, 2038 .fc_dst_len = 8, 2039 .fc_flags = RTF_UP, 2040 .fc_nlinfo.nl_net = dev_net(dev), 2041 }; 2042 2043 ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0); 2044 2045 ip6_route_add(&cfg); 2046 } 2047 2048 static struct inet6_dev *addrconf_add_dev(struct net_device *dev) 2049 { 2050 struct inet6_dev *idev; 2051 2052 ASSERT_RTNL(); 2053 2054 idev = ipv6_find_idev(dev); 2055 if (!idev) 2056 return ERR_PTR(-ENOBUFS); 2057 2058 if (idev->cnf.disable_ipv6) 2059 return ERR_PTR(-EACCES); 2060 2061 /* Add default multicast route */ 2062 if (!(dev->flags & IFF_LOOPBACK)) 2063 addrconf_add_mroute(dev); 2064 2065 return idev; 2066 } 2067 2068 static void manage_tempaddrs(struct inet6_dev *idev, 2069 struct inet6_ifaddr *ifp, 2070 __u32 valid_lft, __u32 prefered_lft, 2071 bool create, unsigned long now) 2072 { 2073 u32 flags; 2074 struct inet6_ifaddr *ift; 2075 2076 read_lock_bh(&idev->lock); 2077 /* update all temporary addresses in the list */ 2078 list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) { 2079 int age, max_valid, max_prefered; 2080 2081 if (ifp != ift->ifpub) 2082 continue; 2083 2084 /* RFC 4941 section 3.3: 2085 * If a received option will extend the lifetime of a public 2086 * address, the lifetimes of temporary addresses should 2087 * be extended, subject to the overall constraint that no 2088 * temporary addresses should ever remain "valid" or "preferred" 2089 * for a time longer than (TEMP_VALID_LIFETIME) or 2090 * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR), respectively. 2091 */ 2092 age = (now - ift->cstamp) / HZ; 2093 max_valid = idev->cnf.temp_valid_lft - age; 2094 if (max_valid < 0) 2095 max_valid = 0; 2096 2097 max_prefered = idev->cnf.temp_prefered_lft - 2098 idev->cnf.max_desync_factor - age; 2099 if (max_prefered < 0) 2100 max_prefered = 0; 2101 2102 if (valid_lft > max_valid) 2103 valid_lft = max_valid; 2104 2105 if (prefered_lft > max_prefered) 2106 prefered_lft = max_prefered; 2107 2108 spin_lock(&ift->lock); 2109 flags = ift->flags; 2110 ift->valid_lft = valid_lft; 2111 ift->prefered_lft = prefered_lft; 2112 ift->tstamp = now; 2113 if (prefered_lft > 0) 2114 ift->flags &= ~IFA_F_DEPRECATED; 2115 2116 spin_unlock(&ift->lock); 2117 if (!(flags&IFA_F_TENTATIVE)) 2118 ipv6_ifa_notify(0, ift); 2119 } 2120 2121 if ((create || list_empty(&idev->tempaddr_list)) && 2122 idev->cnf.use_tempaddr > 0) { 2123 /* When a new public address is created as described 2124 * in [ADDRCONF], also create a new temporary address. 2125 * Also create a temporary address if it's enabled but 2126 * no temporary address currently exists. 2127 */ 2128 read_unlock_bh(&idev->lock); 2129 ipv6_create_tempaddr(ifp, NULL); 2130 } else { 2131 read_unlock_bh(&idev->lock); 2132 } 2133 } 2134 2135 void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao) 2136 { 2137 struct prefix_info *pinfo; 2138 __u32 valid_lft; 2139 __u32 prefered_lft; 2140 int addr_type; 2141 struct inet6_dev *in6_dev; 2142 struct net *net = dev_net(dev); 2143 2144 pinfo = (struct prefix_info *) opt; 2145 2146 if (len < sizeof(struct prefix_info)) { 2147 ADBG("addrconf: prefix option too short\n"); 2148 return; 2149 } 2150 2151 /* 2152 * Validation checks ([ADDRCONF], page 19) 2153 */ 2154 2155 addr_type = ipv6_addr_type(&pinfo->prefix); 2156 2157 if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL)) 2158 return; 2159 2160 valid_lft = ntohl(pinfo->valid); 2161 prefered_lft = ntohl(pinfo->prefered); 2162 2163 if (prefered_lft > valid_lft) { 2164 net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n"); 2165 return; 2166 } 2167 2168 in6_dev = in6_dev_get(dev); 2169 2170 if (in6_dev == NULL) { 2171 net_dbg_ratelimited("addrconf: device %s not configured\n", 2172 dev->name); 2173 return; 2174 } 2175 2176 /* 2177 * Two things going on here: 2178 * 1) Add routes for on-link prefixes 2179 * 2) Configure prefixes with the auto flag set 2180 */ 2181 2182 if (pinfo->onlink) { 2183 struct rt6_info *rt; 2184 unsigned long rt_expires; 2185 2186 /* Avoid arithmetic overflow. Really, we could 2187 * save rt_expires in seconds, likely valid_lft, 2188 * but it would require division in fib gc, that it 2189 * not good. 2190 */ 2191 if (HZ > USER_HZ) 2192 rt_expires = addrconf_timeout_fixup(valid_lft, HZ); 2193 else 2194 rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ); 2195 2196 if (addrconf_finite_timeout(rt_expires)) 2197 rt_expires *= HZ; 2198 2199 rt = addrconf_get_prefix_route(&pinfo->prefix, 2200 pinfo->prefix_len, 2201 dev, 2202 RTF_ADDRCONF | RTF_PREFIX_RT, 2203 RTF_GATEWAY | RTF_DEFAULT); 2204 2205 if (rt) { 2206 /* Autoconf prefix route */ 2207 if (valid_lft == 0) { 2208 ip6_del_rt(rt); 2209 rt = NULL; 2210 } else if (addrconf_finite_timeout(rt_expires)) { 2211 /* not infinity */ 2212 rt6_set_expires(rt, jiffies + rt_expires); 2213 } else { 2214 rt6_clean_expires(rt); 2215 } 2216 } else if (valid_lft) { 2217 clock_t expires = 0; 2218 int flags = RTF_ADDRCONF | RTF_PREFIX_RT; 2219 if (addrconf_finite_timeout(rt_expires)) { 2220 /* not infinity */ 2221 flags |= RTF_EXPIRES; 2222 expires = jiffies_to_clock_t(rt_expires); 2223 } 2224 addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len, 2225 dev, expires, flags); 2226 } 2227 ip6_rt_put(rt); 2228 } 2229 2230 /* Try to figure out our local address for this prefix */ 2231 2232 if (pinfo->autoconf && in6_dev->cnf.autoconf) { 2233 struct inet6_ifaddr *ifp; 2234 struct in6_addr addr; 2235 int create = 0, update_lft = 0; 2236 bool tokenized = false; 2237 2238 if (pinfo->prefix_len == 64) { 2239 memcpy(&addr, &pinfo->prefix, 8); 2240 2241 if (!ipv6_addr_any(&in6_dev->token)) { 2242 read_lock_bh(&in6_dev->lock); 2243 memcpy(addr.s6_addr + 8, 2244 in6_dev->token.s6_addr + 8, 8); 2245 read_unlock_bh(&in6_dev->lock); 2246 tokenized = true; 2247 } else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) && 2248 ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) { 2249 in6_dev_put(in6_dev); 2250 return; 2251 } 2252 goto ok; 2253 } 2254 net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n", 2255 pinfo->prefix_len); 2256 in6_dev_put(in6_dev); 2257 return; 2258 2259 ok: 2260 2261 ifp = ipv6_get_ifaddr(net, &addr, dev, 1); 2262 2263 if (ifp == NULL && valid_lft) { 2264 int max_addresses = in6_dev->cnf.max_addresses; 2265 u32 addr_flags = 0; 2266 2267 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 2268 if (in6_dev->cnf.optimistic_dad && 2269 !net->ipv6.devconf_all->forwarding && sllao) 2270 addr_flags = IFA_F_OPTIMISTIC; 2271 #endif 2272 2273 /* Do not allow to create too much of autoconfigured 2274 * addresses; this would be too easy way to crash kernel. 2275 */ 2276 if (!max_addresses || 2277 ipv6_count_addresses(in6_dev) < max_addresses) 2278 ifp = ipv6_add_addr(in6_dev, &addr, NULL, 2279 pinfo->prefix_len, 2280 addr_type&IPV6_ADDR_SCOPE_MASK, 2281 addr_flags, valid_lft, 2282 prefered_lft); 2283 2284 if (IS_ERR_OR_NULL(ifp)) { 2285 in6_dev_put(in6_dev); 2286 return; 2287 } 2288 2289 update_lft = 0; 2290 create = 1; 2291 spin_lock_bh(&ifp->lock); 2292 ifp->flags |= IFA_F_MANAGETEMPADDR; 2293 ifp->cstamp = jiffies; 2294 ifp->tokenized = tokenized; 2295 spin_unlock_bh(&ifp->lock); 2296 addrconf_dad_start(ifp); 2297 } 2298 2299 if (ifp) { 2300 u32 flags; 2301 unsigned long now; 2302 u32 stored_lft; 2303 2304 /* update lifetime (RFC2462 5.5.3 e) */ 2305 spin_lock(&ifp->lock); 2306 now = jiffies; 2307 if (ifp->valid_lft > (now - ifp->tstamp) / HZ) 2308 stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ; 2309 else 2310 stored_lft = 0; 2311 if (!update_lft && !create && stored_lft) { 2312 const u32 minimum_lft = min( 2313 stored_lft, (u32)MIN_VALID_LIFETIME); 2314 valid_lft = max(valid_lft, minimum_lft); 2315 2316 /* RFC4862 Section 5.5.3e: 2317 * "Note that the preferred lifetime of the 2318 * corresponding address is always reset to 2319 * the Preferred Lifetime in the received 2320 * Prefix Information option, regardless of 2321 * whether the valid lifetime is also reset or 2322 * ignored." 2323 * 2324 * So we should always update prefered_lft here. 2325 */ 2326 update_lft = 1; 2327 } 2328 2329 if (update_lft) { 2330 ifp->valid_lft = valid_lft; 2331 ifp->prefered_lft = prefered_lft; 2332 ifp->tstamp = now; 2333 flags = ifp->flags; 2334 ifp->flags &= ~IFA_F_DEPRECATED; 2335 spin_unlock(&ifp->lock); 2336 2337 if (!(flags&IFA_F_TENTATIVE)) 2338 ipv6_ifa_notify(0, ifp); 2339 } else 2340 spin_unlock(&ifp->lock); 2341 2342 manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft, 2343 create, now); 2344 2345 in6_ifa_put(ifp); 2346 addrconf_verify(); 2347 } 2348 } 2349 inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo); 2350 in6_dev_put(in6_dev); 2351 } 2352 2353 /* 2354 * Set destination address. 2355 * Special case for SIT interfaces where we create a new "virtual" 2356 * device. 2357 */ 2358 int addrconf_set_dstaddr(struct net *net, void __user *arg) 2359 { 2360 struct in6_ifreq ireq; 2361 struct net_device *dev; 2362 int err = -EINVAL; 2363 2364 rtnl_lock(); 2365 2366 err = -EFAULT; 2367 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 2368 goto err_exit; 2369 2370 dev = __dev_get_by_index(net, ireq.ifr6_ifindex); 2371 2372 err = -ENODEV; 2373 if (dev == NULL) 2374 goto err_exit; 2375 2376 #if IS_ENABLED(CONFIG_IPV6_SIT) 2377 if (dev->type == ARPHRD_SIT) { 2378 const struct net_device_ops *ops = dev->netdev_ops; 2379 struct ifreq ifr; 2380 struct ip_tunnel_parm p; 2381 2382 err = -EADDRNOTAVAIL; 2383 if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4)) 2384 goto err_exit; 2385 2386 memset(&p, 0, sizeof(p)); 2387 p.iph.daddr = ireq.ifr6_addr.s6_addr32[3]; 2388 p.iph.saddr = 0; 2389 p.iph.version = 4; 2390 p.iph.ihl = 5; 2391 p.iph.protocol = IPPROTO_IPV6; 2392 p.iph.ttl = 64; 2393 ifr.ifr_ifru.ifru_data = (__force void __user *)&p; 2394 2395 if (ops->ndo_do_ioctl) { 2396 mm_segment_t oldfs = get_fs(); 2397 2398 set_fs(KERNEL_DS); 2399 err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL); 2400 set_fs(oldfs); 2401 } else 2402 err = -EOPNOTSUPP; 2403 2404 if (err == 0) { 2405 err = -ENOBUFS; 2406 dev = __dev_get_by_name(net, p.name); 2407 if (!dev) 2408 goto err_exit; 2409 err = dev_open(dev); 2410 } 2411 } 2412 #endif 2413 2414 err_exit: 2415 rtnl_unlock(); 2416 return err; 2417 } 2418 2419 /* 2420 * Manual configuration of address on an interface 2421 */ 2422 static int inet6_addr_add(struct net *net, int ifindex, 2423 const struct in6_addr *pfx, 2424 const struct in6_addr *peer_pfx, 2425 unsigned int plen, __u32 ifa_flags, 2426 __u32 prefered_lft, __u32 valid_lft) 2427 { 2428 struct inet6_ifaddr *ifp; 2429 struct inet6_dev *idev; 2430 struct net_device *dev; 2431 int scope; 2432 u32 flags; 2433 clock_t expires; 2434 unsigned long timeout; 2435 2436 ASSERT_RTNL(); 2437 2438 if (plen > 128) 2439 return -EINVAL; 2440 2441 /* check the lifetime */ 2442 if (!valid_lft || prefered_lft > valid_lft) 2443 return -EINVAL; 2444 2445 if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64) 2446 return -EINVAL; 2447 2448 dev = __dev_get_by_index(net, ifindex); 2449 if (!dev) 2450 return -ENODEV; 2451 2452 idev = addrconf_add_dev(dev); 2453 if (IS_ERR(idev)) 2454 return PTR_ERR(idev); 2455 2456 scope = ipv6_addr_scope(pfx); 2457 2458 timeout = addrconf_timeout_fixup(valid_lft, HZ); 2459 if (addrconf_finite_timeout(timeout)) { 2460 expires = jiffies_to_clock_t(timeout * HZ); 2461 valid_lft = timeout; 2462 flags = RTF_EXPIRES; 2463 } else { 2464 expires = 0; 2465 flags = 0; 2466 ifa_flags |= IFA_F_PERMANENT; 2467 } 2468 2469 timeout = addrconf_timeout_fixup(prefered_lft, HZ); 2470 if (addrconf_finite_timeout(timeout)) { 2471 if (timeout == 0) 2472 ifa_flags |= IFA_F_DEPRECATED; 2473 prefered_lft = timeout; 2474 } 2475 2476 ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags, 2477 valid_lft, prefered_lft); 2478 2479 if (!IS_ERR(ifp)) { 2480 if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) { 2481 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev, 2482 expires, flags); 2483 } 2484 2485 /* 2486 * Note that section 3.1 of RFC 4429 indicates 2487 * that the Optimistic flag should not be set for 2488 * manually configured addresses 2489 */ 2490 addrconf_dad_start(ifp); 2491 if (ifa_flags & IFA_F_MANAGETEMPADDR) 2492 manage_tempaddrs(idev, ifp, valid_lft, prefered_lft, 2493 true, jiffies); 2494 in6_ifa_put(ifp); 2495 addrconf_verify_rtnl(); 2496 return 0; 2497 } 2498 2499 return PTR_ERR(ifp); 2500 } 2501 2502 static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags, 2503 const struct in6_addr *pfx, unsigned int plen) 2504 { 2505 struct inet6_ifaddr *ifp; 2506 struct inet6_dev *idev; 2507 struct net_device *dev; 2508 2509 if (plen > 128) 2510 return -EINVAL; 2511 2512 dev = __dev_get_by_index(net, ifindex); 2513 if (!dev) 2514 return -ENODEV; 2515 2516 if ((idev = __in6_dev_get(dev)) == NULL) 2517 return -ENXIO; 2518 2519 read_lock_bh(&idev->lock); 2520 list_for_each_entry(ifp, &idev->addr_list, if_list) { 2521 if (ifp->prefix_len == plen && 2522 ipv6_addr_equal(pfx, &ifp->addr)) { 2523 in6_ifa_hold(ifp); 2524 read_unlock_bh(&idev->lock); 2525 2526 if (!(ifp->flags & IFA_F_TEMPORARY) && 2527 (ifa_flags & IFA_F_MANAGETEMPADDR)) 2528 manage_tempaddrs(idev, ifp, 0, 0, false, 2529 jiffies); 2530 ipv6_del_addr(ifp); 2531 addrconf_verify_rtnl(); 2532 return 0; 2533 } 2534 } 2535 read_unlock_bh(&idev->lock); 2536 return -EADDRNOTAVAIL; 2537 } 2538 2539 2540 int addrconf_add_ifaddr(struct net *net, void __user *arg) 2541 { 2542 struct in6_ifreq ireq; 2543 int err; 2544 2545 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 2546 return -EPERM; 2547 2548 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 2549 return -EFAULT; 2550 2551 rtnl_lock(); 2552 err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, 2553 ireq.ifr6_prefixlen, IFA_F_PERMANENT, 2554 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 2555 rtnl_unlock(); 2556 return err; 2557 } 2558 2559 int addrconf_del_ifaddr(struct net *net, void __user *arg) 2560 { 2561 struct in6_ifreq ireq; 2562 int err; 2563 2564 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 2565 return -EPERM; 2566 2567 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq))) 2568 return -EFAULT; 2569 2570 rtnl_lock(); 2571 err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, 2572 ireq.ifr6_prefixlen); 2573 rtnl_unlock(); 2574 return err; 2575 } 2576 2577 static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr, 2578 int plen, int scope) 2579 { 2580 struct inet6_ifaddr *ifp; 2581 2582 ifp = ipv6_add_addr(idev, addr, NULL, plen, 2583 scope, IFA_F_PERMANENT, 2584 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 2585 if (!IS_ERR(ifp)) { 2586 spin_lock_bh(&ifp->lock); 2587 ifp->flags &= ~IFA_F_TENTATIVE; 2588 spin_unlock_bh(&ifp->lock); 2589 ipv6_ifa_notify(RTM_NEWADDR, ifp); 2590 in6_ifa_put(ifp); 2591 } 2592 } 2593 2594 #if IS_ENABLED(CONFIG_IPV6_SIT) 2595 static void sit_add_v4_addrs(struct inet6_dev *idev) 2596 { 2597 struct in6_addr addr; 2598 struct net_device *dev; 2599 struct net *net = dev_net(idev->dev); 2600 int scope, plen; 2601 u32 pflags = 0; 2602 2603 ASSERT_RTNL(); 2604 2605 memset(&addr, 0, sizeof(struct in6_addr)); 2606 memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4); 2607 2608 if (idev->dev->flags&IFF_POINTOPOINT) { 2609 addr.s6_addr32[0] = htonl(0xfe800000); 2610 scope = IFA_LINK; 2611 plen = 64; 2612 } else { 2613 scope = IPV6_ADDR_COMPATv4; 2614 plen = 96; 2615 pflags |= RTF_NONEXTHOP; 2616 } 2617 2618 if (addr.s6_addr32[3]) { 2619 add_addr(idev, &addr, plen, scope); 2620 addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags); 2621 return; 2622 } 2623 2624 for_each_netdev(net, dev) { 2625 struct in_device *in_dev = __in_dev_get_rtnl(dev); 2626 if (in_dev && (dev->flags & IFF_UP)) { 2627 struct in_ifaddr *ifa; 2628 2629 int flag = scope; 2630 2631 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 2632 2633 addr.s6_addr32[3] = ifa->ifa_local; 2634 2635 if (ifa->ifa_scope == RT_SCOPE_LINK) 2636 continue; 2637 if (ifa->ifa_scope >= RT_SCOPE_HOST) { 2638 if (idev->dev->flags&IFF_POINTOPOINT) 2639 continue; 2640 flag |= IFA_HOST; 2641 } 2642 2643 add_addr(idev, &addr, plen, flag); 2644 addrconf_prefix_route(&addr, plen, idev->dev, 0, 2645 pflags); 2646 } 2647 } 2648 } 2649 } 2650 #endif 2651 2652 static void init_loopback(struct net_device *dev) 2653 { 2654 struct inet6_dev *idev; 2655 struct net_device *sp_dev; 2656 struct inet6_ifaddr *sp_ifa; 2657 struct rt6_info *sp_rt; 2658 2659 /* ::1 */ 2660 2661 ASSERT_RTNL(); 2662 2663 if ((idev = ipv6_find_idev(dev)) == NULL) { 2664 pr_debug("%s: add_dev failed\n", __func__); 2665 return; 2666 } 2667 2668 add_addr(idev, &in6addr_loopback, 128, IFA_HOST); 2669 2670 /* Add routes to other interface's IPv6 addresses */ 2671 for_each_netdev(dev_net(dev), sp_dev) { 2672 if (!strcmp(sp_dev->name, dev->name)) 2673 continue; 2674 2675 idev = __in6_dev_get(sp_dev); 2676 if (!idev) 2677 continue; 2678 2679 read_lock_bh(&idev->lock); 2680 list_for_each_entry(sp_ifa, &idev->addr_list, if_list) { 2681 2682 if (sp_ifa->flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE)) 2683 continue; 2684 2685 if (sp_ifa->rt) { 2686 /* This dst has been added to garbage list when 2687 * lo device down, release this obsolete dst and 2688 * reallocate a new router for ifa. 2689 */ 2690 if (sp_ifa->rt->dst.obsolete > 0) { 2691 ip6_rt_put(sp_ifa->rt); 2692 sp_ifa->rt = NULL; 2693 } else { 2694 continue; 2695 } 2696 } 2697 2698 sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, false); 2699 2700 /* Failure cases are ignored */ 2701 if (!IS_ERR(sp_rt)) { 2702 sp_ifa->rt = sp_rt; 2703 ip6_ins_rt(sp_rt); 2704 } 2705 } 2706 read_unlock_bh(&idev->lock); 2707 } 2708 } 2709 2710 static void addrconf_add_linklocal(struct inet6_dev *idev, const struct in6_addr *addr) 2711 { 2712 struct inet6_ifaddr *ifp; 2713 u32 addr_flags = IFA_F_PERMANENT; 2714 2715 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 2716 if (idev->cnf.optimistic_dad && 2717 !dev_net(idev->dev)->ipv6.devconf_all->forwarding) 2718 addr_flags |= IFA_F_OPTIMISTIC; 2719 #endif 2720 2721 2722 ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags, 2723 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 2724 if (!IS_ERR(ifp)) { 2725 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0); 2726 addrconf_dad_start(ifp); 2727 in6_ifa_put(ifp); 2728 } 2729 } 2730 2731 static void addrconf_dev_config(struct net_device *dev) 2732 { 2733 struct in6_addr addr; 2734 struct inet6_dev *idev; 2735 2736 ASSERT_RTNL(); 2737 2738 if ((dev->type != ARPHRD_ETHER) && 2739 (dev->type != ARPHRD_FDDI) && 2740 (dev->type != ARPHRD_ARCNET) && 2741 (dev->type != ARPHRD_INFINIBAND) && 2742 (dev->type != ARPHRD_IEEE802154) && 2743 (dev->type != ARPHRD_IEEE1394) && 2744 (dev->type != ARPHRD_TUNNEL6) && 2745 (dev->type != ARPHRD_6LOWPAN)) { 2746 /* Alas, we support only Ethernet autoconfiguration. */ 2747 return; 2748 } 2749 2750 idev = addrconf_add_dev(dev); 2751 if (IS_ERR(idev)) 2752 return; 2753 2754 memset(&addr, 0, sizeof(struct in6_addr)); 2755 addr.s6_addr32[0] = htonl(0xFE800000); 2756 2757 if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0) 2758 addrconf_add_linklocal(idev, &addr); 2759 } 2760 2761 #if IS_ENABLED(CONFIG_IPV6_SIT) 2762 static void addrconf_sit_config(struct net_device *dev) 2763 { 2764 struct inet6_dev *idev; 2765 2766 ASSERT_RTNL(); 2767 2768 /* 2769 * Configure the tunnel with one of our IPv4 2770 * addresses... we should configure all of 2771 * our v4 addrs in the tunnel 2772 */ 2773 2774 if ((idev = ipv6_find_idev(dev)) == NULL) { 2775 pr_debug("%s: add_dev failed\n", __func__); 2776 return; 2777 } 2778 2779 if (dev->priv_flags & IFF_ISATAP) { 2780 struct in6_addr addr; 2781 2782 ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0); 2783 if (!ipv6_generate_eui64(addr.s6_addr + 8, dev)) 2784 addrconf_add_linklocal(idev, &addr); 2785 return; 2786 } 2787 2788 sit_add_v4_addrs(idev); 2789 2790 if (dev->flags&IFF_POINTOPOINT) 2791 addrconf_add_mroute(dev); 2792 } 2793 #endif 2794 2795 #if IS_ENABLED(CONFIG_NET_IPGRE) 2796 static void addrconf_gre_config(struct net_device *dev) 2797 { 2798 struct inet6_dev *idev; 2799 struct in6_addr addr; 2800 2801 ASSERT_RTNL(); 2802 2803 if ((idev = ipv6_find_idev(dev)) == NULL) { 2804 pr_debug("%s: add_dev failed\n", __func__); 2805 return; 2806 } 2807 2808 ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0); 2809 if (!ipv6_generate_eui64(addr.s6_addr + 8, dev)) 2810 addrconf_add_linklocal(idev, &addr); 2811 else 2812 addrconf_prefix_route(&addr, 64, dev, 0, 0); 2813 } 2814 #endif 2815 2816 static int addrconf_notify(struct notifier_block *this, unsigned long event, 2817 void *ptr) 2818 { 2819 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 2820 struct inet6_dev *idev = __in6_dev_get(dev); 2821 int run_pending = 0; 2822 int err; 2823 2824 switch (event) { 2825 case NETDEV_REGISTER: 2826 if (!idev && dev->mtu >= IPV6_MIN_MTU) { 2827 idev = ipv6_add_dev(dev); 2828 if (!idev) 2829 return notifier_from_errno(-ENOMEM); 2830 } 2831 break; 2832 2833 case NETDEV_UP: 2834 case NETDEV_CHANGE: 2835 if (dev->flags & IFF_SLAVE) 2836 break; 2837 2838 if (event == NETDEV_UP) { 2839 if (!addrconf_qdisc_ok(dev)) { 2840 /* device is not ready yet. */ 2841 pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n", 2842 dev->name); 2843 break; 2844 } 2845 2846 if (!idev && dev->mtu >= IPV6_MIN_MTU) 2847 idev = ipv6_add_dev(dev); 2848 2849 if (idev) { 2850 idev->if_flags |= IF_READY; 2851 run_pending = 1; 2852 } 2853 } else { 2854 if (!addrconf_qdisc_ok(dev)) { 2855 /* device is still not ready. */ 2856 break; 2857 } 2858 2859 if (idev) { 2860 if (idev->if_flags & IF_READY) 2861 /* device is already configured. */ 2862 break; 2863 idev->if_flags |= IF_READY; 2864 } 2865 2866 pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n", 2867 dev->name); 2868 2869 run_pending = 1; 2870 } 2871 2872 switch (dev->type) { 2873 #if IS_ENABLED(CONFIG_IPV6_SIT) 2874 case ARPHRD_SIT: 2875 addrconf_sit_config(dev); 2876 break; 2877 #endif 2878 #if IS_ENABLED(CONFIG_NET_IPGRE) 2879 case ARPHRD_IPGRE: 2880 addrconf_gre_config(dev); 2881 break; 2882 #endif 2883 case ARPHRD_LOOPBACK: 2884 init_loopback(dev); 2885 break; 2886 2887 default: 2888 addrconf_dev_config(dev); 2889 break; 2890 } 2891 2892 if (idev) { 2893 if (run_pending) 2894 addrconf_dad_run(idev); 2895 2896 /* 2897 * If the MTU changed during the interface down, 2898 * when the interface up, the changed MTU must be 2899 * reflected in the idev as well as routers. 2900 */ 2901 if (idev->cnf.mtu6 != dev->mtu && 2902 dev->mtu >= IPV6_MIN_MTU) { 2903 rt6_mtu_change(dev, dev->mtu); 2904 idev->cnf.mtu6 = dev->mtu; 2905 } 2906 idev->tstamp = jiffies; 2907 inet6_ifinfo_notify(RTM_NEWLINK, idev); 2908 2909 /* 2910 * If the changed mtu during down is lower than 2911 * IPV6_MIN_MTU stop IPv6 on this interface. 2912 */ 2913 if (dev->mtu < IPV6_MIN_MTU) 2914 addrconf_ifdown(dev, 1); 2915 } 2916 break; 2917 2918 case NETDEV_CHANGEMTU: 2919 if (idev && dev->mtu >= IPV6_MIN_MTU) { 2920 rt6_mtu_change(dev, dev->mtu); 2921 idev->cnf.mtu6 = dev->mtu; 2922 break; 2923 } 2924 2925 if (!idev && dev->mtu >= IPV6_MIN_MTU) { 2926 idev = ipv6_add_dev(dev); 2927 if (idev) 2928 break; 2929 } 2930 2931 /* 2932 * if MTU under IPV6_MIN_MTU. 2933 * Stop IPv6 on this interface. 2934 */ 2935 2936 case NETDEV_DOWN: 2937 case NETDEV_UNREGISTER: 2938 /* 2939 * Remove all addresses from this interface. 2940 */ 2941 addrconf_ifdown(dev, event != NETDEV_DOWN); 2942 break; 2943 2944 case NETDEV_CHANGENAME: 2945 if (idev) { 2946 snmp6_unregister_dev(idev); 2947 addrconf_sysctl_unregister(idev); 2948 addrconf_sysctl_register(idev); 2949 err = snmp6_register_dev(idev); 2950 if (err) 2951 return notifier_from_errno(err); 2952 } 2953 break; 2954 2955 case NETDEV_PRE_TYPE_CHANGE: 2956 case NETDEV_POST_TYPE_CHANGE: 2957 addrconf_type_change(dev, event); 2958 break; 2959 } 2960 2961 return NOTIFY_OK; 2962 } 2963 2964 /* 2965 * addrconf module should be notified of a device going up 2966 */ 2967 static struct notifier_block ipv6_dev_notf = { 2968 .notifier_call = addrconf_notify, 2969 }; 2970 2971 static void addrconf_type_change(struct net_device *dev, unsigned long event) 2972 { 2973 struct inet6_dev *idev; 2974 ASSERT_RTNL(); 2975 2976 idev = __in6_dev_get(dev); 2977 2978 if (event == NETDEV_POST_TYPE_CHANGE) 2979 ipv6_mc_remap(idev); 2980 else if (event == NETDEV_PRE_TYPE_CHANGE) 2981 ipv6_mc_unmap(idev); 2982 } 2983 2984 static int addrconf_ifdown(struct net_device *dev, int how) 2985 { 2986 struct net *net = dev_net(dev); 2987 struct inet6_dev *idev; 2988 struct inet6_ifaddr *ifa; 2989 int state, i; 2990 2991 ASSERT_RTNL(); 2992 2993 rt6_ifdown(net, dev); 2994 neigh_ifdown(&nd_tbl, dev); 2995 2996 idev = __in6_dev_get(dev); 2997 if (idev == NULL) 2998 return -ENODEV; 2999 3000 /* 3001 * Step 1: remove reference to ipv6 device from parent device. 3002 * Do not dev_put! 3003 */ 3004 if (how) { 3005 idev->dead = 1; 3006 3007 /* protected by rtnl_lock */ 3008 RCU_INIT_POINTER(dev->ip6_ptr, NULL); 3009 3010 /* Step 1.5: remove snmp6 entry */ 3011 snmp6_unregister_dev(idev); 3012 3013 } 3014 3015 /* Step 2: clear hash table */ 3016 for (i = 0; i < IN6_ADDR_HSIZE; i++) { 3017 struct hlist_head *h = &inet6_addr_lst[i]; 3018 3019 spin_lock_bh(&addrconf_hash_lock); 3020 restart: 3021 hlist_for_each_entry_rcu(ifa, h, addr_lst) { 3022 if (ifa->idev == idev) { 3023 hlist_del_init_rcu(&ifa->addr_lst); 3024 addrconf_del_dad_work(ifa); 3025 goto restart; 3026 } 3027 } 3028 spin_unlock_bh(&addrconf_hash_lock); 3029 } 3030 3031 write_lock_bh(&idev->lock); 3032 3033 addrconf_del_rs_timer(idev); 3034 3035 /* Step 2: clear flags for stateless addrconf */ 3036 if (!how) 3037 idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY); 3038 3039 if (how && del_timer(&idev->regen_timer)) 3040 in6_dev_put(idev); 3041 3042 /* Step 3: clear tempaddr list */ 3043 while (!list_empty(&idev->tempaddr_list)) { 3044 ifa = list_first_entry(&idev->tempaddr_list, 3045 struct inet6_ifaddr, tmp_list); 3046 list_del(&ifa->tmp_list); 3047 write_unlock_bh(&idev->lock); 3048 spin_lock_bh(&ifa->lock); 3049 3050 if (ifa->ifpub) { 3051 in6_ifa_put(ifa->ifpub); 3052 ifa->ifpub = NULL; 3053 } 3054 spin_unlock_bh(&ifa->lock); 3055 in6_ifa_put(ifa); 3056 write_lock_bh(&idev->lock); 3057 } 3058 3059 while (!list_empty(&idev->addr_list)) { 3060 ifa = list_first_entry(&idev->addr_list, 3061 struct inet6_ifaddr, if_list); 3062 addrconf_del_dad_work(ifa); 3063 3064 list_del(&ifa->if_list); 3065 3066 write_unlock_bh(&idev->lock); 3067 3068 spin_lock_bh(&ifa->state_lock); 3069 state = ifa->state; 3070 ifa->state = INET6_IFADDR_STATE_DEAD; 3071 spin_unlock_bh(&ifa->state_lock); 3072 3073 if (state != INET6_IFADDR_STATE_DEAD) { 3074 __ipv6_ifa_notify(RTM_DELADDR, ifa); 3075 inet6addr_notifier_call_chain(NETDEV_DOWN, ifa); 3076 } 3077 in6_ifa_put(ifa); 3078 3079 write_lock_bh(&idev->lock); 3080 } 3081 3082 write_unlock_bh(&idev->lock); 3083 3084 /* Step 5: Discard multicast list */ 3085 if (how) 3086 ipv6_mc_destroy_dev(idev); 3087 else 3088 ipv6_mc_down(idev); 3089 3090 idev->tstamp = jiffies; 3091 3092 /* Last: Shot the device (if unregistered) */ 3093 if (how) { 3094 addrconf_sysctl_unregister(idev); 3095 neigh_parms_release(&nd_tbl, idev->nd_parms); 3096 neigh_ifdown(&nd_tbl, dev); 3097 in6_dev_put(idev); 3098 } 3099 return 0; 3100 } 3101 3102 static void addrconf_rs_timer(unsigned long data) 3103 { 3104 struct inet6_dev *idev = (struct inet6_dev *)data; 3105 struct net_device *dev = idev->dev; 3106 struct in6_addr lladdr; 3107 3108 write_lock(&idev->lock); 3109 if (idev->dead || !(idev->if_flags & IF_READY)) 3110 goto out; 3111 3112 if (!ipv6_accept_ra(idev)) 3113 goto out; 3114 3115 /* Announcement received after solicitation was sent */ 3116 if (idev->if_flags & IF_RA_RCVD) 3117 goto out; 3118 3119 if (idev->rs_probes++ < idev->cnf.rtr_solicits) { 3120 write_unlock(&idev->lock); 3121 if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE)) 3122 ndisc_send_rs(dev, &lladdr, 3123 &in6addr_linklocal_allrouters); 3124 else 3125 goto put; 3126 3127 write_lock(&idev->lock); 3128 /* The wait after the last probe can be shorter */ 3129 addrconf_mod_rs_timer(idev, (idev->rs_probes == 3130 idev->cnf.rtr_solicits) ? 3131 idev->cnf.rtr_solicit_delay : 3132 idev->cnf.rtr_solicit_interval); 3133 } else { 3134 /* 3135 * Note: we do not support deprecated "all on-link" 3136 * assumption any longer. 3137 */ 3138 pr_debug("%s: no IPv6 routers present\n", idev->dev->name); 3139 } 3140 3141 out: 3142 write_unlock(&idev->lock); 3143 put: 3144 in6_dev_put(idev); 3145 } 3146 3147 /* 3148 * Duplicate Address Detection 3149 */ 3150 static void addrconf_dad_kick(struct inet6_ifaddr *ifp) 3151 { 3152 unsigned long rand_num; 3153 struct inet6_dev *idev = ifp->idev; 3154 3155 if (ifp->flags & IFA_F_OPTIMISTIC) 3156 rand_num = 0; 3157 else 3158 rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1); 3159 3160 ifp->dad_probes = idev->cnf.dad_transmits; 3161 addrconf_mod_dad_work(ifp, rand_num); 3162 } 3163 3164 static void addrconf_dad_begin(struct inet6_ifaddr *ifp) 3165 { 3166 struct inet6_dev *idev = ifp->idev; 3167 struct net_device *dev = idev->dev; 3168 3169 addrconf_join_solict(dev, &ifp->addr); 3170 3171 prandom_seed((__force u32) ifp->addr.s6_addr32[3]); 3172 3173 read_lock_bh(&idev->lock); 3174 spin_lock(&ifp->lock); 3175 if (ifp->state == INET6_IFADDR_STATE_DEAD) 3176 goto out; 3177 3178 if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) || 3179 idev->cnf.accept_dad < 1 || 3180 !(ifp->flags&IFA_F_TENTATIVE) || 3181 ifp->flags & IFA_F_NODAD) { 3182 ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED); 3183 spin_unlock(&ifp->lock); 3184 read_unlock_bh(&idev->lock); 3185 3186 addrconf_dad_completed(ifp); 3187 return; 3188 } 3189 3190 if (!(idev->if_flags & IF_READY)) { 3191 spin_unlock(&ifp->lock); 3192 read_unlock_bh(&idev->lock); 3193 /* 3194 * If the device is not ready: 3195 * - keep it tentative if it is a permanent address. 3196 * - otherwise, kill it. 3197 */ 3198 in6_ifa_hold(ifp); 3199 addrconf_dad_stop(ifp, 0); 3200 return; 3201 } 3202 3203 /* 3204 * Optimistic nodes can start receiving 3205 * Frames right away 3206 */ 3207 if (ifp->flags & IFA_F_OPTIMISTIC) 3208 ip6_ins_rt(ifp->rt); 3209 3210 addrconf_dad_kick(ifp); 3211 out: 3212 spin_unlock(&ifp->lock); 3213 read_unlock_bh(&idev->lock); 3214 } 3215 3216 static void addrconf_dad_start(struct inet6_ifaddr *ifp) 3217 { 3218 bool begin_dad = false; 3219 3220 spin_lock_bh(&ifp->state_lock); 3221 if (ifp->state != INET6_IFADDR_STATE_DEAD) { 3222 ifp->state = INET6_IFADDR_STATE_PREDAD; 3223 begin_dad = true; 3224 } 3225 spin_unlock_bh(&ifp->state_lock); 3226 3227 if (begin_dad) 3228 addrconf_mod_dad_work(ifp, 0); 3229 } 3230 3231 static void addrconf_dad_work(struct work_struct *w) 3232 { 3233 struct inet6_ifaddr *ifp = container_of(to_delayed_work(w), 3234 struct inet6_ifaddr, 3235 dad_work); 3236 struct inet6_dev *idev = ifp->idev; 3237 struct in6_addr mcaddr; 3238 3239 enum { 3240 DAD_PROCESS, 3241 DAD_BEGIN, 3242 DAD_ABORT, 3243 } action = DAD_PROCESS; 3244 3245 rtnl_lock(); 3246 3247 spin_lock_bh(&ifp->state_lock); 3248 if (ifp->state == INET6_IFADDR_STATE_PREDAD) { 3249 action = DAD_BEGIN; 3250 ifp->state = INET6_IFADDR_STATE_DAD; 3251 } else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) { 3252 action = DAD_ABORT; 3253 ifp->state = INET6_IFADDR_STATE_POSTDAD; 3254 } 3255 spin_unlock_bh(&ifp->state_lock); 3256 3257 if (action == DAD_BEGIN) { 3258 addrconf_dad_begin(ifp); 3259 goto out; 3260 } else if (action == DAD_ABORT) { 3261 addrconf_dad_stop(ifp, 1); 3262 goto out; 3263 } 3264 3265 if (!ifp->dad_probes && addrconf_dad_end(ifp)) 3266 goto out; 3267 3268 write_lock_bh(&idev->lock); 3269 if (idev->dead || !(idev->if_flags & IF_READY)) { 3270 write_unlock_bh(&idev->lock); 3271 goto out; 3272 } 3273 3274 spin_lock(&ifp->lock); 3275 if (ifp->state == INET6_IFADDR_STATE_DEAD) { 3276 spin_unlock(&ifp->lock); 3277 write_unlock_bh(&idev->lock); 3278 goto out; 3279 } 3280 3281 if (ifp->dad_probes == 0) { 3282 /* 3283 * DAD was successful 3284 */ 3285 3286 ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED); 3287 spin_unlock(&ifp->lock); 3288 write_unlock_bh(&idev->lock); 3289 3290 addrconf_dad_completed(ifp); 3291 3292 goto out; 3293 } 3294 3295 ifp->dad_probes--; 3296 addrconf_mod_dad_work(ifp, 3297 NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME)); 3298 spin_unlock(&ifp->lock); 3299 write_unlock_bh(&idev->lock); 3300 3301 /* send a neighbour solicitation for our addr */ 3302 addrconf_addr_solict_mult(&ifp->addr, &mcaddr); 3303 ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &in6addr_any); 3304 out: 3305 in6_ifa_put(ifp); 3306 rtnl_unlock(); 3307 } 3308 3309 /* ifp->idev must be at least read locked */ 3310 static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp) 3311 { 3312 struct inet6_ifaddr *ifpiter; 3313 struct inet6_dev *idev = ifp->idev; 3314 3315 list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) { 3316 if (ifpiter->scope > IFA_LINK) 3317 break; 3318 if (ifp != ifpiter && ifpiter->scope == IFA_LINK && 3319 (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE| 3320 IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) == 3321 IFA_F_PERMANENT) 3322 return false; 3323 } 3324 return true; 3325 } 3326 3327 static void addrconf_dad_completed(struct inet6_ifaddr *ifp) 3328 { 3329 struct net_device *dev = ifp->idev->dev; 3330 struct in6_addr lladdr; 3331 bool send_rs, send_mld; 3332 3333 addrconf_del_dad_work(ifp); 3334 3335 /* 3336 * Configure the address for reception. Now it is valid. 3337 */ 3338 3339 ipv6_ifa_notify(RTM_NEWADDR, ifp); 3340 3341 /* If added prefix is link local and we are prepared to process 3342 router advertisements, start sending router solicitations. 3343 */ 3344 3345 read_lock_bh(&ifp->idev->lock); 3346 send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp); 3347 send_rs = send_mld && 3348 ipv6_accept_ra(ifp->idev) && 3349 ifp->idev->cnf.rtr_solicits > 0 && 3350 (dev->flags&IFF_LOOPBACK) == 0; 3351 read_unlock_bh(&ifp->idev->lock); 3352 3353 /* While dad is in progress mld report's source address is in6_addrany. 3354 * Resend with proper ll now. 3355 */ 3356 if (send_mld) 3357 ipv6_mc_dad_complete(ifp->idev); 3358 3359 if (send_rs) { 3360 /* 3361 * If a host as already performed a random delay 3362 * [...] as part of DAD [...] there is no need 3363 * to delay again before sending the first RS 3364 */ 3365 if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE)) 3366 return; 3367 ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters); 3368 3369 write_lock_bh(&ifp->idev->lock); 3370 spin_lock(&ifp->lock); 3371 ifp->idev->rs_probes = 1; 3372 ifp->idev->if_flags |= IF_RS_SENT; 3373 addrconf_mod_rs_timer(ifp->idev, 3374 ifp->idev->cnf.rtr_solicit_interval); 3375 spin_unlock(&ifp->lock); 3376 write_unlock_bh(&ifp->idev->lock); 3377 } 3378 } 3379 3380 static void addrconf_dad_run(struct inet6_dev *idev) 3381 { 3382 struct inet6_ifaddr *ifp; 3383 3384 read_lock_bh(&idev->lock); 3385 list_for_each_entry(ifp, &idev->addr_list, if_list) { 3386 spin_lock(&ifp->lock); 3387 if (ifp->flags & IFA_F_TENTATIVE && 3388 ifp->state == INET6_IFADDR_STATE_DAD) 3389 addrconf_dad_kick(ifp); 3390 spin_unlock(&ifp->lock); 3391 } 3392 read_unlock_bh(&idev->lock); 3393 } 3394 3395 #ifdef CONFIG_PROC_FS 3396 struct if6_iter_state { 3397 struct seq_net_private p; 3398 int bucket; 3399 int offset; 3400 }; 3401 3402 static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos) 3403 { 3404 struct inet6_ifaddr *ifa = NULL; 3405 struct if6_iter_state *state = seq->private; 3406 struct net *net = seq_file_net(seq); 3407 int p = 0; 3408 3409 /* initial bucket if pos is 0 */ 3410 if (pos == 0) { 3411 state->bucket = 0; 3412 state->offset = 0; 3413 } 3414 3415 for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) { 3416 hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket], 3417 addr_lst) { 3418 if (!net_eq(dev_net(ifa->idev->dev), net)) 3419 continue; 3420 /* sync with offset */ 3421 if (p < state->offset) { 3422 p++; 3423 continue; 3424 } 3425 state->offset++; 3426 return ifa; 3427 } 3428 3429 /* prepare for next bucket */ 3430 state->offset = 0; 3431 p = 0; 3432 } 3433 return NULL; 3434 } 3435 3436 static struct inet6_ifaddr *if6_get_next(struct seq_file *seq, 3437 struct inet6_ifaddr *ifa) 3438 { 3439 struct if6_iter_state *state = seq->private; 3440 struct net *net = seq_file_net(seq); 3441 3442 hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) { 3443 if (!net_eq(dev_net(ifa->idev->dev), net)) 3444 continue; 3445 state->offset++; 3446 return ifa; 3447 } 3448 3449 while (++state->bucket < IN6_ADDR_HSIZE) { 3450 state->offset = 0; 3451 hlist_for_each_entry_rcu_bh(ifa, 3452 &inet6_addr_lst[state->bucket], addr_lst) { 3453 if (!net_eq(dev_net(ifa->idev->dev), net)) 3454 continue; 3455 state->offset++; 3456 return ifa; 3457 } 3458 } 3459 3460 return NULL; 3461 } 3462 3463 static void *if6_seq_start(struct seq_file *seq, loff_t *pos) 3464 __acquires(rcu_bh) 3465 { 3466 rcu_read_lock_bh(); 3467 return if6_get_first(seq, *pos); 3468 } 3469 3470 static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos) 3471 { 3472 struct inet6_ifaddr *ifa; 3473 3474 ifa = if6_get_next(seq, v); 3475 ++*pos; 3476 return ifa; 3477 } 3478 3479 static void if6_seq_stop(struct seq_file *seq, void *v) 3480 __releases(rcu_bh) 3481 { 3482 rcu_read_unlock_bh(); 3483 } 3484 3485 static int if6_seq_show(struct seq_file *seq, void *v) 3486 { 3487 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v; 3488 seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n", 3489 &ifp->addr, 3490 ifp->idev->dev->ifindex, 3491 ifp->prefix_len, 3492 ifp->scope, 3493 (u8) ifp->flags, 3494 ifp->idev->dev->name); 3495 return 0; 3496 } 3497 3498 static const struct seq_operations if6_seq_ops = { 3499 .start = if6_seq_start, 3500 .next = if6_seq_next, 3501 .show = if6_seq_show, 3502 .stop = if6_seq_stop, 3503 }; 3504 3505 static int if6_seq_open(struct inode *inode, struct file *file) 3506 { 3507 return seq_open_net(inode, file, &if6_seq_ops, 3508 sizeof(struct if6_iter_state)); 3509 } 3510 3511 static const struct file_operations if6_fops = { 3512 .owner = THIS_MODULE, 3513 .open = if6_seq_open, 3514 .read = seq_read, 3515 .llseek = seq_lseek, 3516 .release = seq_release_net, 3517 }; 3518 3519 static int __net_init if6_proc_net_init(struct net *net) 3520 { 3521 if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops)) 3522 return -ENOMEM; 3523 return 0; 3524 } 3525 3526 static void __net_exit if6_proc_net_exit(struct net *net) 3527 { 3528 remove_proc_entry("if_inet6", net->proc_net); 3529 } 3530 3531 static struct pernet_operations if6_proc_net_ops = { 3532 .init = if6_proc_net_init, 3533 .exit = if6_proc_net_exit, 3534 }; 3535 3536 int __init if6_proc_init(void) 3537 { 3538 return register_pernet_subsys(&if6_proc_net_ops); 3539 } 3540 3541 void if6_proc_exit(void) 3542 { 3543 unregister_pernet_subsys(&if6_proc_net_ops); 3544 } 3545 #endif /* CONFIG_PROC_FS */ 3546 3547 #if IS_ENABLED(CONFIG_IPV6_MIP6) 3548 /* Check if address is a home address configured on any interface. */ 3549 int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr) 3550 { 3551 int ret = 0; 3552 struct inet6_ifaddr *ifp = NULL; 3553 unsigned int hash = inet6_addr_hash(addr); 3554 3555 rcu_read_lock_bh(); 3556 hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) { 3557 if (!net_eq(dev_net(ifp->idev->dev), net)) 3558 continue; 3559 if (ipv6_addr_equal(&ifp->addr, addr) && 3560 (ifp->flags & IFA_F_HOMEADDRESS)) { 3561 ret = 1; 3562 break; 3563 } 3564 } 3565 rcu_read_unlock_bh(); 3566 return ret; 3567 } 3568 #endif 3569 3570 /* 3571 * Periodic address status verification 3572 */ 3573 3574 static void addrconf_verify_rtnl(void) 3575 { 3576 unsigned long now, next, next_sec, next_sched; 3577 struct inet6_ifaddr *ifp; 3578 int i; 3579 3580 ASSERT_RTNL(); 3581 3582 rcu_read_lock_bh(); 3583 now = jiffies; 3584 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY); 3585 3586 cancel_delayed_work(&addr_chk_work); 3587 3588 for (i = 0; i < IN6_ADDR_HSIZE; i++) { 3589 restart: 3590 hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) { 3591 unsigned long age; 3592 3593 /* When setting preferred_lft to a value not zero or 3594 * infinity, while valid_lft is infinity 3595 * IFA_F_PERMANENT has a non-infinity life time. 3596 */ 3597 if ((ifp->flags & IFA_F_PERMANENT) && 3598 (ifp->prefered_lft == INFINITY_LIFE_TIME)) 3599 continue; 3600 3601 spin_lock(&ifp->lock); 3602 /* We try to batch several events at once. */ 3603 age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ; 3604 3605 if (ifp->valid_lft != INFINITY_LIFE_TIME && 3606 age >= ifp->valid_lft) { 3607 spin_unlock(&ifp->lock); 3608 in6_ifa_hold(ifp); 3609 ipv6_del_addr(ifp); 3610 goto restart; 3611 } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) { 3612 spin_unlock(&ifp->lock); 3613 continue; 3614 } else if (age >= ifp->prefered_lft) { 3615 /* jiffies - ifp->tstamp > age >= ifp->prefered_lft */ 3616 int deprecate = 0; 3617 3618 if (!(ifp->flags&IFA_F_DEPRECATED)) { 3619 deprecate = 1; 3620 ifp->flags |= IFA_F_DEPRECATED; 3621 } 3622 3623 if ((ifp->valid_lft != INFINITY_LIFE_TIME) && 3624 (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))) 3625 next = ifp->tstamp + ifp->valid_lft * HZ; 3626 3627 spin_unlock(&ifp->lock); 3628 3629 if (deprecate) { 3630 in6_ifa_hold(ifp); 3631 3632 ipv6_ifa_notify(0, ifp); 3633 in6_ifa_put(ifp); 3634 goto restart; 3635 } 3636 } else if ((ifp->flags&IFA_F_TEMPORARY) && 3637 !(ifp->flags&IFA_F_TENTATIVE)) { 3638 unsigned long regen_advance = ifp->idev->cnf.regen_max_retry * 3639 ifp->idev->cnf.dad_transmits * 3640 NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ; 3641 3642 if (age >= ifp->prefered_lft - regen_advance) { 3643 struct inet6_ifaddr *ifpub = ifp->ifpub; 3644 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next)) 3645 next = ifp->tstamp + ifp->prefered_lft * HZ; 3646 if (!ifp->regen_count && ifpub) { 3647 ifp->regen_count++; 3648 in6_ifa_hold(ifp); 3649 in6_ifa_hold(ifpub); 3650 spin_unlock(&ifp->lock); 3651 3652 spin_lock(&ifpub->lock); 3653 ifpub->regen_count = 0; 3654 spin_unlock(&ifpub->lock); 3655 ipv6_create_tempaddr(ifpub, ifp); 3656 in6_ifa_put(ifpub); 3657 in6_ifa_put(ifp); 3658 goto restart; 3659 } 3660 } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next)) 3661 next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ; 3662 spin_unlock(&ifp->lock); 3663 } else { 3664 /* ifp->prefered_lft <= ifp->valid_lft */ 3665 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next)) 3666 next = ifp->tstamp + ifp->prefered_lft * HZ; 3667 spin_unlock(&ifp->lock); 3668 } 3669 } 3670 } 3671 3672 next_sec = round_jiffies_up(next); 3673 next_sched = next; 3674 3675 /* If rounded timeout is accurate enough, accept it. */ 3676 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ)) 3677 next_sched = next_sec; 3678 3679 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */ 3680 if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX)) 3681 next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX; 3682 3683 ADBG(KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n", 3684 now, next, next_sec, next_sched); 3685 mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now); 3686 rcu_read_unlock_bh(); 3687 } 3688 3689 static void addrconf_verify_work(struct work_struct *w) 3690 { 3691 rtnl_lock(); 3692 addrconf_verify_rtnl(); 3693 rtnl_unlock(); 3694 } 3695 3696 static void addrconf_verify(void) 3697 { 3698 mod_delayed_work(addrconf_wq, &addr_chk_work, 0); 3699 } 3700 3701 static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local, 3702 struct in6_addr **peer_pfx) 3703 { 3704 struct in6_addr *pfx = NULL; 3705 3706 *peer_pfx = NULL; 3707 3708 if (addr) 3709 pfx = nla_data(addr); 3710 3711 if (local) { 3712 if (pfx && nla_memcmp(local, pfx, sizeof(*pfx))) 3713 *peer_pfx = pfx; 3714 pfx = nla_data(local); 3715 } 3716 3717 return pfx; 3718 } 3719 3720 static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = { 3721 [IFA_ADDRESS] = { .len = sizeof(struct in6_addr) }, 3722 [IFA_LOCAL] = { .len = sizeof(struct in6_addr) }, 3723 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) }, 3724 [IFA_FLAGS] = { .len = sizeof(u32) }, 3725 }; 3726 3727 static int 3728 inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh) 3729 { 3730 struct net *net = sock_net(skb->sk); 3731 struct ifaddrmsg *ifm; 3732 struct nlattr *tb[IFA_MAX+1]; 3733 struct in6_addr *pfx, *peer_pfx; 3734 u32 ifa_flags; 3735 int err; 3736 3737 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 3738 if (err < 0) 3739 return err; 3740 3741 ifm = nlmsg_data(nlh); 3742 pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx); 3743 if (pfx == NULL) 3744 return -EINVAL; 3745 3746 ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags; 3747 3748 /* We ignore other flags so far. */ 3749 ifa_flags &= IFA_F_MANAGETEMPADDR; 3750 3751 return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx, 3752 ifm->ifa_prefixlen); 3753 } 3754 3755 static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags, 3756 u32 prefered_lft, u32 valid_lft) 3757 { 3758 u32 flags; 3759 clock_t expires; 3760 unsigned long timeout; 3761 bool was_managetempaddr; 3762 bool had_prefixroute; 3763 3764 ASSERT_RTNL(); 3765 3766 if (!valid_lft || (prefered_lft > valid_lft)) 3767 return -EINVAL; 3768 3769 if (ifa_flags & IFA_F_MANAGETEMPADDR && 3770 (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64)) 3771 return -EINVAL; 3772 3773 timeout = addrconf_timeout_fixup(valid_lft, HZ); 3774 if (addrconf_finite_timeout(timeout)) { 3775 expires = jiffies_to_clock_t(timeout * HZ); 3776 valid_lft = timeout; 3777 flags = RTF_EXPIRES; 3778 } else { 3779 expires = 0; 3780 flags = 0; 3781 ifa_flags |= IFA_F_PERMANENT; 3782 } 3783 3784 timeout = addrconf_timeout_fixup(prefered_lft, HZ); 3785 if (addrconf_finite_timeout(timeout)) { 3786 if (timeout == 0) 3787 ifa_flags |= IFA_F_DEPRECATED; 3788 prefered_lft = timeout; 3789 } 3790 3791 spin_lock_bh(&ifp->lock); 3792 was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR; 3793 had_prefixroute = ifp->flags & IFA_F_PERMANENT && 3794 !(ifp->flags & IFA_F_NOPREFIXROUTE); 3795 ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | 3796 IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR | 3797 IFA_F_NOPREFIXROUTE); 3798 ifp->flags |= ifa_flags; 3799 ifp->tstamp = jiffies; 3800 ifp->valid_lft = valid_lft; 3801 ifp->prefered_lft = prefered_lft; 3802 3803 spin_unlock_bh(&ifp->lock); 3804 if (!(ifp->flags&IFA_F_TENTATIVE)) 3805 ipv6_ifa_notify(0, ifp); 3806 3807 if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) { 3808 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev, 3809 expires, flags); 3810 } else if (had_prefixroute) { 3811 enum cleanup_prefix_rt_t action; 3812 unsigned long rt_expires; 3813 3814 write_lock_bh(&ifp->idev->lock); 3815 action = check_cleanup_prefix_route(ifp, &rt_expires); 3816 write_unlock_bh(&ifp->idev->lock); 3817 3818 if (action != CLEANUP_PREFIX_RT_NOP) { 3819 cleanup_prefix_route(ifp, rt_expires, 3820 action == CLEANUP_PREFIX_RT_DEL); 3821 } 3822 } 3823 3824 if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) { 3825 if (was_managetempaddr && !(ifp->flags & IFA_F_MANAGETEMPADDR)) 3826 valid_lft = prefered_lft = 0; 3827 manage_tempaddrs(ifp->idev, ifp, valid_lft, prefered_lft, 3828 !was_managetempaddr, jiffies); 3829 } 3830 3831 addrconf_verify_rtnl(); 3832 3833 return 0; 3834 } 3835 3836 static int 3837 inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh) 3838 { 3839 struct net *net = sock_net(skb->sk); 3840 struct ifaddrmsg *ifm; 3841 struct nlattr *tb[IFA_MAX+1]; 3842 struct in6_addr *pfx, *peer_pfx; 3843 struct inet6_ifaddr *ifa; 3844 struct net_device *dev; 3845 u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; 3846 u32 ifa_flags; 3847 int err; 3848 3849 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 3850 if (err < 0) 3851 return err; 3852 3853 ifm = nlmsg_data(nlh); 3854 pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx); 3855 if (pfx == NULL) 3856 return -EINVAL; 3857 3858 if (tb[IFA_CACHEINFO]) { 3859 struct ifa_cacheinfo *ci; 3860 3861 ci = nla_data(tb[IFA_CACHEINFO]); 3862 valid_lft = ci->ifa_valid; 3863 preferred_lft = ci->ifa_prefered; 3864 } else { 3865 preferred_lft = INFINITY_LIFE_TIME; 3866 valid_lft = INFINITY_LIFE_TIME; 3867 } 3868 3869 dev = __dev_get_by_index(net, ifm->ifa_index); 3870 if (dev == NULL) 3871 return -ENODEV; 3872 3873 ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags; 3874 3875 /* We ignore other flags so far. */ 3876 ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR | 3877 IFA_F_NOPREFIXROUTE; 3878 3879 ifa = ipv6_get_ifaddr(net, pfx, dev, 1); 3880 if (ifa == NULL) { 3881 /* 3882 * It would be best to check for !NLM_F_CREATE here but 3883 * userspace already relies on not having to provide this. 3884 */ 3885 return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx, 3886 ifm->ifa_prefixlen, ifa_flags, 3887 preferred_lft, valid_lft); 3888 } 3889 3890 if (nlh->nlmsg_flags & NLM_F_EXCL || 3891 !(nlh->nlmsg_flags & NLM_F_REPLACE)) 3892 err = -EEXIST; 3893 else 3894 err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft); 3895 3896 in6_ifa_put(ifa); 3897 3898 return err; 3899 } 3900 3901 static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags, 3902 u8 scope, int ifindex) 3903 { 3904 struct ifaddrmsg *ifm; 3905 3906 ifm = nlmsg_data(nlh); 3907 ifm->ifa_family = AF_INET6; 3908 ifm->ifa_prefixlen = prefixlen; 3909 ifm->ifa_flags = flags; 3910 ifm->ifa_scope = scope; 3911 ifm->ifa_index = ifindex; 3912 } 3913 3914 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp, 3915 unsigned long tstamp, u32 preferred, u32 valid) 3916 { 3917 struct ifa_cacheinfo ci; 3918 3919 ci.cstamp = cstamp_delta(cstamp); 3920 ci.tstamp = cstamp_delta(tstamp); 3921 ci.ifa_prefered = preferred; 3922 ci.ifa_valid = valid; 3923 3924 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci); 3925 } 3926 3927 static inline int rt_scope(int ifa_scope) 3928 { 3929 if (ifa_scope & IFA_HOST) 3930 return RT_SCOPE_HOST; 3931 else if (ifa_scope & IFA_LINK) 3932 return RT_SCOPE_LINK; 3933 else if (ifa_scope & IFA_SITE) 3934 return RT_SCOPE_SITE; 3935 else 3936 return RT_SCOPE_UNIVERSE; 3937 } 3938 3939 static inline int inet6_ifaddr_msgsize(void) 3940 { 3941 return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 3942 + nla_total_size(16) /* IFA_LOCAL */ 3943 + nla_total_size(16) /* IFA_ADDRESS */ 3944 + nla_total_size(sizeof(struct ifa_cacheinfo)) 3945 + nla_total_size(4) /* IFA_FLAGS */; 3946 } 3947 3948 static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa, 3949 u32 portid, u32 seq, int event, unsigned int flags) 3950 { 3951 struct nlmsghdr *nlh; 3952 u32 preferred, valid; 3953 3954 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags); 3955 if (nlh == NULL) 3956 return -EMSGSIZE; 3957 3958 put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope), 3959 ifa->idev->dev->ifindex); 3960 3961 if (!((ifa->flags&IFA_F_PERMANENT) && 3962 (ifa->prefered_lft == INFINITY_LIFE_TIME))) { 3963 preferred = ifa->prefered_lft; 3964 valid = ifa->valid_lft; 3965 if (preferred != INFINITY_LIFE_TIME) { 3966 long tval = (jiffies - ifa->tstamp)/HZ; 3967 if (preferred > tval) 3968 preferred -= tval; 3969 else 3970 preferred = 0; 3971 if (valid != INFINITY_LIFE_TIME) { 3972 if (valid > tval) 3973 valid -= tval; 3974 else 3975 valid = 0; 3976 } 3977 } 3978 } else { 3979 preferred = INFINITY_LIFE_TIME; 3980 valid = INFINITY_LIFE_TIME; 3981 } 3982 3983 if (!ipv6_addr_any(&ifa->peer_addr)) { 3984 if (nla_put(skb, IFA_LOCAL, 16, &ifa->addr) < 0 || 3985 nla_put(skb, IFA_ADDRESS, 16, &ifa->peer_addr) < 0) 3986 goto error; 3987 } else 3988 if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0) 3989 goto error; 3990 3991 if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0) 3992 goto error; 3993 3994 if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0) 3995 goto error; 3996 3997 return nlmsg_end(skb, nlh); 3998 3999 error: 4000 nlmsg_cancel(skb, nlh); 4001 return -EMSGSIZE; 4002 } 4003 4004 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca, 4005 u32 portid, u32 seq, int event, u16 flags) 4006 { 4007 struct nlmsghdr *nlh; 4008 u8 scope = RT_SCOPE_UNIVERSE; 4009 int ifindex = ifmca->idev->dev->ifindex; 4010 4011 if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE) 4012 scope = RT_SCOPE_SITE; 4013 4014 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags); 4015 if (nlh == NULL) 4016 return -EMSGSIZE; 4017 4018 put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex); 4019 if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 || 4020 put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp, 4021 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) { 4022 nlmsg_cancel(skb, nlh); 4023 return -EMSGSIZE; 4024 } 4025 4026 return nlmsg_end(skb, nlh); 4027 } 4028 4029 static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca, 4030 u32 portid, u32 seq, int event, unsigned int flags) 4031 { 4032 struct nlmsghdr *nlh; 4033 u8 scope = RT_SCOPE_UNIVERSE; 4034 int ifindex = ifaca->aca_idev->dev->ifindex; 4035 4036 if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE) 4037 scope = RT_SCOPE_SITE; 4038 4039 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags); 4040 if (nlh == NULL) 4041 return -EMSGSIZE; 4042 4043 put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex); 4044 if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 || 4045 put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp, 4046 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) { 4047 nlmsg_cancel(skb, nlh); 4048 return -EMSGSIZE; 4049 } 4050 4051 return nlmsg_end(skb, nlh); 4052 } 4053 4054 enum addr_type_t { 4055 UNICAST_ADDR, 4056 MULTICAST_ADDR, 4057 ANYCAST_ADDR, 4058 }; 4059 4060 /* called with rcu_read_lock() */ 4061 static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb, 4062 struct netlink_callback *cb, enum addr_type_t type, 4063 int s_ip_idx, int *p_ip_idx) 4064 { 4065 struct ifmcaddr6 *ifmca; 4066 struct ifacaddr6 *ifaca; 4067 int err = 1; 4068 int ip_idx = *p_ip_idx; 4069 4070 read_lock_bh(&idev->lock); 4071 switch (type) { 4072 case UNICAST_ADDR: { 4073 struct inet6_ifaddr *ifa; 4074 4075 /* unicast address incl. temp addr */ 4076 list_for_each_entry(ifa, &idev->addr_list, if_list) { 4077 if (++ip_idx < s_ip_idx) 4078 continue; 4079 err = inet6_fill_ifaddr(skb, ifa, 4080 NETLINK_CB(cb->skb).portid, 4081 cb->nlh->nlmsg_seq, 4082 RTM_NEWADDR, 4083 NLM_F_MULTI); 4084 if (err <= 0) 4085 break; 4086 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 4087 } 4088 break; 4089 } 4090 case MULTICAST_ADDR: 4091 /* multicast address */ 4092 for (ifmca = idev->mc_list; ifmca; 4093 ifmca = ifmca->next, ip_idx++) { 4094 if (ip_idx < s_ip_idx) 4095 continue; 4096 err = inet6_fill_ifmcaddr(skb, ifmca, 4097 NETLINK_CB(cb->skb).portid, 4098 cb->nlh->nlmsg_seq, 4099 RTM_GETMULTICAST, 4100 NLM_F_MULTI); 4101 if (err <= 0) 4102 break; 4103 } 4104 break; 4105 case ANYCAST_ADDR: 4106 /* anycast address */ 4107 for (ifaca = idev->ac_list; ifaca; 4108 ifaca = ifaca->aca_next, ip_idx++) { 4109 if (ip_idx < s_ip_idx) 4110 continue; 4111 err = inet6_fill_ifacaddr(skb, ifaca, 4112 NETLINK_CB(cb->skb).portid, 4113 cb->nlh->nlmsg_seq, 4114 RTM_GETANYCAST, 4115 NLM_F_MULTI); 4116 if (err <= 0) 4117 break; 4118 } 4119 break; 4120 default: 4121 break; 4122 } 4123 read_unlock_bh(&idev->lock); 4124 *p_ip_idx = ip_idx; 4125 return err; 4126 } 4127 4128 static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb, 4129 enum addr_type_t type) 4130 { 4131 struct net *net = sock_net(skb->sk); 4132 int h, s_h; 4133 int idx, ip_idx; 4134 int s_idx, s_ip_idx; 4135 struct net_device *dev; 4136 struct inet6_dev *idev; 4137 struct hlist_head *head; 4138 4139 s_h = cb->args[0]; 4140 s_idx = idx = cb->args[1]; 4141 s_ip_idx = ip_idx = cb->args[2]; 4142 4143 rcu_read_lock(); 4144 cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq; 4145 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 4146 idx = 0; 4147 head = &net->dev_index_head[h]; 4148 hlist_for_each_entry_rcu(dev, head, index_hlist) { 4149 if (idx < s_idx) 4150 goto cont; 4151 if (h > s_h || idx > s_idx) 4152 s_ip_idx = 0; 4153 ip_idx = 0; 4154 idev = __in6_dev_get(dev); 4155 if (!idev) 4156 goto cont; 4157 4158 if (in6_dump_addrs(idev, skb, cb, type, 4159 s_ip_idx, &ip_idx) <= 0) 4160 goto done; 4161 cont: 4162 idx++; 4163 } 4164 } 4165 done: 4166 rcu_read_unlock(); 4167 cb->args[0] = h; 4168 cb->args[1] = idx; 4169 cb->args[2] = ip_idx; 4170 4171 return skb->len; 4172 } 4173 4174 static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 4175 { 4176 enum addr_type_t type = UNICAST_ADDR; 4177 4178 return inet6_dump_addr(skb, cb, type); 4179 } 4180 4181 static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb) 4182 { 4183 enum addr_type_t type = MULTICAST_ADDR; 4184 4185 return inet6_dump_addr(skb, cb, type); 4186 } 4187 4188 4189 static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb) 4190 { 4191 enum addr_type_t type = ANYCAST_ADDR; 4192 4193 return inet6_dump_addr(skb, cb, type); 4194 } 4195 4196 static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh) 4197 { 4198 struct net *net = sock_net(in_skb->sk); 4199 struct ifaddrmsg *ifm; 4200 struct nlattr *tb[IFA_MAX+1]; 4201 struct in6_addr *addr = NULL, *peer; 4202 struct net_device *dev = NULL; 4203 struct inet6_ifaddr *ifa; 4204 struct sk_buff *skb; 4205 int err; 4206 4207 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy); 4208 if (err < 0) 4209 goto errout; 4210 4211 addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer); 4212 if (addr == NULL) { 4213 err = -EINVAL; 4214 goto errout; 4215 } 4216 4217 ifm = nlmsg_data(nlh); 4218 if (ifm->ifa_index) 4219 dev = __dev_get_by_index(net, ifm->ifa_index); 4220 4221 ifa = ipv6_get_ifaddr(net, addr, dev, 1); 4222 if (!ifa) { 4223 err = -EADDRNOTAVAIL; 4224 goto errout; 4225 } 4226 4227 skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL); 4228 if (!skb) { 4229 err = -ENOBUFS; 4230 goto errout_ifa; 4231 } 4232 4233 err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid, 4234 nlh->nlmsg_seq, RTM_NEWADDR, 0); 4235 if (err < 0) { 4236 /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */ 4237 WARN_ON(err == -EMSGSIZE); 4238 kfree_skb(skb); 4239 goto errout_ifa; 4240 } 4241 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 4242 errout_ifa: 4243 in6_ifa_put(ifa); 4244 errout: 4245 return err; 4246 } 4247 4248 static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa) 4249 { 4250 struct sk_buff *skb; 4251 struct net *net = dev_net(ifa->idev->dev); 4252 int err = -ENOBUFS; 4253 4254 skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC); 4255 if (skb == NULL) 4256 goto errout; 4257 4258 err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0); 4259 if (err < 0) { 4260 /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */ 4261 WARN_ON(err == -EMSGSIZE); 4262 kfree_skb(skb); 4263 goto errout; 4264 } 4265 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC); 4266 return; 4267 errout: 4268 if (err < 0) 4269 rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err); 4270 } 4271 4272 static inline void ipv6_store_devconf(struct ipv6_devconf *cnf, 4273 __s32 *array, int bytes) 4274 { 4275 BUG_ON(bytes < (DEVCONF_MAX * 4)); 4276 4277 memset(array, 0, bytes); 4278 array[DEVCONF_FORWARDING] = cnf->forwarding; 4279 array[DEVCONF_HOPLIMIT] = cnf->hop_limit; 4280 array[DEVCONF_MTU6] = cnf->mtu6; 4281 array[DEVCONF_ACCEPT_RA] = cnf->accept_ra; 4282 array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects; 4283 array[DEVCONF_AUTOCONF] = cnf->autoconf; 4284 array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits; 4285 array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits; 4286 array[DEVCONF_RTR_SOLICIT_INTERVAL] = 4287 jiffies_to_msecs(cnf->rtr_solicit_interval); 4288 array[DEVCONF_RTR_SOLICIT_DELAY] = 4289 jiffies_to_msecs(cnf->rtr_solicit_delay); 4290 array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version; 4291 array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] = 4292 jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval); 4293 array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] = 4294 jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval); 4295 array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr; 4296 array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft; 4297 array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft; 4298 array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry; 4299 array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor; 4300 array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses; 4301 array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr; 4302 array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo; 4303 #ifdef CONFIG_IPV6_ROUTER_PREF 4304 array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref; 4305 array[DEVCONF_RTR_PROBE_INTERVAL] = 4306 jiffies_to_msecs(cnf->rtr_probe_interval); 4307 #ifdef CONFIG_IPV6_ROUTE_INFO 4308 array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen; 4309 #endif 4310 #endif 4311 array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp; 4312 array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route; 4313 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 4314 array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad; 4315 #endif 4316 #ifdef CONFIG_IPV6_MROUTE 4317 array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding; 4318 #endif 4319 array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6; 4320 array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad; 4321 array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao; 4322 array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify; 4323 array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc; 4324 } 4325 4326 static inline size_t inet6_ifla6_size(void) 4327 { 4328 return nla_total_size(4) /* IFLA_INET6_FLAGS */ 4329 + nla_total_size(sizeof(struct ifla_cacheinfo)) 4330 + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */ 4331 + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */ 4332 + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */ 4333 + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */ 4334 } 4335 4336 static inline size_t inet6_if_nlmsg_size(void) 4337 { 4338 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 4339 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 4340 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 4341 + nla_total_size(4) /* IFLA_MTU */ 4342 + nla_total_size(4) /* IFLA_LINK */ 4343 + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */ 4344 } 4345 4346 static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib, 4347 int items, int bytes) 4348 { 4349 int i; 4350 int pad = bytes - sizeof(u64) * items; 4351 BUG_ON(pad < 0); 4352 4353 /* Use put_unaligned() because stats may not be aligned for u64. */ 4354 put_unaligned(items, &stats[0]); 4355 for (i = 1; i < items; i++) 4356 put_unaligned(atomic_long_read(&mib[i]), &stats[i]); 4357 4358 memset(&stats[items], 0, pad); 4359 } 4360 4361 static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib, 4362 int items, int bytes, size_t syncpoff) 4363 { 4364 int i; 4365 int pad = bytes - sizeof(u64) * items; 4366 BUG_ON(pad < 0); 4367 4368 /* Use put_unaligned() because stats may not be aligned for u64. */ 4369 put_unaligned(items, &stats[0]); 4370 for (i = 1; i < items; i++) 4371 put_unaligned(snmp_fold_field64(mib, i, syncpoff), &stats[i]); 4372 4373 memset(&stats[items], 0, pad); 4374 } 4375 4376 static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype, 4377 int bytes) 4378 { 4379 switch (attrtype) { 4380 case IFLA_INET6_STATS: 4381 __snmp6_fill_stats64(stats, idev->stats.ipv6, 4382 IPSTATS_MIB_MAX, bytes, offsetof(struct ipstats_mib, syncp)); 4383 break; 4384 case IFLA_INET6_ICMP6STATS: 4385 __snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes); 4386 break; 4387 } 4388 } 4389 4390 static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev) 4391 { 4392 struct nlattr *nla; 4393 struct ifla_cacheinfo ci; 4394 4395 if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags)) 4396 goto nla_put_failure; 4397 ci.max_reasm_len = IPV6_MAXPLEN; 4398 ci.tstamp = cstamp_delta(idev->tstamp); 4399 ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time); 4400 ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME)); 4401 if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci)) 4402 goto nla_put_failure; 4403 nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32)); 4404 if (nla == NULL) 4405 goto nla_put_failure; 4406 ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla)); 4407 4408 /* XXX - MC not implemented */ 4409 4410 nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64)); 4411 if (nla == NULL) 4412 goto nla_put_failure; 4413 snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla)); 4414 4415 nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64)); 4416 if (nla == NULL) 4417 goto nla_put_failure; 4418 snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla)); 4419 4420 nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr)); 4421 if (nla == NULL) 4422 goto nla_put_failure; 4423 read_lock_bh(&idev->lock); 4424 memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla)); 4425 read_unlock_bh(&idev->lock); 4426 4427 return 0; 4428 4429 nla_put_failure: 4430 return -EMSGSIZE; 4431 } 4432 4433 static size_t inet6_get_link_af_size(const struct net_device *dev) 4434 { 4435 if (!__in6_dev_get(dev)) 4436 return 0; 4437 4438 return inet6_ifla6_size(); 4439 } 4440 4441 static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev) 4442 { 4443 struct inet6_dev *idev = __in6_dev_get(dev); 4444 4445 if (!idev) 4446 return -ENODATA; 4447 4448 if (inet6_fill_ifla6_attrs(skb, idev) < 0) 4449 return -EMSGSIZE; 4450 4451 return 0; 4452 } 4453 4454 static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token) 4455 { 4456 struct inet6_ifaddr *ifp; 4457 struct net_device *dev = idev->dev; 4458 bool update_rs = false; 4459 struct in6_addr ll_addr; 4460 4461 ASSERT_RTNL(); 4462 4463 if (token == NULL) 4464 return -EINVAL; 4465 if (ipv6_addr_any(token)) 4466 return -EINVAL; 4467 if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) 4468 return -EINVAL; 4469 if (!ipv6_accept_ra(idev)) 4470 return -EINVAL; 4471 if (idev->cnf.rtr_solicits <= 0) 4472 return -EINVAL; 4473 4474 write_lock_bh(&idev->lock); 4475 4476 BUILD_BUG_ON(sizeof(token->s6_addr) != 16); 4477 memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8); 4478 4479 write_unlock_bh(&idev->lock); 4480 4481 if (!idev->dead && (idev->if_flags & IF_READY) && 4482 !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE | 4483 IFA_F_OPTIMISTIC)) { 4484 4485 /* If we're not ready, then normal ifup will take care 4486 * of this. Otherwise, we need to request our rs here. 4487 */ 4488 ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters); 4489 update_rs = true; 4490 } 4491 4492 write_lock_bh(&idev->lock); 4493 4494 if (update_rs) { 4495 idev->if_flags |= IF_RS_SENT; 4496 idev->rs_probes = 1; 4497 addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval); 4498 } 4499 4500 /* Well, that's kinda nasty ... */ 4501 list_for_each_entry(ifp, &idev->addr_list, if_list) { 4502 spin_lock(&ifp->lock); 4503 if (ifp->tokenized) { 4504 ifp->valid_lft = 0; 4505 ifp->prefered_lft = 0; 4506 } 4507 spin_unlock(&ifp->lock); 4508 } 4509 4510 write_unlock_bh(&idev->lock); 4511 addrconf_verify_rtnl(); 4512 return 0; 4513 } 4514 4515 static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla) 4516 { 4517 int err = -EINVAL; 4518 struct inet6_dev *idev = __in6_dev_get(dev); 4519 struct nlattr *tb[IFLA_INET6_MAX + 1]; 4520 4521 if (!idev) 4522 return -EAFNOSUPPORT; 4523 4524 if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL) < 0) 4525 BUG(); 4526 4527 if (tb[IFLA_INET6_TOKEN]) 4528 err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN])); 4529 4530 return err; 4531 } 4532 4533 static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev, 4534 u32 portid, u32 seq, int event, unsigned int flags) 4535 { 4536 struct net_device *dev = idev->dev; 4537 struct ifinfomsg *hdr; 4538 struct nlmsghdr *nlh; 4539 void *protoinfo; 4540 4541 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags); 4542 if (nlh == NULL) 4543 return -EMSGSIZE; 4544 4545 hdr = nlmsg_data(nlh); 4546 hdr->ifi_family = AF_INET6; 4547 hdr->__ifi_pad = 0; 4548 hdr->ifi_type = dev->type; 4549 hdr->ifi_index = dev->ifindex; 4550 hdr->ifi_flags = dev_get_flags(dev); 4551 hdr->ifi_change = 0; 4552 4553 if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 4554 (dev->addr_len && 4555 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) || 4556 nla_put_u32(skb, IFLA_MTU, dev->mtu) || 4557 (dev->ifindex != dev->iflink && 4558 nla_put_u32(skb, IFLA_LINK, dev->iflink))) 4559 goto nla_put_failure; 4560 protoinfo = nla_nest_start(skb, IFLA_PROTINFO); 4561 if (protoinfo == NULL) 4562 goto nla_put_failure; 4563 4564 if (inet6_fill_ifla6_attrs(skb, idev) < 0) 4565 goto nla_put_failure; 4566 4567 nla_nest_end(skb, protoinfo); 4568 return nlmsg_end(skb, nlh); 4569 4570 nla_put_failure: 4571 nlmsg_cancel(skb, nlh); 4572 return -EMSGSIZE; 4573 } 4574 4575 static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 4576 { 4577 struct net *net = sock_net(skb->sk); 4578 int h, s_h; 4579 int idx = 0, s_idx; 4580 struct net_device *dev; 4581 struct inet6_dev *idev; 4582 struct hlist_head *head; 4583 4584 s_h = cb->args[0]; 4585 s_idx = cb->args[1]; 4586 4587 rcu_read_lock(); 4588 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 4589 idx = 0; 4590 head = &net->dev_index_head[h]; 4591 hlist_for_each_entry_rcu(dev, head, index_hlist) { 4592 if (idx < s_idx) 4593 goto cont; 4594 idev = __in6_dev_get(dev); 4595 if (!idev) 4596 goto cont; 4597 if (inet6_fill_ifinfo(skb, idev, 4598 NETLINK_CB(cb->skb).portid, 4599 cb->nlh->nlmsg_seq, 4600 RTM_NEWLINK, NLM_F_MULTI) <= 0) 4601 goto out; 4602 cont: 4603 idx++; 4604 } 4605 } 4606 out: 4607 rcu_read_unlock(); 4608 cb->args[1] = idx; 4609 cb->args[0] = h; 4610 4611 return skb->len; 4612 } 4613 4614 void inet6_ifinfo_notify(int event, struct inet6_dev *idev) 4615 { 4616 struct sk_buff *skb; 4617 struct net *net = dev_net(idev->dev); 4618 int err = -ENOBUFS; 4619 4620 skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC); 4621 if (skb == NULL) 4622 goto errout; 4623 4624 err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0); 4625 if (err < 0) { 4626 /* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */ 4627 WARN_ON(err == -EMSGSIZE); 4628 kfree_skb(skb); 4629 goto errout; 4630 } 4631 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC); 4632 return; 4633 errout: 4634 if (err < 0) 4635 rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err); 4636 } 4637 4638 static inline size_t inet6_prefix_nlmsg_size(void) 4639 { 4640 return NLMSG_ALIGN(sizeof(struct prefixmsg)) 4641 + nla_total_size(sizeof(struct in6_addr)) 4642 + nla_total_size(sizeof(struct prefix_cacheinfo)); 4643 } 4644 4645 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev, 4646 struct prefix_info *pinfo, u32 portid, u32 seq, 4647 int event, unsigned int flags) 4648 { 4649 struct prefixmsg *pmsg; 4650 struct nlmsghdr *nlh; 4651 struct prefix_cacheinfo ci; 4652 4653 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags); 4654 if (nlh == NULL) 4655 return -EMSGSIZE; 4656 4657 pmsg = nlmsg_data(nlh); 4658 pmsg->prefix_family = AF_INET6; 4659 pmsg->prefix_pad1 = 0; 4660 pmsg->prefix_pad2 = 0; 4661 pmsg->prefix_ifindex = idev->dev->ifindex; 4662 pmsg->prefix_len = pinfo->prefix_len; 4663 pmsg->prefix_type = pinfo->type; 4664 pmsg->prefix_pad3 = 0; 4665 pmsg->prefix_flags = 0; 4666 if (pinfo->onlink) 4667 pmsg->prefix_flags |= IF_PREFIX_ONLINK; 4668 if (pinfo->autoconf) 4669 pmsg->prefix_flags |= IF_PREFIX_AUTOCONF; 4670 4671 if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix)) 4672 goto nla_put_failure; 4673 ci.preferred_time = ntohl(pinfo->prefered); 4674 ci.valid_time = ntohl(pinfo->valid); 4675 if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci)) 4676 goto nla_put_failure; 4677 return nlmsg_end(skb, nlh); 4678 4679 nla_put_failure: 4680 nlmsg_cancel(skb, nlh); 4681 return -EMSGSIZE; 4682 } 4683 4684 static void inet6_prefix_notify(int event, struct inet6_dev *idev, 4685 struct prefix_info *pinfo) 4686 { 4687 struct sk_buff *skb; 4688 struct net *net = dev_net(idev->dev); 4689 int err = -ENOBUFS; 4690 4691 skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC); 4692 if (skb == NULL) 4693 goto errout; 4694 4695 err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0); 4696 if (err < 0) { 4697 /* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */ 4698 WARN_ON(err == -EMSGSIZE); 4699 kfree_skb(skb); 4700 goto errout; 4701 } 4702 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC); 4703 return; 4704 errout: 4705 if (err < 0) 4706 rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err); 4707 } 4708 4709 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp) 4710 { 4711 struct net *net = dev_net(ifp->idev->dev); 4712 4713 if (event) 4714 ASSERT_RTNL(); 4715 4716 inet6_ifa_notify(event ? : RTM_NEWADDR, ifp); 4717 4718 switch (event) { 4719 case RTM_NEWADDR: 4720 /* 4721 * If the address was optimistic 4722 * we inserted the route at the start of 4723 * our DAD process, so we don't need 4724 * to do it again 4725 */ 4726 if (!(ifp->rt->rt6i_node)) 4727 ip6_ins_rt(ifp->rt); 4728 if (ifp->idev->cnf.forwarding) 4729 addrconf_join_anycast(ifp); 4730 if (!ipv6_addr_any(&ifp->peer_addr)) 4731 addrconf_prefix_route(&ifp->peer_addr, 128, 4732 ifp->idev->dev, 0, 0); 4733 break; 4734 case RTM_DELADDR: 4735 if (ifp->idev->cnf.forwarding) 4736 addrconf_leave_anycast(ifp); 4737 addrconf_leave_solict(ifp->idev, &ifp->addr); 4738 if (!ipv6_addr_any(&ifp->peer_addr)) { 4739 struct rt6_info *rt; 4740 struct net_device *dev = ifp->idev->dev; 4741 4742 rt = rt6_lookup(dev_net(dev), &ifp->peer_addr, NULL, 4743 dev->ifindex, 1); 4744 if (rt) { 4745 dst_hold(&rt->dst); 4746 if (ip6_del_rt(rt)) 4747 dst_free(&rt->dst); 4748 } 4749 } 4750 dst_hold(&ifp->rt->dst); 4751 4752 if (ip6_del_rt(ifp->rt)) 4753 dst_free(&ifp->rt->dst); 4754 break; 4755 } 4756 atomic_inc(&net->ipv6.dev_addr_genid); 4757 rt_genid_bump_ipv6(net); 4758 } 4759 4760 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp) 4761 { 4762 rcu_read_lock_bh(); 4763 if (likely(ifp->idev->dead == 0)) 4764 __ipv6_ifa_notify(event, ifp); 4765 rcu_read_unlock_bh(); 4766 } 4767 4768 #ifdef CONFIG_SYSCTL 4769 4770 static 4771 int addrconf_sysctl_forward(struct ctl_table *ctl, int write, 4772 void __user *buffer, size_t *lenp, loff_t *ppos) 4773 { 4774 int *valp = ctl->data; 4775 int val = *valp; 4776 loff_t pos = *ppos; 4777 struct ctl_table lctl; 4778 int ret; 4779 4780 /* 4781 * ctl->data points to idev->cnf.forwarding, we should 4782 * not modify it until we get the rtnl lock. 4783 */ 4784 lctl = *ctl; 4785 lctl.data = &val; 4786 4787 ret = proc_dointvec(&lctl, write, buffer, lenp, ppos); 4788 4789 if (write) 4790 ret = addrconf_fixup_forwarding(ctl, valp, val); 4791 if (ret) 4792 *ppos = pos; 4793 return ret; 4794 } 4795 4796 static void dev_disable_change(struct inet6_dev *idev) 4797 { 4798 struct netdev_notifier_info info; 4799 4800 if (!idev || !idev->dev) 4801 return; 4802 4803 netdev_notifier_info_init(&info, idev->dev); 4804 if (idev->cnf.disable_ipv6) 4805 addrconf_notify(NULL, NETDEV_DOWN, &info); 4806 else 4807 addrconf_notify(NULL, NETDEV_UP, &info); 4808 } 4809 4810 static void addrconf_disable_change(struct net *net, __s32 newf) 4811 { 4812 struct net_device *dev; 4813 struct inet6_dev *idev; 4814 4815 rcu_read_lock(); 4816 for_each_netdev_rcu(net, dev) { 4817 idev = __in6_dev_get(dev); 4818 if (idev) { 4819 int changed = (!idev->cnf.disable_ipv6) ^ (!newf); 4820 idev->cnf.disable_ipv6 = newf; 4821 if (changed) 4822 dev_disable_change(idev); 4823 } 4824 } 4825 rcu_read_unlock(); 4826 } 4827 4828 static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf) 4829 { 4830 struct net *net; 4831 int old; 4832 4833 if (!rtnl_trylock()) 4834 return restart_syscall(); 4835 4836 net = (struct net *)table->extra2; 4837 old = *p; 4838 *p = newf; 4839 4840 if (p == &net->ipv6.devconf_dflt->disable_ipv6) { 4841 rtnl_unlock(); 4842 return 0; 4843 } 4844 4845 if (p == &net->ipv6.devconf_all->disable_ipv6) { 4846 net->ipv6.devconf_dflt->disable_ipv6 = newf; 4847 addrconf_disable_change(net, newf); 4848 } else if ((!newf) ^ (!old)) 4849 dev_disable_change((struct inet6_dev *)table->extra1); 4850 4851 rtnl_unlock(); 4852 return 0; 4853 } 4854 4855 static 4856 int addrconf_sysctl_disable(struct ctl_table *ctl, int write, 4857 void __user *buffer, size_t *lenp, loff_t *ppos) 4858 { 4859 int *valp = ctl->data; 4860 int val = *valp; 4861 loff_t pos = *ppos; 4862 struct ctl_table lctl; 4863 int ret; 4864 4865 /* 4866 * ctl->data points to idev->cnf.disable_ipv6, we should 4867 * not modify it until we get the rtnl lock. 4868 */ 4869 lctl = *ctl; 4870 lctl.data = &val; 4871 4872 ret = proc_dointvec(&lctl, write, buffer, lenp, ppos); 4873 4874 if (write) 4875 ret = addrconf_disable_ipv6(ctl, valp, val); 4876 if (ret) 4877 *ppos = pos; 4878 return ret; 4879 } 4880 4881 static 4882 int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write, 4883 void __user *buffer, size_t *lenp, loff_t *ppos) 4884 { 4885 int *valp = ctl->data; 4886 int ret; 4887 int old, new; 4888 4889 old = *valp; 4890 ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 4891 new = *valp; 4892 4893 if (write && old != new) { 4894 struct net *net = ctl->extra2; 4895 4896 if (!rtnl_trylock()) 4897 return restart_syscall(); 4898 4899 if (valp == &net->ipv6.devconf_dflt->proxy_ndp) 4900 inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH, 4901 NETCONFA_IFINDEX_DEFAULT, 4902 net->ipv6.devconf_dflt); 4903 else if (valp == &net->ipv6.devconf_all->proxy_ndp) 4904 inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH, 4905 NETCONFA_IFINDEX_ALL, 4906 net->ipv6.devconf_all); 4907 else { 4908 struct inet6_dev *idev = ctl->extra1; 4909 4910 inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH, 4911 idev->dev->ifindex, 4912 &idev->cnf); 4913 } 4914 rtnl_unlock(); 4915 } 4916 4917 return ret; 4918 } 4919 4920 4921 static struct addrconf_sysctl_table 4922 { 4923 struct ctl_table_header *sysctl_header; 4924 struct ctl_table addrconf_vars[DEVCONF_MAX+1]; 4925 } addrconf_sysctl __read_mostly = { 4926 .sysctl_header = NULL, 4927 .addrconf_vars = { 4928 { 4929 .procname = "forwarding", 4930 .data = &ipv6_devconf.forwarding, 4931 .maxlen = sizeof(int), 4932 .mode = 0644, 4933 .proc_handler = addrconf_sysctl_forward, 4934 }, 4935 { 4936 .procname = "hop_limit", 4937 .data = &ipv6_devconf.hop_limit, 4938 .maxlen = sizeof(int), 4939 .mode = 0644, 4940 .proc_handler = proc_dointvec, 4941 }, 4942 { 4943 .procname = "mtu", 4944 .data = &ipv6_devconf.mtu6, 4945 .maxlen = sizeof(int), 4946 .mode = 0644, 4947 .proc_handler = proc_dointvec, 4948 }, 4949 { 4950 .procname = "accept_ra", 4951 .data = &ipv6_devconf.accept_ra, 4952 .maxlen = sizeof(int), 4953 .mode = 0644, 4954 .proc_handler = proc_dointvec, 4955 }, 4956 { 4957 .procname = "accept_redirects", 4958 .data = &ipv6_devconf.accept_redirects, 4959 .maxlen = sizeof(int), 4960 .mode = 0644, 4961 .proc_handler = proc_dointvec, 4962 }, 4963 { 4964 .procname = "autoconf", 4965 .data = &ipv6_devconf.autoconf, 4966 .maxlen = sizeof(int), 4967 .mode = 0644, 4968 .proc_handler = proc_dointvec, 4969 }, 4970 { 4971 .procname = "dad_transmits", 4972 .data = &ipv6_devconf.dad_transmits, 4973 .maxlen = sizeof(int), 4974 .mode = 0644, 4975 .proc_handler = proc_dointvec, 4976 }, 4977 { 4978 .procname = "router_solicitations", 4979 .data = &ipv6_devconf.rtr_solicits, 4980 .maxlen = sizeof(int), 4981 .mode = 0644, 4982 .proc_handler = proc_dointvec, 4983 }, 4984 { 4985 .procname = "router_solicitation_interval", 4986 .data = &ipv6_devconf.rtr_solicit_interval, 4987 .maxlen = sizeof(int), 4988 .mode = 0644, 4989 .proc_handler = proc_dointvec_jiffies, 4990 }, 4991 { 4992 .procname = "router_solicitation_delay", 4993 .data = &ipv6_devconf.rtr_solicit_delay, 4994 .maxlen = sizeof(int), 4995 .mode = 0644, 4996 .proc_handler = proc_dointvec_jiffies, 4997 }, 4998 { 4999 .procname = "force_mld_version", 5000 .data = &ipv6_devconf.force_mld_version, 5001 .maxlen = sizeof(int), 5002 .mode = 0644, 5003 .proc_handler = proc_dointvec, 5004 }, 5005 { 5006 .procname = "mldv1_unsolicited_report_interval", 5007 .data = 5008 &ipv6_devconf.mldv1_unsolicited_report_interval, 5009 .maxlen = sizeof(int), 5010 .mode = 0644, 5011 .proc_handler = proc_dointvec_ms_jiffies, 5012 }, 5013 { 5014 .procname = "mldv2_unsolicited_report_interval", 5015 .data = 5016 &ipv6_devconf.mldv2_unsolicited_report_interval, 5017 .maxlen = sizeof(int), 5018 .mode = 0644, 5019 .proc_handler = proc_dointvec_ms_jiffies, 5020 }, 5021 { 5022 .procname = "use_tempaddr", 5023 .data = &ipv6_devconf.use_tempaddr, 5024 .maxlen = sizeof(int), 5025 .mode = 0644, 5026 .proc_handler = proc_dointvec, 5027 }, 5028 { 5029 .procname = "temp_valid_lft", 5030 .data = &ipv6_devconf.temp_valid_lft, 5031 .maxlen = sizeof(int), 5032 .mode = 0644, 5033 .proc_handler = proc_dointvec, 5034 }, 5035 { 5036 .procname = "temp_prefered_lft", 5037 .data = &ipv6_devconf.temp_prefered_lft, 5038 .maxlen = sizeof(int), 5039 .mode = 0644, 5040 .proc_handler = proc_dointvec, 5041 }, 5042 { 5043 .procname = "regen_max_retry", 5044 .data = &ipv6_devconf.regen_max_retry, 5045 .maxlen = sizeof(int), 5046 .mode = 0644, 5047 .proc_handler = proc_dointvec, 5048 }, 5049 { 5050 .procname = "max_desync_factor", 5051 .data = &ipv6_devconf.max_desync_factor, 5052 .maxlen = sizeof(int), 5053 .mode = 0644, 5054 .proc_handler = proc_dointvec, 5055 }, 5056 { 5057 .procname = "max_addresses", 5058 .data = &ipv6_devconf.max_addresses, 5059 .maxlen = sizeof(int), 5060 .mode = 0644, 5061 .proc_handler = proc_dointvec, 5062 }, 5063 { 5064 .procname = "accept_ra_defrtr", 5065 .data = &ipv6_devconf.accept_ra_defrtr, 5066 .maxlen = sizeof(int), 5067 .mode = 0644, 5068 .proc_handler = proc_dointvec, 5069 }, 5070 { 5071 .procname = "accept_ra_pinfo", 5072 .data = &ipv6_devconf.accept_ra_pinfo, 5073 .maxlen = sizeof(int), 5074 .mode = 0644, 5075 .proc_handler = proc_dointvec, 5076 }, 5077 #ifdef CONFIG_IPV6_ROUTER_PREF 5078 { 5079 .procname = "accept_ra_rtr_pref", 5080 .data = &ipv6_devconf.accept_ra_rtr_pref, 5081 .maxlen = sizeof(int), 5082 .mode = 0644, 5083 .proc_handler = proc_dointvec, 5084 }, 5085 { 5086 .procname = "router_probe_interval", 5087 .data = &ipv6_devconf.rtr_probe_interval, 5088 .maxlen = sizeof(int), 5089 .mode = 0644, 5090 .proc_handler = proc_dointvec_jiffies, 5091 }, 5092 #ifdef CONFIG_IPV6_ROUTE_INFO 5093 { 5094 .procname = "accept_ra_rt_info_max_plen", 5095 .data = &ipv6_devconf.accept_ra_rt_info_max_plen, 5096 .maxlen = sizeof(int), 5097 .mode = 0644, 5098 .proc_handler = proc_dointvec, 5099 }, 5100 #endif 5101 #endif 5102 { 5103 .procname = "proxy_ndp", 5104 .data = &ipv6_devconf.proxy_ndp, 5105 .maxlen = sizeof(int), 5106 .mode = 0644, 5107 .proc_handler = addrconf_sysctl_proxy_ndp, 5108 }, 5109 { 5110 .procname = "accept_source_route", 5111 .data = &ipv6_devconf.accept_source_route, 5112 .maxlen = sizeof(int), 5113 .mode = 0644, 5114 .proc_handler = proc_dointvec, 5115 }, 5116 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 5117 { 5118 .procname = "optimistic_dad", 5119 .data = &ipv6_devconf.optimistic_dad, 5120 .maxlen = sizeof(int), 5121 .mode = 0644, 5122 .proc_handler = proc_dointvec, 5123 5124 }, 5125 #endif 5126 #ifdef CONFIG_IPV6_MROUTE 5127 { 5128 .procname = "mc_forwarding", 5129 .data = &ipv6_devconf.mc_forwarding, 5130 .maxlen = sizeof(int), 5131 .mode = 0444, 5132 .proc_handler = proc_dointvec, 5133 }, 5134 #endif 5135 { 5136 .procname = "disable_ipv6", 5137 .data = &ipv6_devconf.disable_ipv6, 5138 .maxlen = sizeof(int), 5139 .mode = 0644, 5140 .proc_handler = addrconf_sysctl_disable, 5141 }, 5142 { 5143 .procname = "accept_dad", 5144 .data = &ipv6_devconf.accept_dad, 5145 .maxlen = sizeof(int), 5146 .mode = 0644, 5147 .proc_handler = proc_dointvec, 5148 }, 5149 { 5150 .procname = "force_tllao", 5151 .data = &ipv6_devconf.force_tllao, 5152 .maxlen = sizeof(int), 5153 .mode = 0644, 5154 .proc_handler = proc_dointvec 5155 }, 5156 { 5157 .procname = "ndisc_notify", 5158 .data = &ipv6_devconf.ndisc_notify, 5159 .maxlen = sizeof(int), 5160 .mode = 0644, 5161 .proc_handler = proc_dointvec 5162 }, 5163 { 5164 .procname = "suppress_frag_ndisc", 5165 .data = &ipv6_devconf.suppress_frag_ndisc, 5166 .maxlen = sizeof(int), 5167 .mode = 0644, 5168 .proc_handler = proc_dointvec 5169 }, 5170 { 5171 /* sentinel */ 5172 } 5173 }, 5174 }; 5175 5176 static int __addrconf_sysctl_register(struct net *net, char *dev_name, 5177 struct inet6_dev *idev, struct ipv6_devconf *p) 5178 { 5179 int i; 5180 struct addrconf_sysctl_table *t; 5181 char path[sizeof("net/ipv6/conf/") + IFNAMSIZ]; 5182 5183 t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL); 5184 if (t == NULL) 5185 goto out; 5186 5187 for (i = 0; t->addrconf_vars[i].data; i++) { 5188 t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf; 5189 t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */ 5190 t->addrconf_vars[i].extra2 = net; 5191 } 5192 5193 snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name); 5194 5195 t->sysctl_header = register_net_sysctl(net, path, t->addrconf_vars); 5196 if (t->sysctl_header == NULL) 5197 goto free; 5198 5199 p->sysctl = t; 5200 return 0; 5201 5202 free: 5203 kfree(t); 5204 out: 5205 return -ENOBUFS; 5206 } 5207 5208 static void __addrconf_sysctl_unregister(struct ipv6_devconf *p) 5209 { 5210 struct addrconf_sysctl_table *t; 5211 5212 if (p->sysctl == NULL) 5213 return; 5214 5215 t = p->sysctl; 5216 p->sysctl = NULL; 5217 unregister_net_sysctl_table(t->sysctl_header); 5218 kfree(t); 5219 } 5220 5221 static void addrconf_sysctl_register(struct inet6_dev *idev) 5222 { 5223 neigh_sysctl_register(idev->dev, idev->nd_parms, 5224 &ndisc_ifinfo_sysctl_change); 5225 __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name, 5226 idev, &idev->cnf); 5227 } 5228 5229 static void addrconf_sysctl_unregister(struct inet6_dev *idev) 5230 { 5231 __addrconf_sysctl_unregister(&idev->cnf); 5232 neigh_sysctl_unregister(idev->nd_parms); 5233 } 5234 5235 5236 #endif 5237 5238 static int __net_init addrconf_init_net(struct net *net) 5239 { 5240 int err = -ENOMEM; 5241 struct ipv6_devconf *all, *dflt; 5242 5243 all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL); 5244 if (all == NULL) 5245 goto err_alloc_all; 5246 5247 dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL); 5248 if (dflt == NULL) 5249 goto err_alloc_dflt; 5250 5251 /* these will be inherited by all namespaces */ 5252 dflt->autoconf = ipv6_defaults.autoconf; 5253 dflt->disable_ipv6 = ipv6_defaults.disable_ipv6; 5254 5255 net->ipv6.devconf_all = all; 5256 net->ipv6.devconf_dflt = dflt; 5257 5258 #ifdef CONFIG_SYSCTL 5259 err = __addrconf_sysctl_register(net, "all", NULL, all); 5260 if (err < 0) 5261 goto err_reg_all; 5262 5263 err = __addrconf_sysctl_register(net, "default", NULL, dflt); 5264 if (err < 0) 5265 goto err_reg_dflt; 5266 #endif 5267 return 0; 5268 5269 #ifdef CONFIG_SYSCTL 5270 err_reg_dflt: 5271 __addrconf_sysctl_unregister(all); 5272 err_reg_all: 5273 kfree(dflt); 5274 #endif 5275 err_alloc_dflt: 5276 kfree(all); 5277 err_alloc_all: 5278 return err; 5279 } 5280 5281 static void __net_exit addrconf_exit_net(struct net *net) 5282 { 5283 #ifdef CONFIG_SYSCTL 5284 __addrconf_sysctl_unregister(net->ipv6.devconf_dflt); 5285 __addrconf_sysctl_unregister(net->ipv6.devconf_all); 5286 #endif 5287 if (!net_eq(net, &init_net)) { 5288 kfree(net->ipv6.devconf_dflt); 5289 kfree(net->ipv6.devconf_all); 5290 } 5291 } 5292 5293 static struct pernet_operations addrconf_ops = { 5294 .init = addrconf_init_net, 5295 .exit = addrconf_exit_net, 5296 }; 5297 5298 static struct rtnl_af_ops inet6_ops = { 5299 .family = AF_INET6, 5300 .fill_link_af = inet6_fill_link_af, 5301 .get_link_af_size = inet6_get_link_af_size, 5302 .set_link_af = inet6_set_link_af, 5303 }; 5304 5305 /* 5306 * Init / cleanup code 5307 */ 5308 5309 int __init addrconf_init(void) 5310 { 5311 int i, err; 5312 5313 err = ipv6_addr_label_init(); 5314 if (err < 0) { 5315 pr_crit("%s: cannot initialize default policy table: %d\n", 5316 __func__, err); 5317 goto out; 5318 } 5319 5320 err = register_pernet_subsys(&addrconf_ops); 5321 if (err < 0) 5322 goto out_addrlabel; 5323 5324 addrconf_wq = create_workqueue("ipv6_addrconf"); 5325 if (!addrconf_wq) { 5326 err = -ENOMEM; 5327 goto out_nowq; 5328 } 5329 5330 /* The addrconf netdev notifier requires that loopback_dev 5331 * has it's ipv6 private information allocated and setup 5332 * before it can bring up and give link-local addresses 5333 * to other devices which are up. 5334 * 5335 * Unfortunately, loopback_dev is not necessarily the first 5336 * entry in the global dev_base list of net devices. In fact, 5337 * it is likely to be the very last entry on that list. 5338 * So this causes the notifier registry below to try and 5339 * give link-local addresses to all devices besides loopback_dev 5340 * first, then loopback_dev, which cases all the non-loopback_dev 5341 * devices to fail to get a link-local address. 5342 * 5343 * So, as a temporary fix, allocate the ipv6 structure for 5344 * loopback_dev first by hand. 5345 * Longer term, all of the dependencies ipv6 has upon the loopback 5346 * device and it being up should be removed. 5347 */ 5348 rtnl_lock(); 5349 if (!ipv6_add_dev(init_net.loopback_dev)) 5350 err = -ENOMEM; 5351 rtnl_unlock(); 5352 if (err) 5353 goto errlo; 5354 5355 for (i = 0; i < IN6_ADDR_HSIZE; i++) 5356 INIT_HLIST_HEAD(&inet6_addr_lst[i]); 5357 5358 register_netdevice_notifier(&ipv6_dev_notf); 5359 5360 addrconf_verify(); 5361 5362 rtnl_af_register(&inet6_ops); 5363 5364 err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo, 5365 NULL); 5366 if (err < 0) 5367 goto errout; 5368 5369 /* Only the first call to __rtnl_register can fail */ 5370 __rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL); 5371 __rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL); 5372 __rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr, 5373 inet6_dump_ifaddr, NULL); 5374 __rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL, 5375 inet6_dump_ifmcaddr, NULL); 5376 __rtnl_register(PF_INET6, RTM_GETANYCAST, NULL, 5377 inet6_dump_ifacaddr, NULL); 5378 __rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf, 5379 inet6_netconf_dump_devconf, NULL); 5380 5381 ipv6_addr_label_rtnl_register(); 5382 5383 return 0; 5384 errout: 5385 rtnl_af_unregister(&inet6_ops); 5386 unregister_netdevice_notifier(&ipv6_dev_notf); 5387 errlo: 5388 destroy_workqueue(addrconf_wq); 5389 out_nowq: 5390 unregister_pernet_subsys(&addrconf_ops); 5391 out_addrlabel: 5392 ipv6_addr_label_cleanup(); 5393 out: 5394 return err; 5395 } 5396 5397 void addrconf_cleanup(void) 5398 { 5399 struct net_device *dev; 5400 int i; 5401 5402 unregister_netdevice_notifier(&ipv6_dev_notf); 5403 unregister_pernet_subsys(&addrconf_ops); 5404 ipv6_addr_label_cleanup(); 5405 5406 rtnl_lock(); 5407 5408 __rtnl_af_unregister(&inet6_ops); 5409 5410 /* clean dev list */ 5411 for_each_netdev(&init_net, dev) { 5412 if (__in6_dev_get(dev) == NULL) 5413 continue; 5414 addrconf_ifdown(dev, 1); 5415 } 5416 addrconf_ifdown(init_net.loopback_dev, 2); 5417 5418 /* 5419 * Check hash table. 5420 */ 5421 spin_lock_bh(&addrconf_hash_lock); 5422 for (i = 0; i < IN6_ADDR_HSIZE; i++) 5423 WARN_ON(!hlist_empty(&inet6_addr_lst[i])); 5424 spin_unlock_bh(&addrconf_hash_lock); 5425 cancel_delayed_work(&addr_chk_work); 5426 rtnl_unlock(); 5427 5428 destroy_workqueue(addrconf_wq); 5429 } 5430