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