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