root/net/ipv4/devinet.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. inet_addr_hash
  2. inet_hash_insert
  3. inet_hash_remove
  4. __ip_dev_find
  5. inet_lookup_ifaddr_rcu
  6. devinet_sysctl_register
  7. devinet_sysctl_unregister
  8. inet_alloc_ifa
  9. inet_rcu_free_ifa
  10. inet_free_ifa
  11. in_dev_finish_destroy
  12. inetdev_init
  13. in_dev_rcu_put
  14. inetdev_destroy
  15. inet_addr_onlink
  16. __inet_del_ifa
  17. inet_del_ifa
  18. __inet_insert_ifa
  19. inet_insert_ifa
  20. inet_set_ifa
  21. inetdev_by_index
  22. inet_ifa_byprefix
  23. ip_mc_autojoin_config
  24. inet_rtm_deladdr
  25. check_lifetime
  26. set_ifa_lifetime
  27. rtm_to_ifaddr
  28. find_matching_ifa
  29. inet_rtm_newaddr
  30. inet_abc_len
  31. devinet_ioctl
  32. inet_gifconf
  33. in_dev_select_addr
  34. inet_select_addr
  35. confirm_addr_indev
  36. inet_confirm_addr
  37. register_inetaddr_notifier
  38. unregister_inetaddr_notifier
  39. register_inetaddr_validator_notifier
  40. unregister_inetaddr_validator_notifier
  41. inetdev_changename
  42. inetdev_send_gratuitous_arp
  43. inetdev_event
  44. inet_nlmsg_size
  45. cstamp_delta
  46. put_cacheinfo
  47. inet_fill_ifaddr
  48. inet_valid_dump_ifaddr_req
  49. in_dev_dump_addr
  50. inet_dump_ifaddr
  51. rtmsg_ifa
  52. inet_get_link_af_size
  53. inet_fill_link_af
  54. inet_validate_link_af
  55. inet_set_link_af
  56. inet_netconf_msgsize_devconf
  57. inet_netconf_fill_devconf
  58. inet_netconf_notify_devconf
  59. inet_netconf_valid_get_req
  60. inet_netconf_get_devconf
  61. inet_netconf_dump_devconf
  62. devinet_copy_dflt_conf
  63. inet_forward_change
  64. devinet_conf_ifindex
  65. devinet_conf_proc
  66. devinet_sysctl_forward
  67. ipv4_doint_and_flush
  68. __devinet_sysctl_register
  69. __devinet_sysctl_unregister
  70. devinet_sysctl_register
  71. devinet_sysctl_unregister
  72. devinet_init_net
  73. devinet_exit_net
  74. devinet_init

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

/* [<][>][^][v][top][bottom][index][help] */