1 /* 2 * NET3 IP device support routines. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 * 9 * Derived from the IP parts of dev.c 1.0.19 10 * Authors: Ross Biro 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 * Mark Evans, <evansmp@uhura.aston.ac.uk> 13 * 14 * Additional Authors: 15 * Alan Cox, <gw4pts@gw4pts.ampr.org> 16 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 17 * 18 * Changes: 19 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr 20 * lists. 21 * Cyrus Durgin: updated for kmod 22 * Matthias Andree: in devinet_ioctl, compare label and 23 * address (4.4BSD alias style support), 24 * fall back to comparing just the label 25 * if no match found. 26 */ 27 28 29 #include <linux/uaccess.h> 30 #include <linux/bitops.h> 31 #include <linux/capability.h> 32 #include <linux/module.h> 33 #include <linux/types.h> 34 #include <linux/kernel.h> 35 #include <linux/sched/signal.h> 36 #include <linux/string.h> 37 #include <linux/mm.h> 38 #include <linux/socket.h> 39 #include <linux/sockios.h> 40 #include <linux/in.h> 41 #include <linux/errno.h> 42 #include <linux/interrupt.h> 43 #include <linux/if_addr.h> 44 #include <linux/if_ether.h> 45 #include <linux/inet.h> 46 #include <linux/netdevice.h> 47 #include <linux/etherdevice.h> 48 #include <linux/skbuff.h> 49 #include <linux/init.h> 50 #include <linux/notifier.h> 51 #include <linux/inetdevice.h> 52 #include <linux/igmp.h> 53 #include <linux/slab.h> 54 #include <linux/hash.h> 55 #ifdef CONFIG_SYSCTL 56 #include <linux/sysctl.h> 57 #endif 58 #include <linux/kmod.h> 59 #include <linux/netconf.h> 60 61 #include <net/arp.h> 62 #include <net/ip.h> 63 #include <net/route.h> 64 #include <net/ip_fib.h> 65 #include <net/rtnetlink.h> 66 #include <net/net_namespace.h> 67 #include <net/addrconf.h> 68 69 static struct ipv4_devconf ipv4_devconf = { 70 .data = { 71 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1, 72 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1, 73 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1, 74 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1, 75 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/, 76 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/, 77 }, 78 }; 79 80 static struct ipv4_devconf ipv4_devconf_dflt = { 81 .data = { 82 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1, 83 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1, 84 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1, 85 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1, 86 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1, 87 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/, 88 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/, 89 }, 90 }; 91 92 #define IPV4_DEVCONF_DFLT(net, attr) \ 93 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr) 94 95 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = { 96 [IFA_LOCAL] = { .type = NLA_U32 }, 97 [IFA_ADDRESS] = { .type = NLA_U32 }, 98 [IFA_BROADCAST] = { .type = NLA_U32 }, 99 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, 100 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) }, 101 [IFA_FLAGS] = { .type = NLA_U32 }, 102 }; 103 104 #define IN4_ADDR_HSIZE_SHIFT 8 105 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT) 106 107 static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE]; 108 109 static u32 inet_addr_hash(const struct net *net, __be32 addr) 110 { 111 u32 val = (__force u32) addr ^ net_hash_mix(net); 112 113 return hash_32(val, IN4_ADDR_HSIZE_SHIFT); 114 } 115 116 static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa) 117 { 118 u32 hash = inet_addr_hash(net, ifa->ifa_local); 119 120 ASSERT_RTNL(); 121 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]); 122 } 123 124 static void inet_hash_remove(struct in_ifaddr *ifa) 125 { 126 ASSERT_RTNL(); 127 hlist_del_init_rcu(&ifa->hash); 128 } 129 130 /** 131 * __ip_dev_find - find the first device with a given source address. 132 * @net: the net namespace 133 * @addr: the source address 134 * @devref: if true, take a reference on the found device 135 * 136 * If a caller uses devref=false, it should be protected by RCU, or RTNL 137 */ 138 struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref) 139 { 140 u32 hash = inet_addr_hash(net, addr); 141 struct net_device *result = NULL; 142 struct in_ifaddr *ifa; 143 144 rcu_read_lock(); 145 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) { 146 if (ifa->ifa_local == addr) { 147 struct net_device *dev = ifa->ifa_dev->dev; 148 149 if (!net_eq(dev_net(dev), net)) 150 continue; 151 result = dev; 152 break; 153 } 154 } 155 if (!result) { 156 struct flowi4 fl4 = { .daddr = addr }; 157 struct fib_result res = { 0 }; 158 struct fib_table *local; 159 160 /* Fallback to FIB local table so that communication 161 * over loopback subnets work. 162 */ 163 local = fib_get_table(net, RT_TABLE_LOCAL); 164 if (local && 165 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) && 166 res.type == RTN_LOCAL) 167 result = FIB_RES_DEV(res); 168 } 169 if (result && devref) 170 dev_hold(result); 171 rcu_read_unlock(); 172 return result; 173 } 174 EXPORT_SYMBOL(__ip_dev_find); 175 176 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32); 177 178 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain); 179 static BLOCKING_NOTIFIER_HEAD(inetaddr_validator_chain); 180 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 181 int destroy); 182 #ifdef CONFIG_SYSCTL 183 static int devinet_sysctl_register(struct in_device *idev); 184 static void devinet_sysctl_unregister(struct in_device *idev); 185 #else 186 static int devinet_sysctl_register(struct in_device *idev) 187 { 188 return 0; 189 } 190 static void devinet_sysctl_unregister(struct in_device *idev) 191 { 192 } 193 #endif 194 195 /* Locks all the inet devices. */ 196 197 static struct in_ifaddr *inet_alloc_ifa(void) 198 { 199 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL); 200 } 201 202 static void inet_rcu_free_ifa(struct rcu_head *head) 203 { 204 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 205 if (ifa->ifa_dev) 206 in_dev_put(ifa->ifa_dev); 207 kfree(ifa); 208 } 209 210 static void inet_free_ifa(struct in_ifaddr *ifa) 211 { 212 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 213 } 214 215 void in_dev_finish_destroy(struct in_device *idev) 216 { 217 struct net_device *dev = idev->dev; 218 219 WARN_ON(idev->ifa_list); 220 WARN_ON(idev->mc_list); 221 kfree(rcu_dereference_protected(idev->mc_hash, 1)); 222 #ifdef NET_REFCNT_DEBUG 223 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL"); 224 #endif 225 dev_put(dev); 226 if (!idev->dead) 227 pr_err("Freeing alive in_device %p\n", idev); 228 else 229 kfree(idev); 230 } 231 EXPORT_SYMBOL(in_dev_finish_destroy); 232 233 static struct in_device *inetdev_init(struct net_device *dev) 234 { 235 struct in_device *in_dev; 236 int err = -ENOMEM; 237 238 ASSERT_RTNL(); 239 240 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL); 241 if (!in_dev) 242 goto out; 243 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt, 244 sizeof(in_dev->cnf)); 245 in_dev->cnf.sysctl = NULL; 246 in_dev->dev = dev; 247 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl); 248 if (!in_dev->arp_parms) 249 goto out_kfree; 250 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING)) 251 dev_disable_lro(dev); 252 /* Reference in_dev->dev */ 253 dev_hold(dev); 254 /* Account for reference dev->ip_ptr (below) */ 255 refcount_set(&in_dev->refcnt, 1); 256 257 err = devinet_sysctl_register(in_dev); 258 if (err) { 259 in_dev->dead = 1; 260 in_dev_put(in_dev); 261 in_dev = NULL; 262 goto out; 263 } 264 ip_mc_init_dev(in_dev); 265 if (dev->flags & IFF_UP) 266 ip_mc_up(in_dev); 267 268 /* we can receive as soon as ip_ptr is set -- do this last */ 269 rcu_assign_pointer(dev->ip_ptr, in_dev); 270 out: 271 return in_dev ?: ERR_PTR(err); 272 out_kfree: 273 kfree(in_dev); 274 in_dev = NULL; 275 goto out; 276 } 277 278 static void in_dev_rcu_put(struct rcu_head *head) 279 { 280 struct in_device *idev = container_of(head, struct in_device, rcu_head); 281 in_dev_put(idev); 282 } 283 284 static void inetdev_destroy(struct in_device *in_dev) 285 { 286 struct in_ifaddr *ifa; 287 struct net_device *dev; 288 289 ASSERT_RTNL(); 290 291 dev = in_dev->dev; 292 293 in_dev->dead = 1; 294 295 ip_mc_destroy_dev(in_dev); 296 297 while ((ifa = in_dev->ifa_list) != NULL) { 298 inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 299 inet_free_ifa(ifa); 300 } 301 302 RCU_INIT_POINTER(dev->ip_ptr, NULL); 303 304 devinet_sysctl_unregister(in_dev); 305 neigh_parms_release(&arp_tbl, in_dev->arp_parms); 306 arp_ifdown(dev); 307 308 call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 309 } 310 311 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b) 312 { 313 rcu_read_lock(); 314 for_primary_ifa(in_dev) { 315 if (inet_ifa_match(a, ifa)) { 316 if (!b || inet_ifa_match(b, ifa)) { 317 rcu_read_unlock(); 318 return 1; 319 } 320 } 321 } endfor_ifa(in_dev); 322 rcu_read_unlock(); 323 return 0; 324 } 325 326 static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 327 int destroy, struct nlmsghdr *nlh, u32 portid) 328 { 329 struct in_ifaddr *promote = NULL; 330 struct in_ifaddr *ifa, *ifa1 = *ifap; 331 struct in_ifaddr *last_prim = in_dev->ifa_list; 332 struct in_ifaddr *prev_prom = NULL; 333 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 334 335 ASSERT_RTNL(); 336 337 if (in_dev->dead) 338 goto no_promotions; 339 340 /* 1. Deleting primary ifaddr forces deletion all secondaries 341 * unless alias promotion is set 342 **/ 343 344 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 345 struct in_ifaddr **ifap1 = &ifa1->ifa_next; 346 347 while ((ifa = *ifap1) != NULL) { 348 if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 349 ifa1->ifa_scope <= ifa->ifa_scope) 350 last_prim = ifa; 351 352 if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 353 ifa1->ifa_mask != ifa->ifa_mask || 354 !inet_ifa_match(ifa1->ifa_address, ifa)) { 355 ifap1 = &ifa->ifa_next; 356 prev_prom = ifa; 357 continue; 358 } 359 360 if (!do_promote) { 361 inet_hash_remove(ifa); 362 *ifap1 = ifa->ifa_next; 363 364 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid); 365 blocking_notifier_call_chain(&inetaddr_chain, 366 NETDEV_DOWN, ifa); 367 inet_free_ifa(ifa); 368 } else { 369 promote = ifa; 370 break; 371 } 372 } 373 } 374 375 /* On promotion all secondaries from subnet are changing 376 * the primary IP, we must remove all their routes silently 377 * and later to add them back with new prefsrc. Do this 378 * while all addresses are on the device list. 379 */ 380 for (ifa = promote; ifa; ifa = ifa->ifa_next) { 381 if (ifa1->ifa_mask == ifa->ifa_mask && 382 inet_ifa_match(ifa1->ifa_address, ifa)) 383 fib_del_ifaddr(ifa, ifa1); 384 } 385 386 no_promotions: 387 /* 2. Unlink it */ 388 389 *ifap = ifa1->ifa_next; 390 inet_hash_remove(ifa1); 391 392 /* 3. Announce address deletion */ 393 394 /* Send message first, then call notifier. 395 At first sight, FIB update triggered by notifier 396 will refer to already deleted ifaddr, that could confuse 397 netlink listeners. It is not true: look, gated sees 398 that route deleted and if it still thinks that ifaddr 399 is valid, it will try to restore deleted routes... Grr. 400 So that, this order is correct. 401 */ 402 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid); 403 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 404 405 if (promote) { 406 struct in_ifaddr *next_sec = promote->ifa_next; 407 408 if (prev_prom) { 409 prev_prom->ifa_next = promote->ifa_next; 410 promote->ifa_next = last_prim->ifa_next; 411 last_prim->ifa_next = promote; 412 } 413 414 promote->ifa_flags &= ~IFA_F_SECONDARY; 415 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid); 416 blocking_notifier_call_chain(&inetaddr_chain, 417 NETDEV_UP, promote); 418 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) { 419 if (ifa1->ifa_mask != ifa->ifa_mask || 420 !inet_ifa_match(ifa1->ifa_address, ifa)) 421 continue; 422 fib_add_ifaddr(ifa); 423 } 424 425 } 426 if (destroy) 427 inet_free_ifa(ifa1); 428 } 429 430 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 431 int destroy) 432 { 433 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0); 434 } 435 436 static void check_lifetime(struct work_struct *work); 437 438 static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime); 439 440 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh, 441 u32 portid) 442 { 443 struct in_device *in_dev = ifa->ifa_dev; 444 struct in_ifaddr *ifa1, **ifap, **last_primary; 445 struct in_validator_info ivi; 446 int ret; 447 448 ASSERT_RTNL(); 449 450 if (!ifa->ifa_local) { 451 inet_free_ifa(ifa); 452 return 0; 453 } 454 455 ifa->ifa_flags &= ~IFA_F_SECONDARY; 456 last_primary = &in_dev->ifa_list; 457 458 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 459 ifap = &ifa1->ifa_next) { 460 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 461 ifa->ifa_scope <= ifa1->ifa_scope) 462 last_primary = &ifa1->ifa_next; 463 if (ifa1->ifa_mask == ifa->ifa_mask && 464 inet_ifa_match(ifa1->ifa_address, ifa)) { 465 if (ifa1->ifa_local == ifa->ifa_local) { 466 inet_free_ifa(ifa); 467 return -EEXIST; 468 } 469 if (ifa1->ifa_scope != ifa->ifa_scope) { 470 inet_free_ifa(ifa); 471 return -EINVAL; 472 } 473 ifa->ifa_flags |= IFA_F_SECONDARY; 474 } 475 } 476 477 /* Allow any devices that wish to register ifaddr validtors to weigh 478 * in now, before changes are committed. The rntl lock is serializing 479 * access here, so the state should not change between a validator call 480 * and a final notify on commit. This isn't invoked on promotion under 481 * the assumption that validators are checking the address itself, and 482 * not the flags. 483 */ 484 ivi.ivi_addr = ifa->ifa_address; 485 ivi.ivi_dev = ifa->ifa_dev; 486 ret = blocking_notifier_call_chain(&inetaddr_validator_chain, 487 NETDEV_UP, &ivi); 488 ret = notifier_to_errno(ret); 489 if (ret) { 490 inet_free_ifa(ifa); 491 return ret; 492 } 493 494 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 495 prandom_seed((__force u32) ifa->ifa_local); 496 ifap = last_primary; 497 } 498 499 ifa->ifa_next = *ifap; 500 *ifap = ifa; 501 502 inet_hash_insert(dev_net(in_dev->dev), ifa); 503 504 cancel_delayed_work(&check_lifetime_work); 505 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0); 506 507 /* Send message first, then call notifier. 508 Notifier will trigger FIB update, so that 509 listeners of netlink will know about new ifaddr */ 510 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid); 511 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 512 513 return 0; 514 } 515 516 static int inet_insert_ifa(struct in_ifaddr *ifa) 517 { 518 return __inet_insert_ifa(ifa, NULL, 0); 519 } 520 521 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 522 { 523 struct in_device *in_dev = __in_dev_get_rtnl(dev); 524 525 ASSERT_RTNL(); 526 527 if (!in_dev) { 528 inet_free_ifa(ifa); 529 return -ENOBUFS; 530 } 531 ipv4_devconf_setall(in_dev); 532 neigh_parms_data_state_setall(in_dev->arp_parms); 533 if (ifa->ifa_dev != in_dev) { 534 WARN_ON(ifa->ifa_dev); 535 in_dev_hold(in_dev); 536 ifa->ifa_dev = in_dev; 537 } 538 if (ipv4_is_loopback(ifa->ifa_local)) 539 ifa->ifa_scope = RT_SCOPE_HOST; 540 return inet_insert_ifa(ifa); 541 } 542 543 /* Caller must hold RCU or RTNL : 544 * We dont take a reference on found in_device 545 */ 546 struct in_device *inetdev_by_index(struct net *net, int ifindex) 547 { 548 struct net_device *dev; 549 struct in_device *in_dev = NULL; 550 551 rcu_read_lock(); 552 dev = dev_get_by_index_rcu(net, ifindex); 553 if (dev) 554 in_dev = rcu_dereference_rtnl(dev->ip_ptr); 555 rcu_read_unlock(); 556 return in_dev; 557 } 558 EXPORT_SYMBOL(inetdev_by_index); 559 560 /* Called only from RTNL semaphored context. No locks. */ 561 562 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix, 563 __be32 mask) 564 { 565 ASSERT_RTNL(); 566 567 for_primary_ifa(in_dev) { 568 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa)) 569 return ifa; 570 } endfor_ifa(in_dev); 571 return NULL; 572 } 573 574 static int ip_mc_config(struct sock *sk, bool join, const struct in_ifaddr *ifa) 575 { 576 struct ip_mreqn mreq = { 577 .imr_multiaddr.s_addr = ifa->ifa_address, 578 .imr_ifindex = ifa->ifa_dev->dev->ifindex, 579 }; 580 int ret; 581 582 ASSERT_RTNL(); 583 584 lock_sock(sk); 585 if (join) 586 ret = ip_mc_join_group(sk, &mreq); 587 else 588 ret = ip_mc_leave_group(sk, &mreq); 589 release_sock(sk); 590 591 return ret; 592 } 593 594 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, 595 struct netlink_ext_ack *extack) 596 { 597 struct net *net = sock_net(skb->sk); 598 struct nlattr *tb[IFA_MAX+1]; 599 struct in_device *in_dev; 600 struct ifaddrmsg *ifm; 601 struct in_ifaddr *ifa, **ifap; 602 int err = -EINVAL; 603 604 ASSERT_RTNL(); 605 606 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy, 607 extack); 608 if (err < 0) 609 goto errout; 610 611 ifm = nlmsg_data(nlh); 612 in_dev = inetdev_by_index(net, ifm->ifa_index); 613 if (!in_dev) { 614 err = -ENODEV; 615 goto errout; 616 } 617 618 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 619 ifap = &ifa->ifa_next) { 620 if (tb[IFA_LOCAL] && 621 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL])) 622 continue; 623 624 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) 625 continue; 626 627 if (tb[IFA_ADDRESS] && 628 (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 629 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa))) 630 continue; 631 632 if (ipv4_is_multicast(ifa->ifa_address)) 633 ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa); 634 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid); 635 return 0; 636 } 637 638 err = -EADDRNOTAVAIL; 639 errout: 640 return err; 641 } 642 643 #define INFINITY_LIFE_TIME 0xFFFFFFFF 644 645 static void check_lifetime(struct work_struct *work) 646 { 647 unsigned long now, next, next_sec, next_sched; 648 struct in_ifaddr *ifa; 649 struct hlist_node *n; 650 int i; 651 652 now = jiffies; 653 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY); 654 655 for (i = 0; i < IN4_ADDR_HSIZE; i++) { 656 bool change_needed = false; 657 658 rcu_read_lock(); 659 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) { 660 unsigned long age; 661 662 if (ifa->ifa_flags & IFA_F_PERMANENT) 663 continue; 664 665 /* We try to batch several events at once. */ 666 age = (now - ifa->ifa_tstamp + 667 ADDRCONF_TIMER_FUZZ_MINUS) / HZ; 668 669 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME && 670 age >= ifa->ifa_valid_lft) { 671 change_needed = true; 672 } else if (ifa->ifa_preferred_lft == 673 INFINITY_LIFE_TIME) { 674 continue; 675 } else if (age >= ifa->ifa_preferred_lft) { 676 if (time_before(ifa->ifa_tstamp + 677 ifa->ifa_valid_lft * HZ, next)) 678 next = ifa->ifa_tstamp + 679 ifa->ifa_valid_lft * HZ; 680 681 if (!(ifa->ifa_flags & IFA_F_DEPRECATED)) 682 change_needed = true; 683 } else if (time_before(ifa->ifa_tstamp + 684 ifa->ifa_preferred_lft * HZ, 685 next)) { 686 next = ifa->ifa_tstamp + 687 ifa->ifa_preferred_lft * HZ; 688 } 689 } 690 rcu_read_unlock(); 691 if (!change_needed) 692 continue; 693 rtnl_lock(); 694 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) { 695 unsigned long age; 696 697 if (ifa->ifa_flags & IFA_F_PERMANENT) 698 continue; 699 700 /* We try to batch several events at once. */ 701 age = (now - ifa->ifa_tstamp + 702 ADDRCONF_TIMER_FUZZ_MINUS) / HZ; 703 704 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME && 705 age >= ifa->ifa_valid_lft) { 706 struct in_ifaddr **ifap; 707 708 for (ifap = &ifa->ifa_dev->ifa_list; 709 *ifap != NULL; ifap = &(*ifap)->ifa_next) { 710 if (*ifap == ifa) { 711 inet_del_ifa(ifa->ifa_dev, 712 ifap, 1); 713 break; 714 } 715 } 716 } else if (ifa->ifa_preferred_lft != 717 INFINITY_LIFE_TIME && 718 age >= ifa->ifa_preferred_lft && 719 !(ifa->ifa_flags & IFA_F_DEPRECATED)) { 720 ifa->ifa_flags |= IFA_F_DEPRECATED; 721 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0); 722 } 723 } 724 rtnl_unlock(); 725 } 726 727 next_sec = round_jiffies_up(next); 728 next_sched = next; 729 730 /* If rounded timeout is accurate enough, accept it. */ 731 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ)) 732 next_sched = next_sec; 733 734 now = jiffies; 735 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */ 736 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX)) 737 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX; 738 739 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 740 next_sched - now); 741 } 742 743 static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft, 744 __u32 prefered_lft) 745 { 746 unsigned long timeout; 747 748 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED); 749 750 timeout = addrconf_timeout_fixup(valid_lft, HZ); 751 if (addrconf_finite_timeout(timeout)) 752 ifa->ifa_valid_lft = timeout; 753 else 754 ifa->ifa_flags |= IFA_F_PERMANENT; 755 756 timeout = addrconf_timeout_fixup(prefered_lft, HZ); 757 if (addrconf_finite_timeout(timeout)) { 758 if (timeout == 0) 759 ifa->ifa_flags |= IFA_F_DEPRECATED; 760 ifa->ifa_preferred_lft = timeout; 761 } 762 ifa->ifa_tstamp = jiffies; 763 if (!ifa->ifa_cstamp) 764 ifa->ifa_cstamp = ifa->ifa_tstamp; 765 } 766 767 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh, 768 __u32 *pvalid_lft, __u32 *pprefered_lft) 769 { 770 struct nlattr *tb[IFA_MAX+1]; 771 struct in_ifaddr *ifa; 772 struct ifaddrmsg *ifm; 773 struct net_device *dev; 774 struct in_device *in_dev; 775 int err; 776 777 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy, 778 NULL); 779 if (err < 0) 780 goto errout; 781 782 ifm = nlmsg_data(nlh); 783 err = -EINVAL; 784 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL]) 785 goto errout; 786 787 dev = __dev_get_by_index(net, ifm->ifa_index); 788 err = -ENODEV; 789 if (!dev) 790 goto errout; 791 792 in_dev = __in_dev_get_rtnl(dev); 793 err = -ENOBUFS; 794 if (!in_dev) 795 goto errout; 796 797 ifa = inet_alloc_ifa(); 798 if (!ifa) 799 /* 800 * A potential indev allocation can be left alive, it stays 801 * assigned to its device and is destroy with it. 802 */ 803 goto errout; 804 805 ipv4_devconf_setall(in_dev); 806 neigh_parms_data_state_setall(in_dev->arp_parms); 807 in_dev_hold(in_dev); 808 809 if (!tb[IFA_ADDRESS]) 810 tb[IFA_ADDRESS] = tb[IFA_LOCAL]; 811 812 INIT_HLIST_NODE(&ifa->hash); 813 ifa->ifa_prefixlen = ifm->ifa_prefixlen; 814 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 815 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : 816 ifm->ifa_flags; 817 ifa->ifa_scope = ifm->ifa_scope; 818 ifa->ifa_dev = in_dev; 819 820 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]); 821 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]); 822 823 if (tb[IFA_BROADCAST]) 824 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]); 825 826 if (tb[IFA_LABEL]) 827 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ); 828 else 829 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 830 831 if (tb[IFA_CACHEINFO]) { 832 struct ifa_cacheinfo *ci; 833 834 ci = nla_data(tb[IFA_CACHEINFO]); 835 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) { 836 err = -EINVAL; 837 goto errout_free; 838 } 839 *pvalid_lft = ci->ifa_valid; 840 *pprefered_lft = ci->ifa_prefered; 841 } 842 843 return ifa; 844 845 errout_free: 846 inet_free_ifa(ifa); 847 errout: 848 return ERR_PTR(err); 849 } 850 851 static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa) 852 { 853 struct in_device *in_dev = ifa->ifa_dev; 854 struct in_ifaddr *ifa1, **ifap; 855 856 if (!ifa->ifa_local) 857 return NULL; 858 859 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 860 ifap = &ifa1->ifa_next) { 861 if (ifa1->ifa_mask == ifa->ifa_mask && 862 inet_ifa_match(ifa1->ifa_address, ifa) && 863 ifa1->ifa_local == ifa->ifa_local) 864 return ifa1; 865 } 866 return NULL; 867 } 868 869 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, 870 struct netlink_ext_ack *extack) 871 { 872 struct net *net = sock_net(skb->sk); 873 struct in_ifaddr *ifa; 874 struct in_ifaddr *ifa_existing; 875 __u32 valid_lft = INFINITY_LIFE_TIME; 876 __u32 prefered_lft = INFINITY_LIFE_TIME; 877 878 ASSERT_RTNL(); 879 880 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft); 881 if (IS_ERR(ifa)) 882 return PTR_ERR(ifa); 883 884 ifa_existing = find_matching_ifa(ifa); 885 if (!ifa_existing) { 886 /* It would be best to check for !NLM_F_CREATE here but 887 * userspace already relies on not having to provide this. 888 */ 889 set_ifa_lifetime(ifa, valid_lft, prefered_lft); 890 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) { 891 int ret = ip_mc_config(net->ipv4.mc_autojoin_sk, 892 true, ifa); 893 894 if (ret < 0) { 895 inet_free_ifa(ifa); 896 return ret; 897 } 898 } 899 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid); 900 } else { 901 inet_free_ifa(ifa); 902 903 if (nlh->nlmsg_flags & NLM_F_EXCL || 904 !(nlh->nlmsg_flags & NLM_F_REPLACE)) 905 return -EEXIST; 906 ifa = ifa_existing; 907 set_ifa_lifetime(ifa, valid_lft, prefered_lft); 908 cancel_delayed_work(&check_lifetime_work); 909 queue_delayed_work(system_power_efficient_wq, 910 &check_lifetime_work, 0); 911 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid); 912 } 913 return 0; 914 } 915 916 /* 917 * Determine a default network mask, based on the IP address. 918 */ 919 920 static int inet_abc_len(__be32 addr) 921 { 922 int rc = -1; /* Something else, probably a multicast. */ 923 924 if (ipv4_is_zeronet(addr)) 925 rc = 0; 926 else { 927 __u32 haddr = ntohl(addr); 928 929 if (IN_CLASSA(haddr)) 930 rc = 8; 931 else if (IN_CLASSB(haddr)) 932 rc = 16; 933 else if (IN_CLASSC(haddr)) 934 rc = 24; 935 } 936 937 return rc; 938 } 939 940 941 int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg) 942 { 943 struct ifreq ifr; 944 struct sockaddr_in sin_orig; 945 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 946 struct in_device *in_dev; 947 struct in_ifaddr **ifap = NULL; 948 struct in_ifaddr *ifa = NULL; 949 struct net_device *dev; 950 char *colon; 951 int ret = -EFAULT; 952 int tryaddrmatch = 0; 953 954 /* 955 * Fetch the caller's info block into kernel space 956 */ 957 958 if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 959 goto out; 960 ifr.ifr_name[IFNAMSIZ - 1] = 0; 961 962 /* save original address for comparison */ 963 memcpy(&sin_orig, sin, sizeof(*sin)); 964 965 colon = strchr(ifr.ifr_name, ':'); 966 if (colon) 967 *colon = 0; 968 969 dev_load(net, ifr.ifr_name); 970 971 switch (cmd) { 972 case SIOCGIFADDR: /* Get interface address */ 973 case SIOCGIFBRDADDR: /* Get the broadcast address */ 974 case SIOCGIFDSTADDR: /* Get the destination address */ 975 case SIOCGIFNETMASK: /* Get the netmask for the interface */ 976 /* Note that these ioctls will not sleep, 977 so that we do not impose a lock. 978 One day we will be forced to put shlock here (I mean SMP) 979 */ 980 tryaddrmatch = (sin_orig.sin_family == AF_INET); 981 memset(sin, 0, sizeof(*sin)); 982 sin->sin_family = AF_INET; 983 break; 984 985 case SIOCSIFFLAGS: 986 ret = -EPERM; 987 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 988 goto out; 989 break; 990 case SIOCSIFADDR: /* Set interface address (and family) */ 991 case SIOCSIFBRDADDR: /* Set the broadcast address */ 992 case SIOCSIFDSTADDR: /* Set the destination address */ 993 case SIOCSIFNETMASK: /* Set the netmask for the interface */ 994 ret = -EPERM; 995 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 996 goto out; 997 ret = -EINVAL; 998 if (sin->sin_family != AF_INET) 999 goto out; 1000 break; 1001 default: 1002 ret = -EINVAL; 1003 goto out; 1004 } 1005 1006 rtnl_lock(); 1007 1008 ret = -ENODEV; 1009 dev = __dev_get_by_name(net, ifr.ifr_name); 1010 if (!dev) 1011 goto done; 1012 1013 if (colon) 1014 *colon = ':'; 1015 1016 in_dev = __in_dev_get_rtnl(dev); 1017 if (in_dev) { 1018 if (tryaddrmatch) { 1019 /* Matthias Andree */ 1020 /* compare label and address (4.4BSD style) */ 1021 /* note: we only do this for a limited set of ioctls 1022 and only if the original address family was AF_INET. 1023 This is checked above. */ 1024 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 1025 ifap = &ifa->ifa_next) { 1026 if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 1027 sin_orig.sin_addr.s_addr == 1028 ifa->ifa_local) { 1029 break; /* found */ 1030 } 1031 } 1032 } 1033 /* we didn't get a match, maybe the application is 1034 4.3BSD-style and passed in junk so we fall back to 1035 comparing just the label */ 1036 if (!ifa) { 1037 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 1038 ifap = &ifa->ifa_next) 1039 if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 1040 break; 1041 } 1042 } 1043 1044 ret = -EADDRNOTAVAIL; 1045 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 1046 goto done; 1047 1048 switch (cmd) { 1049 case SIOCGIFADDR: /* Get interface address */ 1050 sin->sin_addr.s_addr = ifa->ifa_local; 1051 goto rarok; 1052 1053 case SIOCGIFBRDADDR: /* Get the broadcast address */ 1054 sin->sin_addr.s_addr = ifa->ifa_broadcast; 1055 goto rarok; 1056 1057 case SIOCGIFDSTADDR: /* Get the destination address */ 1058 sin->sin_addr.s_addr = ifa->ifa_address; 1059 goto rarok; 1060 1061 case SIOCGIFNETMASK: /* Get the netmask for the interface */ 1062 sin->sin_addr.s_addr = ifa->ifa_mask; 1063 goto rarok; 1064 1065 case SIOCSIFFLAGS: 1066 if (colon) { 1067 ret = -EADDRNOTAVAIL; 1068 if (!ifa) 1069 break; 1070 ret = 0; 1071 if (!(ifr.ifr_flags & IFF_UP)) 1072 inet_del_ifa(in_dev, ifap, 1); 1073 break; 1074 } 1075 ret = dev_change_flags(dev, ifr.ifr_flags); 1076 break; 1077 1078 case SIOCSIFADDR: /* Set interface address (and family) */ 1079 ret = -EINVAL; 1080 if (inet_abc_len(sin->sin_addr.s_addr) < 0) 1081 break; 1082 1083 if (!ifa) { 1084 ret = -ENOBUFS; 1085 ifa = inet_alloc_ifa(); 1086 if (!ifa) 1087 break; 1088 INIT_HLIST_NODE(&ifa->hash); 1089 if (colon) 1090 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 1091 else 1092 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 1093 } else { 1094 ret = 0; 1095 if (ifa->ifa_local == sin->sin_addr.s_addr) 1096 break; 1097 inet_del_ifa(in_dev, ifap, 0); 1098 ifa->ifa_broadcast = 0; 1099 ifa->ifa_scope = 0; 1100 } 1101 1102 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 1103 1104 if (!(dev->flags & IFF_POINTOPOINT)) { 1105 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 1106 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 1107 if ((dev->flags & IFF_BROADCAST) && 1108 ifa->ifa_prefixlen < 31) 1109 ifa->ifa_broadcast = ifa->ifa_address | 1110 ~ifa->ifa_mask; 1111 } else { 1112 ifa->ifa_prefixlen = 32; 1113 ifa->ifa_mask = inet_make_mask(32); 1114 } 1115 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME); 1116 ret = inet_set_ifa(dev, ifa); 1117 break; 1118 1119 case SIOCSIFBRDADDR: /* Set the broadcast address */ 1120 ret = 0; 1121 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 1122 inet_del_ifa(in_dev, ifap, 0); 1123 ifa->ifa_broadcast = sin->sin_addr.s_addr; 1124 inet_insert_ifa(ifa); 1125 } 1126 break; 1127 1128 case SIOCSIFDSTADDR: /* Set the destination address */ 1129 ret = 0; 1130 if (ifa->ifa_address == sin->sin_addr.s_addr) 1131 break; 1132 ret = -EINVAL; 1133 if (inet_abc_len(sin->sin_addr.s_addr) < 0) 1134 break; 1135 ret = 0; 1136 inet_del_ifa(in_dev, ifap, 0); 1137 ifa->ifa_address = sin->sin_addr.s_addr; 1138 inet_insert_ifa(ifa); 1139 break; 1140 1141 case SIOCSIFNETMASK: /* Set the netmask for the interface */ 1142 1143 /* 1144 * The mask we set must be legal. 1145 */ 1146 ret = -EINVAL; 1147 if (bad_mask(sin->sin_addr.s_addr, 0)) 1148 break; 1149 ret = 0; 1150 if (ifa->ifa_mask != sin->sin_addr.s_addr) { 1151 __be32 old_mask = ifa->ifa_mask; 1152 inet_del_ifa(in_dev, ifap, 0); 1153 ifa->ifa_mask = sin->sin_addr.s_addr; 1154 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 1155 1156 /* See if current broadcast address matches 1157 * with current netmask, then recalculate 1158 * the broadcast address. Otherwise it's a 1159 * funny address, so don't touch it since 1160 * the user seems to know what (s)he's doing... 1161 */ 1162 if ((dev->flags & IFF_BROADCAST) && 1163 (ifa->ifa_prefixlen < 31) && 1164 (ifa->ifa_broadcast == 1165 (ifa->ifa_local|~old_mask))) { 1166 ifa->ifa_broadcast = (ifa->ifa_local | 1167 ~sin->sin_addr.s_addr); 1168 } 1169 inet_insert_ifa(ifa); 1170 } 1171 break; 1172 } 1173 done: 1174 rtnl_unlock(); 1175 out: 1176 return ret; 1177 rarok: 1178 rtnl_unlock(); 1179 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 1180 goto out; 1181 } 1182 1183 static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 1184 { 1185 struct in_device *in_dev = __in_dev_get_rtnl(dev); 1186 struct in_ifaddr *ifa; 1187 struct ifreq ifr; 1188 int done = 0; 1189 1190 if (!in_dev) 1191 goto out; 1192 1193 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 1194 if (!buf) { 1195 done += sizeof(ifr); 1196 continue; 1197 } 1198 if (len < (int) sizeof(ifr)) 1199 break; 1200 memset(&ifr, 0, sizeof(struct ifreq)); 1201 strcpy(ifr.ifr_name, ifa->ifa_label); 1202 1203 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 1204 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 1205 ifa->ifa_local; 1206 1207 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 1208 done = -EFAULT; 1209 break; 1210 } 1211 buf += sizeof(struct ifreq); 1212 len -= sizeof(struct ifreq); 1213 done += sizeof(struct ifreq); 1214 } 1215 out: 1216 return done; 1217 } 1218 1219 static __be32 in_dev_select_addr(const struct in_device *in_dev, 1220 int scope) 1221 { 1222 for_primary_ifa(in_dev) { 1223 if (ifa->ifa_scope != RT_SCOPE_LINK && 1224 ifa->ifa_scope <= scope) 1225 return ifa->ifa_local; 1226 } endfor_ifa(in_dev); 1227 1228 return 0; 1229 } 1230 1231 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope) 1232 { 1233 __be32 addr = 0; 1234 struct in_device *in_dev; 1235 struct net *net = dev_net(dev); 1236 int master_idx; 1237 1238 rcu_read_lock(); 1239 in_dev = __in_dev_get_rcu(dev); 1240 if (!in_dev) 1241 goto no_in_dev; 1242 1243 for_primary_ifa(in_dev) { 1244 if (ifa->ifa_scope > scope) 1245 continue; 1246 if (!dst || inet_ifa_match(dst, ifa)) { 1247 addr = ifa->ifa_local; 1248 break; 1249 } 1250 if (!addr) 1251 addr = ifa->ifa_local; 1252 } endfor_ifa(in_dev); 1253 1254 if (addr) 1255 goto out_unlock; 1256 no_in_dev: 1257 master_idx = l3mdev_master_ifindex_rcu(dev); 1258 1259 /* For VRFs, the VRF device takes the place of the loopback device, 1260 * with addresses on it being preferred. Note in such cases the 1261 * loopback device will be among the devices that fail the master_idx 1262 * equality check in the loop below. 1263 */ 1264 if (master_idx && 1265 (dev = dev_get_by_index_rcu(net, master_idx)) && 1266 (in_dev = __in_dev_get_rcu(dev))) { 1267 addr = in_dev_select_addr(in_dev, scope); 1268 if (addr) 1269 goto out_unlock; 1270 } 1271 1272 /* Not loopback addresses on loopback should be preferred 1273 in this case. It is important that lo is the first interface 1274 in dev_base list. 1275 */ 1276 for_each_netdev_rcu(net, dev) { 1277 if (l3mdev_master_ifindex_rcu(dev) != master_idx) 1278 continue; 1279 1280 in_dev = __in_dev_get_rcu(dev); 1281 if (!in_dev) 1282 continue; 1283 1284 addr = in_dev_select_addr(in_dev, scope); 1285 if (addr) 1286 goto out_unlock; 1287 } 1288 out_unlock: 1289 rcu_read_unlock(); 1290 return addr; 1291 } 1292 EXPORT_SYMBOL(inet_select_addr); 1293 1294 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst, 1295 __be32 local, int scope) 1296 { 1297 int same = 0; 1298 __be32 addr = 0; 1299 1300 for_ifa(in_dev) { 1301 if (!addr && 1302 (local == ifa->ifa_local || !local) && 1303 ifa->ifa_scope <= scope) { 1304 addr = ifa->ifa_local; 1305 if (same) 1306 break; 1307 } 1308 if (!same) { 1309 same = (!local || inet_ifa_match(local, ifa)) && 1310 (!dst || inet_ifa_match(dst, ifa)); 1311 if (same && addr) { 1312 if (local || !dst) 1313 break; 1314 /* Is the selected addr into dst subnet? */ 1315 if (inet_ifa_match(addr, ifa)) 1316 break; 1317 /* No, then can we use new local src? */ 1318 if (ifa->ifa_scope <= scope) { 1319 addr = ifa->ifa_local; 1320 break; 1321 } 1322 /* search for large dst subnet for addr */ 1323 same = 0; 1324 } 1325 } 1326 } endfor_ifa(in_dev); 1327 1328 return same ? addr : 0; 1329 } 1330 1331 /* 1332 * Confirm that local IP address exists using wildcards: 1333 * - net: netns to check, cannot be NULL 1334 * - in_dev: only on this interface, NULL=any interface 1335 * - dst: only in the same subnet as dst, 0=any dst 1336 * - local: address, 0=autoselect the local address 1337 * - scope: maximum allowed scope value for the local address 1338 */ 1339 __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev, 1340 __be32 dst, __be32 local, int scope) 1341 { 1342 __be32 addr = 0; 1343 struct net_device *dev; 1344 1345 if (in_dev) 1346 return confirm_addr_indev(in_dev, dst, local, scope); 1347 1348 rcu_read_lock(); 1349 for_each_netdev_rcu(net, dev) { 1350 in_dev = __in_dev_get_rcu(dev); 1351 if (in_dev) { 1352 addr = confirm_addr_indev(in_dev, dst, local, scope); 1353 if (addr) 1354 break; 1355 } 1356 } 1357 rcu_read_unlock(); 1358 1359 return addr; 1360 } 1361 EXPORT_SYMBOL(inet_confirm_addr); 1362 1363 /* 1364 * Device notifier 1365 */ 1366 1367 int register_inetaddr_notifier(struct notifier_block *nb) 1368 { 1369 return blocking_notifier_chain_register(&inetaddr_chain, nb); 1370 } 1371 EXPORT_SYMBOL(register_inetaddr_notifier); 1372 1373 int unregister_inetaddr_notifier(struct notifier_block *nb) 1374 { 1375 return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 1376 } 1377 EXPORT_SYMBOL(unregister_inetaddr_notifier); 1378 1379 int register_inetaddr_validator_notifier(struct notifier_block *nb) 1380 { 1381 return blocking_notifier_chain_register(&inetaddr_validator_chain, nb); 1382 } 1383 EXPORT_SYMBOL(register_inetaddr_validator_notifier); 1384 1385 int unregister_inetaddr_validator_notifier(struct notifier_block *nb) 1386 { 1387 return blocking_notifier_chain_unregister(&inetaddr_validator_chain, 1388 nb); 1389 } 1390 EXPORT_SYMBOL(unregister_inetaddr_validator_notifier); 1391 1392 /* Rename ifa_labels for a device name change. Make some effort to preserve 1393 * existing alias numbering and to create unique labels if possible. 1394 */ 1395 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 1396 { 1397 struct in_ifaddr *ifa; 1398 int named = 0; 1399 1400 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 1401 char old[IFNAMSIZ], *dot; 1402 1403 memcpy(old, ifa->ifa_label, IFNAMSIZ); 1404 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 1405 if (named++ == 0) 1406 goto skip; 1407 dot = strchr(old, ':'); 1408 if (!dot) { 1409 sprintf(old, ":%d", named); 1410 dot = old; 1411 } 1412 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) 1413 strcat(ifa->ifa_label, dot); 1414 else 1415 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 1416 skip: 1417 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0); 1418 } 1419 } 1420 1421 static bool inetdev_valid_mtu(unsigned int mtu) 1422 { 1423 return mtu >= 68; 1424 } 1425 1426 static void inetdev_send_gratuitous_arp(struct net_device *dev, 1427 struct in_device *in_dev) 1428 1429 { 1430 struct in_ifaddr *ifa; 1431 1432 for (ifa = in_dev->ifa_list; ifa; 1433 ifa = ifa->ifa_next) { 1434 arp_send(ARPOP_REQUEST, ETH_P_ARP, 1435 ifa->ifa_local, dev, 1436 ifa->ifa_local, NULL, 1437 dev->dev_addr, NULL); 1438 } 1439 } 1440 1441 /* Called only under RTNL semaphore */ 1442 1443 static int inetdev_event(struct notifier_block *this, unsigned long event, 1444 void *ptr) 1445 { 1446 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1447 struct in_device *in_dev = __in_dev_get_rtnl(dev); 1448 1449 ASSERT_RTNL(); 1450 1451 if (!in_dev) { 1452 if (event == NETDEV_REGISTER) { 1453 in_dev = inetdev_init(dev); 1454 if (IS_ERR(in_dev)) 1455 return notifier_from_errno(PTR_ERR(in_dev)); 1456 if (dev->flags & IFF_LOOPBACK) { 1457 IN_DEV_CONF_SET(in_dev, NOXFRM, 1); 1458 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1); 1459 } 1460 } else if (event == NETDEV_CHANGEMTU) { 1461 /* Re-enabling IP */ 1462 if (inetdev_valid_mtu(dev->mtu)) 1463 in_dev = inetdev_init(dev); 1464 } 1465 goto out; 1466 } 1467 1468 switch (event) { 1469 case NETDEV_REGISTER: 1470 pr_debug("%s: bug\n", __func__); 1471 RCU_INIT_POINTER(dev->ip_ptr, NULL); 1472 break; 1473 case NETDEV_UP: 1474 if (!inetdev_valid_mtu(dev->mtu)) 1475 break; 1476 if (dev->flags & IFF_LOOPBACK) { 1477 struct in_ifaddr *ifa = inet_alloc_ifa(); 1478 1479 if (ifa) { 1480 INIT_HLIST_NODE(&ifa->hash); 1481 ifa->ifa_local = 1482 ifa->ifa_address = htonl(INADDR_LOOPBACK); 1483 ifa->ifa_prefixlen = 8; 1484 ifa->ifa_mask = inet_make_mask(8); 1485 in_dev_hold(in_dev); 1486 ifa->ifa_dev = in_dev; 1487 ifa->ifa_scope = RT_SCOPE_HOST; 1488 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 1489 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, 1490 INFINITY_LIFE_TIME); 1491 ipv4_devconf_setall(in_dev); 1492 neigh_parms_data_state_setall(in_dev->arp_parms); 1493 inet_insert_ifa(ifa); 1494 } 1495 } 1496 ip_mc_up(in_dev); 1497 /* fall through */ 1498 case NETDEV_CHANGEADDR: 1499 if (!IN_DEV_ARP_NOTIFY(in_dev)) 1500 break; 1501 /* fall through */ 1502 case NETDEV_NOTIFY_PEERS: 1503 /* Send gratuitous ARP to notify of link change */ 1504 inetdev_send_gratuitous_arp(dev, in_dev); 1505 break; 1506 case NETDEV_DOWN: 1507 ip_mc_down(in_dev); 1508 break; 1509 case NETDEV_PRE_TYPE_CHANGE: 1510 ip_mc_unmap(in_dev); 1511 break; 1512 case NETDEV_POST_TYPE_CHANGE: 1513 ip_mc_remap(in_dev); 1514 break; 1515 case NETDEV_CHANGEMTU: 1516 if (inetdev_valid_mtu(dev->mtu)) 1517 break; 1518 /* disable IP when MTU is not enough */ 1519 case NETDEV_UNREGISTER: 1520 inetdev_destroy(in_dev); 1521 break; 1522 case NETDEV_CHANGENAME: 1523 /* Do not notify about label change, this event is 1524 * not interesting to applications using netlink. 1525 */ 1526 inetdev_changename(dev, in_dev); 1527 1528 devinet_sysctl_unregister(in_dev); 1529 devinet_sysctl_register(in_dev); 1530 break; 1531 } 1532 out: 1533 return NOTIFY_DONE; 1534 } 1535 1536 static struct notifier_block ip_netdev_notifier = { 1537 .notifier_call = inetdev_event, 1538 }; 1539 1540 static size_t inet_nlmsg_size(void) 1541 { 1542 return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 1543 + nla_total_size(4) /* IFA_ADDRESS */ 1544 + nla_total_size(4) /* IFA_LOCAL */ 1545 + nla_total_size(4) /* IFA_BROADCAST */ 1546 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */ 1547 + nla_total_size(4) /* IFA_FLAGS */ 1548 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */ 1549 } 1550 1551 static inline u32 cstamp_delta(unsigned long cstamp) 1552 { 1553 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ; 1554 } 1555 1556 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp, 1557 unsigned long tstamp, u32 preferred, u32 valid) 1558 { 1559 struct ifa_cacheinfo ci; 1560 1561 ci.cstamp = cstamp_delta(cstamp); 1562 ci.tstamp = cstamp_delta(tstamp); 1563 ci.ifa_prefered = preferred; 1564 ci.ifa_valid = valid; 1565 1566 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci); 1567 } 1568 1569 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1570 u32 portid, u32 seq, int event, unsigned int flags) 1571 { 1572 struct ifaddrmsg *ifm; 1573 struct nlmsghdr *nlh; 1574 u32 preferred, valid; 1575 1576 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags); 1577 if (!nlh) 1578 return -EMSGSIZE; 1579 1580 ifm = nlmsg_data(nlh); 1581 ifm->ifa_family = AF_INET; 1582 ifm->ifa_prefixlen = ifa->ifa_prefixlen; 1583 ifm->ifa_flags = ifa->ifa_flags; 1584 ifm->ifa_scope = ifa->ifa_scope; 1585 ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 1586 1587 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) { 1588 preferred = ifa->ifa_preferred_lft; 1589 valid = ifa->ifa_valid_lft; 1590 if (preferred != INFINITY_LIFE_TIME) { 1591 long tval = (jiffies - ifa->ifa_tstamp) / HZ; 1592 1593 if (preferred > tval) 1594 preferred -= tval; 1595 else 1596 preferred = 0; 1597 if (valid != INFINITY_LIFE_TIME) { 1598 if (valid > tval) 1599 valid -= tval; 1600 else 1601 valid = 0; 1602 } 1603 } 1604 } else { 1605 preferred = INFINITY_LIFE_TIME; 1606 valid = INFINITY_LIFE_TIME; 1607 } 1608 if ((ifa->ifa_address && 1609 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) || 1610 (ifa->ifa_local && 1611 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) || 1612 (ifa->ifa_broadcast && 1613 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) || 1614 (ifa->ifa_label[0] && 1615 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) || 1616 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) || 1617 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp, 1618 preferred, valid)) 1619 goto nla_put_failure; 1620 1621 nlmsg_end(skb, nlh); 1622 return 0; 1623 1624 nla_put_failure: 1625 nlmsg_cancel(skb, nlh); 1626 return -EMSGSIZE; 1627 } 1628 1629 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 1630 { 1631 struct net *net = sock_net(skb->sk); 1632 int h, s_h; 1633 int idx, s_idx; 1634 int ip_idx, s_ip_idx; 1635 struct net_device *dev; 1636 struct in_device *in_dev; 1637 struct in_ifaddr *ifa; 1638 struct hlist_head *head; 1639 1640 s_h = cb->args[0]; 1641 s_idx = idx = cb->args[1]; 1642 s_ip_idx = ip_idx = cb->args[2]; 1643 1644 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 1645 idx = 0; 1646 head = &net->dev_index_head[h]; 1647 rcu_read_lock(); 1648 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ 1649 net->dev_base_seq; 1650 hlist_for_each_entry_rcu(dev, head, index_hlist) { 1651 if (idx < s_idx) 1652 goto cont; 1653 if (h > s_h || idx > s_idx) 1654 s_ip_idx = 0; 1655 in_dev = __in_dev_get_rcu(dev); 1656 if (!in_dev) 1657 goto cont; 1658 1659 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 1660 ifa = ifa->ifa_next, ip_idx++) { 1661 if (ip_idx < s_ip_idx) 1662 continue; 1663 if (inet_fill_ifaddr(skb, ifa, 1664 NETLINK_CB(cb->skb).portid, 1665 cb->nlh->nlmsg_seq, 1666 RTM_NEWADDR, NLM_F_MULTI) < 0) { 1667 rcu_read_unlock(); 1668 goto done; 1669 } 1670 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 1671 } 1672 cont: 1673 idx++; 1674 } 1675 rcu_read_unlock(); 1676 } 1677 1678 done: 1679 cb->args[0] = h; 1680 cb->args[1] = idx; 1681 cb->args[2] = ip_idx; 1682 1683 return skb->len; 1684 } 1685 1686 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh, 1687 u32 portid) 1688 { 1689 struct sk_buff *skb; 1690 u32 seq = nlh ? nlh->nlmsg_seq : 0; 1691 int err = -ENOBUFS; 1692 struct net *net; 1693 1694 net = dev_net(ifa->ifa_dev->dev); 1695 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL); 1696 if (!skb) 1697 goto errout; 1698 1699 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0); 1700 if (err < 0) { 1701 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */ 1702 WARN_ON(err == -EMSGSIZE); 1703 kfree_skb(skb); 1704 goto errout; 1705 } 1706 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL); 1707 return; 1708 errout: 1709 if (err < 0) 1710 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err); 1711 } 1712 1713 static size_t inet_get_link_af_size(const struct net_device *dev, 1714 u32 ext_filter_mask) 1715 { 1716 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); 1717 1718 if (!in_dev) 1719 return 0; 1720 1721 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */ 1722 } 1723 1724 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev, 1725 u32 ext_filter_mask) 1726 { 1727 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); 1728 struct nlattr *nla; 1729 int i; 1730 1731 if (!in_dev) 1732 return -ENODATA; 1733 1734 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4); 1735 if (!nla) 1736 return -EMSGSIZE; 1737 1738 for (i = 0; i < IPV4_DEVCONF_MAX; i++) 1739 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i]; 1740 1741 return 0; 1742 } 1743 1744 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = { 1745 [IFLA_INET_CONF] = { .type = NLA_NESTED }, 1746 }; 1747 1748 static int inet_validate_link_af(const struct net_device *dev, 1749 const struct nlattr *nla) 1750 { 1751 struct nlattr *a, *tb[IFLA_INET_MAX+1]; 1752 int err, rem; 1753 1754 if (dev && !__in_dev_get_rtnl(dev)) 1755 return -EAFNOSUPPORT; 1756 1757 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL); 1758 if (err < 0) 1759 return err; 1760 1761 if (tb[IFLA_INET_CONF]) { 1762 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) { 1763 int cfgid = nla_type(a); 1764 1765 if (nla_len(a) < 4) 1766 return -EINVAL; 1767 1768 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX) 1769 return -EINVAL; 1770 } 1771 } 1772 1773 return 0; 1774 } 1775 1776 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla) 1777 { 1778 struct in_device *in_dev = __in_dev_get_rtnl(dev); 1779 struct nlattr *a, *tb[IFLA_INET_MAX+1]; 1780 int rem; 1781 1782 if (!in_dev) 1783 return -EAFNOSUPPORT; 1784 1785 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL, NULL) < 0) 1786 BUG(); 1787 1788 if (tb[IFLA_INET_CONF]) { 1789 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) 1790 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a)); 1791 } 1792 1793 return 0; 1794 } 1795 1796 static int inet_netconf_msgsize_devconf(int type) 1797 { 1798 int size = NLMSG_ALIGN(sizeof(struct netconfmsg)) 1799 + nla_total_size(4); /* NETCONFA_IFINDEX */ 1800 bool all = false; 1801 1802 if (type == NETCONFA_ALL) 1803 all = true; 1804 1805 if (all || type == NETCONFA_FORWARDING) 1806 size += nla_total_size(4); 1807 if (all || type == NETCONFA_RP_FILTER) 1808 size += nla_total_size(4); 1809 if (all || type == NETCONFA_MC_FORWARDING) 1810 size += nla_total_size(4); 1811 if (all || type == NETCONFA_PROXY_NEIGH) 1812 size += nla_total_size(4); 1813 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) 1814 size += nla_total_size(4); 1815 1816 return size; 1817 } 1818 1819 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex, 1820 struct ipv4_devconf *devconf, u32 portid, 1821 u32 seq, int event, unsigned int flags, 1822 int type) 1823 { 1824 struct nlmsghdr *nlh; 1825 struct netconfmsg *ncm; 1826 bool all = false; 1827 1828 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg), 1829 flags); 1830 if (!nlh) 1831 return -EMSGSIZE; 1832 1833 if (type == NETCONFA_ALL) 1834 all = true; 1835 1836 ncm = nlmsg_data(nlh); 1837 ncm->ncm_family = AF_INET; 1838 1839 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0) 1840 goto nla_put_failure; 1841 1842 if (!devconf) 1843 goto out; 1844 1845 if ((all || type == NETCONFA_FORWARDING) && 1846 nla_put_s32(skb, NETCONFA_FORWARDING, 1847 IPV4_DEVCONF(*devconf, FORWARDING)) < 0) 1848 goto nla_put_failure; 1849 if ((all || type == NETCONFA_RP_FILTER) && 1850 nla_put_s32(skb, NETCONFA_RP_FILTER, 1851 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0) 1852 goto nla_put_failure; 1853 if ((all || type == NETCONFA_MC_FORWARDING) && 1854 nla_put_s32(skb, NETCONFA_MC_FORWARDING, 1855 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0) 1856 goto nla_put_failure; 1857 if ((all || type == NETCONFA_PROXY_NEIGH) && 1858 nla_put_s32(skb, NETCONFA_PROXY_NEIGH, 1859 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0) 1860 goto nla_put_failure; 1861 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) && 1862 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN, 1863 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0) 1864 goto nla_put_failure; 1865 1866 out: 1867 nlmsg_end(skb, nlh); 1868 return 0; 1869 1870 nla_put_failure: 1871 nlmsg_cancel(skb, nlh); 1872 return -EMSGSIZE; 1873 } 1874 1875 void inet_netconf_notify_devconf(struct net *net, int event, int type, 1876 int ifindex, struct ipv4_devconf *devconf) 1877 { 1878 struct sk_buff *skb; 1879 int err = -ENOBUFS; 1880 1881 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL); 1882 if (!skb) 1883 goto errout; 1884 1885 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0, 1886 event, 0, type); 1887 if (err < 0) { 1888 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */ 1889 WARN_ON(err == -EMSGSIZE); 1890 kfree_skb(skb); 1891 goto errout; 1892 } 1893 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL); 1894 return; 1895 errout: 1896 if (err < 0) 1897 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err); 1898 } 1899 1900 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = { 1901 [NETCONFA_IFINDEX] = { .len = sizeof(int) }, 1902 [NETCONFA_FORWARDING] = { .len = sizeof(int) }, 1903 [NETCONFA_RP_FILTER] = { .len = sizeof(int) }, 1904 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) }, 1905 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) }, 1906 }; 1907 1908 static int inet_netconf_get_devconf(struct sk_buff *in_skb, 1909 struct nlmsghdr *nlh, 1910 struct netlink_ext_ack *extack) 1911 { 1912 struct net *net = sock_net(in_skb->sk); 1913 struct nlattr *tb[NETCONFA_MAX+1]; 1914 struct netconfmsg *ncm; 1915 struct sk_buff *skb; 1916 struct ipv4_devconf *devconf; 1917 struct in_device *in_dev; 1918 struct net_device *dev; 1919 int ifindex; 1920 int err; 1921 1922 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX, 1923 devconf_ipv4_policy, extack); 1924 if (err < 0) 1925 goto errout; 1926 1927 err = -EINVAL; 1928 if (!tb[NETCONFA_IFINDEX]) 1929 goto errout; 1930 1931 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]); 1932 switch (ifindex) { 1933 case NETCONFA_IFINDEX_ALL: 1934 devconf = net->ipv4.devconf_all; 1935 break; 1936 case NETCONFA_IFINDEX_DEFAULT: 1937 devconf = net->ipv4.devconf_dflt; 1938 break; 1939 default: 1940 dev = __dev_get_by_index(net, ifindex); 1941 if (!dev) 1942 goto errout; 1943 in_dev = __in_dev_get_rtnl(dev); 1944 if (!in_dev) 1945 goto errout; 1946 devconf = &in_dev->cnf; 1947 break; 1948 } 1949 1950 err = -ENOBUFS; 1951 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL); 1952 if (!skb) 1953 goto errout; 1954 1955 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 1956 NETLINK_CB(in_skb).portid, 1957 nlh->nlmsg_seq, RTM_NEWNETCONF, 0, 1958 NETCONFA_ALL); 1959 if (err < 0) { 1960 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */ 1961 WARN_ON(err == -EMSGSIZE); 1962 kfree_skb(skb); 1963 goto errout; 1964 } 1965 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 1966 errout: 1967 return err; 1968 } 1969 1970 static int inet_netconf_dump_devconf(struct sk_buff *skb, 1971 struct netlink_callback *cb) 1972 { 1973 struct net *net = sock_net(skb->sk); 1974 int h, s_h; 1975 int idx, s_idx; 1976 struct net_device *dev; 1977 struct in_device *in_dev; 1978 struct hlist_head *head; 1979 1980 s_h = cb->args[0]; 1981 s_idx = idx = cb->args[1]; 1982 1983 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 1984 idx = 0; 1985 head = &net->dev_index_head[h]; 1986 rcu_read_lock(); 1987 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ 1988 net->dev_base_seq; 1989 hlist_for_each_entry_rcu(dev, head, index_hlist) { 1990 if (idx < s_idx) 1991 goto cont; 1992 in_dev = __in_dev_get_rcu(dev); 1993 if (!in_dev) 1994 goto cont; 1995 1996 if (inet_netconf_fill_devconf(skb, dev->ifindex, 1997 &in_dev->cnf, 1998 NETLINK_CB(cb->skb).portid, 1999 cb->nlh->nlmsg_seq, 2000 RTM_NEWNETCONF, 2001 NLM_F_MULTI, 2002 NETCONFA_ALL) < 0) { 2003 rcu_read_unlock(); 2004 goto done; 2005 } 2006 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 2007 cont: 2008 idx++; 2009 } 2010 rcu_read_unlock(); 2011 } 2012 if (h == NETDEV_HASHENTRIES) { 2013 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL, 2014 net->ipv4.devconf_all, 2015 NETLINK_CB(cb->skb).portid, 2016 cb->nlh->nlmsg_seq, 2017 RTM_NEWNETCONF, NLM_F_MULTI, 2018 NETCONFA_ALL) < 0) 2019 goto done; 2020 else 2021 h++; 2022 } 2023 if (h == NETDEV_HASHENTRIES + 1) { 2024 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT, 2025 net->ipv4.devconf_dflt, 2026 NETLINK_CB(cb->skb).portid, 2027 cb->nlh->nlmsg_seq, 2028 RTM_NEWNETCONF, NLM_F_MULTI, 2029 NETCONFA_ALL) < 0) 2030 goto done; 2031 else 2032 h++; 2033 } 2034 done: 2035 cb->args[0] = h; 2036 cb->args[1] = idx; 2037 2038 return skb->len; 2039 } 2040 2041 #ifdef CONFIG_SYSCTL 2042 2043 static void devinet_copy_dflt_conf(struct net *net, int i) 2044 { 2045 struct net_device *dev; 2046 2047 rcu_read_lock(); 2048 for_each_netdev_rcu(net, dev) { 2049 struct in_device *in_dev; 2050 2051 in_dev = __in_dev_get_rcu(dev); 2052 if (in_dev && !test_bit(i, in_dev->cnf.state)) 2053 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i]; 2054 } 2055 rcu_read_unlock(); 2056 } 2057 2058 /* called with RTNL locked */ 2059 static void inet_forward_change(struct net *net) 2060 { 2061 struct net_device *dev; 2062 int on = IPV4_DEVCONF_ALL(net, FORWARDING); 2063 2064 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on; 2065 IPV4_DEVCONF_DFLT(net, FORWARDING) = on; 2066 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2067 NETCONFA_FORWARDING, 2068 NETCONFA_IFINDEX_ALL, 2069 net->ipv4.devconf_all); 2070 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2071 NETCONFA_FORWARDING, 2072 NETCONFA_IFINDEX_DEFAULT, 2073 net->ipv4.devconf_dflt); 2074 2075 for_each_netdev(net, dev) { 2076 struct in_device *in_dev; 2077 2078 if (on) 2079 dev_disable_lro(dev); 2080 2081 in_dev = __in_dev_get_rtnl(dev); 2082 if (in_dev) { 2083 IN_DEV_CONF_SET(in_dev, FORWARDING, on); 2084 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2085 NETCONFA_FORWARDING, 2086 dev->ifindex, &in_dev->cnf); 2087 } 2088 } 2089 } 2090 2091 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf) 2092 { 2093 if (cnf == net->ipv4.devconf_dflt) 2094 return NETCONFA_IFINDEX_DEFAULT; 2095 else if (cnf == net->ipv4.devconf_all) 2096 return NETCONFA_IFINDEX_ALL; 2097 else { 2098 struct in_device *idev 2099 = container_of(cnf, struct in_device, cnf); 2100 return idev->dev->ifindex; 2101 } 2102 } 2103 2104 static int devinet_conf_proc(struct ctl_table *ctl, int write, 2105 void __user *buffer, 2106 size_t *lenp, loff_t *ppos) 2107 { 2108 int old_value = *(int *)ctl->data; 2109 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 2110 int new_value = *(int *)ctl->data; 2111 2112 if (write) { 2113 struct ipv4_devconf *cnf = ctl->extra1; 2114 struct net *net = ctl->extra2; 2115 int i = (int *)ctl->data - cnf->data; 2116 int ifindex; 2117 2118 set_bit(i, cnf->state); 2119 2120 if (cnf == net->ipv4.devconf_dflt) 2121 devinet_copy_dflt_conf(net, i); 2122 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 || 2123 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1) 2124 if ((new_value == 0) && (old_value != 0)) 2125 rt_cache_flush(net); 2126 2127 if (i == IPV4_DEVCONF_RP_FILTER - 1 && 2128 new_value != old_value) { 2129 ifindex = devinet_conf_ifindex(net, cnf); 2130 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2131 NETCONFA_RP_FILTER, 2132 ifindex, cnf); 2133 } 2134 if (i == IPV4_DEVCONF_PROXY_ARP - 1 && 2135 new_value != old_value) { 2136 ifindex = devinet_conf_ifindex(net, cnf); 2137 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2138 NETCONFA_PROXY_NEIGH, 2139 ifindex, cnf); 2140 } 2141 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 && 2142 new_value != old_value) { 2143 ifindex = devinet_conf_ifindex(net, cnf); 2144 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2145 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN, 2146 ifindex, cnf); 2147 } 2148 } 2149 2150 return ret; 2151 } 2152 2153 static int devinet_sysctl_forward(struct ctl_table *ctl, int write, 2154 void __user *buffer, 2155 size_t *lenp, loff_t *ppos) 2156 { 2157 int *valp = ctl->data; 2158 int val = *valp; 2159 loff_t pos = *ppos; 2160 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 2161 2162 if (write && *valp != val) { 2163 struct net *net = ctl->extra2; 2164 2165 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) { 2166 if (!rtnl_trylock()) { 2167 /* Restore the original values before restarting */ 2168 *valp = val; 2169 *ppos = pos; 2170 return restart_syscall(); 2171 } 2172 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) { 2173 inet_forward_change(net); 2174 } else { 2175 struct ipv4_devconf *cnf = ctl->extra1; 2176 struct in_device *idev = 2177 container_of(cnf, struct in_device, cnf); 2178 if (*valp) 2179 dev_disable_lro(idev->dev); 2180 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2181 NETCONFA_FORWARDING, 2182 idev->dev->ifindex, 2183 cnf); 2184 } 2185 rtnl_unlock(); 2186 rt_cache_flush(net); 2187 } else 2188 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 2189 NETCONFA_FORWARDING, 2190 NETCONFA_IFINDEX_DEFAULT, 2191 net->ipv4.devconf_dflt); 2192 } 2193 2194 return ret; 2195 } 2196 2197 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write, 2198 void __user *buffer, 2199 size_t *lenp, loff_t *ppos) 2200 { 2201 int *valp = ctl->data; 2202 int val = *valp; 2203 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 2204 struct net *net = ctl->extra2; 2205 2206 if (write && *valp != val) 2207 rt_cache_flush(net); 2208 2209 return ret; 2210 } 2211 2212 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \ 2213 { \ 2214 .procname = name, \ 2215 .data = ipv4_devconf.data + \ 2216 IPV4_DEVCONF_ ## attr - 1, \ 2217 .maxlen = sizeof(int), \ 2218 .mode = mval, \ 2219 .proc_handler = proc, \ 2220 .extra1 = &ipv4_devconf, \ 2221 } 2222 2223 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \ 2224 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc) 2225 2226 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \ 2227 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc) 2228 2229 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \ 2230 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc) 2231 2232 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \ 2233 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush) 2234 2235 static struct devinet_sysctl_table { 2236 struct ctl_table_header *sysctl_header; 2237 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX]; 2238 } devinet_sysctl = { 2239 .devinet_vars = { 2240 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding", 2241 devinet_sysctl_forward), 2242 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"), 2243 2244 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"), 2245 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"), 2246 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"), 2247 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"), 2248 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"), 2249 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE, 2250 "accept_source_route"), 2251 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"), 2252 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"), 2253 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"), 2254 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"), 2255 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"), 2256 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"), 2257 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"), 2258 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"), 2259 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"), 2260 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"), 2261 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"), 2262 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"), 2263 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"), 2264 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION, 2265 "force_igmp_version"), 2266 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL, 2267 "igmpv2_unsolicited_report_interval"), 2268 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL, 2269 "igmpv3_unsolicited_report_interval"), 2270 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN, 2271 "ignore_routes_with_linkdown"), 2272 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP, 2273 "drop_gratuitous_arp"), 2274 2275 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"), 2276 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"), 2277 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES, 2278 "promote_secondaries"), 2279 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET, 2280 "route_localnet"), 2281 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST, 2282 "drop_unicast_in_l2_multicast"), 2283 }, 2284 }; 2285 2286 static int __devinet_sysctl_register(struct net *net, char *dev_name, 2287 int ifindex, struct ipv4_devconf *p) 2288 { 2289 int i; 2290 struct devinet_sysctl_table *t; 2291 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ]; 2292 2293 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL); 2294 if (!t) 2295 goto out; 2296 2297 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 2298 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 2299 t->devinet_vars[i].extra1 = p; 2300 t->devinet_vars[i].extra2 = net; 2301 } 2302 2303 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name); 2304 2305 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars); 2306 if (!t->sysctl_header) 2307 goto free; 2308 2309 p->sysctl = t; 2310 2311 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL, 2312 ifindex, p); 2313 return 0; 2314 2315 free: 2316 kfree(t); 2317 out: 2318 return -ENOBUFS; 2319 } 2320 2321 static void __devinet_sysctl_unregister(struct net *net, 2322 struct ipv4_devconf *cnf, int ifindex) 2323 { 2324 struct devinet_sysctl_table *t = cnf->sysctl; 2325 2326 if (t) { 2327 cnf->sysctl = NULL; 2328 unregister_net_sysctl_table(t->sysctl_header); 2329 kfree(t); 2330 } 2331 2332 inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL); 2333 } 2334 2335 static int devinet_sysctl_register(struct in_device *idev) 2336 { 2337 int err; 2338 2339 if (!sysctl_dev_name_is_allowed(idev->dev->name)) 2340 return -EINVAL; 2341 2342 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL); 2343 if (err) 2344 return err; 2345 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name, 2346 idev->dev->ifindex, &idev->cnf); 2347 if (err) 2348 neigh_sysctl_unregister(idev->arp_parms); 2349 return err; 2350 } 2351 2352 static void devinet_sysctl_unregister(struct in_device *idev) 2353 { 2354 struct net *net = dev_net(idev->dev); 2355 2356 __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex); 2357 neigh_sysctl_unregister(idev->arp_parms); 2358 } 2359 2360 static struct ctl_table ctl_forward_entry[] = { 2361 { 2362 .procname = "ip_forward", 2363 .data = &ipv4_devconf.data[ 2364 IPV4_DEVCONF_FORWARDING - 1], 2365 .maxlen = sizeof(int), 2366 .mode = 0644, 2367 .proc_handler = devinet_sysctl_forward, 2368 .extra1 = &ipv4_devconf, 2369 .extra2 = &init_net, 2370 }, 2371 { }, 2372 }; 2373 #endif 2374 2375 static __net_init int devinet_init_net(struct net *net) 2376 { 2377 int err; 2378 struct ipv4_devconf *all, *dflt; 2379 #ifdef CONFIG_SYSCTL 2380 struct ctl_table *tbl = ctl_forward_entry; 2381 struct ctl_table_header *forw_hdr; 2382 #endif 2383 2384 err = -ENOMEM; 2385 all = &ipv4_devconf; 2386 dflt = &ipv4_devconf_dflt; 2387 2388 if (!net_eq(net, &init_net)) { 2389 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL); 2390 if (!all) 2391 goto err_alloc_all; 2392 2393 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL); 2394 if (!dflt) 2395 goto err_alloc_dflt; 2396 2397 #ifdef CONFIG_SYSCTL 2398 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL); 2399 if (!tbl) 2400 goto err_alloc_ctl; 2401 2402 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1]; 2403 tbl[0].extra1 = all; 2404 tbl[0].extra2 = net; 2405 #endif 2406 } 2407 2408 #ifdef CONFIG_SYSCTL 2409 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all); 2410 if (err < 0) 2411 goto err_reg_all; 2412 2413 err = __devinet_sysctl_register(net, "default", 2414 NETCONFA_IFINDEX_DEFAULT, dflt); 2415 if (err < 0) 2416 goto err_reg_dflt; 2417 2418 err = -ENOMEM; 2419 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl); 2420 if (!forw_hdr) 2421 goto err_reg_ctl; 2422 net->ipv4.forw_hdr = forw_hdr; 2423 #endif 2424 2425 net->ipv4.devconf_all = all; 2426 net->ipv4.devconf_dflt = dflt; 2427 return 0; 2428 2429 #ifdef CONFIG_SYSCTL 2430 err_reg_ctl: 2431 __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT); 2432 err_reg_dflt: 2433 __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL); 2434 err_reg_all: 2435 if (tbl != ctl_forward_entry) 2436 kfree(tbl); 2437 err_alloc_ctl: 2438 #endif 2439 if (dflt != &ipv4_devconf_dflt) 2440 kfree(dflt); 2441 err_alloc_dflt: 2442 if (all != &ipv4_devconf) 2443 kfree(all); 2444 err_alloc_all: 2445 return err; 2446 } 2447 2448 static __net_exit void devinet_exit_net(struct net *net) 2449 { 2450 #ifdef CONFIG_SYSCTL 2451 struct ctl_table *tbl; 2452 2453 tbl = net->ipv4.forw_hdr->ctl_table_arg; 2454 unregister_net_sysctl_table(net->ipv4.forw_hdr); 2455 __devinet_sysctl_unregister(net, net->ipv4.devconf_dflt, 2456 NETCONFA_IFINDEX_DEFAULT); 2457 __devinet_sysctl_unregister(net, net->ipv4.devconf_all, 2458 NETCONFA_IFINDEX_ALL); 2459 kfree(tbl); 2460 #endif 2461 kfree(net->ipv4.devconf_dflt); 2462 kfree(net->ipv4.devconf_all); 2463 } 2464 2465 static __net_initdata struct pernet_operations devinet_ops = { 2466 .init = devinet_init_net, 2467 .exit = devinet_exit_net, 2468 }; 2469 2470 static struct rtnl_af_ops inet_af_ops __read_mostly = { 2471 .family = AF_INET, 2472 .fill_link_af = inet_fill_link_af, 2473 .get_link_af_size = inet_get_link_af_size, 2474 .validate_link_af = inet_validate_link_af, 2475 .set_link_af = inet_set_link_af, 2476 }; 2477 2478 void __init devinet_init(void) 2479 { 2480 int i; 2481 2482 for (i = 0; i < IN4_ADDR_HSIZE; i++) 2483 INIT_HLIST_HEAD(&inet_addr_lst[i]); 2484 2485 register_pernet_subsys(&devinet_ops); 2486 2487 register_gifconf(PF_INET, inet_gifconf); 2488 register_netdevice_notifier(&ip_netdev_notifier); 2489 2490 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0); 2491 2492 rtnl_af_register(&inet_af_ops); 2493 2494 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0); 2495 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0); 2496 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0); 2497 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf, 2498 inet_netconf_dump_devconf, 0); 2499 } 2500