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 struct net_device
*result
= NULL
;
146 struct in_ifaddr
*ifa
;
149 ifa
= inet_lookup_ifaddr_rcu(net
, addr
);
151 struct flowi4 fl4
= { .daddr
= addr
};
152 struct fib_result res
= { 0 };
153 struct fib_table
*local
;
155 /* Fallback to FIB local table so that communication
156 * over loopback subnets work.
158 local
= fib_get_table(net
, RT_TABLE_LOCAL
);
160 !fib_table_lookup(local
, &fl4
, &res
, FIB_LOOKUP_NOREF
) &&
161 res
.type
== RTN_LOCAL
)
162 result
= FIB_RES_DEV(res
);
164 result
= ifa
->ifa_dev
->dev
;
166 if (result
&& devref
)
171 EXPORT_SYMBOL(__ip_dev_find
);
173 /* called under RCU lock */
174 struct in_ifaddr
*inet_lookup_ifaddr_rcu(struct net
*net
, __be32 addr
)
176 u32 hash
= inet_addr_hash(net
, addr
);
177 struct in_ifaddr
*ifa
;
179 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[hash
], hash
)
180 if (ifa
->ifa_local
== addr
&&
181 net_eq(dev_net(ifa
->ifa_dev
->dev
), net
))
187 static void rtmsg_ifa(int event
, struct in_ifaddr
*, struct nlmsghdr
*, u32
);
189 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain
);
190 static BLOCKING_NOTIFIER_HEAD(inetaddr_validator_chain
);
191 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
194 static int devinet_sysctl_register(struct in_device
*idev
);
195 static void devinet_sysctl_unregister(struct in_device
*idev
);
197 static int devinet_sysctl_register(struct in_device
*idev
)
201 static void devinet_sysctl_unregister(struct in_device
*idev
)
206 /* Locks all the inet devices. */
208 static struct in_ifaddr
*inet_alloc_ifa(void)
210 return kzalloc(sizeof(struct in_ifaddr
), GFP_KERNEL
);
213 static void inet_rcu_free_ifa(struct rcu_head
*head
)
215 struct in_ifaddr
*ifa
= container_of(head
, struct in_ifaddr
, rcu_head
);
217 in_dev_put(ifa
->ifa_dev
);
221 static void inet_free_ifa(struct in_ifaddr
*ifa
)
223 call_rcu(&ifa
->rcu_head
, inet_rcu_free_ifa
);
226 void in_dev_finish_destroy(struct in_device
*idev
)
228 struct net_device
*dev
= idev
->dev
;
230 WARN_ON(idev
->ifa_list
);
231 WARN_ON(idev
->mc_list
);
232 kfree(rcu_dereference_protected(idev
->mc_hash
, 1));
233 #ifdef NET_REFCNT_DEBUG
234 pr_debug("%s: %p=%s\n", __func__
, idev
, dev
? dev
->name
: "NIL");
238 pr_err("Freeing alive in_device %p\n", idev
);
242 EXPORT_SYMBOL(in_dev_finish_destroy
);
244 static struct in_device
*inetdev_init(struct net_device
*dev
)
246 struct in_device
*in_dev
;
251 in_dev
= kzalloc(sizeof(*in_dev
), GFP_KERNEL
);
254 memcpy(&in_dev
->cnf
, dev_net(dev
)->ipv4
.devconf_dflt
,
255 sizeof(in_dev
->cnf
));
256 in_dev
->cnf
.sysctl
= NULL
;
258 in_dev
->arp_parms
= neigh_parms_alloc(dev
, &arp_tbl
);
259 if (!in_dev
->arp_parms
)
261 if (IPV4_DEVCONF(in_dev
->cnf
, FORWARDING
))
262 dev_disable_lro(dev
);
263 /* Reference in_dev->dev */
265 /* Account for reference dev->ip_ptr (below) */
266 refcount_set(&in_dev
->refcnt
, 1);
268 err
= devinet_sysctl_register(in_dev
);
275 ip_mc_init_dev(in_dev
);
276 if (dev
->flags
& IFF_UP
)
279 /* we can receive as soon as ip_ptr is set -- do this last */
280 rcu_assign_pointer(dev
->ip_ptr
, in_dev
);
282 return in_dev
?: ERR_PTR(err
);
289 static void in_dev_rcu_put(struct rcu_head
*head
)
291 struct in_device
*idev
= container_of(head
, struct in_device
, rcu_head
);
295 static void inetdev_destroy(struct in_device
*in_dev
)
297 struct in_ifaddr
*ifa
;
298 struct net_device
*dev
;
306 ip_mc_destroy_dev(in_dev
);
308 while ((ifa
= in_dev
->ifa_list
) != NULL
) {
309 inet_del_ifa(in_dev
, &in_dev
->ifa_list
, 0);
313 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
315 devinet_sysctl_unregister(in_dev
);
316 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
319 call_rcu(&in_dev
->rcu_head
, in_dev_rcu_put
);
322 int inet_addr_onlink(struct in_device
*in_dev
, __be32 a
, __be32 b
)
325 for_primary_ifa(in_dev
) {
326 if (inet_ifa_match(a
, ifa
)) {
327 if (!b
|| inet_ifa_match(b
, ifa
)) {
332 } endfor_ifa(in_dev
);
337 static void __inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
338 int destroy
, struct nlmsghdr
*nlh
, u32 portid
)
340 struct in_ifaddr
*promote
= NULL
;
341 struct in_ifaddr
*ifa
, *ifa1
= *ifap
;
342 struct in_ifaddr
*last_prim
= in_dev
->ifa_list
;
343 struct in_ifaddr
*prev_prom
= NULL
;
344 int do_promote
= IN_DEV_PROMOTE_SECONDARIES(in_dev
);
351 /* 1. Deleting primary ifaddr forces deletion all secondaries
352 * unless alias promotion is set
355 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
)) {
356 struct in_ifaddr
**ifap1
= &ifa1
->ifa_next
;
358 while ((ifa
= *ifap1
) != NULL
) {
359 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) &&
360 ifa1
->ifa_scope
<= ifa
->ifa_scope
)
363 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) ||
364 ifa1
->ifa_mask
!= ifa
->ifa_mask
||
365 !inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
366 ifap1
= &ifa
->ifa_next
;
372 inet_hash_remove(ifa
);
373 *ifap1
= ifa
->ifa_next
;
375 rtmsg_ifa(RTM_DELADDR
, ifa
, nlh
, portid
);
376 blocking_notifier_call_chain(&inetaddr_chain
,
386 /* On promotion all secondaries from subnet are changing
387 * the primary IP, we must remove all their routes silently
388 * and later to add them back with new prefsrc. Do this
389 * while all addresses are on the device list.
391 for (ifa
= promote
; ifa
; ifa
= ifa
->ifa_next
) {
392 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
393 inet_ifa_match(ifa1
->ifa_address
, ifa
))
394 fib_del_ifaddr(ifa
, ifa1
);
400 *ifap
= ifa1
->ifa_next
;
401 inet_hash_remove(ifa1
);
403 /* 3. Announce address deletion */
405 /* Send message first, then call notifier.
406 At first sight, FIB update triggered by notifier
407 will refer to already deleted ifaddr, that could confuse
408 netlink listeners. It is not true: look, gated sees
409 that route deleted and if it still thinks that ifaddr
410 is valid, it will try to restore deleted routes... Grr.
411 So that, this order is correct.
413 rtmsg_ifa(RTM_DELADDR
, ifa1
, nlh
, portid
);
414 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_DOWN
, ifa1
);
417 struct in_ifaddr
*next_sec
= promote
->ifa_next
;
420 prev_prom
->ifa_next
= promote
->ifa_next
;
421 promote
->ifa_next
= last_prim
->ifa_next
;
422 last_prim
->ifa_next
= promote
;
425 promote
->ifa_flags
&= ~IFA_F_SECONDARY
;
426 rtmsg_ifa(RTM_NEWADDR
, promote
, nlh
, portid
);
427 blocking_notifier_call_chain(&inetaddr_chain
,
429 for (ifa
= next_sec
; ifa
; ifa
= ifa
->ifa_next
) {
430 if (ifa1
->ifa_mask
!= ifa
->ifa_mask
||
431 !inet_ifa_match(ifa1
->ifa_address
, ifa
))
441 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
444 __inet_del_ifa(in_dev
, ifap
, destroy
, NULL
, 0);
447 static void check_lifetime(struct work_struct
*work
);
449 static DECLARE_DELAYED_WORK(check_lifetime_work
, check_lifetime
);
451 static int __inet_insert_ifa(struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
452 u32 portid
, struct netlink_ext_ack
*extack
)
454 struct in_device
*in_dev
= ifa
->ifa_dev
;
455 struct in_ifaddr
*ifa1
, **ifap
, **last_primary
;
456 struct in_validator_info ivi
;
461 if (!ifa
->ifa_local
) {
466 ifa
->ifa_flags
&= ~IFA_F_SECONDARY
;
467 last_primary
= &in_dev
->ifa_list
;
469 /* Don't set IPv6 only flags to IPv4 addresses */
470 ifa
->ifa_flags
&= ~IPV6ONLY_FLAGS
;
472 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
473 ifap
= &ifa1
->ifa_next
) {
474 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
) &&
475 ifa
->ifa_scope
<= ifa1
->ifa_scope
)
476 last_primary
= &ifa1
->ifa_next
;
477 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
478 inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
479 if (ifa1
->ifa_local
== ifa
->ifa_local
) {
483 if (ifa1
->ifa_scope
!= ifa
->ifa_scope
) {
487 ifa
->ifa_flags
|= IFA_F_SECONDARY
;
491 /* Allow any devices that wish to register ifaddr validtors to weigh
492 * in now, before changes are committed. The rntl lock is serializing
493 * access here, so the state should not change between a validator call
494 * and a final notify on commit. This isn't invoked on promotion under
495 * the assumption that validators are checking the address itself, and
498 ivi
.ivi_addr
= ifa
->ifa_address
;
499 ivi
.ivi_dev
= ifa
->ifa_dev
;
501 ret
= blocking_notifier_call_chain(&inetaddr_validator_chain
,
503 ret
= notifier_to_errno(ret
);
509 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
)) {
510 prandom_seed((__force u32
) ifa
->ifa_local
);
514 ifa
->ifa_next
= *ifap
;
517 inet_hash_insert(dev_net(in_dev
->dev
), ifa
);
519 cancel_delayed_work(&check_lifetime_work
);
520 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
522 /* Send message first, then call notifier.
523 Notifier will trigger FIB update, so that
524 listeners of netlink will know about new ifaddr */
525 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, portid
);
526 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
531 static int inet_insert_ifa(struct in_ifaddr
*ifa
)
533 return __inet_insert_ifa(ifa
, NULL
, 0, NULL
);
536 static int inet_set_ifa(struct net_device
*dev
, struct in_ifaddr
*ifa
)
538 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
546 ipv4_devconf_setall(in_dev
);
547 neigh_parms_data_state_setall(in_dev
->arp_parms
);
548 if (ifa
->ifa_dev
!= in_dev
) {
549 WARN_ON(ifa
->ifa_dev
);
551 ifa
->ifa_dev
= in_dev
;
553 if (ipv4_is_loopback(ifa
->ifa_local
))
554 ifa
->ifa_scope
= RT_SCOPE_HOST
;
555 return inet_insert_ifa(ifa
);
558 /* Caller must hold RCU or RTNL :
559 * We dont take a reference on found in_device
561 struct in_device
*inetdev_by_index(struct net
*net
, int ifindex
)
563 struct net_device
*dev
;
564 struct in_device
*in_dev
= NULL
;
567 dev
= dev_get_by_index_rcu(net
, ifindex
);
569 in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
573 EXPORT_SYMBOL(inetdev_by_index
);
575 /* Called only from RTNL semaphored context. No locks. */
577 struct in_ifaddr
*inet_ifa_byprefix(struct in_device
*in_dev
, __be32 prefix
,
582 for_primary_ifa(in_dev
) {
583 if (ifa
->ifa_mask
== mask
&& inet_ifa_match(prefix
, ifa
))
585 } endfor_ifa(in_dev
);
589 static int ip_mc_config(struct sock
*sk
, bool join
, const struct in_ifaddr
*ifa
)
591 struct ip_mreqn mreq
= {
592 .imr_multiaddr
.s_addr
= ifa
->ifa_address
,
593 .imr_ifindex
= ifa
->ifa_dev
->dev
->ifindex
,
601 ret
= ip_mc_join_group(sk
, &mreq
);
603 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_config(net
->ipv4
.mc_autojoin_sk
, 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_config(net
->ipv4
.mc_autojoin_sk
,
914 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).portid
,
919 if (nlh
->nlmsg_flags
& NLM_F_EXCL
||
920 !(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
923 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
924 cancel_delayed_work(&check_lifetime_work
);
925 queue_delayed_work(system_power_efficient_wq
,
926 &check_lifetime_work
, 0);
927 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, NETLINK_CB(skb
).portid
);
933 * Determine a default network mask, based on the IP address.
936 static int inet_abc_len(__be32 addr
)
938 int rc
= -1; /* Something else, probably a multicast. */
940 if (ipv4_is_zeronet(addr
))
943 __u32 haddr
= ntohl(addr
);
945 if (IN_CLASSA(haddr
))
947 else if (IN_CLASSB(haddr
))
949 else if (IN_CLASSC(haddr
))
957 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
960 struct sockaddr_in sin_orig
;
961 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
962 struct in_device
*in_dev
;
963 struct in_ifaddr
**ifap
= NULL
;
964 struct in_ifaddr
*ifa
= NULL
;
965 struct net_device
*dev
;
968 int tryaddrmatch
= 0;
971 * Fetch the caller's info block into kernel space
974 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
976 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
978 /* save original address for comparison */
979 memcpy(&sin_orig
, sin
, sizeof(*sin
));
981 colon
= strchr(ifr
.ifr_name
, ':');
985 dev_load(net
, ifr
.ifr_name
);
988 case SIOCGIFADDR
: /* Get interface address */
989 case SIOCGIFBRDADDR
: /* Get the broadcast address */
990 case SIOCGIFDSTADDR
: /* Get the destination address */
991 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
992 /* Note that these ioctls will not sleep,
993 so that we do not impose a lock.
994 One day we will be forced to put shlock here (I mean SMP)
996 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
997 memset(sin
, 0, sizeof(*sin
));
998 sin
->sin_family
= AF_INET
;
1003 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1006 case SIOCSIFADDR
: /* Set interface address (and family) */
1007 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1008 case SIOCSIFDSTADDR
: /* Set the destination address */
1009 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1011 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1014 if (sin
->sin_family
!= AF_INET
)
1025 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
1032 in_dev
= __in_dev_get_rtnl(dev
);
1035 /* Matthias Andree */
1036 /* compare label and address (4.4BSD style) */
1037 /* note: we only do this for a limited set of ioctls
1038 and only if the original address family was AF_INET.
1039 This is checked above. */
1040 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1041 ifap
= &ifa
->ifa_next
) {
1042 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
1043 sin_orig
.sin_addr
.s_addr
==
1049 /* we didn't get a match, maybe the application is
1050 4.3BSD-style and passed in junk so we fall back to
1051 comparing just the label */
1053 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1054 ifap
= &ifa
->ifa_next
)
1055 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
1060 ret
= -EADDRNOTAVAIL
;
1061 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
1065 case SIOCGIFADDR
: /* Get interface address */
1066 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
1069 case SIOCGIFBRDADDR
: /* Get the broadcast address */
1070 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
1073 case SIOCGIFDSTADDR
: /* Get the destination address */
1074 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
1077 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
1078 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
1083 ret
= -EADDRNOTAVAIL
;
1087 if (!(ifr
.ifr_flags
& IFF_UP
))
1088 inet_del_ifa(in_dev
, ifap
, 1);
1091 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
1094 case SIOCSIFADDR
: /* Set interface address (and family) */
1096 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1101 ifa
= inet_alloc_ifa();
1104 INIT_HLIST_NODE(&ifa
->hash
);
1106 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
1108 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1111 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
1113 inet_del_ifa(in_dev
, ifap
, 0);
1114 ifa
->ifa_broadcast
= 0;
1118 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
1120 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
1121 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
1122 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
1123 if ((dev
->flags
& IFF_BROADCAST
) &&
1124 ifa
->ifa_prefixlen
< 31)
1125 ifa
->ifa_broadcast
= ifa
->ifa_address
|
1128 ifa
->ifa_prefixlen
= 32;
1129 ifa
->ifa_mask
= inet_make_mask(32);
1131 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
, INFINITY_LIFE_TIME
);
1132 ret
= inet_set_ifa(dev
, ifa
);
1135 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1137 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
1138 inet_del_ifa(in_dev
, ifap
, 0);
1139 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
1140 inet_insert_ifa(ifa
);
1144 case SIOCSIFDSTADDR
: /* Set the destination address */
1146 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
1149 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1152 inet_del_ifa(in_dev
, ifap
, 0);
1153 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
1154 inet_insert_ifa(ifa
);
1157 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1160 * The mask we set must be legal.
1163 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
1166 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
1167 __be32 old_mask
= ifa
->ifa_mask
;
1168 inet_del_ifa(in_dev
, ifap
, 0);
1169 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
1170 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
1172 /* See if current broadcast address matches
1173 * with current netmask, then recalculate
1174 * the broadcast address. Otherwise it's a
1175 * funny address, so don't touch it since
1176 * the user seems to know what (s)he's doing...
1178 if ((dev
->flags
& IFF_BROADCAST
) &&
1179 (ifa
->ifa_prefixlen
< 31) &&
1180 (ifa
->ifa_broadcast
==
1181 (ifa
->ifa_local
|~old_mask
))) {
1182 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
1183 ~sin
->sin_addr
.s_addr
);
1185 inet_insert_ifa(ifa
);
1195 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
1199 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
1201 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1202 struct in_ifaddr
*ifa
;
1209 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1211 done
+= sizeof(ifr
);
1214 if (len
< (int) sizeof(ifr
))
1216 memset(&ifr
, 0, sizeof(struct ifreq
));
1217 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
1219 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
1220 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
1223 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
1227 buf
+= sizeof(struct ifreq
);
1228 len
-= sizeof(struct ifreq
);
1229 done
+= sizeof(struct ifreq
);
1235 static __be32
in_dev_select_addr(const struct in_device
*in_dev
,
1238 for_primary_ifa(in_dev
) {
1239 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1240 ifa
->ifa_scope
<= scope
)
1241 return ifa
->ifa_local
;
1242 } endfor_ifa(in_dev
);
1247 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
1250 struct in_device
*in_dev
;
1251 struct net
*net
= dev_net(dev
);
1255 in_dev
= __in_dev_get_rcu(dev
);
1259 for_primary_ifa(in_dev
) {
1260 if (ifa
->ifa_scope
> scope
)
1262 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
1263 addr
= ifa
->ifa_local
;
1267 addr
= ifa
->ifa_local
;
1268 } endfor_ifa(in_dev
);
1273 master_idx
= l3mdev_master_ifindex_rcu(dev
);
1275 /* For VRFs, the VRF device takes the place of the loopback device,
1276 * with addresses on it being preferred. Note in such cases the
1277 * loopback device will be among the devices that fail the master_idx
1278 * equality check in the loop below.
1281 (dev
= dev_get_by_index_rcu(net
, master_idx
)) &&
1282 (in_dev
= __in_dev_get_rcu(dev
))) {
1283 addr
= in_dev_select_addr(in_dev
, scope
);
1288 /* Not loopback addresses on loopback should be preferred
1289 in this case. It is important that lo is the first interface
1292 for_each_netdev_rcu(net
, dev
) {
1293 if (l3mdev_master_ifindex_rcu(dev
) != master_idx
)
1296 in_dev
= __in_dev_get_rcu(dev
);
1300 addr
= in_dev_select_addr(in_dev
, scope
);
1308 EXPORT_SYMBOL(inet_select_addr
);
1310 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1311 __be32 local
, int scope
)
1318 (local
== ifa
->ifa_local
|| !local
) &&
1319 ifa
->ifa_scope
<= scope
) {
1320 addr
= ifa
->ifa_local
;
1325 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1326 (!dst
|| inet_ifa_match(dst
, ifa
));
1330 /* Is the selected addr into dst subnet? */
1331 if (inet_ifa_match(addr
, ifa
))
1333 /* No, then can we use new local src? */
1334 if (ifa
->ifa_scope
<= scope
) {
1335 addr
= ifa
->ifa_local
;
1338 /* search for large dst subnet for addr */
1342 } endfor_ifa(in_dev
);
1344 return same
? addr
: 0;
1348 * Confirm that local IP address exists using wildcards:
1349 * - net: netns to check, cannot be NULL
1350 * - in_dev: only on this interface, NULL=any interface
1351 * - dst: only in the same subnet as dst, 0=any dst
1352 * - local: address, 0=autoselect the local address
1353 * - scope: maximum allowed scope value for the local address
1355 __be32
inet_confirm_addr(struct net
*net
, struct in_device
*in_dev
,
1356 __be32 dst
, __be32 local
, int scope
)
1359 struct net_device
*dev
;
1362 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1365 for_each_netdev_rcu(net
, dev
) {
1366 in_dev
= __in_dev_get_rcu(dev
);
1368 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1377 EXPORT_SYMBOL(inet_confirm_addr
);
1383 int register_inetaddr_notifier(struct notifier_block
*nb
)
1385 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1387 EXPORT_SYMBOL(register_inetaddr_notifier
);
1389 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1391 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1393 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1395 int register_inetaddr_validator_notifier(struct notifier_block
*nb
)
1397 return blocking_notifier_chain_register(&inetaddr_validator_chain
, nb
);
1399 EXPORT_SYMBOL(register_inetaddr_validator_notifier
);
1401 int unregister_inetaddr_validator_notifier(struct notifier_block
*nb
)
1403 return blocking_notifier_chain_unregister(&inetaddr_validator_chain
,
1406 EXPORT_SYMBOL(unregister_inetaddr_validator_notifier
);
1408 /* Rename ifa_labels for a device name change. Make some effort to preserve
1409 * existing alias numbering and to create unique labels if possible.
1411 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1413 struct in_ifaddr
*ifa
;
1416 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1417 char old
[IFNAMSIZ
], *dot
;
1419 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1420 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1423 dot
= strchr(old
, ':');
1425 sprintf(old
, ":%d", named
);
1428 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1429 strcat(ifa
->ifa_label
, dot
);
1431 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1433 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1437 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1438 struct in_device
*in_dev
)
1441 struct in_ifaddr
*ifa
;
1443 for (ifa
= in_dev
->ifa_list
; ifa
;
1444 ifa
= ifa
->ifa_next
) {
1445 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1446 ifa
->ifa_local
, dev
,
1447 ifa
->ifa_local
, NULL
,
1448 dev
->dev_addr
, NULL
);
1452 /* Called only under RTNL semaphore */
1454 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1457 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1458 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1463 if (event
== NETDEV_REGISTER
) {
1464 in_dev
= inetdev_init(dev
);
1466 return notifier_from_errno(PTR_ERR(in_dev
));
1467 if (dev
->flags
& IFF_LOOPBACK
) {
1468 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1469 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1471 } else if (event
== NETDEV_CHANGEMTU
) {
1472 /* Re-enabling IP */
1473 if (inetdev_valid_mtu(dev
->mtu
))
1474 in_dev
= inetdev_init(dev
);
1480 case NETDEV_REGISTER
:
1481 pr_debug("%s: bug\n", __func__
);
1482 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1485 if (!inetdev_valid_mtu(dev
->mtu
))
1487 if (dev
->flags
& IFF_LOOPBACK
) {
1488 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1491 INIT_HLIST_NODE(&ifa
->hash
);
1493 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1494 ifa
->ifa_prefixlen
= 8;
1495 ifa
->ifa_mask
= inet_make_mask(8);
1496 in_dev_hold(in_dev
);
1497 ifa
->ifa_dev
= in_dev
;
1498 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1499 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1500 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
,
1501 INFINITY_LIFE_TIME
);
1502 ipv4_devconf_setall(in_dev
);
1503 neigh_parms_data_state_setall(in_dev
->arp_parms
);
1504 inet_insert_ifa(ifa
);
1509 case NETDEV_CHANGEADDR
:
1510 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1513 case NETDEV_NOTIFY_PEERS
:
1514 /* Send gratuitous ARP to notify of link change */
1515 inetdev_send_gratuitous_arp(dev
, in_dev
);
1520 case NETDEV_PRE_TYPE_CHANGE
:
1521 ip_mc_unmap(in_dev
);
1523 case NETDEV_POST_TYPE_CHANGE
:
1524 ip_mc_remap(in_dev
);
1526 case NETDEV_CHANGEMTU
:
1527 if (inetdev_valid_mtu(dev
->mtu
))
1529 /* disable IP when MTU is not enough */
1531 case NETDEV_UNREGISTER
:
1532 inetdev_destroy(in_dev
);
1534 case NETDEV_CHANGENAME
:
1535 /* Do not notify about label change, this event is
1536 * not interesting to applications using netlink.
1538 inetdev_changename(dev
, in_dev
);
1540 devinet_sysctl_unregister(in_dev
);
1541 devinet_sysctl_register(in_dev
);
1548 static struct notifier_block ip_netdev_notifier
= {
1549 .notifier_call
= inetdev_event
,
1552 static size_t inet_nlmsg_size(void)
1554 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1555 + nla_total_size(4) /* IFA_ADDRESS */
1556 + nla_total_size(4) /* IFA_LOCAL */
1557 + nla_total_size(4) /* IFA_BROADCAST */
1558 + nla_total_size(IFNAMSIZ
) /* IFA_LABEL */
1559 + nla_total_size(4) /* IFA_FLAGS */
1560 + nla_total_size(sizeof(struct ifa_cacheinfo
)); /* IFA_CACHEINFO */
1563 static inline u32
cstamp_delta(unsigned long cstamp
)
1565 return (cstamp
- INITIAL_JIFFIES
) * 100UL / HZ
;
1568 static int put_cacheinfo(struct sk_buff
*skb
, unsigned long cstamp
,
1569 unsigned long tstamp
, u32 preferred
, u32 valid
)
1571 struct ifa_cacheinfo ci
;
1573 ci
.cstamp
= cstamp_delta(cstamp
);
1574 ci
.tstamp
= cstamp_delta(tstamp
);
1575 ci
.ifa_prefered
= preferred
;
1576 ci
.ifa_valid
= valid
;
1578 return nla_put(skb
, IFA_CACHEINFO
, sizeof(ci
), &ci
);
1581 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1582 u32 portid
, u32 seq
, int event
, unsigned int flags
)
1584 struct ifaddrmsg
*ifm
;
1585 struct nlmsghdr
*nlh
;
1586 u32 preferred
, valid
;
1588 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*ifm
), flags
);
1592 ifm
= nlmsg_data(nlh
);
1593 ifm
->ifa_family
= AF_INET
;
1594 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1595 ifm
->ifa_flags
= ifa
->ifa_flags
;
1596 ifm
->ifa_scope
= ifa
->ifa_scope
;
1597 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1599 if (!(ifm
->ifa_flags
& IFA_F_PERMANENT
)) {
1600 preferred
= ifa
->ifa_preferred_lft
;
1601 valid
= ifa
->ifa_valid_lft
;
1602 if (preferred
!= INFINITY_LIFE_TIME
) {
1603 long tval
= (jiffies
- ifa
->ifa_tstamp
) / HZ
;
1605 if (preferred
> tval
)
1609 if (valid
!= INFINITY_LIFE_TIME
) {
1617 preferred
= INFINITY_LIFE_TIME
;
1618 valid
= INFINITY_LIFE_TIME
;
1620 if ((ifa
->ifa_address
&&
1621 nla_put_in_addr(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1623 nla_put_in_addr(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1624 (ifa
->ifa_broadcast
&&
1625 nla_put_in_addr(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1626 (ifa
->ifa_label
[0] &&
1627 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)) ||
1628 nla_put_u32(skb
, IFA_FLAGS
, ifa
->ifa_flags
) ||
1629 put_cacheinfo(skb
, ifa
->ifa_cstamp
, ifa
->ifa_tstamp
,
1631 goto nla_put_failure
;
1633 nlmsg_end(skb
, nlh
);
1637 nlmsg_cancel(skb
, nlh
);
1641 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1643 struct net
*net
= sock_net(skb
->sk
);
1646 int ip_idx
, s_ip_idx
;
1647 struct net_device
*dev
;
1648 struct in_device
*in_dev
;
1649 struct in_ifaddr
*ifa
;
1650 struct hlist_head
*head
;
1653 s_idx
= idx
= cb
->args
[1];
1654 s_ip_idx
= ip_idx
= cb
->args
[2];
1656 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1658 head
= &net
->dev_index_head
[h
];
1660 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1662 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1665 if (h
> s_h
|| idx
> s_idx
)
1667 in_dev
= __in_dev_get_rcu(dev
);
1671 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1672 ifa
= ifa
->ifa_next
, ip_idx
++) {
1673 if (ip_idx
< s_ip_idx
)
1675 if (inet_fill_ifaddr(skb
, ifa
,
1676 NETLINK_CB(cb
->skb
).portid
,
1678 RTM_NEWADDR
, NLM_F_MULTI
) < 0) {
1682 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1693 cb
->args
[2] = ip_idx
;
1698 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1701 struct sk_buff
*skb
;
1702 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1706 net
= dev_net(ifa
->ifa_dev
->dev
);
1707 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1711 err
= inet_fill_ifaddr(skb
, ifa
, portid
, seq
, event
, 0);
1713 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1714 WARN_ON(err
== -EMSGSIZE
);
1718 rtnl_notify(skb
, net
, portid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1722 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1725 static size_t inet_get_link_af_size(const struct net_device
*dev
,
1726 u32 ext_filter_mask
)
1728 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1733 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1736 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
,
1737 u32 ext_filter_mask
)
1739 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1746 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1750 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1751 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1756 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1757 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1760 static int inet_validate_link_af(const struct net_device
*dev
,
1761 const struct nlattr
*nla
)
1763 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1766 if (dev
&& !__in_dev_get_rcu(dev
))
1767 return -EAFNOSUPPORT
;
1769 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
, NULL
);
1773 if (tb
[IFLA_INET_CONF
]) {
1774 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1775 int cfgid
= nla_type(a
);
1780 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1788 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1790 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
1791 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1795 return -EAFNOSUPPORT
;
1797 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
, NULL
) < 0)
1800 if (tb
[IFLA_INET_CONF
]) {
1801 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1802 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1808 static int inet_netconf_msgsize_devconf(int type
)
1810 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1811 + nla_total_size(4); /* NETCONFA_IFINDEX */
1814 if (type
== NETCONFA_ALL
)
1817 if (all
|| type
== NETCONFA_FORWARDING
)
1818 size
+= nla_total_size(4);
1819 if (all
|| type
== NETCONFA_RP_FILTER
)
1820 size
+= nla_total_size(4);
1821 if (all
|| type
== NETCONFA_MC_FORWARDING
)
1822 size
+= nla_total_size(4);
1823 if (all
|| type
== NETCONFA_PROXY_NEIGH
)
1824 size
+= nla_total_size(4);
1825 if (all
|| type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
)
1826 size
+= nla_total_size(4);
1831 static int inet_netconf_fill_devconf(struct sk_buff
*skb
, int ifindex
,
1832 struct ipv4_devconf
*devconf
, u32 portid
,
1833 u32 seq
, int event
, unsigned int flags
,
1836 struct nlmsghdr
*nlh
;
1837 struct netconfmsg
*ncm
;
1840 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1845 if (type
== NETCONFA_ALL
)
1848 ncm
= nlmsg_data(nlh
);
1849 ncm
->ncm_family
= AF_INET
;
1851 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, ifindex
) < 0)
1852 goto nla_put_failure
;
1857 if ((all
|| type
== NETCONFA_FORWARDING
) &&
1858 nla_put_s32(skb
, NETCONFA_FORWARDING
,
1859 IPV4_DEVCONF(*devconf
, FORWARDING
)) < 0)
1860 goto nla_put_failure
;
1861 if ((all
|| type
== NETCONFA_RP_FILTER
) &&
1862 nla_put_s32(skb
, NETCONFA_RP_FILTER
,
1863 IPV4_DEVCONF(*devconf
, RP_FILTER
)) < 0)
1864 goto nla_put_failure
;
1865 if ((all
|| type
== NETCONFA_MC_FORWARDING
) &&
1866 nla_put_s32(skb
, NETCONFA_MC_FORWARDING
,
1867 IPV4_DEVCONF(*devconf
, MC_FORWARDING
)) < 0)
1868 goto nla_put_failure
;
1869 if ((all
|| type
== NETCONFA_PROXY_NEIGH
) &&
1870 nla_put_s32(skb
, NETCONFA_PROXY_NEIGH
,
1871 IPV4_DEVCONF(*devconf
, PROXY_ARP
)) < 0)
1872 goto nla_put_failure
;
1873 if ((all
|| type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
) &&
1874 nla_put_s32(skb
, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
1875 IPV4_DEVCONF(*devconf
, IGNORE_ROUTES_WITH_LINKDOWN
)) < 0)
1876 goto nla_put_failure
;
1879 nlmsg_end(skb
, nlh
);
1883 nlmsg_cancel(skb
, nlh
);
1887 void inet_netconf_notify_devconf(struct net
*net
, int event
, int type
,
1888 int ifindex
, struct ipv4_devconf
*devconf
)
1890 struct sk_buff
*skb
;
1893 skb
= nlmsg_new(inet_netconf_msgsize_devconf(type
), GFP_KERNEL
);
1897 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
, 0, 0,
1900 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1901 WARN_ON(err
== -EMSGSIZE
);
1905 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_NETCONF
, NULL
, GFP_KERNEL
);
1909 rtnl_set_sk_err(net
, RTNLGRP_IPV4_NETCONF
, err
);
1912 static const struct nla_policy devconf_ipv4_policy
[NETCONFA_MAX
+1] = {
1913 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1914 [NETCONFA_FORWARDING
] = { .len
= sizeof(int) },
1915 [NETCONFA_RP_FILTER
] = { .len
= sizeof(int) },
1916 [NETCONFA_PROXY_NEIGH
] = { .len
= sizeof(int) },
1917 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
] = { .len
= sizeof(int) },
1920 static int inet_netconf_get_devconf(struct sk_buff
*in_skb
,
1921 struct nlmsghdr
*nlh
,
1922 struct netlink_ext_ack
*extack
)
1924 struct net
*net
= sock_net(in_skb
->sk
);
1925 struct nlattr
*tb
[NETCONFA_MAX
+1];
1926 struct netconfmsg
*ncm
;
1927 struct sk_buff
*skb
;
1928 struct ipv4_devconf
*devconf
;
1929 struct in_device
*in_dev
;
1930 struct net_device
*dev
;
1934 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1935 devconf_ipv4_policy
, extack
);
1940 if (!tb
[NETCONFA_IFINDEX
])
1943 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1945 case NETCONFA_IFINDEX_ALL
:
1946 devconf
= net
->ipv4
.devconf_all
;
1948 case NETCONFA_IFINDEX_DEFAULT
:
1949 devconf
= net
->ipv4
.devconf_dflt
;
1952 dev
= __dev_get_by_index(net
, ifindex
);
1955 in_dev
= __in_dev_get_rtnl(dev
);
1958 devconf
= &in_dev
->cnf
;
1963 skb
= nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL
), GFP_KERNEL
);
1967 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
,
1968 NETLINK_CB(in_skb
).portid
,
1969 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1972 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1973 WARN_ON(err
== -EMSGSIZE
);
1977 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1982 static int inet_netconf_dump_devconf(struct sk_buff
*skb
,
1983 struct netlink_callback
*cb
)
1985 struct net
*net
= sock_net(skb
->sk
);
1988 struct net_device
*dev
;
1989 struct in_device
*in_dev
;
1990 struct hlist_head
*head
;
1993 s_idx
= idx
= cb
->args
[1];
1995 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1997 head
= &net
->dev_index_head
[h
];
1999 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
2001 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
2004 in_dev
= __in_dev_get_rcu(dev
);
2008 if (inet_netconf_fill_devconf(skb
, dev
->ifindex
,
2010 NETLINK_CB(cb
->skb
).portid
,
2014 NETCONFA_ALL
) < 0) {
2018 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
2024 if (h
== NETDEV_HASHENTRIES
) {
2025 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_ALL
,
2026 net
->ipv4
.devconf_all
,
2027 NETLINK_CB(cb
->skb
).portid
,
2029 RTM_NEWNETCONF
, NLM_F_MULTI
,
2035 if (h
== NETDEV_HASHENTRIES
+ 1) {
2036 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_DEFAULT
,
2037 net
->ipv4
.devconf_dflt
,
2038 NETLINK_CB(cb
->skb
).portid
,
2040 RTM_NEWNETCONF
, NLM_F_MULTI
,
2053 #ifdef CONFIG_SYSCTL
2055 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
2057 struct net_device
*dev
;
2060 for_each_netdev_rcu(net
, dev
) {
2061 struct in_device
*in_dev
;
2063 in_dev
= __in_dev_get_rcu(dev
);
2064 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
2065 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
2070 /* called with RTNL locked */
2071 static void inet_forward_change(struct net
*net
)
2073 struct net_device
*dev
;
2074 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
2076 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
2077 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
2078 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2079 NETCONFA_FORWARDING
,
2080 NETCONFA_IFINDEX_ALL
,
2081 net
->ipv4
.devconf_all
);
2082 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2083 NETCONFA_FORWARDING
,
2084 NETCONFA_IFINDEX_DEFAULT
,
2085 net
->ipv4
.devconf_dflt
);
2087 for_each_netdev(net
, dev
) {
2088 struct in_device
*in_dev
;
2091 dev_disable_lro(dev
);
2093 in_dev
= __in_dev_get_rtnl(dev
);
2095 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
2096 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2097 NETCONFA_FORWARDING
,
2098 dev
->ifindex
, &in_dev
->cnf
);
2103 static int devinet_conf_ifindex(struct net
*net
, struct ipv4_devconf
*cnf
)
2105 if (cnf
== net
->ipv4
.devconf_dflt
)
2106 return NETCONFA_IFINDEX_DEFAULT
;
2107 else if (cnf
== net
->ipv4
.devconf_all
)
2108 return NETCONFA_IFINDEX_ALL
;
2110 struct in_device
*idev
2111 = container_of(cnf
, struct in_device
, cnf
);
2112 return idev
->dev
->ifindex
;
2116 static int devinet_conf_proc(struct ctl_table
*ctl
, int write
,
2117 void __user
*buffer
,
2118 size_t *lenp
, loff_t
*ppos
)
2120 int old_value
= *(int *)ctl
->data
;
2121 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2122 int new_value
= *(int *)ctl
->data
;
2125 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2126 struct net
*net
= ctl
->extra2
;
2127 int i
= (int *)ctl
->data
- cnf
->data
;
2130 set_bit(i
, cnf
->state
);
2132 if (cnf
== net
->ipv4
.devconf_dflt
)
2133 devinet_copy_dflt_conf(net
, i
);
2134 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1 ||
2135 i
== IPV4_DEVCONF_ROUTE_LOCALNET
- 1)
2136 if ((new_value
== 0) && (old_value
!= 0))
2137 rt_cache_flush(net
);
2139 if (i
== IPV4_DEVCONF_RP_FILTER
- 1 &&
2140 new_value
!= old_value
) {
2141 ifindex
= devinet_conf_ifindex(net
, cnf
);
2142 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2146 if (i
== IPV4_DEVCONF_PROXY_ARP
- 1 &&
2147 new_value
!= old_value
) {
2148 ifindex
= devinet_conf_ifindex(net
, cnf
);
2149 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2150 NETCONFA_PROXY_NEIGH
,
2153 if (i
== IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN
- 1 &&
2154 new_value
!= old_value
) {
2155 ifindex
= devinet_conf_ifindex(net
, cnf
);
2156 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2157 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
2165 static int devinet_sysctl_forward(struct ctl_table
*ctl
, int write
,
2166 void __user
*buffer
,
2167 size_t *lenp
, loff_t
*ppos
)
2169 int *valp
= ctl
->data
;
2172 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2174 if (write
&& *valp
!= val
) {
2175 struct net
*net
= ctl
->extra2
;
2177 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
2178 if (!rtnl_trylock()) {
2179 /* Restore the original values before restarting */
2182 return restart_syscall();
2184 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
2185 inet_forward_change(net
);
2187 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2188 struct in_device
*idev
=
2189 container_of(cnf
, struct in_device
, cnf
);
2191 dev_disable_lro(idev
->dev
);
2192 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2193 NETCONFA_FORWARDING
,
2198 rt_cache_flush(net
);
2200 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2201 NETCONFA_FORWARDING
,
2202 NETCONFA_IFINDEX_DEFAULT
,
2203 net
->ipv4
.devconf_dflt
);
2209 static int ipv4_doint_and_flush(struct ctl_table
*ctl
, int write
,
2210 void __user
*buffer
,
2211 size_t *lenp
, loff_t
*ppos
)
2213 int *valp
= ctl
->data
;
2215 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2216 struct net
*net
= ctl
->extra2
;
2218 if (write
&& *valp
!= val
)
2219 rt_cache_flush(net
);
2224 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2227 .data = ipv4_devconf.data + \
2228 IPV4_DEVCONF_ ## attr - 1, \
2229 .maxlen = sizeof(int), \
2231 .proc_handler = proc, \
2232 .extra1 = &ipv4_devconf, \
2235 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2236 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2238 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2239 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2241 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2242 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2244 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2245 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2247 static struct devinet_sysctl_table
{
2248 struct ctl_table_header
*sysctl_header
;
2249 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
2250 } devinet_sysctl
= {
2252 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
2253 devinet_sysctl_forward
),
2254 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
2256 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
2257 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
2258 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
2259 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
2260 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
2261 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
2262 "accept_source_route"),
2263 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
2264 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
2265 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
2266 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
2267 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
2268 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
2269 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
2270 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
2271 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
2272 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
2273 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
2274 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
2275 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
2276 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION
,
2277 "force_igmp_version"),
2278 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL
,
2279 "igmpv2_unsolicited_report_interval"),
2280 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL
,
2281 "igmpv3_unsolicited_report_interval"),
2282 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN
,
2283 "ignore_routes_with_linkdown"),
2284 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP
,
2285 "drop_gratuitous_arp"),
2287 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
2288 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
2289 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
2290 "promote_secondaries"),
2291 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET
,
2293 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST
,
2294 "drop_unicast_in_l2_multicast"),
2298 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
2299 int ifindex
, struct ipv4_devconf
*p
)
2302 struct devinet_sysctl_table
*t
;
2303 char path
[sizeof("net/ipv4/conf/") + IFNAMSIZ
];
2305 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
2309 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
2310 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
2311 t
->devinet_vars
[i
].extra1
= p
;
2312 t
->devinet_vars
[i
].extra2
= net
;
2315 snprintf(path
, sizeof(path
), "net/ipv4/conf/%s", dev_name
);
2317 t
->sysctl_header
= register_net_sysctl(net
, path
, t
->devinet_vars
);
2318 if (!t
->sysctl_header
)
2323 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
, NETCONFA_ALL
,
2333 static void __devinet_sysctl_unregister(struct net
*net
,
2334 struct ipv4_devconf
*cnf
, int ifindex
)
2336 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
2340 unregister_net_sysctl_table(t
->sysctl_header
);
2344 inet_netconf_notify_devconf(net
, RTM_DELNETCONF
, 0, ifindex
, NULL
);
2347 static int devinet_sysctl_register(struct in_device
*idev
)
2351 if (!sysctl_dev_name_is_allowed(idev
->dev
->name
))
2354 err
= neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, NULL
);
2357 err
= __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
2358 idev
->dev
->ifindex
, &idev
->cnf
);
2360 neigh_sysctl_unregister(idev
->arp_parms
);
2364 static void devinet_sysctl_unregister(struct in_device
*idev
)
2366 struct net
*net
= dev_net(idev
->dev
);
2368 __devinet_sysctl_unregister(net
, &idev
->cnf
, idev
->dev
->ifindex
);
2369 neigh_sysctl_unregister(idev
->arp_parms
);
2372 static struct ctl_table ctl_forward_entry
[] = {
2374 .procname
= "ip_forward",
2375 .data
= &ipv4_devconf
.data
[
2376 IPV4_DEVCONF_FORWARDING
- 1],
2377 .maxlen
= sizeof(int),
2379 .proc_handler
= devinet_sysctl_forward
,
2380 .extra1
= &ipv4_devconf
,
2381 .extra2
= &init_net
,
2387 static __net_init
int devinet_init_net(struct net
*net
)
2390 struct ipv4_devconf
*all
, *dflt
;
2391 #ifdef CONFIG_SYSCTL
2392 struct ctl_table
*tbl
= ctl_forward_entry
;
2393 struct ctl_table_header
*forw_hdr
;
2397 all
= &ipv4_devconf
;
2398 dflt
= &ipv4_devconf_dflt
;
2400 if (!net_eq(net
, &init_net
)) {
2401 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
2405 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
2407 goto err_alloc_dflt
;
2409 #ifdef CONFIG_SYSCTL
2410 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
2414 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
2415 tbl
[0].extra1
= all
;
2416 tbl
[0].extra2
= net
;
2420 #ifdef CONFIG_SYSCTL
2421 err
= __devinet_sysctl_register(net
, "all", NETCONFA_IFINDEX_ALL
, all
);
2425 err
= __devinet_sysctl_register(net
, "default",
2426 NETCONFA_IFINDEX_DEFAULT
, dflt
);
2431 forw_hdr
= register_net_sysctl(net
, "net/ipv4", tbl
);
2434 net
->ipv4
.forw_hdr
= forw_hdr
;
2437 net
->ipv4
.devconf_all
= all
;
2438 net
->ipv4
.devconf_dflt
= dflt
;
2441 #ifdef CONFIG_SYSCTL
2443 __devinet_sysctl_unregister(net
, dflt
, NETCONFA_IFINDEX_DEFAULT
);
2445 __devinet_sysctl_unregister(net
, all
, NETCONFA_IFINDEX_ALL
);
2447 if (tbl
!= ctl_forward_entry
)
2451 if (dflt
!= &ipv4_devconf_dflt
)
2454 if (all
!= &ipv4_devconf
)
2460 static __net_exit
void devinet_exit_net(struct net
*net
)
2462 #ifdef CONFIG_SYSCTL
2463 struct ctl_table
*tbl
;
2465 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
2466 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
2467 __devinet_sysctl_unregister(net
, net
->ipv4
.devconf_dflt
,
2468 NETCONFA_IFINDEX_DEFAULT
);
2469 __devinet_sysctl_unregister(net
, net
->ipv4
.devconf_all
,
2470 NETCONFA_IFINDEX_ALL
);
2473 kfree(net
->ipv4
.devconf_dflt
);
2474 kfree(net
->ipv4
.devconf_all
);
2477 static __net_initdata
struct pernet_operations devinet_ops
= {
2478 .init
= devinet_init_net
,
2479 .exit
= devinet_exit_net
,
2482 static struct rtnl_af_ops inet_af_ops __read_mostly
= {
2484 .fill_link_af
= inet_fill_link_af
,
2485 .get_link_af_size
= inet_get_link_af_size
,
2486 .validate_link_af
= inet_validate_link_af
,
2487 .set_link_af
= inet_set_link_af
,
2490 void __init
devinet_init(void)
2494 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
2495 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
2497 register_pernet_subsys(&devinet_ops
);
2499 register_gifconf(PF_INET
, inet_gifconf
);
2500 register_netdevice_notifier(&ip_netdev_notifier
);
2502 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
2504 rtnl_af_register(&inet_af_ops
);
2506 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, 0);
2507 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, 0);
2508 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, 0);
2509 rtnl_register(PF_INET
, RTM_GETNETCONF
, inet_netconf_get_devconf
,
2510 inet_netconf_dump_devconf
, 0);