2 * NET3 IP device support routines.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Derived from the IP parts of dev.c 1.0.19
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
19 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
21 * Cyrus Durgin: updated for kmod
22 * Matthias Andree: in devinet_ioctl, compare label and
23 * address (4.4BSD alias style support),
24 * fall back to comparing just the label
29 #include <linux/uaccess.h>
30 #include <linux/bitops.h>
31 #include <linux/capability.h>
32 #include <linux/module.h>
33 #include <linux/types.h>
34 #include <linux/kernel.h>
35 #include <linux/sched/signal.h>
36 #include <linux/string.h>
38 #include <linux/socket.h>
39 #include <linux/sockios.h>
41 #include <linux/errno.h>
42 #include <linux/interrupt.h>
43 #include <linux/if_addr.h>
44 #include <linux/if_ether.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/skbuff.h>
49 #include <linux/init.h>
50 #include <linux/notifier.h>
51 #include <linux/inetdevice.h>
52 #include <linux/igmp.h>
53 #include <linux/slab.h>
54 #include <linux/hash.h>
56 #include <linux/sysctl.h>
58 #include <linux/kmod.h>
59 #include <linux/netconf.h>
63 #include <net/route.h>
64 #include <net/ip_fib.h>
65 #include <net/rtnetlink.h>
66 #include <net/net_namespace.h>
67 #include <net/addrconf.h>
69 #define IPV6ONLY_FLAGS \
70 (IFA_F_NODAD | IFA_F_OPTIMISTIC | IFA_F_DADFAILED | \
71 IFA_F_HOMEADDRESS | IFA_F_TENTATIVE | \
72 IFA_F_MANAGETEMPADDR | IFA_F_STABLE_PRIVACY)
74 static struct ipv4_devconf ipv4_devconf = {
76 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
77 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
78 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
79 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
80 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
81 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
85 static struct ipv4_devconf ipv4_devconf_dflt = {
87 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
88 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
89 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
90 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
91 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
92 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
93 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
97 #define IPV4_DEVCONF_DFLT(net, attr) \
98 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
100 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
101 [IFA_LOCAL] = { .type = NLA_U32 },
102 [IFA_ADDRESS] = { .type = NLA_U32 },
103 [IFA_BROADCAST] = { .type = NLA_U32 },
104 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
105 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
106 [IFA_FLAGS] = { .type = NLA_U32 },
109 #define IN4_ADDR_HSIZE_SHIFT 8
110 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
112 static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
114 static u32 inet_addr_hash(const struct net *net, __be32 addr)
116 u32 val = (__force u32) addr ^ net_hash_mix(net);
118 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
121 static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
123 u32 hash = inet_addr_hash(net, ifa->ifa_local);
126 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
129 static void inet_hash_remove(struct in_ifaddr *ifa)
132 hlist_del_init_rcu(&ifa->hash);
136 * __ip_dev_find - find the first device with a given source address.
137 * @net: the net namespace
138 * @addr: the source address
139 * @devref: if true, take a reference on the found device
141 * If a caller uses devref=false, it should be protected by RCU, or RTNL
143 struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
145 u32 hash = inet_addr_hash(net, addr);
146 struct net_device *result = NULL;
147 struct in_ifaddr *ifa;
150 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
151 if (ifa->ifa_local == addr) {
152 struct net_device *dev = ifa->ifa_dev->dev;
154 if (!net_eq(dev_net(dev), net))
161 struct flowi4 fl4 = { .daddr = addr };
162 struct fib_result res = { 0 };
163 struct fib_table *local;
165 /* Fallback to FIB local table so that communication
166 * over loopback subnets work.
168 local = fib_get_table(net, RT_TABLE_LOCAL);
170 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
171 res.type == RTN_LOCAL)
172 result = FIB_RES_DEV(res);
174 if (result && devref)
179 EXPORT_SYMBOL(__ip_dev_find);
181 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
183 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
184 static BLOCKING_NOTIFIER_HEAD(inetaddr_validator_chain);
185 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
188 static int devinet_sysctl_register(struct in_device *idev);
189 static void devinet_sysctl_unregister(struct in_device *idev);
191 static int devinet_sysctl_register(struct in_device *idev)
195 static void devinet_sysctl_unregister(struct in_device *idev)
200 /* Locks all the inet devices. */
202 static struct in_ifaddr *inet_alloc_ifa(void)
204 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
207 static void inet_rcu_free_ifa(struct rcu_head *head)
209 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
211 in_dev_put(ifa->ifa_dev);
215 static void inet_free_ifa(struct in_ifaddr *ifa)
217 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
220 void in_dev_finish_destroy(struct in_device *idev)
222 struct net_device *dev = idev->dev;
224 WARN_ON(idev->ifa_list);
225 WARN_ON(idev->mc_list);
226 kfree(rcu_dereference_protected(idev->mc_hash, 1));
227 #ifdef NET_REFCNT_DEBUG
228 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
232 pr_err("Freeing alive in_device %p\n", idev);
236 EXPORT_SYMBOL(in_dev_finish_destroy);
238 static struct in_device *inetdev_init(struct net_device *dev)
240 struct in_device *in_dev;
245 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
248 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
249 sizeof(in_dev->cnf));
250 in_dev->cnf.sysctl = NULL;
252 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
253 if (!in_dev->arp_parms)
255 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
256 dev_disable_lro(dev);
257 /* Reference in_dev->dev */
259 /* Account for reference dev->ip_ptr (below) */
260 refcount_set(&in_dev->refcnt, 1);
262 err = devinet_sysctl_register(in_dev);
265 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
270 ip_mc_init_dev(in_dev);
271 if (dev->flags & IFF_UP)
274 /* we can receive as soon as ip_ptr is set -- do this last */
275 rcu_assign_pointer(dev->ip_ptr, in_dev);
277 return in_dev ?: ERR_PTR(err);
284 static void in_dev_rcu_put(struct rcu_head *head)
286 struct in_device *idev = container_of(head, struct in_device, rcu_head);
290 static void inetdev_destroy(struct in_device *in_dev)
292 struct in_ifaddr *ifa;
293 struct net_device *dev;
301 ip_mc_destroy_dev(in_dev);
303 while ((ifa = in_dev->ifa_list) != NULL) {
304 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
308 RCU_INIT_POINTER(dev->ip_ptr, NULL);
310 devinet_sysctl_unregister(in_dev);
311 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
314 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
317 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
320 for_primary_ifa(in_dev) {
321 if (inet_ifa_match(a, ifa)) {
322 if (!b || inet_ifa_match(b, ifa)) {
327 } endfor_ifa(in_dev);
332 static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
333 int destroy, struct nlmsghdr *nlh, u32 portid)
335 struct in_ifaddr *promote = NULL;
336 struct in_ifaddr *ifa, *ifa1 = *ifap;
337 struct in_ifaddr *last_prim = in_dev->ifa_list;
338 struct in_ifaddr *prev_prom = NULL;
339 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
346 /* 1. Deleting primary ifaddr forces deletion all secondaries
347 * unless alias promotion is set
350 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
351 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
353 while ((ifa = *ifap1) != NULL) {
354 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
355 ifa1->ifa_scope <= ifa->ifa_scope)
358 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
359 ifa1->ifa_mask != ifa->ifa_mask ||
360 !inet_ifa_match(ifa1->ifa_address, ifa)) {
361 ifap1 = &ifa->ifa_next;
367 inet_hash_remove(ifa);
368 *ifap1 = ifa->ifa_next;
370 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
371 blocking_notifier_call_chain(&inetaddr_chain,
381 /* On promotion all secondaries from subnet are changing
382 * the primary IP, we must remove all their routes silently
383 * and later to add them back with new prefsrc. Do this
384 * while all addresses are on the device list.
386 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
387 if (ifa1->ifa_mask == ifa->ifa_mask &&
388 inet_ifa_match(ifa1->ifa_address, ifa))
389 fib_del_ifaddr(ifa, ifa1);
395 *ifap = ifa1->ifa_next;
396 inet_hash_remove(ifa1);
398 /* 3. Announce address deletion */
400 /* Send message first, then call notifier.
401 At first sight, FIB update triggered by notifier
402 will refer to already deleted ifaddr, that could confuse
403 netlink listeners. It is not true: look, gated sees
404 that route deleted and if it still thinks that ifaddr
405 is valid, it will try to restore deleted routes... Grr.
406 So that, this order is correct.
408 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
409 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
412 struct in_ifaddr *next_sec = promote->ifa_next;
415 prev_prom->ifa_next = promote->ifa_next;
416 promote->ifa_next = last_prim->ifa_next;
417 last_prim->ifa_next = promote;
420 promote->ifa_flags &= ~IFA_F_SECONDARY;
421 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
422 blocking_notifier_call_chain(&inetaddr_chain,
424 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
425 if (ifa1->ifa_mask != ifa->ifa_mask ||
426 !inet_ifa_match(ifa1->ifa_address, ifa))
436 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
439 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
442 static void check_lifetime(struct work_struct *work);
444 static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
446 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
449 struct in_device *in_dev = ifa->ifa_dev;
450 struct in_ifaddr *ifa1, **ifap, **last_primary;
451 struct in_validator_info ivi;
456 if (!ifa->ifa_local) {
461 ifa->ifa_flags &= ~IFA_F_SECONDARY;
462 last_primary = &in_dev->ifa_list;
464 /* Don't set IPv6 only flags to IPv4 addresses */
465 ifa->ifa_flags &= ~IPV6ONLY_FLAGS;
467 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
468 ifap = &ifa1->ifa_next) {
469 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
470 ifa->ifa_scope <= ifa1->ifa_scope)
471 last_primary = &ifa1->ifa_next;
472 if (ifa1->ifa_mask == ifa->ifa_mask &&
473 inet_ifa_match(ifa1->ifa_address, ifa)) {
474 if (ifa1->ifa_local == ifa->ifa_local) {
478 if (ifa1->ifa_scope != ifa->ifa_scope) {
482 ifa->ifa_flags |= IFA_F_SECONDARY;
486 /* Allow any devices that wish to register ifaddr validtors to weigh
487 * in now, before changes are committed. The rntl lock is serializing
488 * access here, so the state should not change between a validator call
489 * and a final notify on commit. This isn't invoked on promotion under
490 * the assumption that validators are checking the address itself, and
493 ivi.ivi_addr = ifa->ifa_address;
494 ivi.ivi_dev = ifa->ifa_dev;
495 ret = blocking_notifier_call_chain(&inetaddr_validator_chain,
497 ret = notifier_to_errno(ret);
503 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
504 prandom_seed((__force u32) ifa->ifa_local);
508 ifa->ifa_next = *ifap;
511 inet_hash_insert(dev_net(in_dev->dev), ifa);
513 cancel_delayed_work(&check_lifetime_work);
514 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
516 /* Send message first, then call notifier.
517 Notifier will trigger FIB update, so that
518 listeners of netlink will know about new ifaddr */
519 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
520 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
525 static int inet_insert_ifa(struct in_ifaddr *ifa)
527 return __inet_insert_ifa(ifa, NULL, 0);
530 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
532 struct in_device *in_dev = __in_dev_get_rtnl(dev);
540 ipv4_devconf_setall(in_dev);
541 neigh_parms_data_state_setall(in_dev->arp_parms);
542 if (ifa->ifa_dev != in_dev) {
543 WARN_ON(ifa->ifa_dev);
545 ifa->ifa_dev = in_dev;
547 if (ipv4_is_loopback(ifa->ifa_local))
548 ifa->ifa_scope = RT_SCOPE_HOST;
549 return inet_insert_ifa(ifa);
552 /* Caller must hold RCU or RTNL :
553 * We dont take a reference on found in_device
555 struct in_device *inetdev_by_index(struct net *net, int ifindex)
557 struct net_device *dev;
558 struct in_device *in_dev = NULL;
561 dev = dev_get_by_index_rcu(net, ifindex);
563 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
567 EXPORT_SYMBOL(inetdev_by_index);
569 /* Called only from RTNL semaphored context. No locks. */
571 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
576 for_primary_ifa(in_dev) {
577 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
579 } endfor_ifa(in_dev);
583 static int ip_mc_autojoin_config(struct net *net, bool join,
584 const struct in_ifaddr *ifa)
586 #if defined(CONFIG_IP_MULTICAST)
587 struct ip_mreqn mreq = {
588 .imr_multiaddr.s_addr = ifa->ifa_address,
589 .imr_ifindex = ifa->ifa_dev->dev->ifindex,
591 struct sock *sk = net->ipv4.mc_autojoin_sk;
598 ret = ip_mc_join_group(sk, &mreq);
600 ret = ip_mc_leave_group(sk, &mreq);
609 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
610 struct netlink_ext_ack *extack)
612 struct net *net = sock_net(skb->sk);
613 struct nlattr *tb[IFA_MAX+1];
614 struct in_device *in_dev;
615 struct ifaddrmsg *ifm;
616 struct in_ifaddr *ifa, **ifap;
621 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy,
626 ifm = nlmsg_data(nlh);
627 in_dev = inetdev_by_index(net, ifm->ifa_index);
633 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
634 ifap = &ifa->ifa_next) {
636 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
639 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
642 if (tb[IFA_ADDRESS] &&
643 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
644 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
647 if (ipv4_is_multicast(ifa->ifa_address))
648 ip_mc_autojoin_config(net, false, ifa);
649 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
653 err = -EADDRNOTAVAIL;
658 #define INFINITY_LIFE_TIME 0xFFFFFFFF
660 static void check_lifetime(struct work_struct *work)
662 unsigned long now, next, next_sec, next_sched;
663 struct in_ifaddr *ifa;
664 struct hlist_node *n;
668 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
670 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
671 bool change_needed = false;
674 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
677 if (ifa->ifa_flags & IFA_F_PERMANENT)
680 /* We try to batch several events at once. */
681 age = (now - ifa->ifa_tstamp +
682 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
684 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
685 age >= ifa->ifa_valid_lft) {
686 change_needed = true;
687 } else if (ifa->ifa_preferred_lft ==
688 INFINITY_LIFE_TIME) {
690 } else if (age >= ifa->ifa_preferred_lft) {
691 if (time_before(ifa->ifa_tstamp +
692 ifa->ifa_valid_lft * HZ, next))
693 next = ifa->ifa_tstamp +
694 ifa->ifa_valid_lft * HZ;
696 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
697 change_needed = true;
698 } else if (time_before(ifa->ifa_tstamp +
699 ifa->ifa_preferred_lft * HZ,
701 next = ifa->ifa_tstamp +
702 ifa->ifa_preferred_lft * HZ;
709 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
712 if (ifa->ifa_flags & IFA_F_PERMANENT)
715 /* We try to batch several events at once. */
716 age = (now - ifa->ifa_tstamp +
717 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
719 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
720 age >= ifa->ifa_valid_lft) {
721 struct in_ifaddr **ifap;
723 for (ifap = &ifa->ifa_dev->ifa_list;
724 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
726 inet_del_ifa(ifa->ifa_dev,
731 } else if (ifa->ifa_preferred_lft !=
732 INFINITY_LIFE_TIME &&
733 age >= ifa->ifa_preferred_lft &&
734 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
735 ifa->ifa_flags |= IFA_F_DEPRECATED;
736 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
742 next_sec = round_jiffies_up(next);
745 /* If rounded timeout is accurate enough, accept it. */
746 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
747 next_sched = next_sec;
750 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
751 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
752 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
754 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
758 static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
761 unsigned long timeout;
763 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
765 timeout = addrconf_timeout_fixup(valid_lft, HZ);
766 if (addrconf_finite_timeout(timeout))
767 ifa->ifa_valid_lft = timeout;
769 ifa->ifa_flags |= IFA_F_PERMANENT;
771 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
772 if (addrconf_finite_timeout(timeout)) {
774 ifa->ifa_flags |= IFA_F_DEPRECATED;
775 ifa->ifa_preferred_lft = timeout;
777 ifa->ifa_tstamp = jiffies;
778 if (!ifa->ifa_cstamp)
779 ifa->ifa_cstamp = ifa->ifa_tstamp;
782 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
783 __u32 *pvalid_lft, __u32 *pprefered_lft)
785 struct nlattr *tb[IFA_MAX+1];
786 struct in_ifaddr *ifa;
787 struct ifaddrmsg *ifm;
788 struct net_device *dev;
789 struct in_device *in_dev;
792 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy,
797 ifm = nlmsg_data(nlh);
799 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
802 dev = __dev_get_by_index(net, ifm->ifa_index);
807 in_dev = __in_dev_get_rtnl(dev);
812 ifa = inet_alloc_ifa();
815 * A potential indev allocation can be left alive, it stays
816 * assigned to its device and is destroy with it.
820 ipv4_devconf_setall(in_dev);
821 neigh_parms_data_state_setall(in_dev->arp_parms);
824 if (!tb[IFA_ADDRESS])
825 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
827 INIT_HLIST_NODE(&ifa->hash);
828 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
829 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
830 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
832 ifa->ifa_scope = ifm->ifa_scope;
833 ifa->ifa_dev = in_dev;
835 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
836 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
838 if (tb[IFA_BROADCAST])
839 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
842 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
844 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
846 if (tb[IFA_CACHEINFO]) {
847 struct ifa_cacheinfo *ci;
849 ci = nla_data(tb[IFA_CACHEINFO]);
850 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
854 *pvalid_lft = ci->ifa_valid;
855 *pprefered_lft = ci->ifa_prefered;
866 static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
868 struct in_device *in_dev = ifa->ifa_dev;
869 struct in_ifaddr *ifa1, **ifap;
874 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
875 ifap = &ifa1->ifa_next) {
876 if (ifa1->ifa_mask == ifa->ifa_mask &&
877 inet_ifa_match(ifa1->ifa_address, ifa) &&
878 ifa1->ifa_local == ifa->ifa_local)
884 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
885 struct netlink_ext_ack *extack)
887 struct net *net = sock_net(skb->sk);
888 struct in_ifaddr *ifa;
889 struct in_ifaddr *ifa_existing;
890 __u32 valid_lft = INFINITY_LIFE_TIME;
891 __u32 prefered_lft = INFINITY_LIFE_TIME;
895 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
899 ifa_existing = find_matching_ifa(ifa);
901 /* It would be best to check for !NLM_F_CREATE here but
902 * userspace already relies on not having to provide this.
904 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
905 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
906 int ret = ip_mc_autojoin_config(net, true, ifa);
913 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
917 if (nlh->nlmsg_flags & NLM_F_EXCL ||
918 !(nlh->nlmsg_flags & NLM_F_REPLACE))
921 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
922 cancel_delayed_work(&check_lifetime_work);
923 queue_delayed_work(system_power_efficient_wq,
924 &check_lifetime_work, 0);
925 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
931 * Determine a default network mask, based on the IP address.
934 static int inet_abc_len(__be32 addr)
936 int rc = -1; /* Something else, probably a multicast. */
938 if (ipv4_is_zeronet(addr))
941 __u32 haddr = ntohl(addr);
943 if (IN_CLASSA(haddr))
945 else if (IN_CLASSB(haddr))
947 else if (IN_CLASSC(haddr))
955 int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
958 struct sockaddr_in sin_orig;
959 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
960 struct in_device *in_dev;
961 struct in_ifaddr **ifap = NULL;
962 struct in_ifaddr *ifa = NULL;
963 struct net_device *dev;
966 int tryaddrmatch = 0;
969 * Fetch the caller's info block into kernel space
972 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
974 ifr.ifr_name[IFNAMSIZ - 1] = 0;
976 /* save original address for comparison */
977 memcpy(&sin_orig, sin, sizeof(*sin));
979 colon = strchr(ifr.ifr_name, ':');
983 dev_load(net, ifr.ifr_name);
986 case SIOCGIFADDR: /* Get interface address */
987 case SIOCGIFBRDADDR: /* Get the broadcast address */
988 case SIOCGIFDSTADDR: /* Get the destination address */
989 case SIOCGIFNETMASK: /* Get the netmask for the interface */
990 /* Note that these ioctls will not sleep,
991 so that we do not impose a lock.
992 One day we will be forced to put shlock here (I mean SMP)
994 tryaddrmatch = (sin_orig.sin_family == AF_INET);
995 memset(sin, 0, sizeof(*sin));
996 sin->sin_family = AF_INET;
1001 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1004 case SIOCSIFADDR: /* Set interface address (and family) */
1005 case SIOCSIFBRDADDR: /* Set the broadcast address */
1006 case SIOCSIFDSTADDR: /* Set the destination address */
1007 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1009 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1012 if (sin->sin_family != AF_INET)
1023 dev = __dev_get_by_name(net, ifr.ifr_name);
1030 in_dev = __in_dev_get_rtnl(dev);
1033 /* Matthias Andree */
1034 /* compare label and address (4.4BSD style) */
1035 /* note: we only do this for a limited set of ioctls
1036 and only if the original address family was AF_INET.
1037 This is checked above. */
1038 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1039 ifap = &ifa->ifa_next) {
1040 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
1041 sin_orig.sin_addr.s_addr ==
1047 /* we didn't get a match, maybe the application is
1048 4.3BSD-style and passed in junk so we fall back to
1049 comparing just the label */
1051 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1052 ifap = &ifa->ifa_next)
1053 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
1058 ret = -EADDRNOTAVAIL;
1059 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
1063 case SIOCGIFADDR: /* Get interface address */
1064 sin->sin_addr.s_addr = ifa->ifa_local;
1067 case SIOCGIFBRDADDR: /* Get the broadcast address */
1068 sin->sin_addr.s_addr = ifa->ifa_broadcast;
1071 case SIOCGIFDSTADDR: /* Get the destination address */
1072 sin->sin_addr.s_addr = ifa->ifa_address;
1075 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1076 sin->sin_addr.s_addr = ifa->ifa_mask;
1081 ret = -EADDRNOTAVAIL;
1085 if (!(ifr.ifr_flags & IFF_UP))
1086 inet_del_ifa(in_dev, ifap, 1);
1089 ret = dev_change_flags(dev, ifr.ifr_flags);
1092 case SIOCSIFADDR: /* Set interface address (and family) */
1094 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1099 ifa = inet_alloc_ifa();
1102 INIT_HLIST_NODE(&ifa->hash);
1104 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1106 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1109 if (ifa->ifa_local == sin->sin_addr.s_addr)
1111 inet_del_ifa(in_dev, ifap, 0);
1112 ifa->ifa_broadcast = 0;
1116 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1118 if (!(dev->flags & IFF_POINTOPOINT)) {
1119 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1120 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1121 if ((dev->flags & IFF_BROADCAST) &&
1122 ifa->ifa_prefixlen < 31)
1123 ifa->ifa_broadcast = ifa->ifa_address |
1126 ifa->ifa_prefixlen = 32;
1127 ifa->ifa_mask = inet_make_mask(32);
1129 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
1130 ret = inet_set_ifa(dev, ifa);
1133 case SIOCSIFBRDADDR: /* Set the broadcast address */
1135 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1136 inet_del_ifa(in_dev, ifap, 0);
1137 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1138 inet_insert_ifa(ifa);
1142 case SIOCSIFDSTADDR: /* Set the destination address */
1144 if (ifa->ifa_address == sin->sin_addr.s_addr)
1147 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1150 inet_del_ifa(in_dev, ifap, 0);
1151 ifa->ifa_address = sin->sin_addr.s_addr;
1152 inet_insert_ifa(ifa);
1155 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1158 * The mask we set must be legal.
1161 if (bad_mask(sin->sin_addr.s_addr, 0))
1164 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
1165 __be32 old_mask = ifa->ifa_mask;
1166 inet_del_ifa(in_dev, ifap, 0);
1167 ifa->ifa_mask = sin->sin_addr.s_addr;
1168 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1170 /* See if current broadcast address matches
1171 * with current netmask, then recalculate
1172 * the broadcast address. Otherwise it's a
1173 * funny address, so don't touch it since
1174 * the user seems to know what (s)he's doing...
1176 if ((dev->flags & IFF_BROADCAST) &&
1177 (ifa->ifa_prefixlen < 31) &&
1178 (ifa->ifa_broadcast ==
1179 (ifa->ifa_local|~old_mask))) {
1180 ifa->ifa_broadcast = (ifa->ifa_local |
1181 ~sin->sin_addr.s_addr);
1183 inet_insert_ifa(ifa);
1193 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1197 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1199 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1200 struct in_ifaddr *ifa;
1207 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1209 done += sizeof(ifr);
1212 if (len < (int) sizeof(ifr))
1214 memset(&ifr, 0, sizeof(struct ifreq));
1215 strcpy(ifr.ifr_name, ifa->ifa_label);
1217 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1218 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1221 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1225 buf += sizeof(struct ifreq);
1226 len -= sizeof(struct ifreq);
1227 done += sizeof(struct ifreq);
1233 static __be32 in_dev_select_addr(const struct in_device *in_dev,
1236 for_primary_ifa(in_dev) {
1237 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1238 ifa->ifa_scope <= scope)
1239 return ifa->ifa_local;
1240 } endfor_ifa(in_dev);
1245 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
1248 struct in_device *in_dev;
1249 struct net *net = dev_net(dev);
1253 in_dev = __in_dev_get_rcu(dev);
1257 for_primary_ifa(in_dev) {
1258 if (ifa->ifa_scope > scope)
1260 if (!dst || inet_ifa_match(dst, ifa)) {
1261 addr = ifa->ifa_local;
1265 addr = ifa->ifa_local;
1266 } endfor_ifa(in_dev);
1271 master_idx = l3mdev_master_ifindex_rcu(dev);
1273 /* For VRFs, the VRF device takes the place of the loopback device,
1274 * with addresses on it being preferred. Note in such cases the
1275 * loopback device will be among the devices that fail the master_idx
1276 * equality check in the loop below.
1279 (dev = dev_get_by_index_rcu(net, master_idx)) &&
1280 (in_dev = __in_dev_get_rcu(dev))) {
1281 addr = in_dev_select_addr(in_dev, scope);
1286 /* Not loopback addresses on loopback should be preferred
1287 in this case. It is important that lo is the first interface
1290 for_each_netdev_rcu(net, dev) {
1291 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1294 in_dev = __in_dev_get_rcu(dev);
1298 addr = in_dev_select_addr(in_dev, scope);
1306 EXPORT_SYMBOL(inet_select_addr);
1308 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1309 __be32 local, int scope)
1316 (local == ifa->ifa_local || !local) &&
1317 ifa->ifa_scope <= scope) {
1318 addr = ifa->ifa_local;
1323 same = (!local || inet_ifa_match(local, ifa)) &&
1324 (!dst || inet_ifa_match(dst, ifa));
1328 /* Is the selected addr into dst subnet? */
1329 if (inet_ifa_match(addr, ifa))
1331 /* No, then can we use new local src? */
1332 if (ifa->ifa_scope <= scope) {
1333 addr = ifa->ifa_local;
1336 /* search for large dst subnet for addr */
1340 } endfor_ifa(in_dev);
1342 return same ? addr : 0;
1346 * Confirm that local IP address exists using wildcards:
1347 * - net: netns to check, cannot be NULL
1348 * - in_dev: only on this interface, NULL=any interface
1349 * - dst: only in the same subnet as dst, 0=any dst
1350 * - local: address, 0=autoselect the local address
1351 * - scope: maximum allowed scope value for the local address
1353 __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1354 __be32 dst, __be32 local, int scope)
1357 struct net_device *dev;
1360 return confirm_addr_indev(in_dev, dst, local, scope);
1363 for_each_netdev_rcu(net, dev) {
1364 in_dev = __in_dev_get_rcu(dev);
1366 addr = confirm_addr_indev(in_dev, dst, local, scope);
1375 EXPORT_SYMBOL(inet_confirm_addr);
1381 int register_inetaddr_notifier(struct notifier_block *nb)
1383 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1385 EXPORT_SYMBOL(register_inetaddr_notifier);
1387 int unregister_inetaddr_notifier(struct notifier_block *nb)
1389 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1391 EXPORT_SYMBOL(unregister_inetaddr_notifier);
1393 int register_inetaddr_validator_notifier(struct notifier_block *nb)
1395 return blocking_notifier_chain_register(&inetaddr_validator_chain, nb);
1397 EXPORT_SYMBOL(register_inetaddr_validator_notifier);
1399 int unregister_inetaddr_validator_notifier(struct notifier_block *nb)
1401 return blocking_notifier_chain_unregister(&inetaddr_validator_chain,
1404 EXPORT_SYMBOL(unregister_inetaddr_validator_notifier);
1406 /* Rename ifa_labels for a device name change. Make some effort to preserve
1407 * existing alias numbering and to create unique labels if possible.
1409 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1411 struct in_ifaddr *ifa;
1414 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1415 char old[IFNAMSIZ], *dot;
1417 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1418 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1421 dot = strchr(old, ':');
1423 sprintf(old, ":%d", named);
1426 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1427 strcat(ifa->ifa_label, dot);
1429 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1431 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1435 static void inetdev_send_gratuitous_arp(struct net_device *dev,
1436 struct in_device *in_dev)
1439 struct in_ifaddr *ifa;
1441 for (ifa = in_dev->ifa_list; ifa;
1442 ifa = ifa->ifa_next) {
1443 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1444 ifa->ifa_local, dev,
1445 ifa->ifa_local, NULL,
1446 dev->dev_addr, NULL);
1450 /* Called only under RTNL semaphore */
1452 static int inetdev_event(struct notifier_block *this, unsigned long event,
1455 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1456 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1461 if (event == NETDEV_REGISTER) {
1462 in_dev = inetdev_init(dev);
1464 return notifier_from_errno(PTR_ERR(in_dev));
1465 if (dev->flags & IFF_LOOPBACK) {
1466 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1467 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1469 } else if (event == NETDEV_CHANGEMTU) {
1470 /* Re-enabling IP */
1471 if (inetdev_valid_mtu(dev->mtu))
1472 in_dev = inetdev_init(dev);
1478 case NETDEV_REGISTER:
1479 pr_debug("%s: bug\n", __func__);
1480 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1483 if (!inetdev_valid_mtu(dev->mtu))
1485 if (dev->flags & IFF_LOOPBACK) {
1486 struct in_ifaddr *ifa = inet_alloc_ifa();
1489 INIT_HLIST_NODE(&ifa->hash);
1491 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1492 ifa->ifa_prefixlen = 8;
1493 ifa->ifa_mask = inet_make_mask(8);
1494 in_dev_hold(in_dev);
1495 ifa->ifa_dev = in_dev;
1496 ifa->ifa_scope = RT_SCOPE_HOST;
1497 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1498 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1499 INFINITY_LIFE_TIME);
1500 ipv4_devconf_setall(in_dev);
1501 neigh_parms_data_state_setall(in_dev->arp_parms);
1502 inet_insert_ifa(ifa);
1507 case NETDEV_CHANGEADDR:
1508 if (!IN_DEV_ARP_NOTIFY(in_dev))
1511 case NETDEV_NOTIFY_PEERS:
1512 /* Send gratuitous ARP to notify of link change */
1513 inetdev_send_gratuitous_arp(dev, in_dev);
1518 case NETDEV_PRE_TYPE_CHANGE:
1519 ip_mc_unmap(in_dev);
1521 case NETDEV_POST_TYPE_CHANGE:
1522 ip_mc_remap(in_dev);
1524 case NETDEV_CHANGEMTU:
1525 if (inetdev_valid_mtu(dev->mtu))
1527 /* disable IP when MTU is not enough */
1528 case NETDEV_UNREGISTER:
1529 inetdev_destroy(in_dev);
1531 case NETDEV_CHANGENAME:
1532 /* Do not notify about label change, this event is
1533 * not interesting to applications using netlink.
1535 inetdev_changename(dev, in_dev);
1537 devinet_sysctl_unregister(in_dev);
1538 devinet_sysctl_register(in_dev);
1545 static struct notifier_block ip_netdev_notifier = {
1546 .notifier_call = inetdev_event,
1549 static size_t inet_nlmsg_size(void)
1551 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1552 + nla_total_size(4) /* IFA_ADDRESS */
1553 + nla_total_size(4) /* IFA_LOCAL */
1554 + nla_total_size(4) /* IFA_BROADCAST */
1555 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1556 + nla_total_size(4) /* IFA_FLAGS */
1557 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1560 static inline u32 cstamp_delta(unsigned long cstamp)
1562 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1565 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1566 unsigned long tstamp, u32 preferred, u32 valid)
1568 struct ifa_cacheinfo ci;
1570 ci.cstamp = cstamp_delta(cstamp);
1571 ci.tstamp = cstamp_delta(tstamp);
1572 ci.ifa_prefered = preferred;
1573 ci.ifa_valid = valid;
1575 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1578 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1579 u32 portid, u32 seq, int event, unsigned int flags)
1581 struct ifaddrmsg *ifm;
1582 struct nlmsghdr *nlh;
1583 u32 preferred, valid;
1585 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1589 ifm = nlmsg_data(nlh);
1590 ifm->ifa_family = AF_INET;
1591 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1592 ifm->ifa_flags = ifa->ifa_flags;
1593 ifm->ifa_scope = ifa->ifa_scope;
1594 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1596 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1597 preferred = ifa->ifa_preferred_lft;
1598 valid = ifa->ifa_valid_lft;
1599 if (preferred != INFINITY_LIFE_TIME) {
1600 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1602 if (preferred > tval)
1606 if (valid != INFINITY_LIFE_TIME) {
1614 preferred = INFINITY_LIFE_TIME;
1615 valid = INFINITY_LIFE_TIME;
1617 if ((ifa->ifa_address &&
1618 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1620 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
1621 (ifa->ifa_broadcast &&
1622 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1623 (ifa->ifa_label[0] &&
1624 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1625 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
1626 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1628 goto nla_put_failure;
1630 nlmsg_end(skb, nlh);
1634 nlmsg_cancel(skb, nlh);
1638 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1640 struct net *net = sock_net(skb->sk);
1643 int ip_idx, s_ip_idx;
1644 struct net_device *dev;
1645 struct in_device *in_dev;
1646 struct in_ifaddr *ifa;
1647 struct hlist_head *head;
1650 s_idx = idx = cb->args[1];
1651 s_ip_idx = ip_idx = cb->args[2];
1653 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1655 head = &net->dev_index_head[h];
1657 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1659 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1662 if (h > s_h || idx > s_idx)
1664 in_dev = __in_dev_get_rcu(dev);
1668 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1669 ifa = ifa->ifa_next, ip_idx++) {
1670 if (ip_idx < s_ip_idx)
1672 if (inet_fill_ifaddr(skb, ifa,
1673 NETLINK_CB(cb->skb).portid,
1675 RTM_NEWADDR, NLM_F_MULTI) < 0) {
1679 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1690 cb->args[2] = ip_idx;
1695 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1698 struct sk_buff *skb;
1699 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1703 net = dev_net(ifa->ifa_dev->dev);
1704 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1708 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1710 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1711 WARN_ON(err == -EMSGSIZE);
1715 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1719 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1722 static size_t inet_get_link_af_size(const struct net_device *dev,
1723 u32 ext_filter_mask)
1725 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1730 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1733 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1734 u32 ext_filter_mask)
1736 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1743 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1747 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1748 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1753 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1754 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1757 static int inet_validate_link_af(const struct net_device *dev,
1758 const struct nlattr *nla)
1760 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1763 if (dev && !__in_dev_get_rtnl(dev))
1764 return -EAFNOSUPPORT;
1766 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL);
1770 if (tb[IFLA_INET_CONF]) {
1771 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1772 int cfgid = nla_type(a);
1777 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1785 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1787 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1788 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1792 return -EAFNOSUPPORT;
1794 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL, NULL) < 0)
1797 if (tb[IFLA_INET_CONF]) {
1798 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1799 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1805 static int inet_netconf_msgsize_devconf(int type)
1807 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1808 + nla_total_size(4); /* NETCONFA_IFINDEX */
1811 if (type == NETCONFA_ALL)
1814 if (all || type == NETCONFA_FORWARDING)
1815 size += nla_total_size(4);
1816 if (all || type == NETCONFA_RP_FILTER)
1817 size += nla_total_size(4);
1818 if (all || type == NETCONFA_MC_FORWARDING)
1819 size += nla_total_size(4);
1820 if (all || type == NETCONFA_PROXY_NEIGH)
1821 size += nla_total_size(4);
1822 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
1823 size += nla_total_size(4);
1828 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1829 struct ipv4_devconf *devconf, u32 portid,
1830 u32 seq, int event, unsigned int flags,
1833 struct nlmsghdr *nlh;
1834 struct netconfmsg *ncm;
1837 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1842 if (type == NETCONFA_ALL)
1845 ncm = nlmsg_data(nlh);
1846 ncm->ncm_family = AF_INET;
1848 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1849 goto nla_put_failure;
1854 if ((all || type == NETCONFA_FORWARDING) &&
1855 nla_put_s32(skb, NETCONFA_FORWARDING,
1856 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1857 goto nla_put_failure;
1858 if ((all || type == NETCONFA_RP_FILTER) &&
1859 nla_put_s32(skb, NETCONFA_RP_FILTER,
1860 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1861 goto nla_put_failure;
1862 if ((all || type == NETCONFA_MC_FORWARDING) &&
1863 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1864 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1865 goto nla_put_failure;
1866 if ((all || type == NETCONFA_PROXY_NEIGH) &&
1867 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
1868 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1869 goto nla_put_failure;
1870 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
1871 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
1872 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
1873 goto nla_put_failure;
1876 nlmsg_end(skb, nlh);
1880 nlmsg_cancel(skb, nlh);
1884 void inet_netconf_notify_devconf(struct net *net, int event, int type,
1885 int ifindex, struct ipv4_devconf *devconf)
1887 struct sk_buff *skb;
1890 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
1894 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1897 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1898 WARN_ON(err == -EMSGSIZE);
1902 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
1906 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1909 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1910 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1911 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
1912 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
1913 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
1914 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
1917 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1918 struct nlmsghdr *nlh,
1919 struct netlink_ext_ack *extack)
1921 struct net *net = sock_net(in_skb->sk);
1922 struct nlattr *tb[NETCONFA_MAX+1];
1923 struct netconfmsg *ncm;
1924 struct sk_buff *skb;
1925 struct ipv4_devconf *devconf;
1926 struct in_device *in_dev;
1927 struct net_device *dev;
1931 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1932 devconf_ipv4_policy, extack);
1937 if (!tb[NETCONFA_IFINDEX])
1940 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1942 case NETCONFA_IFINDEX_ALL:
1943 devconf = net->ipv4.devconf_all;
1945 case NETCONFA_IFINDEX_DEFAULT:
1946 devconf = net->ipv4.devconf_dflt;
1949 dev = __dev_get_by_index(net, ifindex);
1952 in_dev = __in_dev_get_rtnl(dev);
1955 devconf = &in_dev->cnf;
1960 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
1964 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1965 NETLINK_CB(in_skb).portid,
1966 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1969 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1970 WARN_ON(err == -EMSGSIZE);
1974 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1979 static int inet_netconf_dump_devconf(struct sk_buff *skb,
1980 struct netlink_callback *cb)
1982 struct net *net = sock_net(skb->sk);
1985 struct net_device *dev;
1986 struct in_device *in_dev;
1987 struct hlist_head *head;
1990 s_idx = idx = cb->args[1];
1992 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1994 head = &net->dev_index_head[h];
1996 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1998 hlist_for_each_entry_rcu(dev, head, index_hlist) {
2001 in_dev = __in_dev_get_rcu(dev);
2005 if (inet_netconf_fill_devconf(skb, dev->ifindex,
2007 NETLINK_CB(cb->skb).portid,
2011 NETCONFA_ALL) < 0) {
2015 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2021 if (h == NETDEV_HASHENTRIES) {
2022 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
2023 net->ipv4.devconf_all,
2024 NETLINK_CB(cb->skb).portid,
2026 RTM_NEWNETCONF, NLM_F_MULTI,
2032 if (h == NETDEV_HASHENTRIES + 1) {
2033 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
2034 net->ipv4.devconf_dflt,
2035 NETLINK_CB(cb->skb).portid,
2037 RTM_NEWNETCONF, NLM_F_MULTI,
2050 #ifdef CONFIG_SYSCTL
2052 static void devinet_copy_dflt_conf(struct net *net, int i)
2054 struct net_device *dev;
2057 for_each_netdev_rcu(net, dev) {
2058 struct in_device *in_dev;
2060 in_dev = __in_dev_get_rcu(dev);
2061 if (in_dev && !test_bit(i, in_dev->cnf.state))
2062 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2067 /* called with RTNL locked */
2068 static void inet_forward_change(struct net *net)
2070 struct net_device *dev;
2071 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2073 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2074 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2075 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2076 NETCONFA_FORWARDING,
2077 NETCONFA_IFINDEX_ALL,
2078 net->ipv4.devconf_all);
2079 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2080 NETCONFA_FORWARDING,
2081 NETCONFA_IFINDEX_DEFAULT,
2082 net->ipv4.devconf_dflt);
2084 for_each_netdev(net, dev) {
2085 struct in_device *in_dev;
2088 dev_disable_lro(dev);
2090 in_dev = __in_dev_get_rtnl(dev);
2092 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2093 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2094 NETCONFA_FORWARDING,
2095 dev->ifindex, &in_dev->cnf);
2100 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2102 if (cnf == net->ipv4.devconf_dflt)
2103 return NETCONFA_IFINDEX_DEFAULT;
2104 else if (cnf == net->ipv4.devconf_all)
2105 return NETCONFA_IFINDEX_ALL;
2107 struct in_device *idev
2108 = container_of(cnf, struct in_device, cnf);
2109 return idev->dev->ifindex;
2113 static int devinet_conf_proc(struct ctl_table *ctl, int write,
2114 void __user *buffer,
2115 size_t *lenp, loff_t *ppos)
2117 int old_value = *(int *)ctl->data;
2118 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2119 int new_value = *(int *)ctl->data;
2122 struct ipv4_devconf *cnf = ctl->extra1;
2123 struct net *net = ctl->extra2;
2124 int i = (int *)ctl->data - cnf->data;
2127 set_bit(i, cnf->state);
2129 if (cnf == net->ipv4.devconf_dflt)
2130 devinet_copy_dflt_conf(net, i);
2131 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2132 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2133 if ((new_value == 0) && (old_value != 0))
2134 rt_cache_flush(net);
2136 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2137 new_value != old_value) {
2138 ifindex = devinet_conf_ifindex(net, cnf);
2139 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2143 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2144 new_value != old_value) {
2145 ifindex = devinet_conf_ifindex(net, cnf);
2146 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2147 NETCONFA_PROXY_NEIGH,
2150 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2151 new_value != old_value) {
2152 ifindex = devinet_conf_ifindex(net, cnf);
2153 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2154 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2162 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2163 void __user *buffer,
2164 size_t *lenp, loff_t *ppos)
2166 int *valp = ctl->data;
2169 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2171 if (write && *valp != val) {
2172 struct net *net = ctl->extra2;
2174 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2175 if (!rtnl_trylock()) {
2176 /* Restore the original values before restarting */
2179 return restart_syscall();
2181 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2182 inet_forward_change(net);
2184 struct ipv4_devconf *cnf = ctl->extra1;
2185 struct in_device *idev =
2186 container_of(cnf, struct in_device, cnf);
2188 dev_disable_lro(idev->dev);
2189 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2190 NETCONFA_FORWARDING,
2195 rt_cache_flush(net);
2197 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2198 NETCONFA_FORWARDING,
2199 NETCONFA_IFINDEX_DEFAULT,
2200 net->ipv4.devconf_dflt);
2206 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2207 void __user *buffer,
2208 size_t *lenp, loff_t *ppos)
2210 int *valp = ctl->data;
2212 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2213 struct net *net = ctl->extra2;
2215 if (write && *valp != val)
2216 rt_cache_flush(net);
2221 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2224 .data = ipv4_devconf.data + \
2225 IPV4_DEVCONF_ ## attr - 1, \
2226 .maxlen = sizeof(int), \
2228 .proc_handler = proc, \
2229 .extra1 = &ipv4_devconf, \
2232 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2233 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2235 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2236 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2238 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2239 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2241 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2242 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2244 static struct devinet_sysctl_table {
2245 struct ctl_table_header *sysctl_header;
2246 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
2247 } devinet_sysctl = {
2249 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2250 devinet_sysctl_forward),
2251 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2253 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2254 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2255 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2256 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2257 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2258 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2259 "accept_source_route"),
2260 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2261 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2262 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2263 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2264 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2265 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2266 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2267 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2268 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2269 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2270 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2271 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2272 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2273 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2274 "force_igmp_version"),
2275 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2276 "igmpv2_unsolicited_report_interval"),
2277 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2278 "igmpv3_unsolicited_report_interval"),
2279 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2280 "ignore_routes_with_linkdown"),
2281 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2282 "drop_gratuitous_arp"),
2284 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2285 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
2286 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2287 "promote_secondaries"),
2288 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2290 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2291 "drop_unicast_in_l2_multicast"),
2295 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2296 int ifindex, struct ipv4_devconf *p)
2299 struct devinet_sysctl_table *t;
2300 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2302 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
2306 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2307 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2308 t->devinet_vars[i].extra1 = p;
2309 t->devinet_vars[i].extra2 = net;
2312 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2314 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2315 if (!t->sysctl_header)
2320 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
2330 static void __devinet_sysctl_unregister(struct net *net,
2331 struct ipv4_devconf *cnf, int ifindex)
2333 struct devinet_sysctl_table *t = cnf->sysctl;
2337 unregister_net_sysctl_table(t->sysctl_header);
2341 inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2344 static int devinet_sysctl_register(struct in_device *idev)
2348 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2351 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2354 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2355 idev->dev->ifindex, &idev->cnf);
2357 neigh_sysctl_unregister(idev->arp_parms);
2361 static void devinet_sysctl_unregister(struct in_device *idev)
2363 struct net *net = dev_net(idev->dev);
2365 __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2366 neigh_sysctl_unregister(idev->arp_parms);
2369 static struct ctl_table ctl_forward_entry[] = {
2371 .procname = "ip_forward",
2372 .data = &ipv4_devconf.data[
2373 IPV4_DEVCONF_FORWARDING - 1],
2374 .maxlen = sizeof(int),
2376 .proc_handler = devinet_sysctl_forward,
2377 .extra1 = &ipv4_devconf,
2378 .extra2 = &init_net,
2384 static __net_init int devinet_init_net(struct net *net)
2387 struct ipv4_devconf *all, *dflt;
2388 #ifdef CONFIG_SYSCTL
2389 struct ctl_table *tbl = ctl_forward_entry;
2390 struct ctl_table_header *forw_hdr;
2394 all = &ipv4_devconf;
2395 dflt = &ipv4_devconf_dflt;
2397 if (!net_eq(net, &init_net)) {
2398 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2402 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2404 goto err_alloc_dflt;
2406 #ifdef CONFIG_SYSCTL
2407 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2411 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2412 tbl[0].extra1 = all;
2413 tbl[0].extra2 = net;
2417 #ifdef CONFIG_SYSCTL
2418 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2422 err = __devinet_sysctl_register(net, "default",
2423 NETCONFA_IFINDEX_DEFAULT, dflt);
2428 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2431 net->ipv4.forw_hdr = forw_hdr;
2434 net->ipv4.devconf_all = all;
2435 net->ipv4.devconf_dflt = dflt;
2438 #ifdef CONFIG_SYSCTL
2440 __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2442 __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2444 if (tbl != ctl_forward_entry)
2448 if (dflt != &ipv4_devconf_dflt)
2451 if (all != &ipv4_devconf)
2457 static __net_exit void devinet_exit_net(struct net *net)
2459 #ifdef CONFIG_SYSCTL
2460 struct ctl_table *tbl;
2462 tbl = net->ipv4.forw_hdr->ctl_table_arg;
2463 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2464 __devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
2465 NETCONFA_IFINDEX_DEFAULT);
2466 __devinet_sysctl_unregister(net, net->ipv4.devconf_all,
2467 NETCONFA_IFINDEX_ALL);
2470 kfree(net->ipv4.devconf_dflt);
2471 kfree(net->ipv4.devconf_all);
2474 static __net_initdata struct pernet_operations devinet_ops = {
2475 .init = devinet_init_net,
2476 .exit = devinet_exit_net,
2479 static struct rtnl_af_ops inet_af_ops __read_mostly = {
2481 .fill_link_af = inet_fill_link_af,
2482 .get_link_af_size = inet_get_link_af_size,
2483 .validate_link_af = inet_validate_link_af,
2484 .set_link_af = inet_set_link_af,
2487 void __init devinet_init(void)
2491 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2492 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2494 register_pernet_subsys(&devinet_ops);
2496 register_gifconf(PF_INET, inet_gifconf);
2497 register_netdevice_notifier(&ip_netdev_notifier);
2499 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
2501 rtnl_af_register(&inet_af_ops);
2503 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0);
2504 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0);
2505 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0);
2506 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2507 inet_netconf_dump_devconf, 0);