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);
283 ip_mc_init_dev(in_dev);
284 if (dev->flags & IFF_UP)
287 /* we can receive as soon as ip_ptr is set -- do this last */
288 rcu_assign_pointer(dev->ip_ptr, in_dev);
290 return in_dev ?: ERR_PTR(err);
297 static void in_dev_rcu_put(struct rcu_head *head)
299 struct in_device *idev = container_of(head, struct in_device, rcu_head);
303 static void inetdev_destroy(struct in_device *in_dev)
305 struct net_device *dev;
306 struct in_ifaddr *ifa;
314 ip_mc_destroy_dev(in_dev);
316 while ((ifa = rtnl_dereference(in_dev->ifa_list)) != NULL) {
317 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
321 RCU_INIT_POINTER(dev->ip_ptr, NULL);
323 devinet_sysctl_unregister(in_dev);
324 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
327 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
330 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
332 const struct in_ifaddr *ifa;
335 in_dev_for_each_ifa_rcu(ifa, in_dev) {
336 if (inet_ifa_match(a, ifa)) {
337 if (!b || inet_ifa_match(b, ifa)) {
347 static void __inet_del_ifa(struct in_device *in_dev,
348 struct in_ifaddr __rcu **ifap,
349 int destroy, struct nlmsghdr *nlh, u32 portid)
351 struct in_ifaddr *promote = NULL;
352 struct in_ifaddr *ifa, *ifa1;
353 struct in_ifaddr *last_prim;
354 struct in_ifaddr *prev_prom = NULL;
355 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
359 ifa1 = rtnl_dereference(*ifap);
360 last_prim = rtnl_dereference(in_dev->ifa_list);
364 /* 1. Deleting primary ifaddr forces deletion all secondaries
365 * unless alias promotion is set
368 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
369 struct in_ifaddr __rcu **ifap1 = &ifa1->ifa_next;
371 while ((ifa = rtnl_dereference(*ifap1)) != NULL) {
372 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
373 ifa1->ifa_scope <= ifa->ifa_scope)
376 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
377 ifa1->ifa_mask != ifa->ifa_mask ||
378 !inet_ifa_match(ifa1->ifa_address, ifa)) {
379 ifap1 = &ifa->ifa_next;
385 inet_hash_remove(ifa);
386 *ifap1 = ifa->ifa_next;
388 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
389 blocking_notifier_call_chain(&inetaddr_chain,
399 /* On promotion all secondaries from subnet are changing
400 * the primary IP, we must remove all their routes silently
401 * and later to add them back with new prefsrc. Do this
402 * while all addresses are on the device list.
404 for (ifa = promote; ifa; ifa = rtnl_dereference(ifa->ifa_next)) {
405 if (ifa1->ifa_mask == ifa->ifa_mask &&
406 inet_ifa_match(ifa1->ifa_address, ifa))
407 fib_del_ifaddr(ifa, ifa1);
413 *ifap = ifa1->ifa_next;
414 inet_hash_remove(ifa1);
416 /* 3. Announce address deletion */
418 /* Send message first, then call notifier.
419 At first sight, FIB update triggered by notifier
420 will refer to already deleted ifaddr, that could confuse
421 netlink listeners. It is not true: look, gated sees
422 that route deleted and if it still thinks that ifaddr
423 is valid, it will try to restore deleted routes... Grr.
424 So that, this order is correct.
426 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
427 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
430 struct in_ifaddr *next_sec;
432 next_sec = rtnl_dereference(promote->ifa_next);
434 struct in_ifaddr *last_sec;
436 rcu_assign_pointer(prev_prom->ifa_next, next_sec);
438 last_sec = rtnl_dereference(last_prim->ifa_next);
439 rcu_assign_pointer(promote->ifa_next, last_sec);
440 rcu_assign_pointer(last_prim->ifa_next, promote);
443 promote->ifa_flags &= ~IFA_F_SECONDARY;
444 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
445 blocking_notifier_call_chain(&inetaddr_chain,
447 for (ifa = next_sec; ifa;
448 ifa = rtnl_dereference(ifa->ifa_next)) {
449 if (ifa1->ifa_mask != ifa->ifa_mask ||
450 !inet_ifa_match(ifa1->ifa_address, ifa))
460 static void inet_del_ifa(struct in_device *in_dev,
461 struct in_ifaddr __rcu **ifap,
464 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
467 static void check_lifetime(struct work_struct *work);
469 static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
471 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
472 u32 portid, struct netlink_ext_ack *extack)
474 struct in_ifaddr __rcu **last_primary, **ifap;
475 struct in_device *in_dev = ifa->ifa_dev;
476 struct in_validator_info ivi;
477 struct in_ifaddr *ifa1;
482 if (!ifa->ifa_local) {
487 ifa->ifa_flags &= ~IFA_F_SECONDARY;
488 last_primary = &in_dev->ifa_list;
490 /* Don't set IPv6 only flags to IPv4 addresses */
491 ifa->ifa_flags &= ~IPV6ONLY_FLAGS;
493 ifap = &in_dev->ifa_list;
494 ifa1 = rtnl_dereference(*ifap);
497 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
498 ifa->ifa_scope <= ifa1->ifa_scope)
499 last_primary = &ifa1->ifa_next;
500 if (ifa1->ifa_mask == ifa->ifa_mask &&
501 inet_ifa_match(ifa1->ifa_address, ifa)) {
502 if (ifa1->ifa_local == ifa->ifa_local) {
506 if (ifa1->ifa_scope != ifa->ifa_scope) {
510 ifa->ifa_flags |= IFA_F_SECONDARY;
513 ifap = &ifa1->ifa_next;
514 ifa1 = rtnl_dereference(*ifap);
517 /* Allow any devices that wish to register ifaddr validtors to weigh
518 * in now, before changes are committed. The rntl lock is serializing
519 * access here, so the state should not change between a validator call
520 * and a final notify on commit. This isn't invoked on promotion under
521 * the assumption that validators are checking the address itself, and
524 ivi.ivi_addr = ifa->ifa_address;
525 ivi.ivi_dev = ifa->ifa_dev;
527 ret = blocking_notifier_call_chain(&inetaddr_validator_chain,
529 ret = notifier_to_errno(ret);
535 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
536 prandom_seed((__force u32) ifa->ifa_local);
540 rcu_assign_pointer(ifa->ifa_next, *ifap);
541 rcu_assign_pointer(*ifap, ifa);
543 inet_hash_insert(dev_net(in_dev->dev), ifa);
545 cancel_delayed_work(&check_lifetime_work);
546 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
548 /* Send message first, then call notifier.
549 Notifier will trigger FIB update, so that
550 listeners of netlink will know about new ifaddr */
551 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
552 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
557 static int inet_insert_ifa(struct in_ifaddr *ifa)
559 return __inet_insert_ifa(ifa, NULL, 0, NULL);
562 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
564 struct in_device *in_dev = __in_dev_get_rtnl(dev);
572 ipv4_devconf_setall(in_dev);
573 neigh_parms_data_state_setall(in_dev->arp_parms);
574 if (ifa->ifa_dev != in_dev) {
575 WARN_ON(ifa->ifa_dev);
577 ifa->ifa_dev = in_dev;
579 if (ipv4_is_loopback(ifa->ifa_local))
580 ifa->ifa_scope = RT_SCOPE_HOST;
581 return inet_insert_ifa(ifa);
584 /* Caller must hold RCU or RTNL :
585 * We dont take a reference on found in_device
587 struct in_device *inetdev_by_index(struct net *net, int ifindex)
589 struct net_device *dev;
590 struct in_device *in_dev = NULL;
593 dev = dev_get_by_index_rcu(net, ifindex);
595 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
599 EXPORT_SYMBOL(inetdev_by_index);
601 /* Called only from RTNL semaphored context. No locks. */
603 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
606 struct in_ifaddr *ifa;
610 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
611 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
617 static int ip_mc_config(struct sock *sk, bool join, const struct in_ifaddr *ifa)
619 struct ip_mreqn mreq = {
620 .imr_multiaddr.s_addr = ifa->ifa_address,
621 .imr_ifindex = ifa->ifa_dev->dev->ifindex,
629 ret = ip_mc_join_group(sk, &mreq);
631 ret = ip_mc_leave_group(sk, &mreq);
637 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
638 struct netlink_ext_ack *extack)
640 struct net *net = sock_net(skb->sk);
641 struct in_ifaddr __rcu **ifap;
642 struct nlattr *tb[IFA_MAX+1];
643 struct in_device *in_dev;
644 struct ifaddrmsg *ifm;
645 struct in_ifaddr *ifa;
651 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
652 ifa_ipv4_policy, extack);
656 ifm = nlmsg_data(nlh);
657 in_dev = inetdev_by_index(net, ifm->ifa_index);
663 for (ifap = &in_dev->ifa_list; (ifa = rtnl_dereference(*ifap)) != NULL;
664 ifap = &ifa->ifa_next) {
666 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
669 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
672 if (tb[IFA_ADDRESS] &&
673 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
674 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
677 if (ipv4_is_multicast(ifa->ifa_address))
678 ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
679 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
683 err = -EADDRNOTAVAIL;
688 #define INFINITY_LIFE_TIME 0xFFFFFFFF
690 static void check_lifetime(struct work_struct *work)
692 unsigned long now, next, next_sec, next_sched;
693 struct in_ifaddr *ifa;
694 struct hlist_node *n;
698 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
700 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
701 bool change_needed = false;
704 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
707 if (ifa->ifa_flags & IFA_F_PERMANENT)
710 /* We try to batch several events at once. */
711 age = (now - ifa->ifa_tstamp +
712 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
714 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
715 age >= ifa->ifa_valid_lft) {
716 change_needed = true;
717 } else if (ifa->ifa_preferred_lft ==
718 INFINITY_LIFE_TIME) {
720 } else if (age >= ifa->ifa_preferred_lft) {
721 if (time_before(ifa->ifa_tstamp +
722 ifa->ifa_valid_lft * HZ, next))
723 next = ifa->ifa_tstamp +
724 ifa->ifa_valid_lft * HZ;
726 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
727 change_needed = true;
728 } else if (time_before(ifa->ifa_tstamp +
729 ifa->ifa_preferred_lft * HZ,
731 next = ifa->ifa_tstamp +
732 ifa->ifa_preferred_lft * HZ;
739 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
742 if (ifa->ifa_flags & IFA_F_PERMANENT)
745 /* We try to batch several events at once. */
746 age = (now - ifa->ifa_tstamp +
747 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
749 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
750 age >= ifa->ifa_valid_lft) {
751 struct in_ifaddr __rcu **ifap;
752 struct in_ifaddr *tmp;
754 ifap = &ifa->ifa_dev->ifa_list;
755 tmp = rtnl_dereference(*ifap);
758 inet_del_ifa(ifa->ifa_dev,
762 ifap = &tmp->ifa_next;
763 tmp = rtnl_dereference(*ifap);
765 } else if (ifa->ifa_preferred_lft !=
766 INFINITY_LIFE_TIME &&
767 age >= ifa->ifa_preferred_lft &&
768 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
769 ifa->ifa_flags |= IFA_F_DEPRECATED;
770 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
776 next_sec = round_jiffies_up(next);
779 /* If rounded timeout is accurate enough, accept it. */
780 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
781 next_sched = next_sec;
784 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
785 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
786 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
788 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
792 static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
795 unsigned long timeout;
797 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
799 timeout = addrconf_timeout_fixup(valid_lft, HZ);
800 if (addrconf_finite_timeout(timeout))
801 ifa->ifa_valid_lft = timeout;
803 ifa->ifa_flags |= IFA_F_PERMANENT;
805 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
806 if (addrconf_finite_timeout(timeout)) {
808 ifa->ifa_flags |= IFA_F_DEPRECATED;
809 ifa->ifa_preferred_lft = timeout;
811 ifa->ifa_tstamp = jiffies;
812 if (!ifa->ifa_cstamp)
813 ifa->ifa_cstamp = ifa->ifa_tstamp;
816 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
817 __u32 *pvalid_lft, __u32 *pprefered_lft,
818 struct netlink_ext_ack *extack)
820 struct nlattr *tb[IFA_MAX+1];
821 struct in_ifaddr *ifa;
822 struct ifaddrmsg *ifm;
823 struct net_device *dev;
824 struct in_device *in_dev;
827 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
828 ifa_ipv4_policy, extack);
832 ifm = nlmsg_data(nlh);
834 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
837 dev = __dev_get_by_index(net, ifm->ifa_index);
842 in_dev = __in_dev_get_rtnl(dev);
847 ifa = inet_alloc_ifa();
850 * A potential indev allocation can be left alive, it stays
851 * assigned to its device and is destroy with it.
855 ipv4_devconf_setall(in_dev);
856 neigh_parms_data_state_setall(in_dev->arp_parms);
859 if (!tb[IFA_ADDRESS])
860 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
862 INIT_HLIST_NODE(&ifa->hash);
863 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
864 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
865 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
867 ifa->ifa_scope = ifm->ifa_scope;
868 ifa->ifa_dev = in_dev;
870 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
871 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
873 if (tb[IFA_BROADCAST])
874 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
877 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
879 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
881 if (tb[IFA_RT_PRIORITY])
882 ifa->ifa_rt_priority = nla_get_u32(tb[IFA_RT_PRIORITY]);
884 if (tb[IFA_CACHEINFO]) {
885 struct ifa_cacheinfo *ci;
887 ci = nla_data(tb[IFA_CACHEINFO]);
888 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
892 *pvalid_lft = ci->ifa_valid;
893 *pprefered_lft = ci->ifa_prefered;
904 static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
906 struct in_device *in_dev = ifa->ifa_dev;
907 struct in_ifaddr *ifa1;
912 in_dev_for_each_ifa_rtnl(ifa1, in_dev) {
913 if (ifa1->ifa_mask == ifa->ifa_mask &&
914 inet_ifa_match(ifa1->ifa_address, ifa) &&
915 ifa1->ifa_local == ifa->ifa_local)
921 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
922 struct netlink_ext_ack *extack)
924 struct net *net = sock_net(skb->sk);
925 struct in_ifaddr *ifa;
926 struct in_ifaddr *ifa_existing;
927 __u32 valid_lft = INFINITY_LIFE_TIME;
928 __u32 prefered_lft = INFINITY_LIFE_TIME;
932 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft, extack);
936 ifa_existing = find_matching_ifa(ifa);
938 /* It would be best to check for !NLM_F_CREATE here but
939 * userspace already relies on not having to provide this.
941 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
942 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
943 int ret = ip_mc_config(net->ipv4.mc_autojoin_sk,
951 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid,
954 u32 new_metric = ifa->ifa_rt_priority;
958 if (nlh->nlmsg_flags & NLM_F_EXCL ||
959 !(nlh->nlmsg_flags & NLM_F_REPLACE))
963 if (ifa->ifa_rt_priority != new_metric) {
964 fib_modify_prefix_metric(ifa, new_metric);
965 ifa->ifa_rt_priority = new_metric;
968 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
969 cancel_delayed_work(&check_lifetime_work);
970 queue_delayed_work(system_power_efficient_wq,
971 &check_lifetime_work, 0);
972 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
978 * Determine a default network mask, based on the IP address.
981 static int inet_abc_len(__be32 addr)
983 int rc = -1; /* Something else, probably a multicast. */
985 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
988 __u32 haddr = ntohl(addr);
989 if (IN_CLASSA(haddr))
991 else if (IN_CLASSB(haddr))
993 else if (IN_CLASSC(haddr))
995 else if (IN_CLASSE(haddr))
1003 int devinet_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr)
1005 struct sockaddr_in sin_orig;
1006 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr->ifr_addr;
1007 struct in_ifaddr __rcu **ifap = NULL;
1008 struct in_device *in_dev;
1009 struct in_ifaddr *ifa = NULL;
1010 struct net_device *dev;
1013 int tryaddrmatch = 0;
1015 ifr->ifr_name[IFNAMSIZ - 1] = 0;
1017 /* save original address for comparison */
1018 memcpy(&sin_orig, sin, sizeof(*sin));
1020 colon = strchr(ifr->ifr_name, ':');
1024 dev_load(net, ifr->ifr_name);
1027 case SIOCGIFADDR: /* Get interface address */
1028 case SIOCGIFBRDADDR: /* Get the broadcast address */
1029 case SIOCGIFDSTADDR: /* Get the destination address */
1030 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1031 /* Note that these ioctls will not sleep,
1032 so that we do not impose a lock.
1033 One day we will be forced to put shlock here (I mean SMP)
1035 tryaddrmatch = (sin_orig.sin_family == AF_INET);
1036 memset(sin, 0, sizeof(*sin));
1037 sin->sin_family = AF_INET;
1042 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1045 case SIOCSIFADDR: /* Set interface address (and family) */
1046 case SIOCSIFBRDADDR: /* Set the broadcast address */
1047 case SIOCSIFDSTADDR: /* Set the destination address */
1048 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1050 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1053 if (sin->sin_family != AF_INET)
1064 dev = __dev_get_by_name(net, ifr->ifr_name);
1071 in_dev = __in_dev_get_rtnl(dev);
1074 /* Matthias Andree */
1075 /* compare label and address (4.4BSD style) */
1076 /* note: we only do this for a limited set of ioctls
1077 and only if the original address family was AF_INET.
1078 This is checked above. */
1080 for (ifap = &in_dev->ifa_list;
1081 (ifa = rtnl_dereference(*ifap)) != NULL;
1082 ifap = &ifa->ifa_next) {
1083 if (!strcmp(ifr->ifr_name, ifa->ifa_label) &&
1084 sin_orig.sin_addr.s_addr ==
1090 /* we didn't get a match, maybe the application is
1091 4.3BSD-style and passed in junk so we fall back to
1092 comparing just the label */
1094 for (ifap = &in_dev->ifa_list;
1095 (ifa = rtnl_dereference(*ifap)) != NULL;
1096 ifap = &ifa->ifa_next)
1097 if (!strcmp(ifr->ifr_name, ifa->ifa_label))
1102 ret = -EADDRNOTAVAIL;
1103 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
1107 case SIOCGIFADDR: /* Get interface address */
1109 sin->sin_addr.s_addr = ifa->ifa_local;
1112 case SIOCGIFBRDADDR: /* Get the broadcast address */
1114 sin->sin_addr.s_addr = ifa->ifa_broadcast;
1117 case SIOCGIFDSTADDR: /* Get the destination address */
1119 sin->sin_addr.s_addr = ifa->ifa_address;
1122 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1124 sin->sin_addr.s_addr = ifa->ifa_mask;
1129 ret = -EADDRNOTAVAIL;
1133 if (!(ifr->ifr_flags & IFF_UP))
1134 inet_del_ifa(in_dev, ifap, 1);
1137 ret = dev_change_flags(dev, ifr->ifr_flags, NULL);
1140 case SIOCSIFADDR: /* Set interface address (and family) */
1142 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1147 ifa = inet_alloc_ifa();
1150 INIT_HLIST_NODE(&ifa->hash);
1152 memcpy(ifa->ifa_label, ifr->ifr_name, IFNAMSIZ);
1154 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1157 if (ifa->ifa_local == sin->sin_addr.s_addr)
1159 inet_del_ifa(in_dev, ifap, 0);
1160 ifa->ifa_broadcast = 0;
1164 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1166 if (!(dev->flags & IFF_POINTOPOINT)) {
1167 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1168 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1169 if ((dev->flags & IFF_BROADCAST) &&
1170 ifa->ifa_prefixlen < 31)
1171 ifa->ifa_broadcast = ifa->ifa_address |
1174 ifa->ifa_prefixlen = 32;
1175 ifa->ifa_mask = inet_make_mask(32);
1177 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
1178 ret = inet_set_ifa(dev, ifa);
1181 case SIOCSIFBRDADDR: /* Set the broadcast address */
1183 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1184 inet_del_ifa(in_dev, ifap, 0);
1185 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1186 inet_insert_ifa(ifa);
1190 case SIOCSIFDSTADDR: /* Set the destination address */
1192 if (ifa->ifa_address == sin->sin_addr.s_addr)
1195 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1198 inet_del_ifa(in_dev, ifap, 0);
1199 ifa->ifa_address = sin->sin_addr.s_addr;
1200 inet_insert_ifa(ifa);
1203 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1206 * The mask we set must be legal.
1209 if (bad_mask(sin->sin_addr.s_addr, 0))
1212 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
1213 __be32 old_mask = ifa->ifa_mask;
1214 inet_del_ifa(in_dev, ifap, 0);
1215 ifa->ifa_mask = sin->sin_addr.s_addr;
1216 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1218 /* See if current broadcast address matches
1219 * with current netmask, then recalculate
1220 * the broadcast address. Otherwise it's a
1221 * funny address, so don't touch it since
1222 * the user seems to know what (s)he's doing...
1224 if ((dev->flags & IFF_BROADCAST) &&
1225 (ifa->ifa_prefixlen < 31) &&
1226 (ifa->ifa_broadcast ==
1227 (ifa->ifa_local|~old_mask))) {
1228 ifa->ifa_broadcast = (ifa->ifa_local |
1229 ~sin->sin_addr.s_addr);
1231 inet_insert_ifa(ifa);
1241 static int inet_gifconf(struct net_device *dev, char __user *buf, int len, int size)
1243 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1244 const struct in_ifaddr *ifa;
1248 if (WARN_ON(size > sizeof(struct ifreq)))
1254 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1261 memset(&ifr, 0, sizeof(struct ifreq));
1262 strcpy(ifr.ifr_name, ifa->ifa_label);
1264 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1265 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1268 if (copy_to_user(buf + done, &ifr, size)) {
1279 static __be32 in_dev_select_addr(const struct in_device *in_dev,
1282 const struct in_ifaddr *ifa;
1284 in_dev_for_each_ifa_rcu(ifa, in_dev) {
1285 if (ifa->ifa_flags & IFA_F_SECONDARY)
1287 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1288 ifa->ifa_scope <= scope)
1289 return ifa->ifa_local;
1295 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
1297 const struct in_ifaddr *ifa;
1299 unsigned char localnet_scope = RT_SCOPE_HOST;
1300 struct in_device *in_dev;
1301 struct net *net = dev_net(dev);
1305 in_dev = __in_dev_get_rcu(dev);
1309 if (unlikely(IN_DEV_ROUTE_LOCALNET(in_dev)))
1310 localnet_scope = RT_SCOPE_LINK;
1312 in_dev_for_each_ifa_rcu(ifa, in_dev) {
1313 if (ifa->ifa_flags & IFA_F_SECONDARY)
1315 if (min(ifa->ifa_scope, localnet_scope) > scope)
1317 if (!dst || inet_ifa_match(dst, ifa)) {
1318 addr = ifa->ifa_local;
1322 addr = ifa->ifa_local;
1328 master_idx = l3mdev_master_ifindex_rcu(dev);
1330 /* For VRFs, the VRF device takes the place of the loopback device,
1331 * with addresses on it being preferred. Note in such cases the
1332 * loopback device will be among the devices that fail the master_idx
1333 * equality check in the loop below.
1336 (dev = dev_get_by_index_rcu(net, master_idx)) &&
1337 (in_dev = __in_dev_get_rcu(dev))) {
1338 addr = in_dev_select_addr(in_dev, scope);
1343 /* Not loopback addresses on loopback should be preferred
1344 in this case. It is important that lo is the first interface
1347 for_each_netdev_rcu(net, dev) {
1348 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1351 in_dev = __in_dev_get_rcu(dev);
1355 addr = in_dev_select_addr(in_dev, scope);
1363 EXPORT_SYMBOL(inet_select_addr);
1365 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1366 __be32 local, int scope)
1368 unsigned char localnet_scope = RT_SCOPE_HOST;
1369 const struct in_ifaddr *ifa;
1373 if (unlikely(IN_DEV_ROUTE_LOCALNET(in_dev)))
1374 localnet_scope = RT_SCOPE_LINK;
1376 in_dev_for_each_ifa_rcu(ifa, in_dev) {
1377 unsigned char min_scope = min(ifa->ifa_scope, localnet_scope);
1380 (local == ifa->ifa_local || !local) &&
1381 min_scope <= scope) {
1382 addr = ifa->ifa_local;
1387 same = (!local || inet_ifa_match(local, ifa)) &&
1388 (!dst || inet_ifa_match(dst, ifa));
1392 /* Is the selected addr into dst subnet? */
1393 if (inet_ifa_match(addr, ifa))
1395 /* No, then can we use new local src? */
1396 if (min_scope <= scope) {
1397 addr = ifa->ifa_local;
1400 /* search for large dst subnet for addr */
1406 return same ? addr : 0;
1410 * Confirm that local IP address exists using wildcards:
1411 * - net: netns to check, cannot be NULL
1412 * - in_dev: only on this interface, NULL=any interface
1413 * - dst: only in the same subnet as dst, 0=any dst
1414 * - local: address, 0=autoselect the local address
1415 * - scope: maximum allowed scope value for the local address
1417 __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1418 __be32 dst, __be32 local, int scope)
1421 struct net_device *dev;
1424 return confirm_addr_indev(in_dev, dst, local, scope);
1427 for_each_netdev_rcu(net, dev) {
1428 in_dev = __in_dev_get_rcu(dev);
1430 addr = confirm_addr_indev(in_dev, dst, local, scope);
1439 EXPORT_SYMBOL(inet_confirm_addr);
1445 int register_inetaddr_notifier(struct notifier_block *nb)
1447 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1449 EXPORT_SYMBOL(register_inetaddr_notifier);
1451 int unregister_inetaddr_notifier(struct notifier_block *nb)
1453 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1455 EXPORT_SYMBOL(unregister_inetaddr_notifier);
1457 int register_inetaddr_validator_notifier(struct notifier_block *nb)
1459 return blocking_notifier_chain_register(&inetaddr_validator_chain, nb);
1461 EXPORT_SYMBOL(register_inetaddr_validator_notifier);
1463 int unregister_inetaddr_validator_notifier(struct notifier_block *nb)
1465 return blocking_notifier_chain_unregister(&inetaddr_validator_chain,
1468 EXPORT_SYMBOL(unregister_inetaddr_validator_notifier);
1470 /* Rename ifa_labels for a device name change. Make some effort to preserve
1471 * existing alias numbering and to create unique labels if possible.
1473 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1475 struct in_ifaddr *ifa;
1478 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1479 char old[IFNAMSIZ], *dot;
1481 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1482 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1485 dot = strchr(old, ':');
1487 sprintf(old, ":%d", named);
1490 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1491 strcat(ifa->ifa_label, dot);
1493 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1495 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1499 static bool inetdev_valid_mtu(unsigned int mtu)
1501 return mtu >= IPV4_MIN_MTU;
1504 static void inetdev_send_gratuitous_arp(struct net_device *dev,
1505 struct in_device *in_dev)
1508 const struct in_ifaddr *ifa;
1510 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1511 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1512 ifa->ifa_local, dev,
1513 ifa->ifa_local, NULL,
1514 dev->dev_addr, NULL);
1518 /* Called only under RTNL semaphore */
1520 static int inetdev_event(struct notifier_block *this, unsigned long event,
1523 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1524 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1529 if (event == NETDEV_REGISTER) {
1530 in_dev = inetdev_init(dev);
1532 return notifier_from_errno(PTR_ERR(in_dev));
1533 if (dev->flags & IFF_LOOPBACK) {
1534 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1535 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1537 } else if (event == NETDEV_CHANGEMTU) {
1538 /* Re-enabling IP */
1539 if (inetdev_valid_mtu(dev->mtu))
1540 in_dev = inetdev_init(dev);
1546 case NETDEV_REGISTER:
1547 pr_debug("%s: bug\n", __func__);
1548 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1551 if (!inetdev_valid_mtu(dev->mtu))
1553 if (dev->flags & IFF_LOOPBACK) {
1554 struct in_ifaddr *ifa = inet_alloc_ifa();
1557 INIT_HLIST_NODE(&ifa->hash);
1559 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1560 ifa->ifa_prefixlen = 8;
1561 ifa->ifa_mask = inet_make_mask(8);
1562 in_dev_hold(in_dev);
1563 ifa->ifa_dev = in_dev;
1564 ifa->ifa_scope = RT_SCOPE_HOST;
1565 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1566 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1567 INFINITY_LIFE_TIME);
1568 ipv4_devconf_setall(in_dev);
1569 neigh_parms_data_state_setall(in_dev->arp_parms);
1570 inet_insert_ifa(ifa);
1575 case NETDEV_CHANGEADDR:
1576 if (!IN_DEV_ARP_NOTIFY(in_dev))
1579 case NETDEV_NOTIFY_PEERS:
1580 /* Send gratuitous ARP to notify of link change */
1581 inetdev_send_gratuitous_arp(dev, in_dev);
1586 case NETDEV_PRE_TYPE_CHANGE:
1587 ip_mc_unmap(in_dev);
1589 case NETDEV_POST_TYPE_CHANGE:
1590 ip_mc_remap(in_dev);
1592 case NETDEV_CHANGEMTU:
1593 if (inetdev_valid_mtu(dev->mtu))
1595 /* disable IP when MTU is not enough */
1597 case NETDEV_UNREGISTER:
1598 inetdev_destroy(in_dev);
1600 case NETDEV_CHANGENAME:
1601 /* Do not notify about label change, this event is
1602 * not interesting to applications using netlink.
1604 inetdev_changename(dev, in_dev);
1606 devinet_sysctl_unregister(in_dev);
1607 devinet_sysctl_register(in_dev);
1614 static struct notifier_block ip_netdev_notifier = {
1615 .notifier_call = inetdev_event,
1618 static size_t inet_nlmsg_size(void)
1620 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1621 + nla_total_size(4) /* IFA_ADDRESS */
1622 + nla_total_size(4) /* IFA_LOCAL */
1623 + nla_total_size(4) /* IFA_BROADCAST */
1624 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1625 + nla_total_size(4) /* IFA_FLAGS */
1626 + nla_total_size(4) /* IFA_RT_PRIORITY */
1627 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1630 static inline u32 cstamp_delta(unsigned long cstamp)
1632 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1635 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1636 unsigned long tstamp, u32 preferred, u32 valid)
1638 struct ifa_cacheinfo ci;
1640 ci.cstamp = cstamp_delta(cstamp);
1641 ci.tstamp = cstamp_delta(tstamp);
1642 ci.ifa_prefered = preferred;
1643 ci.ifa_valid = valid;
1645 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1648 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1649 struct inet_fill_args *args)
1651 struct ifaddrmsg *ifm;
1652 struct nlmsghdr *nlh;
1653 u32 preferred, valid;
1655 nlh = nlmsg_put(skb, args->portid, args->seq, args->event, sizeof(*ifm),
1660 ifm = nlmsg_data(nlh);
1661 ifm->ifa_family = AF_INET;
1662 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1663 ifm->ifa_flags = ifa->ifa_flags;
1664 ifm->ifa_scope = ifa->ifa_scope;
1665 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1667 if (args->netnsid >= 0 &&
1668 nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
1669 goto nla_put_failure;
1671 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1672 preferred = ifa->ifa_preferred_lft;
1673 valid = ifa->ifa_valid_lft;
1674 if (preferred != INFINITY_LIFE_TIME) {
1675 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1677 if (preferred > tval)
1681 if (valid != INFINITY_LIFE_TIME) {
1689 preferred = INFINITY_LIFE_TIME;
1690 valid = INFINITY_LIFE_TIME;
1692 if ((ifa->ifa_address &&
1693 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1695 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
1696 (ifa->ifa_broadcast &&
1697 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1698 (ifa->ifa_label[0] &&
1699 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1700 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
1701 (ifa->ifa_rt_priority &&
1702 nla_put_u32(skb, IFA_RT_PRIORITY, ifa->ifa_rt_priority)) ||
1703 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1705 goto nla_put_failure;
1707 nlmsg_end(skb, nlh);
1711 nlmsg_cancel(skb, nlh);
1715 static int inet_valid_dump_ifaddr_req(const struct nlmsghdr *nlh,
1716 struct inet_fill_args *fillargs,
1717 struct net **tgt_net, struct sock *sk,
1718 struct netlink_callback *cb)
1720 struct netlink_ext_ack *extack = cb->extack;
1721 struct nlattr *tb[IFA_MAX+1];
1722 struct ifaddrmsg *ifm;
1725 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
1726 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for address dump request");
1730 ifm = nlmsg_data(nlh);
1731 if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
1732 NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for address dump request");
1736 fillargs->ifindex = ifm->ifa_index;
1737 if (fillargs->ifindex) {
1738 cb->answer_flags |= NLM_F_DUMP_FILTERED;
1739 fillargs->flags |= NLM_F_DUMP_FILTERED;
1742 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
1743 ifa_ipv4_policy, extack);
1747 for (i = 0; i <= IFA_MAX; ++i) {
1751 if (i == IFA_TARGET_NETNSID) {
1754 fillargs->netnsid = nla_get_s32(tb[i]);
1756 net = rtnl_get_net_ns_capable(sk, fillargs->netnsid);
1758 fillargs->netnsid = -1;
1759 NL_SET_ERR_MSG(extack, "ipv4: Invalid target network namespace id");
1760 return PTR_ERR(net);
1764 NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in dump request");
1772 static int in_dev_dump_addr(struct in_device *in_dev, struct sk_buff *skb,
1773 struct netlink_callback *cb, int s_ip_idx,
1774 struct inet_fill_args *fillargs)
1776 struct in_ifaddr *ifa;
1780 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1781 if (ip_idx < s_ip_idx) {
1785 err = inet_fill_ifaddr(skb, ifa, fillargs);
1789 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1795 cb->args[2] = ip_idx;
1800 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1802 const struct nlmsghdr *nlh = cb->nlh;
1803 struct inet_fill_args fillargs = {
1804 .portid = NETLINK_CB(cb->skb).portid,
1805 .seq = nlh->nlmsg_seq,
1806 .event = RTM_NEWADDR,
1807 .flags = NLM_F_MULTI,
1810 struct net *net = sock_net(skb->sk);
1811 struct net *tgt_net = net;
1815 struct net_device *dev;
1816 struct in_device *in_dev;
1817 struct hlist_head *head;
1821 s_idx = idx = cb->args[1];
1822 s_ip_idx = cb->args[2];
1824 if (cb->strict_check) {
1825 err = inet_valid_dump_ifaddr_req(nlh, &fillargs, &tgt_net,
1831 if (fillargs.ifindex) {
1832 dev = __dev_get_by_index(tgt_net, fillargs.ifindex);
1838 in_dev = __in_dev_get_rtnl(dev);
1840 err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
1847 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1849 head = &tgt_net->dev_index_head[h];
1851 cb->seq = atomic_read(&tgt_net->ipv4.dev_addr_genid) ^
1852 tgt_net->dev_base_seq;
1853 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1856 if (h > s_h || idx > s_idx)
1858 in_dev = __in_dev_get_rcu(dev);
1862 err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
1878 if (fillargs.netnsid >= 0)
1881 return skb->len ? : err;
1884 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1887 struct inet_fill_args fillargs = {
1889 .seq = nlh ? nlh->nlmsg_seq : 0,
1894 struct sk_buff *skb;
1898 net = dev_net(ifa->ifa_dev->dev);
1899 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1903 err = inet_fill_ifaddr(skb, ifa, &fillargs);
1905 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1906 WARN_ON(err == -EMSGSIZE);
1910 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1914 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1917 static size_t inet_get_link_af_size(const struct net_device *dev,
1918 u32 ext_filter_mask)
1920 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1925 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1928 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1929 u32 ext_filter_mask)
1931 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1938 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1942 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1943 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1948 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1949 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1952 static int inet_validate_link_af(const struct net_device *dev,
1953 const struct nlattr *nla)
1955 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1958 if (dev && !__in_dev_get_rcu(dev))
1959 return -EAFNOSUPPORT;
1961 err = nla_parse_nested_deprecated(tb, IFLA_INET_MAX, nla,
1962 inet_af_policy, NULL);
1966 if (tb[IFLA_INET_CONF]) {
1967 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1968 int cfgid = nla_type(a);
1973 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1981 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1983 struct in_device *in_dev = __in_dev_get_rcu(dev);
1984 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1988 return -EAFNOSUPPORT;
1990 if (nla_parse_nested_deprecated(tb, IFLA_INET_MAX, nla, NULL, NULL) < 0)
1993 if (tb[IFLA_INET_CONF]) {
1994 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1995 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
2001 static int inet_netconf_msgsize_devconf(int type)
2003 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
2004 + nla_total_size(4); /* NETCONFA_IFINDEX */
2007 if (type == NETCONFA_ALL)
2010 if (all || type == NETCONFA_FORWARDING)
2011 size += nla_total_size(4);
2012 if (all || type == NETCONFA_RP_FILTER)
2013 size += nla_total_size(4);
2014 if (all || type == NETCONFA_MC_FORWARDING)
2015 size += nla_total_size(4);
2016 if (all || type == NETCONFA_BC_FORWARDING)
2017 size += nla_total_size(4);
2018 if (all || type == NETCONFA_PROXY_NEIGH)
2019 size += nla_total_size(4);
2020 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
2021 size += nla_total_size(4);
2026 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
2027 struct ipv4_devconf *devconf, u32 portid,
2028 u32 seq, int event, unsigned int flags,
2031 struct nlmsghdr *nlh;
2032 struct netconfmsg *ncm;
2035 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
2040 if (type == NETCONFA_ALL)
2043 ncm = nlmsg_data(nlh);
2044 ncm->ncm_family = AF_INET;
2046 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
2047 goto nla_put_failure;
2052 if ((all || type == NETCONFA_FORWARDING) &&
2053 nla_put_s32(skb, NETCONFA_FORWARDING,
2054 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
2055 goto nla_put_failure;
2056 if ((all || type == NETCONFA_RP_FILTER) &&
2057 nla_put_s32(skb, NETCONFA_RP_FILTER,
2058 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
2059 goto nla_put_failure;
2060 if ((all || type == NETCONFA_MC_FORWARDING) &&
2061 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
2062 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
2063 goto nla_put_failure;
2064 if ((all || type == NETCONFA_BC_FORWARDING) &&
2065 nla_put_s32(skb, NETCONFA_BC_FORWARDING,
2066 IPV4_DEVCONF(*devconf, BC_FORWARDING)) < 0)
2067 goto nla_put_failure;
2068 if ((all || type == NETCONFA_PROXY_NEIGH) &&
2069 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
2070 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
2071 goto nla_put_failure;
2072 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
2073 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2074 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
2075 goto nla_put_failure;
2078 nlmsg_end(skb, nlh);
2082 nlmsg_cancel(skb, nlh);
2086 void inet_netconf_notify_devconf(struct net *net, int event, int type,
2087 int ifindex, struct ipv4_devconf *devconf)
2089 struct sk_buff *skb;
2092 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
2096 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
2099 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
2100 WARN_ON(err == -EMSGSIZE);
2104 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
2108 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
2111 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
2112 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
2113 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
2114 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
2115 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
2116 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
2119 static int inet_netconf_valid_get_req(struct sk_buff *skb,
2120 const struct nlmsghdr *nlh,
2122 struct netlink_ext_ack *extack)
2126 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(struct netconfmsg))) {
2127 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf get request");
2131 if (!netlink_strict_get_check(skb))
2132 return nlmsg_parse_deprecated(nlh, sizeof(struct netconfmsg),
2134 devconf_ipv4_policy, extack);
2136 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct netconfmsg),
2138 devconf_ipv4_policy, extack);
2142 for (i = 0; i <= NETCONFA_MAX; i++) {
2147 case NETCONFA_IFINDEX:
2150 NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in netconf get request");
2158 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
2159 struct nlmsghdr *nlh,
2160 struct netlink_ext_ack *extack)
2162 struct net *net = sock_net(in_skb->sk);
2163 struct nlattr *tb[NETCONFA_MAX+1];
2164 struct sk_buff *skb;
2165 struct ipv4_devconf *devconf;
2166 struct in_device *in_dev;
2167 struct net_device *dev;
2171 err = inet_netconf_valid_get_req(in_skb, nlh, tb, extack);
2176 if (!tb[NETCONFA_IFINDEX])
2179 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
2181 case NETCONFA_IFINDEX_ALL:
2182 devconf = net->ipv4.devconf_all;
2184 case NETCONFA_IFINDEX_DEFAULT:
2185 devconf = net->ipv4.devconf_dflt;
2188 dev = __dev_get_by_index(net, ifindex);
2191 in_dev = __in_dev_get_rtnl(dev);
2194 devconf = &in_dev->cnf;
2199 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
2203 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
2204 NETLINK_CB(in_skb).portid,
2205 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
2208 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
2209 WARN_ON(err == -EMSGSIZE);
2213 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2218 static int inet_netconf_dump_devconf(struct sk_buff *skb,
2219 struct netlink_callback *cb)
2221 const struct nlmsghdr *nlh = cb->nlh;
2222 struct net *net = sock_net(skb->sk);
2225 struct net_device *dev;
2226 struct in_device *in_dev;
2227 struct hlist_head *head;
2229 if (cb->strict_check) {
2230 struct netlink_ext_ack *extack = cb->extack;
2231 struct netconfmsg *ncm;
2233 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ncm))) {
2234 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf dump request");
2238 if (nlmsg_attrlen(nlh, sizeof(*ncm))) {
2239 NL_SET_ERR_MSG(extack, "ipv4: Invalid data after header in netconf dump request");
2245 s_idx = idx = cb->args[1];
2247 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2249 head = &net->dev_index_head[h];
2251 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
2253 hlist_for_each_entry_rcu(dev, head, index_hlist) {
2256 in_dev = __in_dev_get_rcu(dev);
2260 if (inet_netconf_fill_devconf(skb, dev->ifindex,
2262 NETLINK_CB(cb->skb).portid,
2266 NETCONFA_ALL) < 0) {
2270 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2276 if (h == NETDEV_HASHENTRIES) {
2277 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
2278 net->ipv4.devconf_all,
2279 NETLINK_CB(cb->skb).portid,
2281 RTM_NEWNETCONF, NLM_F_MULTI,
2287 if (h == NETDEV_HASHENTRIES + 1) {
2288 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
2289 net->ipv4.devconf_dflt,
2290 NETLINK_CB(cb->skb).portid,
2292 RTM_NEWNETCONF, NLM_F_MULTI,
2305 #ifdef CONFIG_SYSCTL
2307 static void devinet_copy_dflt_conf(struct net *net, int i)
2309 struct net_device *dev;
2312 for_each_netdev_rcu(net, dev) {
2313 struct in_device *in_dev;
2315 in_dev = __in_dev_get_rcu(dev);
2316 if (in_dev && !test_bit(i, in_dev->cnf.state))
2317 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2322 /* called with RTNL locked */
2323 static void inet_forward_change(struct net *net)
2325 struct net_device *dev;
2326 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2328 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2329 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2330 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2331 NETCONFA_FORWARDING,
2332 NETCONFA_IFINDEX_ALL,
2333 net->ipv4.devconf_all);
2334 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2335 NETCONFA_FORWARDING,
2336 NETCONFA_IFINDEX_DEFAULT,
2337 net->ipv4.devconf_dflt);
2339 for_each_netdev(net, dev) {
2340 struct in_device *in_dev;
2343 dev_disable_lro(dev);
2345 in_dev = __in_dev_get_rtnl(dev);
2347 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2348 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2349 NETCONFA_FORWARDING,
2350 dev->ifindex, &in_dev->cnf);
2355 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2357 if (cnf == net->ipv4.devconf_dflt)
2358 return NETCONFA_IFINDEX_DEFAULT;
2359 else if (cnf == net->ipv4.devconf_all)
2360 return NETCONFA_IFINDEX_ALL;
2362 struct in_device *idev
2363 = container_of(cnf, struct in_device, cnf);
2364 return idev->dev->ifindex;
2368 static int devinet_conf_proc(struct ctl_table *ctl, int write,
2369 void __user *buffer,
2370 size_t *lenp, loff_t *ppos)
2372 int old_value = *(int *)ctl->data;
2373 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2374 int new_value = *(int *)ctl->data;
2377 struct ipv4_devconf *cnf = ctl->extra1;
2378 struct net *net = ctl->extra2;
2379 int i = (int *)ctl->data - cnf->data;
2382 set_bit(i, cnf->state);
2384 if (cnf == net->ipv4.devconf_dflt)
2385 devinet_copy_dflt_conf(net, i);
2386 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2387 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2388 if ((new_value == 0) && (old_value != 0))
2389 rt_cache_flush(net);
2391 if (i == IPV4_DEVCONF_BC_FORWARDING - 1 &&
2392 new_value != old_value)
2393 rt_cache_flush(net);
2395 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2396 new_value != old_value) {
2397 ifindex = devinet_conf_ifindex(net, cnf);
2398 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2402 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2403 new_value != old_value) {
2404 ifindex = devinet_conf_ifindex(net, cnf);
2405 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2406 NETCONFA_PROXY_NEIGH,
2409 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2410 new_value != old_value) {
2411 ifindex = devinet_conf_ifindex(net, cnf);
2412 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2413 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2421 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2422 void __user *buffer,
2423 size_t *lenp, loff_t *ppos)
2425 int *valp = ctl->data;
2428 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2430 if (write && *valp != val) {
2431 struct net *net = ctl->extra2;
2433 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2434 if (!rtnl_trylock()) {
2435 /* Restore the original values before restarting */
2438 return restart_syscall();
2440 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2441 inet_forward_change(net);
2443 struct ipv4_devconf *cnf = ctl->extra1;
2444 struct in_device *idev =
2445 container_of(cnf, struct in_device, cnf);
2447 dev_disable_lro(idev->dev);
2448 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2449 NETCONFA_FORWARDING,
2454 rt_cache_flush(net);
2456 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2457 NETCONFA_FORWARDING,
2458 NETCONFA_IFINDEX_DEFAULT,
2459 net->ipv4.devconf_dflt);
2465 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2466 void __user *buffer,
2467 size_t *lenp, loff_t *ppos)
2469 int *valp = ctl->data;
2471 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2472 struct net *net = ctl->extra2;
2474 if (write && *valp != val)
2475 rt_cache_flush(net);
2480 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2483 .data = ipv4_devconf.data + \
2484 IPV4_DEVCONF_ ## attr - 1, \
2485 .maxlen = sizeof(int), \
2487 .proc_handler = proc, \
2488 .extra1 = &ipv4_devconf, \
2491 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2492 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2494 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2495 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2497 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2498 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2500 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2501 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2503 static struct devinet_sysctl_table {
2504 struct ctl_table_header *sysctl_header;
2505 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
2506 } devinet_sysctl = {
2508 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2509 devinet_sysctl_forward),
2510 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2511 DEVINET_SYSCTL_RW_ENTRY(BC_FORWARDING, "bc_forwarding"),
2513 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2514 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2515 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2516 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2517 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2518 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2519 "accept_source_route"),
2520 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2521 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2522 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2523 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2524 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2525 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2526 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2527 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2528 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2529 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2530 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2531 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2532 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2533 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2534 "force_igmp_version"),
2535 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2536 "igmpv2_unsolicited_report_interval"),
2537 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2538 "igmpv3_unsolicited_report_interval"),
2539 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2540 "ignore_routes_with_linkdown"),
2541 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2542 "drop_gratuitous_arp"),
2544 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2545 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
2546 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2547 "promote_secondaries"),
2548 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2550 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2551 "drop_unicast_in_l2_multicast"),
2555 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2556 int ifindex, struct ipv4_devconf *p)
2559 struct devinet_sysctl_table *t;
2560 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2562 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
2566 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2567 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2568 t->devinet_vars[i].extra1 = p;
2569 t->devinet_vars[i].extra2 = net;
2572 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2574 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2575 if (!t->sysctl_header)
2580 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
2590 static void __devinet_sysctl_unregister(struct net *net,
2591 struct ipv4_devconf *cnf, int ifindex)
2593 struct devinet_sysctl_table *t = cnf->sysctl;
2597 unregister_net_sysctl_table(t->sysctl_header);
2601 inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2604 static int devinet_sysctl_register(struct in_device *idev)
2608 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2611 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2614 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2615 idev->dev->ifindex, &idev->cnf);
2617 neigh_sysctl_unregister(idev->arp_parms);
2621 static void devinet_sysctl_unregister(struct in_device *idev)
2623 struct net *net = dev_net(idev->dev);
2625 __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2626 neigh_sysctl_unregister(idev->arp_parms);
2629 static struct ctl_table ctl_forward_entry[] = {
2631 .procname = "ip_forward",
2632 .data = &ipv4_devconf.data[
2633 IPV4_DEVCONF_FORWARDING - 1],
2634 .maxlen = sizeof(int),
2636 .proc_handler = devinet_sysctl_forward,
2637 .extra1 = &ipv4_devconf,
2638 .extra2 = &init_net,
2644 static __net_init int devinet_init_net(struct net *net)
2647 struct ipv4_devconf *all, *dflt;
2648 #ifdef CONFIG_SYSCTL
2649 struct ctl_table *tbl;
2650 struct ctl_table_header *forw_hdr;
2654 all = kmemdup(&ipv4_devconf, sizeof(ipv4_devconf), GFP_KERNEL);
2658 dflt = kmemdup(&ipv4_devconf_dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2660 goto err_alloc_dflt;
2662 #ifdef CONFIG_SYSCTL
2663 tbl = kmemdup(ctl_forward_entry, sizeof(ctl_forward_entry), GFP_KERNEL);
2667 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2668 tbl[0].extra1 = all;
2669 tbl[0].extra2 = net;
2672 if ((!IS_ENABLED(CONFIG_SYSCTL) ||
2673 sysctl_devconf_inherit_init_net != 2) &&
2674 !net_eq(net, &init_net)) {
2675 memcpy(all, init_net.ipv4.devconf_all, sizeof(ipv4_devconf));
2676 memcpy(dflt, init_net.ipv4.devconf_dflt, sizeof(ipv4_devconf_dflt));
2679 #ifdef CONFIG_SYSCTL
2680 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2684 err = __devinet_sysctl_register(net, "default",
2685 NETCONFA_IFINDEX_DEFAULT, dflt);
2690 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2693 net->ipv4.forw_hdr = forw_hdr;
2696 net->ipv4.devconf_all = all;
2697 net->ipv4.devconf_dflt = dflt;
2700 #ifdef CONFIG_SYSCTL
2702 __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2704 __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2716 static __net_exit void devinet_exit_net(struct net *net)
2718 #ifdef CONFIG_SYSCTL
2719 struct ctl_table *tbl;
2721 tbl = net->ipv4.forw_hdr->ctl_table_arg;
2722 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2723 __devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
2724 NETCONFA_IFINDEX_DEFAULT);
2725 __devinet_sysctl_unregister(net, net->ipv4.devconf_all,
2726 NETCONFA_IFINDEX_ALL);
2729 kfree(net->ipv4.devconf_dflt);
2730 kfree(net->ipv4.devconf_all);
2733 static __net_initdata struct pernet_operations devinet_ops = {
2734 .init = devinet_init_net,
2735 .exit = devinet_exit_net,
2738 static struct rtnl_af_ops inet_af_ops __read_mostly = {
2740 .fill_link_af = inet_fill_link_af,
2741 .get_link_af_size = inet_get_link_af_size,
2742 .validate_link_af = inet_validate_link_af,
2743 .set_link_af = inet_set_link_af,
2746 void __init devinet_init(void)
2750 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2751 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2753 register_pernet_subsys(&devinet_ops);
2755 register_gifconf(PF_INET, inet_gifconf);
2756 register_netdevice_notifier(&ip_netdev_notifier);
2758 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
2760 rtnl_af_register(&inet_af_ops);
2762 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0);
2763 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0);
2764 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0);
2765 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2766 inet_netconf_dump_devconf, 0);