1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * NET3 IP device support routines.
5 * Derived from the IP parts of dev.c 1.0.19
7 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
8 * Mark Evans, <evansmp@uhura.aston.ac.uk>
11 * Alan Cox, <gw4pts@gw4pts.ampr.org>
12 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
15 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
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
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>
34 #include <linux/socket.h>
35 #include <linux/sockios.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>
52 #include <linux/sysctl.h>
54 #include <linux/kmod.h>
55 #include <linux/netconf.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>
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)
70 static struct ipv4_devconf ipv4_devconf = {
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*/,
81 static struct ipv4_devconf ipv4_devconf_dflt = {
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*/,
93 #define IPV4_DEVCONF_DFLT(net, attr) \
94 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
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 },
107 struct inet_fill_args {
116 #define IN4_ADDR_HSIZE_SHIFT 8
117 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
119 static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
121 static u32 inet_addr_hash(const struct net *net, __be32 addr)
123 u32 val = (__force u32) addr ^ net_hash_mix(net);
125 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
128 static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
130 u32 hash = inet_addr_hash(net, ifa->ifa_local);
133 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
136 static void inet_hash_remove(struct in_ifaddr *ifa)
139 hlist_del_init_rcu(&ifa->hash);
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
148 * If a caller uses devref=false, it should be protected by RCU, or RTNL
150 struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
152 struct net_device *result = NULL;
153 struct in_ifaddr *ifa;
156 ifa = inet_lookup_ifaddr_rcu(net, addr);
158 struct flowi4 fl4 = { .daddr = addr };
159 struct fib_result res = { 0 };
160 struct fib_table *local;
162 /* Fallback to FIB local table so that communication
163 * over loopback subnets work.
165 local = fib_get_table(net, RT_TABLE_LOCAL);
167 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
168 res.type == RTN_LOCAL)
169 result = FIB_RES_DEV(res);
171 result = ifa->ifa_dev->dev;
173 if (result && devref)
178 EXPORT_SYMBOL(__ip_dev_find);
180 /* called under RCU lock */
181 struct in_ifaddr *inet_lookup_ifaddr_rcu(struct net *net, __be32 addr)
183 u32 hash = inet_addr_hash(net, addr);
184 struct in_ifaddr *ifa;
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))
194 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
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,
202 static int devinet_sysctl_register(struct in_device *idev);
203 static void devinet_sysctl_unregister(struct in_device *idev);
205 static int devinet_sysctl_register(struct in_device *idev)
209 static void devinet_sysctl_unregister(struct in_device *idev)
214 /* Locks all the inet devices. */
216 static struct in_ifaddr *inet_alloc_ifa(void)
218 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
221 static void inet_rcu_free_ifa(struct rcu_head *head)
223 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
225 in_dev_put(ifa->ifa_dev);
229 static void inet_free_ifa(struct in_ifaddr *ifa)
231 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
234 void in_dev_finish_destroy(struct in_device *idev)
236 struct net_device *dev = idev->dev;
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");
246 pr_err("Freeing alive in_device %p\n", idev);
250 EXPORT_SYMBOL(in_dev_finish_destroy);
252 static struct in_device *inetdev_init(struct net_device *dev)
254 struct in_device *in_dev;
259 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
262 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
263 sizeof(in_dev->cnf));
264 in_dev->cnf.sysctl = NULL;
266 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
267 if (!in_dev->arp_parms)
269 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
270 dev_disable_lro(dev);
271 /* Reference in_dev->dev */
273 /* Account for reference dev->ip_ptr (below) */
274 refcount_set(&in_dev->refcnt, 1);
276 err = devinet_sysctl_register(in_dev);
279 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
284 ip_mc_init_dev(in_dev);
285 if (dev->flags & IFF_UP)
288 /* we can receive as soon as ip_ptr is set -- do this last */
289 rcu_assign_pointer(dev->ip_ptr, in_dev);
291 return in_dev ?: ERR_PTR(err);
298 static void in_dev_rcu_put(struct rcu_head *head)
300 struct in_device *idev = container_of(head, struct in_device, rcu_head);
304 static void inetdev_destroy(struct in_device *in_dev)
306 struct net_device *dev;
307 struct in_ifaddr *ifa;
315 ip_mc_destroy_dev(in_dev);
317 while ((ifa = rtnl_dereference(in_dev->ifa_list)) != NULL) {
318 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
322 RCU_INIT_POINTER(dev->ip_ptr, NULL);
324 devinet_sysctl_unregister(in_dev);
325 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
328 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
331 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
333 const struct in_ifaddr *ifa;
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)) {
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)
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);
360 ifa1 = rtnl_dereference(*ifap);
361 last_prim = rtnl_dereference(in_dev->ifa_list);
365 /* 1. Deleting primary ifaddr forces deletion all secondaries
366 * unless alias promotion is set
369 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
370 struct in_ifaddr __rcu **ifap1 = &ifa1->ifa_next;
372 while ((ifa = rtnl_dereference(*ifap1)) != NULL) {
373 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
374 ifa1->ifa_scope <= ifa->ifa_scope)
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;
386 inet_hash_remove(ifa);
387 *ifap1 = ifa->ifa_next;
389 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
390 blocking_notifier_call_chain(&inetaddr_chain,
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.
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);
414 *ifap = ifa1->ifa_next;
415 inet_hash_remove(ifa1);
417 /* 3. Announce address deletion */
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.
427 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
428 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
431 struct in_ifaddr *next_sec;
433 next_sec = rtnl_dereference(promote->ifa_next);
435 struct in_ifaddr *last_sec;
437 rcu_assign_pointer(prev_prom->ifa_next, next_sec);
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);
444 promote->ifa_flags &= ~IFA_F_SECONDARY;
445 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
446 blocking_notifier_call_chain(&inetaddr_chain,
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))
461 static void inet_del_ifa(struct in_device *in_dev,
462 struct in_ifaddr __rcu **ifap,
465 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
468 static void check_lifetime(struct work_struct *work);
470 static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
472 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
473 u32 portid, struct netlink_ext_ack *extack)
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;
483 if (!ifa->ifa_local) {
488 ifa->ifa_flags &= ~IFA_F_SECONDARY;
489 last_primary = &in_dev->ifa_list;
491 /* Don't set IPv6 only flags to IPv4 addresses */
492 ifa->ifa_flags &= ~IPV6ONLY_FLAGS;
494 ifap = &in_dev->ifa_list;
495 ifa1 = rtnl_dereference(*ifap);
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) {
507 if (ifa1->ifa_scope != ifa->ifa_scope) {
511 ifa->ifa_flags |= IFA_F_SECONDARY;
514 ifap = &ifa1->ifa_next;
515 ifa1 = rtnl_dereference(*ifap);
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
525 ivi.ivi_addr = ifa->ifa_address;
526 ivi.ivi_dev = ifa->ifa_dev;
528 ret = blocking_notifier_call_chain(&inetaddr_validator_chain,
530 ret = notifier_to_errno(ret);
536 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
537 prandom_seed((__force u32) ifa->ifa_local);
541 rcu_assign_pointer(ifa->ifa_next, *ifap);
542 rcu_assign_pointer(*ifap, ifa);
544 inet_hash_insert(dev_net(in_dev->dev), ifa);
546 cancel_delayed_work(&check_lifetime_work);
547 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
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);
558 static int inet_insert_ifa(struct in_ifaddr *ifa)
560 return __inet_insert_ifa(ifa, NULL, 0, NULL);
563 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
565 struct in_device *in_dev = __in_dev_get_rtnl(dev);
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);
578 ifa->ifa_dev = in_dev;
580 if (ipv4_is_loopback(ifa->ifa_local))
581 ifa->ifa_scope = RT_SCOPE_HOST;
582 return inet_insert_ifa(ifa);
585 /* Caller must hold RCU or RTNL :
586 * We dont take a reference on found in_device
588 struct in_device *inetdev_by_index(struct net *net, int ifindex)
590 struct net_device *dev;
591 struct in_device *in_dev = NULL;
594 dev = dev_get_by_index_rcu(net, ifindex);
596 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
600 EXPORT_SYMBOL(inetdev_by_index);
602 /* Called only from RTNL semaphored context. No locks. */
604 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
607 struct in_ifaddr *ifa;
611 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
612 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
618 static int ip_mc_autojoin_config(struct net *net, bool join,
619 const struct in_ifaddr *ifa)
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,
626 struct sock *sk = net->ipv4.mc_autojoin_sk;
633 ret = ip_mc_join_group(sk, &mreq);
635 ret = ip_mc_leave_group(sk, &mreq);
644 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
645 struct netlink_ext_ack *extack)
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;
658 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
659 ifa_ipv4_policy, extack);
663 ifm = nlmsg_data(nlh);
664 in_dev = inetdev_by_index(net, ifm->ifa_index);
670 for (ifap = &in_dev->ifa_list; (ifa = rtnl_dereference(*ifap)) != NULL;
671 ifap = &ifa->ifa_next) {
673 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
676 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
679 if (tb[IFA_ADDRESS] &&
680 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
681 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
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);
690 err = -EADDRNOTAVAIL;
695 #define INFINITY_LIFE_TIME 0xFFFFFFFF
697 static void check_lifetime(struct work_struct *work)
699 unsigned long now, next, next_sec, next_sched;
700 struct in_ifaddr *ifa;
701 struct hlist_node *n;
705 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
707 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
708 bool change_needed = false;
711 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
714 if (ifa->ifa_flags & IFA_F_PERMANENT)
717 /* We try to batch several events at once. */
718 age = (now - ifa->ifa_tstamp +
719 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
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) {
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;
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,
738 next = ifa->ifa_tstamp +
739 ifa->ifa_preferred_lft * HZ;
746 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
749 if (ifa->ifa_flags & IFA_F_PERMANENT)
752 /* We try to batch several events at once. */
753 age = (now - ifa->ifa_tstamp +
754 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
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;
761 ifap = &ifa->ifa_dev->ifa_list;
762 tmp = rtnl_dereference(*ifap);
765 inet_del_ifa(ifa->ifa_dev,
769 ifap = &tmp->ifa_next;
770 tmp = rtnl_dereference(*ifap);
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);
783 next_sec = round_jiffies_up(next);
786 /* If rounded timeout is accurate enough, accept it. */
787 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
788 next_sched = next_sec;
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;
795 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
799 static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
802 unsigned long timeout;
804 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
806 timeout = addrconf_timeout_fixup(valid_lft, HZ);
807 if (addrconf_finite_timeout(timeout))
808 ifa->ifa_valid_lft = timeout;
810 ifa->ifa_flags |= IFA_F_PERMANENT;
812 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
813 if (addrconf_finite_timeout(timeout)) {
815 ifa->ifa_flags |= IFA_F_DEPRECATED;
816 ifa->ifa_preferred_lft = timeout;
818 ifa->ifa_tstamp = jiffies;
819 if (!ifa->ifa_cstamp)
820 ifa->ifa_cstamp = ifa->ifa_tstamp;
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)
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;
834 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
835 ifa_ipv4_policy, extack);
839 ifm = nlmsg_data(nlh);
841 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
844 dev = __dev_get_by_index(net, ifm->ifa_index);
849 in_dev = __in_dev_get_rtnl(dev);
854 ifa = inet_alloc_ifa();
857 * A potential indev allocation can be left alive, it stays
858 * assigned to its device and is destroy with it.
862 ipv4_devconf_setall(in_dev);
863 neigh_parms_data_state_setall(in_dev->arp_parms);
866 if (!tb[IFA_ADDRESS])
867 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
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]) :
874 ifa->ifa_scope = ifm->ifa_scope;
875 ifa->ifa_dev = in_dev;
877 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
878 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
880 if (tb[IFA_BROADCAST])
881 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
884 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
886 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
888 if (tb[IFA_RT_PRIORITY])
889 ifa->ifa_rt_priority = nla_get_u32(tb[IFA_RT_PRIORITY]);
891 if (tb[IFA_CACHEINFO]) {
892 struct ifa_cacheinfo *ci;
894 ci = nla_data(tb[IFA_CACHEINFO]);
895 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
899 *pvalid_lft = ci->ifa_valid;
900 *pprefered_lft = ci->ifa_prefered;
911 static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
913 struct in_device *in_dev = ifa->ifa_dev;
914 struct in_ifaddr *ifa1;
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)
928 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
929 struct netlink_ext_ack *extack)
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;
939 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft, extack);
943 ifa_existing = find_matching_ifa(ifa);
945 /* It would be best to check for !NLM_F_CREATE here but
946 * userspace already relies on not having to provide this.
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);
957 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid,
960 u32 new_metric = ifa->ifa_rt_priority;
964 if (nlh->nlmsg_flags & NLM_F_EXCL ||
965 !(nlh->nlmsg_flags & NLM_F_REPLACE))
969 if (ifa->ifa_rt_priority != new_metric) {
970 fib_modify_prefix_metric(ifa, new_metric);
971 ifa->ifa_rt_priority = new_metric;
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);
984 * Determine a default network mask, based on the IP address.
987 static int inet_abc_len(__be32 addr)
989 int rc = -1; /* Something else, probably a multicast. */
991 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
994 __u32 haddr = ntohl(addr);
995 if (IN_CLASSA(haddr))
997 else if (IN_CLASSB(haddr))
999 else if (IN_CLASSC(haddr))
1001 else if (IN_CLASSE(haddr))
1009 int devinet_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr)
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;
1019 int tryaddrmatch = 0;
1021 ifr->ifr_name[IFNAMSIZ - 1] = 0;
1023 /* save original address for comparison */
1024 memcpy(&sin_orig, sin, sizeof(*sin));
1026 colon = strchr(ifr->ifr_name, ':');
1030 dev_load(net, ifr->ifr_name);
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)
1041 tryaddrmatch = (sin_orig.sin_family == AF_INET);
1042 memset(sin, 0, sizeof(*sin));
1043 sin->sin_family = AF_INET;
1048 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
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 */
1056 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1059 if (sin->sin_family != AF_INET)
1070 dev = __dev_get_by_name(net, ifr->ifr_name);
1077 in_dev = __in_dev_get_rtnl(dev);
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. */
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 ==
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 */
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))
1108 ret = -EADDRNOTAVAIL;
1109 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
1113 case SIOCGIFADDR: /* Get interface address */
1115 sin->sin_addr.s_addr = ifa->ifa_local;
1118 case SIOCGIFBRDADDR: /* Get the broadcast address */
1120 sin->sin_addr.s_addr = ifa->ifa_broadcast;
1123 case SIOCGIFDSTADDR: /* Get the destination address */
1125 sin->sin_addr.s_addr = ifa->ifa_address;
1128 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1130 sin->sin_addr.s_addr = ifa->ifa_mask;
1135 ret = -EADDRNOTAVAIL;
1139 if (!(ifr->ifr_flags & IFF_UP))
1140 inet_del_ifa(in_dev, ifap, 1);
1143 ret = dev_change_flags(dev, ifr->ifr_flags, NULL);
1146 case SIOCSIFADDR: /* Set interface address (and family) */
1148 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1153 ifa = inet_alloc_ifa();
1156 INIT_HLIST_NODE(&ifa->hash);
1158 memcpy(ifa->ifa_label, ifr->ifr_name, IFNAMSIZ);
1160 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1163 if (ifa->ifa_local == sin->sin_addr.s_addr)
1165 inet_del_ifa(in_dev, ifap, 0);
1166 ifa->ifa_broadcast = 0;
1170 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
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 |
1180 ifa->ifa_prefixlen = 32;
1181 ifa->ifa_mask = inet_make_mask(32);
1183 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
1184 ret = inet_set_ifa(dev, ifa);
1187 case SIOCSIFBRDADDR: /* Set the broadcast address */
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);
1196 case SIOCSIFDSTADDR: /* Set the destination address */
1198 if (ifa->ifa_address == sin->sin_addr.s_addr)
1201 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1204 inet_del_ifa(in_dev, ifap, 0);
1205 ifa->ifa_address = sin->sin_addr.s_addr;
1206 inet_insert_ifa(ifa);
1209 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1212 * The mask we set must be legal.
1215 if (bad_mask(sin->sin_addr.s_addr, 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);
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...
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);
1237 inet_insert_ifa(ifa);
1247 static int inet_gifconf(struct net_device *dev, char __user *buf, int len, int size)
1249 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1250 const struct in_ifaddr *ifa;
1254 if (WARN_ON(size > sizeof(struct ifreq)))
1260 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1267 memset(&ifr, 0, sizeof(struct ifreq));
1268 strcpy(ifr.ifr_name, ifa->ifa_label);
1270 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1271 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1274 if (copy_to_user(buf + done, &ifr, size)) {
1285 static __be32 in_dev_select_addr(const struct in_device *in_dev,
1288 const struct in_ifaddr *ifa;
1290 in_dev_for_each_ifa_rcu(ifa, in_dev) {
1291 if (ifa->ifa_flags & IFA_F_SECONDARY)
1293 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1294 ifa->ifa_scope <= scope)
1295 return ifa->ifa_local;
1301 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
1303 const struct in_ifaddr *ifa;
1305 unsigned char localnet_scope = RT_SCOPE_HOST;
1306 struct in_device *in_dev;
1307 struct net *net = dev_net(dev);
1311 in_dev = __in_dev_get_rcu(dev);
1315 if (unlikely(IN_DEV_ROUTE_LOCALNET(in_dev)))
1316 localnet_scope = RT_SCOPE_LINK;
1318 in_dev_for_each_ifa_rcu(ifa, in_dev) {
1319 if (ifa->ifa_flags & IFA_F_SECONDARY)
1321 if (min(ifa->ifa_scope, localnet_scope) > scope)
1323 if (!dst || inet_ifa_match(dst, ifa)) {
1324 addr = ifa->ifa_local;
1328 addr = ifa->ifa_local;
1334 master_idx = l3mdev_master_ifindex_rcu(dev);
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.
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);
1349 /* Not loopback addresses on loopback should be preferred
1350 in this case. It is important that lo is the first interface
1353 for_each_netdev_rcu(net, dev) {
1354 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1357 in_dev = __in_dev_get_rcu(dev);
1361 addr = in_dev_select_addr(in_dev, scope);
1369 EXPORT_SYMBOL(inet_select_addr);
1371 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1372 __be32 local, int scope)
1374 unsigned char localnet_scope = RT_SCOPE_HOST;
1375 const struct in_ifaddr *ifa;
1379 if (unlikely(IN_DEV_ROUTE_LOCALNET(in_dev)))
1380 localnet_scope = RT_SCOPE_LINK;
1382 in_dev_for_each_ifa_rcu(ifa, in_dev) {
1383 unsigned char min_scope = min(ifa->ifa_scope, localnet_scope);
1386 (local == ifa->ifa_local || !local) &&
1387 min_scope <= scope) {
1388 addr = ifa->ifa_local;
1393 same = (!local || inet_ifa_match(local, ifa)) &&
1394 (!dst || inet_ifa_match(dst, ifa));
1398 /* Is the selected addr into dst subnet? */
1399 if (inet_ifa_match(addr, ifa))
1401 /* No, then can we use new local src? */
1402 if (min_scope <= scope) {
1403 addr = ifa->ifa_local;
1406 /* search for large dst subnet for addr */
1412 return same ? addr : 0;
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
1423 __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1424 __be32 dst, __be32 local, int scope)
1427 struct net_device *dev;
1430 return confirm_addr_indev(in_dev, dst, local, scope);
1433 for_each_netdev_rcu(net, dev) {
1434 in_dev = __in_dev_get_rcu(dev);
1436 addr = confirm_addr_indev(in_dev, dst, local, scope);
1445 EXPORT_SYMBOL(inet_confirm_addr);
1451 int register_inetaddr_notifier(struct notifier_block *nb)
1453 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1455 EXPORT_SYMBOL(register_inetaddr_notifier);
1457 int unregister_inetaddr_notifier(struct notifier_block *nb)
1459 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1461 EXPORT_SYMBOL(unregister_inetaddr_notifier);
1463 int register_inetaddr_validator_notifier(struct notifier_block *nb)
1465 return blocking_notifier_chain_register(&inetaddr_validator_chain, nb);
1467 EXPORT_SYMBOL(register_inetaddr_validator_notifier);
1469 int unregister_inetaddr_validator_notifier(struct notifier_block *nb)
1471 return blocking_notifier_chain_unregister(&inetaddr_validator_chain,
1474 EXPORT_SYMBOL(unregister_inetaddr_validator_notifier);
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.
1479 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1481 struct in_ifaddr *ifa;
1484 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1485 char old[IFNAMSIZ], *dot;
1487 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1488 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1491 dot = strchr(old, ':');
1493 sprintf(old, ":%d", named);
1496 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1497 strcat(ifa->ifa_label, dot);
1499 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1501 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1505 static void inetdev_send_gratuitous_arp(struct net_device *dev,
1506 struct in_device *in_dev)
1509 const struct in_ifaddr *ifa;
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);
1519 /* Called only under RTNL semaphore */
1521 static int inetdev_event(struct notifier_block *this, unsigned long event,
1524 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1525 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1530 if (event == NETDEV_REGISTER) {
1531 in_dev = inetdev_init(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);
1538 } else if (event == NETDEV_CHANGEMTU) {
1539 /* Re-enabling IP */
1540 if (inetdev_valid_mtu(dev->mtu))
1541 in_dev = inetdev_init(dev);
1547 case NETDEV_REGISTER:
1548 pr_debug("%s: bug\n", __func__);
1549 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1552 if (!inetdev_valid_mtu(dev->mtu))
1554 if (dev->flags & IFF_LOOPBACK) {
1555 struct in_ifaddr *ifa = inet_alloc_ifa();
1558 INIT_HLIST_NODE(&ifa->hash);
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);
1576 case NETDEV_CHANGEADDR:
1577 if (!IN_DEV_ARP_NOTIFY(in_dev))
1580 case NETDEV_NOTIFY_PEERS:
1581 /* Send gratuitous ARP to notify of link change */
1582 inetdev_send_gratuitous_arp(dev, in_dev);
1587 case NETDEV_PRE_TYPE_CHANGE:
1588 ip_mc_unmap(in_dev);
1590 case NETDEV_POST_TYPE_CHANGE:
1591 ip_mc_remap(in_dev);
1593 case NETDEV_CHANGEMTU:
1594 if (inetdev_valid_mtu(dev->mtu))
1596 /* disable IP when MTU is not enough */
1598 case NETDEV_UNREGISTER:
1599 inetdev_destroy(in_dev);
1601 case NETDEV_CHANGENAME:
1602 /* Do not notify about label change, this event is
1603 * not interesting to applications using netlink.
1605 inetdev_changename(dev, in_dev);
1607 devinet_sysctl_unregister(in_dev);
1608 devinet_sysctl_register(in_dev);
1615 static struct notifier_block ip_netdev_notifier = {
1616 .notifier_call = inetdev_event,
1619 static size_t inet_nlmsg_size(void)
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 */
1631 static inline u32 cstamp_delta(unsigned long cstamp)
1633 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1636 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1637 unsigned long tstamp, u32 preferred, u32 valid)
1639 struct ifa_cacheinfo ci;
1641 ci.cstamp = cstamp_delta(cstamp);
1642 ci.tstamp = cstamp_delta(tstamp);
1643 ci.ifa_prefered = preferred;
1644 ci.ifa_valid = valid;
1646 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1649 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1650 struct inet_fill_args *args)
1652 struct ifaddrmsg *ifm;
1653 struct nlmsghdr *nlh;
1654 u32 preferred, valid;
1656 nlh = nlmsg_put(skb, args->portid, args->seq, args->event, sizeof(*ifm),
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;
1668 if (args->netnsid >= 0 &&
1669 nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
1670 goto nla_put_failure;
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;
1678 if (preferred > tval)
1682 if (valid != INFINITY_LIFE_TIME) {
1690 preferred = INFINITY_LIFE_TIME;
1691 valid = INFINITY_LIFE_TIME;
1693 if ((ifa->ifa_address &&
1694 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
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,
1706 goto nla_put_failure;
1708 nlmsg_end(skb, nlh);
1712 nlmsg_cancel(skb, nlh);
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)
1721 struct netlink_ext_ack *extack = cb->extack;
1722 struct nlattr *tb[IFA_MAX+1];
1723 struct ifaddrmsg *ifm;
1726 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
1727 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for address dump request");
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");
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;
1743 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
1744 ifa_ipv4_policy, extack);
1748 for (i = 0; i <= IFA_MAX; ++i) {
1752 if (i == IFA_TARGET_NETNSID) {
1755 fillargs->netnsid = nla_get_s32(tb[i]);
1757 net = rtnl_get_net_ns_capable(sk, fillargs->netnsid);
1759 fillargs->netnsid = -1;
1760 NL_SET_ERR_MSG(extack, "ipv4: Invalid target network namespace id");
1761 return PTR_ERR(net);
1765 NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in dump request");
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)
1777 struct in_ifaddr *ifa;
1781 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1782 if (ip_idx < s_ip_idx) {
1786 err = inet_fill_ifaddr(skb, ifa, fillargs);
1790 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1796 cb->args[2] = ip_idx;
1801 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
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,
1811 struct net *net = sock_net(skb->sk);
1812 struct net *tgt_net = net;
1816 struct net_device *dev;
1817 struct in_device *in_dev;
1818 struct hlist_head *head;
1822 s_idx = idx = cb->args[1];
1823 s_ip_idx = cb->args[2];
1825 if (cb->strict_check) {
1826 err = inet_valid_dump_ifaddr_req(nlh, &fillargs, &tgt_net,
1832 if (fillargs.ifindex) {
1833 dev = __dev_get_by_index(tgt_net, fillargs.ifindex);
1839 in_dev = __in_dev_get_rtnl(dev);
1841 err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
1848 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1850 head = &tgt_net->dev_index_head[h];
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) {
1857 if (h > s_h || idx > s_idx)
1859 in_dev = __in_dev_get_rcu(dev);
1863 err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
1879 if (fillargs.netnsid >= 0)
1882 return skb->len ? : err;
1885 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1888 struct inet_fill_args fillargs = {
1890 .seq = nlh ? nlh->nlmsg_seq : 0,
1895 struct sk_buff *skb;
1899 net = dev_net(ifa->ifa_dev->dev);
1900 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1904 err = inet_fill_ifaddr(skb, ifa, &fillargs);
1906 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1907 WARN_ON(err == -EMSGSIZE);
1911 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1915 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1918 static size_t inet_get_link_af_size(const struct net_device *dev,
1919 u32 ext_filter_mask)
1921 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1926 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1929 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1930 u32 ext_filter_mask)
1932 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1939 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1943 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1944 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1949 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1950 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1953 static int inet_validate_link_af(const struct net_device *dev,
1954 const struct nlattr *nla)
1956 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1959 if (dev && !__in_dev_get_rcu(dev))
1960 return -EAFNOSUPPORT;
1962 err = nla_parse_nested_deprecated(tb, IFLA_INET_MAX, nla,
1963 inet_af_policy, NULL);
1967 if (tb[IFLA_INET_CONF]) {
1968 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1969 int cfgid = nla_type(a);
1974 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1982 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1984 struct in_device *in_dev = __in_dev_get_rcu(dev);
1985 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1989 return -EAFNOSUPPORT;
1991 if (nla_parse_nested_deprecated(tb, IFLA_INET_MAX, nla, NULL, NULL) < 0)
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));
2002 static int inet_netconf_msgsize_devconf(int type)
2004 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
2005 + nla_total_size(4); /* NETCONFA_IFINDEX */
2008 if (type == NETCONFA_ALL)
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);
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,
2032 struct nlmsghdr *nlh;
2033 struct netconfmsg *ncm;
2036 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
2041 if (type == NETCONFA_ALL)
2044 ncm = nlmsg_data(nlh);
2045 ncm->ncm_family = AF_INET;
2047 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
2048 goto nla_put_failure;
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;
2079 nlmsg_end(skb, nlh);
2083 nlmsg_cancel(skb, nlh);
2087 void inet_netconf_notify_devconf(struct net *net, int event, int type,
2088 int ifindex, struct ipv4_devconf *devconf)
2090 struct sk_buff *skb;
2093 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
2097 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
2100 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
2101 WARN_ON(err == -EMSGSIZE);
2105 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
2109 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
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) },
2120 static int inet_netconf_valid_get_req(struct sk_buff *skb,
2121 const struct nlmsghdr *nlh,
2123 struct netlink_ext_ack *extack)
2127 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(struct netconfmsg))) {
2128 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf get request");
2132 if (!netlink_strict_get_check(skb))
2133 return nlmsg_parse_deprecated(nlh, sizeof(struct netconfmsg),
2135 devconf_ipv4_policy, extack);
2137 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct netconfmsg),
2139 devconf_ipv4_policy, extack);
2143 for (i = 0; i <= NETCONFA_MAX; i++) {
2148 case NETCONFA_IFINDEX:
2151 NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in netconf get request");
2159 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
2160 struct nlmsghdr *nlh,
2161 struct netlink_ext_ack *extack)
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;
2172 err = inet_netconf_valid_get_req(in_skb, nlh, tb, extack);
2177 if (!tb[NETCONFA_IFINDEX])
2180 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
2182 case NETCONFA_IFINDEX_ALL:
2183 devconf = net->ipv4.devconf_all;
2185 case NETCONFA_IFINDEX_DEFAULT:
2186 devconf = net->ipv4.devconf_dflt;
2189 dev = __dev_get_by_index(net, ifindex);
2192 in_dev = __in_dev_get_rtnl(dev);
2195 devconf = &in_dev->cnf;
2200 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
2204 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
2205 NETLINK_CB(in_skb).portid,
2206 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
2209 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
2210 WARN_ON(err == -EMSGSIZE);
2214 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2219 static int inet_netconf_dump_devconf(struct sk_buff *skb,
2220 struct netlink_callback *cb)
2222 const struct nlmsghdr *nlh = cb->nlh;
2223 struct net *net = sock_net(skb->sk);
2226 struct net_device *dev;
2227 struct in_device *in_dev;
2228 struct hlist_head *head;
2230 if (cb->strict_check) {
2231 struct netlink_ext_ack *extack = cb->extack;
2232 struct netconfmsg *ncm;
2234 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ncm))) {
2235 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf dump request");
2239 if (nlmsg_attrlen(nlh, sizeof(*ncm))) {
2240 NL_SET_ERR_MSG(extack, "ipv4: Invalid data after header in netconf dump request");
2246 s_idx = idx = cb->args[1];
2248 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2250 head = &net->dev_index_head[h];
2252 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
2254 hlist_for_each_entry_rcu(dev, head, index_hlist) {
2257 in_dev = __in_dev_get_rcu(dev);
2261 if (inet_netconf_fill_devconf(skb, dev->ifindex,
2263 NETLINK_CB(cb->skb).portid,
2267 NETCONFA_ALL) < 0) {
2271 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
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,
2282 RTM_NEWNETCONF, NLM_F_MULTI,
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,
2293 RTM_NEWNETCONF, NLM_F_MULTI,
2306 #ifdef CONFIG_SYSCTL
2308 static void devinet_copy_dflt_conf(struct net *net, int i)
2310 struct net_device *dev;
2313 for_each_netdev_rcu(net, dev) {
2314 struct in_device *in_dev;
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];
2323 /* called with RTNL locked */
2324 static void inet_forward_change(struct net *net)
2326 struct net_device *dev;
2327 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
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);
2340 for_each_netdev(net, dev) {
2341 struct in_device *in_dev;
2344 dev_disable_lro(dev);
2346 in_dev = __in_dev_get_rtnl(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);
2356 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
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;
2363 struct in_device *idev
2364 = container_of(cnf, struct in_device, cnf);
2365 return idev->dev->ifindex;
2369 static int devinet_conf_proc(struct ctl_table *ctl, int write,
2370 void __user *buffer,
2371 size_t *lenp, loff_t *ppos)
2373 int old_value = *(int *)ctl->data;
2374 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2375 int new_value = *(int *)ctl->data;
2378 struct ipv4_devconf *cnf = ctl->extra1;
2379 struct net *net = ctl->extra2;
2380 int i = (int *)ctl->data - cnf->data;
2383 set_bit(i, cnf->state);
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);
2392 if (i == IPV4_DEVCONF_BC_FORWARDING - 1 &&
2393 new_value != old_value)
2394 rt_cache_flush(net);
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,
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,
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,
2422 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2423 void __user *buffer,
2424 size_t *lenp, loff_t *ppos)
2426 int *valp = ctl->data;
2429 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2431 if (write && *valp != val) {
2432 struct net *net = ctl->extra2;
2434 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2435 if (!rtnl_trylock()) {
2436 /* Restore the original values before restarting */
2439 return restart_syscall();
2441 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2442 inet_forward_change(net);
2444 struct ipv4_devconf *cnf = ctl->extra1;
2445 struct in_device *idev =
2446 container_of(cnf, struct in_device, cnf);
2448 dev_disable_lro(idev->dev);
2449 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2450 NETCONFA_FORWARDING,
2455 rt_cache_flush(net);
2457 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2458 NETCONFA_FORWARDING,
2459 NETCONFA_IFINDEX_DEFAULT,
2460 net->ipv4.devconf_dflt);
2466 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2467 void __user *buffer,
2468 size_t *lenp, loff_t *ppos)
2470 int *valp = ctl->data;
2472 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2473 struct net *net = ctl->extra2;
2475 if (write && *valp != val)
2476 rt_cache_flush(net);
2481 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2484 .data = ipv4_devconf.data + \
2485 IPV4_DEVCONF_ ## attr - 1, \
2486 .maxlen = sizeof(int), \
2488 .proc_handler = proc, \
2489 .extra1 = &ipv4_devconf, \
2492 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2493 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2495 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2496 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2498 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2499 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2501 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2502 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
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 = {
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"),
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"),
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,
2551 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2552 "drop_unicast_in_l2_multicast"),
2556 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2557 int ifindex, struct ipv4_devconf *p)
2560 struct devinet_sysctl_table *t;
2561 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2563 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
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;
2573 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2575 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2576 if (!t->sysctl_header)
2581 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
2591 static void __devinet_sysctl_unregister(struct net *net,
2592 struct ipv4_devconf *cnf, int ifindex)
2594 struct devinet_sysctl_table *t = cnf->sysctl;
2598 unregister_net_sysctl_table(t->sysctl_header);
2602 inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2605 static int devinet_sysctl_register(struct in_device *idev)
2609 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2612 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2615 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2616 idev->dev->ifindex, &idev->cnf);
2618 neigh_sysctl_unregister(idev->arp_parms);
2622 static void devinet_sysctl_unregister(struct in_device *idev)
2624 struct net *net = dev_net(idev->dev);
2626 __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2627 neigh_sysctl_unregister(idev->arp_parms);
2630 static struct ctl_table ctl_forward_entry[] = {
2632 .procname = "ip_forward",
2633 .data = &ipv4_devconf.data[
2634 IPV4_DEVCONF_FORWARDING - 1],
2635 .maxlen = sizeof(int),
2637 .proc_handler = devinet_sysctl_forward,
2638 .extra1 = &ipv4_devconf,
2639 .extra2 = &init_net,
2645 static __net_init int devinet_init_net(struct net *net)
2648 struct ipv4_devconf *all, *dflt;
2649 #ifdef CONFIG_SYSCTL
2650 struct ctl_table *tbl;
2651 struct ctl_table_header *forw_hdr;
2655 all = kmemdup(&ipv4_devconf, sizeof(ipv4_devconf), GFP_KERNEL);
2659 dflt = kmemdup(&ipv4_devconf_dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2661 goto err_alloc_dflt;
2663 #ifdef CONFIG_SYSCTL
2664 tbl = kmemdup(ctl_forward_entry, sizeof(ctl_forward_entry), GFP_KERNEL);
2668 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2669 tbl[0].extra1 = all;
2670 tbl[0].extra2 = net;
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));
2680 #ifdef CONFIG_SYSCTL
2681 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2685 err = __devinet_sysctl_register(net, "default",
2686 NETCONFA_IFINDEX_DEFAULT, dflt);
2691 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2694 net->ipv4.forw_hdr = forw_hdr;
2697 net->ipv4.devconf_all = all;
2698 net->ipv4.devconf_dflt = dflt;
2701 #ifdef CONFIG_SYSCTL
2703 __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2705 __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2717 static __net_exit void devinet_exit_net(struct net *net)
2719 #ifdef CONFIG_SYSCTL
2720 struct ctl_table *tbl;
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);
2730 kfree(net->ipv4.devconf_dflt);
2731 kfree(net->ipv4.devconf_all);
2734 static __net_initdata struct pernet_operations devinet_ops = {
2735 .init = devinet_init_net,
2736 .exit = devinet_exit_net,
2739 static struct rtnl_af_ops inet_af_ops __read_mostly = {
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,
2747 void __init devinet_init(void)
2751 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2752 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2754 register_pernet_subsys(&devinet_ops);
2756 register_gifconf(PF_INET, inet_gifconf);
2757 register_netdevice_notifier(&ip_netdev_notifier);
2759 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
2761 rtnl_af_register(&inet_af_ops);
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);