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