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