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 static struct ipv4_devconf ipv4_devconf
= {
71 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
72 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
73 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
74 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
75 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL
- 1] = 10000 /*ms*/,
76 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL
- 1] = 1000 /*ms*/,
80 static struct ipv4_devconf ipv4_devconf_dflt
= {
82 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
83 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
84 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
85 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
86 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE
- 1] = 1,
87 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL
- 1] = 10000 /*ms*/,
88 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL
- 1] = 1000 /*ms*/,
92 #define IPV4_DEVCONF_DFLT(net, attr) \
93 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
95 static const struct nla_policy ifa_ipv4_policy
[IFA_MAX
+1] = {
96 [IFA_LOCAL
] = { .type
= NLA_U32
},
97 [IFA_ADDRESS
] = { .type
= NLA_U32
},
98 [IFA_BROADCAST
] = { .type
= NLA_U32
},
99 [IFA_LABEL
] = { .type
= NLA_STRING
, .len
= IFNAMSIZ
- 1 },
100 [IFA_CACHEINFO
] = { .len
= sizeof(struct ifa_cacheinfo
) },
101 [IFA_FLAGS
] = { .type
= NLA_U32
},
104 #define IN4_ADDR_HSIZE_SHIFT 8
105 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
107 static struct hlist_head inet_addr_lst
[IN4_ADDR_HSIZE
];
109 static u32
inet_addr_hash(const struct net
*net
, __be32 addr
)
111 u32 val
= (__force u32
) addr
^ net_hash_mix(net
);
113 return hash_32(val
, IN4_ADDR_HSIZE_SHIFT
);
116 static void inet_hash_insert(struct net
*net
, struct in_ifaddr
*ifa
)
118 u32 hash
= inet_addr_hash(net
, ifa
->ifa_local
);
121 hlist_add_head_rcu(&ifa
->hash
, &inet_addr_lst
[hash
]);
124 static void inet_hash_remove(struct in_ifaddr
*ifa
)
127 hlist_del_init_rcu(&ifa
->hash
);
131 * __ip_dev_find - find the first device with a given source address.
132 * @net: the net namespace
133 * @addr: the source address
134 * @devref: if true, take a reference on the found device
136 * If a caller uses devref=false, it should be protected by RCU, or RTNL
138 struct net_device
*__ip_dev_find(struct net
*net
, __be32 addr
, bool devref
)
140 u32 hash
= inet_addr_hash(net
, addr
);
141 struct net_device
*result
= NULL
;
142 struct in_ifaddr
*ifa
;
145 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[hash
], hash
) {
146 if (ifa
->ifa_local
== addr
) {
147 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
149 if (!net_eq(dev_net(dev
), net
))
156 struct flowi4 fl4
= { .daddr
= addr
};
157 struct fib_result res
= { 0 };
158 struct fib_table
*local
;
160 /* Fallback to FIB local table so that communication
161 * over loopback subnets work.
163 local
= fib_get_table(net
, RT_TABLE_LOCAL
);
165 !fib_table_lookup(local
, &fl4
, &res
, FIB_LOOKUP_NOREF
) &&
166 res
.type
== RTN_LOCAL
)
167 result
= FIB_RES_DEV(res
);
169 if (result
&& devref
)
174 EXPORT_SYMBOL(__ip_dev_find
);
176 static void rtmsg_ifa(int event
, struct in_ifaddr
*, struct nlmsghdr
*, u32
);
178 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain
);
179 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
182 static int devinet_sysctl_register(struct in_device
*idev
);
183 static void devinet_sysctl_unregister(struct in_device
*idev
);
185 static int devinet_sysctl_register(struct in_device
*idev
)
189 static void devinet_sysctl_unregister(struct in_device
*idev
)
194 /* Locks all the inet devices. */
196 static struct in_ifaddr
*inet_alloc_ifa(void)
198 return kzalloc(sizeof(struct in_ifaddr
), GFP_KERNEL
);
201 static void inet_rcu_free_ifa(struct rcu_head
*head
)
203 struct in_ifaddr
*ifa
= container_of(head
, struct in_ifaddr
, rcu_head
);
205 in_dev_put(ifa
->ifa_dev
);
209 static void inet_free_ifa(struct in_ifaddr
*ifa
)
211 call_rcu(&ifa
->rcu_head
, inet_rcu_free_ifa
);
214 void in_dev_finish_destroy(struct in_device
*idev
)
216 struct net_device
*dev
= idev
->dev
;
218 WARN_ON(idev
->ifa_list
);
219 WARN_ON(idev
->mc_list
);
220 kfree(rcu_dereference_protected(idev
->mc_hash
, 1));
221 #ifdef NET_REFCNT_DEBUG
222 pr_debug("%s: %p=%s\n", __func__
, idev
, dev
? dev
->name
: "NIL");
226 pr_err("Freeing alive in_device %p\n", idev
);
230 EXPORT_SYMBOL(in_dev_finish_destroy
);
232 static struct in_device
*inetdev_init(struct net_device
*dev
)
234 struct in_device
*in_dev
;
239 in_dev
= kzalloc(sizeof(*in_dev
), GFP_KERNEL
);
242 memcpy(&in_dev
->cnf
, dev_net(dev
)->ipv4
.devconf_dflt
,
243 sizeof(in_dev
->cnf
));
244 in_dev
->cnf
.sysctl
= NULL
;
246 in_dev
->arp_parms
= neigh_parms_alloc(dev
, &arp_tbl
);
247 if (!in_dev
->arp_parms
)
249 if (IPV4_DEVCONF(in_dev
->cnf
, FORWARDING
))
250 dev_disable_lro(dev
);
251 /* Reference in_dev->dev */
253 /* Account for reference dev->ip_ptr (below) */
256 err
= devinet_sysctl_register(in_dev
);
263 ip_mc_init_dev(in_dev
);
264 if (dev
->flags
& IFF_UP
)
267 /* we can receive as soon as ip_ptr is set -- do this last */
268 rcu_assign_pointer(dev
->ip_ptr
, in_dev
);
270 return in_dev
?: ERR_PTR(err
);
277 static void in_dev_rcu_put(struct rcu_head
*head
)
279 struct in_device
*idev
= container_of(head
, struct in_device
, rcu_head
);
283 static void inetdev_destroy(struct in_device
*in_dev
)
285 struct in_ifaddr
*ifa
;
286 struct net_device
*dev
;
294 ip_mc_destroy_dev(in_dev
);
296 while ((ifa
= in_dev
->ifa_list
) != NULL
) {
297 inet_del_ifa(in_dev
, &in_dev
->ifa_list
, 0);
301 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
303 devinet_sysctl_unregister(in_dev
);
304 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
307 call_rcu(&in_dev
->rcu_head
, in_dev_rcu_put
);
310 int inet_addr_onlink(struct in_device
*in_dev
, __be32 a
, __be32 b
)
313 for_primary_ifa(in_dev
) {
314 if (inet_ifa_match(a
, ifa
)) {
315 if (!b
|| inet_ifa_match(b
, ifa
)) {
320 } endfor_ifa(in_dev
);
325 static void __inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
326 int destroy
, struct nlmsghdr
*nlh
, u32 portid
)
328 struct in_ifaddr
*promote
= NULL
;
329 struct in_ifaddr
*ifa
, *ifa1
= *ifap
;
330 struct in_ifaddr
*last_prim
= in_dev
->ifa_list
;
331 struct in_ifaddr
*prev_prom
= NULL
;
332 int do_promote
= IN_DEV_PROMOTE_SECONDARIES(in_dev
);
339 /* 1. Deleting primary ifaddr forces deletion all secondaries
340 * unless alias promotion is set
343 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
)) {
344 struct in_ifaddr
**ifap1
= &ifa1
->ifa_next
;
346 while ((ifa
= *ifap1
) != NULL
) {
347 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) &&
348 ifa1
->ifa_scope
<= ifa
->ifa_scope
)
351 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) ||
352 ifa1
->ifa_mask
!= ifa
->ifa_mask
||
353 !inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
354 ifap1
= &ifa
->ifa_next
;
360 inet_hash_remove(ifa
);
361 *ifap1
= ifa
->ifa_next
;
363 rtmsg_ifa(RTM_DELADDR
, ifa
, nlh
, portid
);
364 blocking_notifier_call_chain(&inetaddr_chain
,
374 /* On promotion all secondaries from subnet are changing
375 * the primary IP, we must remove all their routes silently
376 * and later to add them back with new prefsrc. Do this
377 * while all addresses are on the device list.
379 for (ifa
= promote
; ifa
; ifa
= ifa
->ifa_next
) {
380 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
381 inet_ifa_match(ifa1
->ifa_address
, ifa
))
382 fib_del_ifaddr(ifa
, ifa1
);
388 *ifap
= ifa1
->ifa_next
;
389 inet_hash_remove(ifa1
);
391 /* 3. Announce address deletion */
393 /* Send message first, then call notifier.
394 At first sight, FIB update triggered by notifier
395 will refer to already deleted ifaddr, that could confuse
396 netlink listeners. It is not true: look, gated sees
397 that route deleted and if it still thinks that ifaddr
398 is valid, it will try to restore deleted routes... Grr.
399 So that, this order is correct.
401 rtmsg_ifa(RTM_DELADDR
, ifa1
, nlh
, portid
);
402 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_DOWN
, ifa1
);
405 struct in_ifaddr
*next_sec
= promote
->ifa_next
;
408 prev_prom
->ifa_next
= promote
->ifa_next
;
409 promote
->ifa_next
= last_prim
->ifa_next
;
410 last_prim
->ifa_next
= promote
;
413 promote
->ifa_flags
&= ~IFA_F_SECONDARY
;
414 rtmsg_ifa(RTM_NEWADDR
, promote
, nlh
, portid
);
415 blocking_notifier_call_chain(&inetaddr_chain
,
417 for (ifa
= next_sec
; ifa
; ifa
= ifa
->ifa_next
) {
418 if (ifa1
->ifa_mask
!= ifa
->ifa_mask
||
419 !inet_ifa_match(ifa1
->ifa_address
, ifa
))
429 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
432 __inet_del_ifa(in_dev
, ifap
, destroy
, NULL
, 0);
435 static void check_lifetime(struct work_struct
*work
);
437 static DECLARE_DELAYED_WORK(check_lifetime_work
, check_lifetime
);
439 static int __inet_insert_ifa(struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
442 struct in_device
*in_dev
= ifa
->ifa_dev
;
443 struct in_ifaddr
*ifa1
, **ifap
, **last_primary
;
447 if (!ifa
->ifa_local
) {
452 ifa
->ifa_flags
&= ~IFA_F_SECONDARY
;
453 last_primary
= &in_dev
->ifa_list
;
455 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
456 ifap
= &ifa1
->ifa_next
) {
457 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
) &&
458 ifa
->ifa_scope
<= ifa1
->ifa_scope
)
459 last_primary
= &ifa1
->ifa_next
;
460 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
461 inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
462 if (ifa1
->ifa_local
== ifa
->ifa_local
) {
466 if (ifa1
->ifa_scope
!= ifa
->ifa_scope
) {
470 ifa
->ifa_flags
|= IFA_F_SECONDARY
;
474 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
)) {
475 prandom_seed((__force u32
) ifa
->ifa_local
);
479 ifa
->ifa_next
= *ifap
;
482 inet_hash_insert(dev_net(in_dev
->dev
), ifa
);
484 cancel_delayed_work(&check_lifetime_work
);
485 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
487 /* Send message first, then call notifier.
488 Notifier will trigger FIB update, so that
489 listeners of netlink will know about new ifaddr */
490 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, portid
);
491 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
496 static int inet_insert_ifa(struct in_ifaddr
*ifa
)
498 return __inet_insert_ifa(ifa
, NULL
, 0);
501 static int inet_set_ifa(struct net_device
*dev
, struct in_ifaddr
*ifa
)
503 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
511 ipv4_devconf_setall(in_dev
);
512 neigh_parms_data_state_setall(in_dev
->arp_parms
);
513 if (ifa
->ifa_dev
!= in_dev
) {
514 WARN_ON(ifa
->ifa_dev
);
516 ifa
->ifa_dev
= in_dev
;
518 if (ipv4_is_loopback(ifa
->ifa_local
))
519 ifa
->ifa_scope
= RT_SCOPE_HOST
;
520 return inet_insert_ifa(ifa
);
523 /* Caller must hold RCU or RTNL :
524 * We dont take a reference on found in_device
526 struct in_device
*inetdev_by_index(struct net
*net
, int ifindex
)
528 struct net_device
*dev
;
529 struct in_device
*in_dev
= NULL
;
532 dev
= dev_get_by_index_rcu(net
, ifindex
);
534 in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
538 EXPORT_SYMBOL(inetdev_by_index
);
540 /* Called only from RTNL semaphored context. No locks. */
542 struct in_ifaddr
*inet_ifa_byprefix(struct in_device
*in_dev
, __be32 prefix
,
547 for_primary_ifa(in_dev
) {
548 if (ifa
->ifa_mask
== mask
&& inet_ifa_match(prefix
, ifa
))
550 } endfor_ifa(in_dev
);
554 static int ip_mc_config(struct sock
*sk
, bool join
, const struct in_ifaddr
*ifa
)
556 struct ip_mreqn mreq
= {
557 .imr_multiaddr
.s_addr
= ifa
->ifa_address
,
558 .imr_ifindex
= ifa
->ifa_dev
->dev
->ifindex
,
566 ret
= ip_mc_join_group(sk
, &mreq
);
568 ret
= ip_mc_leave_group(sk
, &mreq
);
574 static int inet_rtm_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
575 struct netlink_ext_ack
*extack
)
577 struct net
*net
= sock_net(skb
->sk
);
578 struct nlattr
*tb
[IFA_MAX
+1];
579 struct in_device
*in_dev
;
580 struct ifaddrmsg
*ifm
;
581 struct in_ifaddr
*ifa
, **ifap
;
586 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
,
591 ifm
= nlmsg_data(nlh
);
592 in_dev
= inetdev_by_index(net
, ifm
->ifa_index
);
598 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
599 ifap
= &ifa
->ifa_next
) {
601 ifa
->ifa_local
!= nla_get_in_addr(tb
[IFA_LOCAL
]))
604 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
607 if (tb
[IFA_ADDRESS
] &&
608 (ifm
->ifa_prefixlen
!= ifa
->ifa_prefixlen
||
609 !inet_ifa_match(nla_get_in_addr(tb
[IFA_ADDRESS
]), ifa
)))
612 if (ipv4_is_multicast(ifa
->ifa_address
))
613 ip_mc_config(net
->ipv4
.mc_autojoin_sk
, false, ifa
);
614 __inet_del_ifa(in_dev
, ifap
, 1, nlh
, NETLINK_CB(skb
).portid
);
618 err
= -EADDRNOTAVAIL
;
623 #define INFINITY_LIFE_TIME 0xFFFFFFFF
625 static void check_lifetime(struct work_struct
*work
)
627 unsigned long now
, next
, next_sec
, next_sched
;
628 struct in_ifaddr
*ifa
;
629 struct hlist_node
*n
;
633 next
= round_jiffies_up(now
+ ADDR_CHECK_FREQUENCY
);
635 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++) {
636 bool change_needed
= false;
639 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[i
], hash
) {
642 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
645 /* We try to batch several events at once. */
646 age
= (now
- ifa
->ifa_tstamp
+
647 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
649 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
650 age
>= ifa
->ifa_valid_lft
) {
651 change_needed
= true;
652 } else if (ifa
->ifa_preferred_lft
==
653 INFINITY_LIFE_TIME
) {
655 } else if (age
>= ifa
->ifa_preferred_lft
) {
656 if (time_before(ifa
->ifa_tstamp
+
657 ifa
->ifa_valid_lft
* HZ
, next
))
658 next
= ifa
->ifa_tstamp
+
659 ifa
->ifa_valid_lft
* HZ
;
661 if (!(ifa
->ifa_flags
& IFA_F_DEPRECATED
))
662 change_needed
= true;
663 } else if (time_before(ifa
->ifa_tstamp
+
664 ifa
->ifa_preferred_lft
* HZ
,
666 next
= ifa
->ifa_tstamp
+
667 ifa
->ifa_preferred_lft
* HZ
;
674 hlist_for_each_entry_safe(ifa
, n
, &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 struct in_ifaddr
**ifap
;
688 for (ifap
= &ifa
->ifa_dev
->ifa_list
;
689 *ifap
!= NULL
; ifap
= &(*ifap
)->ifa_next
) {
691 inet_del_ifa(ifa
->ifa_dev
,
696 } else if (ifa
->ifa_preferred_lft
!=
697 INFINITY_LIFE_TIME
&&
698 age
>= ifa
->ifa_preferred_lft
&&
699 !(ifa
->ifa_flags
& IFA_F_DEPRECATED
)) {
700 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
701 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
707 next_sec
= round_jiffies_up(next
);
710 /* If rounded timeout is accurate enough, accept it. */
711 if (time_before(next_sec
, next
+ ADDRCONF_TIMER_FUZZ
))
712 next_sched
= next_sec
;
715 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
716 if (time_before(next_sched
, now
+ ADDRCONF_TIMER_FUZZ_MAX
))
717 next_sched
= now
+ ADDRCONF_TIMER_FUZZ_MAX
;
719 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
,
723 static void set_ifa_lifetime(struct in_ifaddr
*ifa
, __u32 valid_lft
,
726 unsigned long timeout
;
728 ifa
->ifa_flags
&= ~(IFA_F_PERMANENT
| IFA_F_DEPRECATED
);
730 timeout
= addrconf_timeout_fixup(valid_lft
, HZ
);
731 if (addrconf_finite_timeout(timeout
))
732 ifa
->ifa_valid_lft
= timeout
;
734 ifa
->ifa_flags
|= IFA_F_PERMANENT
;
736 timeout
= addrconf_timeout_fixup(prefered_lft
, HZ
);
737 if (addrconf_finite_timeout(timeout
)) {
739 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
740 ifa
->ifa_preferred_lft
= timeout
;
742 ifa
->ifa_tstamp
= jiffies
;
743 if (!ifa
->ifa_cstamp
)
744 ifa
->ifa_cstamp
= ifa
->ifa_tstamp
;
747 static struct in_ifaddr
*rtm_to_ifaddr(struct net
*net
, struct nlmsghdr
*nlh
,
748 __u32
*pvalid_lft
, __u32
*pprefered_lft
)
750 struct nlattr
*tb
[IFA_MAX
+1];
751 struct in_ifaddr
*ifa
;
752 struct ifaddrmsg
*ifm
;
753 struct net_device
*dev
;
754 struct in_device
*in_dev
;
757 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
,
762 ifm
= nlmsg_data(nlh
);
764 if (ifm
->ifa_prefixlen
> 32 || !tb
[IFA_LOCAL
])
767 dev
= __dev_get_by_index(net
, ifm
->ifa_index
);
772 in_dev
= __in_dev_get_rtnl(dev
);
777 ifa
= inet_alloc_ifa();
780 * A potential indev allocation can be left alive, it stays
781 * assigned to its device and is destroy with it.
785 ipv4_devconf_setall(in_dev
);
786 neigh_parms_data_state_setall(in_dev
->arp_parms
);
789 if (!tb
[IFA_ADDRESS
])
790 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
792 INIT_HLIST_NODE(&ifa
->hash
);
793 ifa
->ifa_prefixlen
= ifm
->ifa_prefixlen
;
794 ifa
->ifa_mask
= inet_make_mask(ifm
->ifa_prefixlen
);
795 ifa
->ifa_flags
= tb
[IFA_FLAGS
] ? nla_get_u32(tb
[IFA_FLAGS
]) :
797 ifa
->ifa_scope
= ifm
->ifa_scope
;
798 ifa
->ifa_dev
= in_dev
;
800 ifa
->ifa_local
= nla_get_in_addr(tb
[IFA_LOCAL
]);
801 ifa
->ifa_address
= nla_get_in_addr(tb
[IFA_ADDRESS
]);
803 if (tb
[IFA_BROADCAST
])
804 ifa
->ifa_broadcast
= nla_get_in_addr(tb
[IFA_BROADCAST
]);
807 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
809 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
811 if (tb
[IFA_CACHEINFO
]) {
812 struct ifa_cacheinfo
*ci
;
814 ci
= nla_data(tb
[IFA_CACHEINFO
]);
815 if (!ci
->ifa_valid
|| ci
->ifa_prefered
> ci
->ifa_valid
) {
819 *pvalid_lft
= ci
->ifa_valid
;
820 *pprefered_lft
= ci
->ifa_prefered
;
831 static struct in_ifaddr
*find_matching_ifa(struct in_ifaddr
*ifa
)
833 struct in_device
*in_dev
= ifa
->ifa_dev
;
834 struct in_ifaddr
*ifa1
, **ifap
;
839 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
840 ifap
= &ifa1
->ifa_next
) {
841 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
842 inet_ifa_match(ifa1
->ifa_address
, ifa
) &&
843 ifa1
->ifa_local
== ifa
->ifa_local
)
849 static int inet_rtm_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
850 struct netlink_ext_ack
*extack
)
852 struct net
*net
= sock_net(skb
->sk
);
853 struct in_ifaddr
*ifa
;
854 struct in_ifaddr
*ifa_existing
;
855 __u32 valid_lft
= INFINITY_LIFE_TIME
;
856 __u32 prefered_lft
= INFINITY_LIFE_TIME
;
860 ifa
= rtm_to_ifaddr(net
, nlh
, &valid_lft
, &prefered_lft
);
864 ifa_existing
= find_matching_ifa(ifa
);
866 /* It would be best to check for !NLM_F_CREATE here but
867 * userspace already relies on not having to provide this.
869 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
870 if (ifa
->ifa_flags
& IFA_F_MCAUTOJOIN
) {
871 int ret
= ip_mc_config(net
->ipv4
.mc_autojoin_sk
,
879 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).portid
);
883 if (nlh
->nlmsg_flags
& NLM_F_EXCL
||
884 !(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
887 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
888 cancel_delayed_work(&check_lifetime_work
);
889 queue_delayed_work(system_power_efficient_wq
,
890 &check_lifetime_work
, 0);
891 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, NETLINK_CB(skb
).portid
);
897 * Determine a default network mask, based on the IP address.
900 static int inet_abc_len(__be32 addr
)
902 int rc
= -1; /* Something else, probably a multicast. */
904 if (ipv4_is_zeronet(addr
))
907 __u32 haddr
= ntohl(addr
);
909 if (IN_CLASSA(haddr
))
911 else if (IN_CLASSB(haddr
))
913 else if (IN_CLASSC(haddr
))
921 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
924 struct sockaddr_in sin_orig
;
925 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
926 struct in_device
*in_dev
;
927 struct in_ifaddr
**ifap
= NULL
;
928 struct in_ifaddr
*ifa
= NULL
;
929 struct net_device
*dev
;
932 int tryaddrmatch
= 0;
935 * Fetch the caller's info block into kernel space
938 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
940 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
942 /* save original address for comparison */
943 memcpy(&sin_orig
, sin
, sizeof(*sin
));
945 colon
= strchr(ifr
.ifr_name
, ':');
949 dev_load(net
, ifr
.ifr_name
);
952 case SIOCGIFADDR
: /* Get interface address */
953 case SIOCGIFBRDADDR
: /* Get the broadcast address */
954 case SIOCGIFDSTADDR
: /* Get the destination address */
955 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
956 /* Note that these ioctls will not sleep,
957 so that we do not impose a lock.
958 One day we will be forced to put shlock here (I mean SMP)
960 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
961 memset(sin
, 0, sizeof(*sin
));
962 sin
->sin_family
= AF_INET
;
967 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
970 case SIOCSIFADDR
: /* Set interface address (and family) */
971 case SIOCSIFBRDADDR
: /* Set the broadcast address */
972 case SIOCSIFDSTADDR
: /* Set the destination address */
973 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
975 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
978 if (sin
->sin_family
!= AF_INET
)
989 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
996 in_dev
= __in_dev_get_rtnl(dev
);
999 /* Matthias Andree */
1000 /* compare label and address (4.4BSD style) */
1001 /* note: we only do this for a limited set of ioctls
1002 and only if the original address family was AF_INET.
1003 This is checked above. */
1004 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1005 ifap
= &ifa
->ifa_next
) {
1006 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
1007 sin_orig
.sin_addr
.s_addr
==
1013 /* we didn't get a match, maybe the application is
1014 4.3BSD-style and passed in junk so we fall back to
1015 comparing just the label */
1017 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1018 ifap
= &ifa
->ifa_next
)
1019 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
1024 ret
= -EADDRNOTAVAIL
;
1025 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
1029 case SIOCGIFADDR
: /* Get interface address */
1030 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
1033 case SIOCGIFBRDADDR
: /* Get the broadcast address */
1034 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
1037 case SIOCGIFDSTADDR
: /* Get the destination address */
1038 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
1041 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
1042 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
1047 ret
= -EADDRNOTAVAIL
;
1051 if (!(ifr
.ifr_flags
& IFF_UP
))
1052 inet_del_ifa(in_dev
, ifap
, 1);
1055 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
1058 case SIOCSIFADDR
: /* Set interface address (and family) */
1060 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1065 ifa
= inet_alloc_ifa();
1068 INIT_HLIST_NODE(&ifa
->hash
);
1070 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
1072 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1075 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
1077 inet_del_ifa(in_dev
, ifap
, 0);
1078 ifa
->ifa_broadcast
= 0;
1082 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
1084 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
1085 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
1086 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
1087 if ((dev
->flags
& IFF_BROADCAST
) &&
1088 ifa
->ifa_prefixlen
< 31)
1089 ifa
->ifa_broadcast
= ifa
->ifa_address
|
1092 ifa
->ifa_prefixlen
= 32;
1093 ifa
->ifa_mask
= inet_make_mask(32);
1095 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
, INFINITY_LIFE_TIME
);
1096 ret
= inet_set_ifa(dev
, ifa
);
1099 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1101 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
1102 inet_del_ifa(in_dev
, ifap
, 0);
1103 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
1104 inet_insert_ifa(ifa
);
1108 case SIOCSIFDSTADDR
: /* Set the destination address */
1110 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
1113 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1116 inet_del_ifa(in_dev
, ifap
, 0);
1117 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
1118 inet_insert_ifa(ifa
);
1121 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1124 * The mask we set must be legal.
1127 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
1130 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
1131 __be32 old_mask
= ifa
->ifa_mask
;
1132 inet_del_ifa(in_dev
, ifap
, 0);
1133 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
1134 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
1136 /* See if current broadcast address matches
1137 * with current netmask, then recalculate
1138 * the broadcast address. Otherwise it's a
1139 * funny address, so don't touch it since
1140 * the user seems to know what (s)he's doing...
1142 if ((dev
->flags
& IFF_BROADCAST
) &&
1143 (ifa
->ifa_prefixlen
< 31) &&
1144 (ifa
->ifa_broadcast
==
1145 (ifa
->ifa_local
|~old_mask
))) {
1146 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
1147 ~sin
->sin_addr
.s_addr
);
1149 inet_insert_ifa(ifa
);
1159 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
1163 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
1165 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1166 struct in_ifaddr
*ifa
;
1173 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1175 done
+= sizeof(ifr
);
1178 if (len
< (int) sizeof(ifr
))
1180 memset(&ifr
, 0, sizeof(struct ifreq
));
1181 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
1183 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
1184 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
1187 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
1191 buf
+= sizeof(struct ifreq
);
1192 len
-= sizeof(struct ifreq
);
1193 done
+= sizeof(struct ifreq
);
1199 static __be32
in_dev_select_addr(const struct in_device
*in_dev
,
1202 for_primary_ifa(in_dev
) {
1203 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1204 ifa
->ifa_scope
<= scope
)
1205 return ifa
->ifa_local
;
1206 } endfor_ifa(in_dev
);
1211 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
1214 struct in_device
*in_dev
;
1215 struct net
*net
= dev_net(dev
);
1219 in_dev
= __in_dev_get_rcu(dev
);
1223 for_primary_ifa(in_dev
) {
1224 if (ifa
->ifa_scope
> scope
)
1226 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
1227 addr
= ifa
->ifa_local
;
1231 addr
= ifa
->ifa_local
;
1232 } endfor_ifa(in_dev
);
1237 master_idx
= l3mdev_master_ifindex_rcu(dev
);
1239 /* For VRFs, the VRF device takes the place of the loopback device,
1240 * with addresses on it being preferred. Note in such cases the
1241 * loopback device will be among the devices that fail the master_idx
1242 * equality check in the loop below.
1245 (dev
= dev_get_by_index_rcu(net
, master_idx
)) &&
1246 (in_dev
= __in_dev_get_rcu(dev
))) {
1247 addr
= in_dev_select_addr(in_dev
, scope
);
1252 /* Not loopback addresses on loopback should be preferred
1253 in this case. It is important that lo is the first interface
1256 for_each_netdev_rcu(net
, dev
) {
1257 if (l3mdev_master_ifindex_rcu(dev
) != master_idx
)
1260 in_dev
= __in_dev_get_rcu(dev
);
1264 addr
= in_dev_select_addr(in_dev
, scope
);
1272 EXPORT_SYMBOL(inet_select_addr
);
1274 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1275 __be32 local
, int scope
)
1282 (local
== ifa
->ifa_local
|| !local
) &&
1283 ifa
->ifa_scope
<= scope
) {
1284 addr
= ifa
->ifa_local
;
1289 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1290 (!dst
|| inet_ifa_match(dst
, ifa
));
1294 /* Is the selected addr into dst subnet? */
1295 if (inet_ifa_match(addr
, ifa
))
1297 /* No, then can we use new local src? */
1298 if (ifa
->ifa_scope
<= scope
) {
1299 addr
= ifa
->ifa_local
;
1302 /* search for large dst subnet for addr */
1306 } endfor_ifa(in_dev
);
1308 return same
? addr
: 0;
1312 * Confirm that local IP address exists using wildcards:
1313 * - net: netns to check, cannot be NULL
1314 * - in_dev: only on this interface, NULL=any interface
1315 * - dst: only in the same subnet as dst, 0=any dst
1316 * - local: address, 0=autoselect the local address
1317 * - scope: maximum allowed scope value for the local address
1319 __be32
inet_confirm_addr(struct net
*net
, struct in_device
*in_dev
,
1320 __be32 dst
, __be32 local
, int scope
)
1323 struct net_device
*dev
;
1326 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1329 for_each_netdev_rcu(net
, dev
) {
1330 in_dev
= __in_dev_get_rcu(dev
);
1332 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1341 EXPORT_SYMBOL(inet_confirm_addr
);
1347 int register_inetaddr_notifier(struct notifier_block
*nb
)
1349 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1351 EXPORT_SYMBOL(register_inetaddr_notifier
);
1353 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1355 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1357 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1359 /* Rename ifa_labels for a device name change. Make some effort to preserve
1360 * existing alias numbering and to create unique labels if possible.
1362 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1364 struct in_ifaddr
*ifa
;
1367 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1368 char old
[IFNAMSIZ
], *dot
;
1370 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1371 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1374 dot
= strchr(old
, ':');
1376 sprintf(old
, ":%d", named
);
1379 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1380 strcat(ifa
->ifa_label
, dot
);
1382 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1384 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1388 static bool inetdev_valid_mtu(unsigned int mtu
)
1393 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1394 struct in_device
*in_dev
)
1397 struct in_ifaddr
*ifa
;
1399 for (ifa
= in_dev
->ifa_list
; ifa
;
1400 ifa
= ifa
->ifa_next
) {
1401 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1402 ifa
->ifa_local
, dev
,
1403 ifa
->ifa_local
, NULL
,
1404 dev
->dev_addr
, NULL
);
1408 /* Called only under RTNL semaphore */
1410 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1413 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1414 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1419 if (event
== NETDEV_REGISTER
) {
1420 in_dev
= inetdev_init(dev
);
1422 return notifier_from_errno(PTR_ERR(in_dev
));
1423 if (dev
->flags
& IFF_LOOPBACK
) {
1424 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1425 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1427 } else if (event
== NETDEV_CHANGEMTU
) {
1428 /* Re-enabling IP */
1429 if (inetdev_valid_mtu(dev
->mtu
))
1430 in_dev
= inetdev_init(dev
);
1436 case NETDEV_REGISTER
:
1437 pr_debug("%s: bug\n", __func__
);
1438 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1441 if (!inetdev_valid_mtu(dev
->mtu
))
1443 if (dev
->flags
& IFF_LOOPBACK
) {
1444 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1447 INIT_HLIST_NODE(&ifa
->hash
);
1449 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1450 ifa
->ifa_prefixlen
= 8;
1451 ifa
->ifa_mask
= inet_make_mask(8);
1452 in_dev_hold(in_dev
);
1453 ifa
->ifa_dev
= in_dev
;
1454 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1455 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1456 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
,
1457 INFINITY_LIFE_TIME
);
1458 ipv4_devconf_setall(in_dev
);
1459 neigh_parms_data_state_setall(in_dev
->arp_parms
);
1460 inet_insert_ifa(ifa
);
1465 case NETDEV_CHANGEADDR
:
1466 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1469 case NETDEV_NOTIFY_PEERS
:
1470 /* Send gratuitous ARP to notify of link change */
1471 inetdev_send_gratuitous_arp(dev
, in_dev
);
1476 case NETDEV_PRE_TYPE_CHANGE
:
1477 ip_mc_unmap(in_dev
);
1479 case NETDEV_POST_TYPE_CHANGE
:
1480 ip_mc_remap(in_dev
);
1482 case NETDEV_CHANGEMTU
:
1483 if (inetdev_valid_mtu(dev
->mtu
))
1485 /* disable IP when MTU is not enough */
1486 case NETDEV_UNREGISTER
:
1487 inetdev_destroy(in_dev
);
1489 case NETDEV_CHANGENAME
:
1490 /* Do not notify about label change, this event is
1491 * not interesting to applications using netlink.
1493 inetdev_changename(dev
, in_dev
);
1495 devinet_sysctl_unregister(in_dev
);
1496 devinet_sysctl_register(in_dev
);
1503 static struct notifier_block ip_netdev_notifier
= {
1504 .notifier_call
= inetdev_event
,
1507 static size_t inet_nlmsg_size(void)
1509 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1510 + nla_total_size(4) /* IFA_ADDRESS */
1511 + nla_total_size(4) /* IFA_LOCAL */
1512 + nla_total_size(4) /* IFA_BROADCAST */
1513 + nla_total_size(IFNAMSIZ
) /* IFA_LABEL */
1514 + nla_total_size(4) /* IFA_FLAGS */
1515 + nla_total_size(sizeof(struct ifa_cacheinfo
)); /* IFA_CACHEINFO */
1518 static inline u32
cstamp_delta(unsigned long cstamp
)
1520 return (cstamp
- INITIAL_JIFFIES
) * 100UL / HZ
;
1523 static int put_cacheinfo(struct sk_buff
*skb
, unsigned long cstamp
,
1524 unsigned long tstamp
, u32 preferred
, u32 valid
)
1526 struct ifa_cacheinfo ci
;
1528 ci
.cstamp
= cstamp_delta(cstamp
);
1529 ci
.tstamp
= cstamp_delta(tstamp
);
1530 ci
.ifa_prefered
= preferred
;
1531 ci
.ifa_valid
= valid
;
1533 return nla_put(skb
, IFA_CACHEINFO
, sizeof(ci
), &ci
);
1536 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1537 u32 portid
, u32 seq
, int event
, unsigned int flags
)
1539 struct ifaddrmsg
*ifm
;
1540 struct nlmsghdr
*nlh
;
1541 u32 preferred
, valid
;
1543 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*ifm
), flags
);
1547 ifm
= nlmsg_data(nlh
);
1548 ifm
->ifa_family
= AF_INET
;
1549 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1550 ifm
->ifa_flags
= ifa
->ifa_flags
;
1551 ifm
->ifa_scope
= ifa
->ifa_scope
;
1552 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1554 if (!(ifm
->ifa_flags
& IFA_F_PERMANENT
)) {
1555 preferred
= ifa
->ifa_preferred_lft
;
1556 valid
= ifa
->ifa_valid_lft
;
1557 if (preferred
!= INFINITY_LIFE_TIME
) {
1558 long tval
= (jiffies
- ifa
->ifa_tstamp
) / HZ
;
1560 if (preferred
> tval
)
1564 if (valid
!= INFINITY_LIFE_TIME
) {
1572 preferred
= INFINITY_LIFE_TIME
;
1573 valid
= INFINITY_LIFE_TIME
;
1575 if ((ifa
->ifa_address
&&
1576 nla_put_in_addr(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1578 nla_put_in_addr(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1579 (ifa
->ifa_broadcast
&&
1580 nla_put_in_addr(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1581 (ifa
->ifa_label
[0] &&
1582 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)) ||
1583 nla_put_u32(skb
, IFA_FLAGS
, ifa
->ifa_flags
) ||
1584 put_cacheinfo(skb
, ifa
->ifa_cstamp
, ifa
->ifa_tstamp
,
1586 goto nla_put_failure
;
1588 nlmsg_end(skb
, nlh
);
1592 nlmsg_cancel(skb
, nlh
);
1596 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1598 struct net
*net
= sock_net(skb
->sk
);
1601 int ip_idx
, s_ip_idx
;
1602 struct net_device
*dev
;
1603 struct in_device
*in_dev
;
1604 struct in_ifaddr
*ifa
;
1605 struct hlist_head
*head
;
1608 s_idx
= idx
= cb
->args
[1];
1609 s_ip_idx
= ip_idx
= cb
->args
[2];
1611 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1613 head
= &net
->dev_index_head
[h
];
1615 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1617 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1620 if (h
> s_h
|| idx
> s_idx
)
1622 in_dev
= __in_dev_get_rcu(dev
);
1626 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1627 ifa
= ifa
->ifa_next
, ip_idx
++) {
1628 if (ip_idx
< s_ip_idx
)
1630 if (inet_fill_ifaddr(skb
, ifa
,
1631 NETLINK_CB(cb
->skb
).portid
,
1633 RTM_NEWADDR
, NLM_F_MULTI
) < 0) {
1637 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1648 cb
->args
[2] = ip_idx
;
1653 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1656 struct sk_buff
*skb
;
1657 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1661 net
= dev_net(ifa
->ifa_dev
->dev
);
1662 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1666 err
= inet_fill_ifaddr(skb
, ifa
, portid
, seq
, event
, 0);
1668 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1669 WARN_ON(err
== -EMSGSIZE
);
1673 rtnl_notify(skb
, net
, portid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1677 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1680 static size_t inet_get_link_af_size(const struct net_device
*dev
,
1681 u32 ext_filter_mask
)
1683 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1688 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1691 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
,
1692 u32 ext_filter_mask
)
1694 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1701 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1705 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1706 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1711 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1712 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1715 static int inet_validate_link_af(const struct net_device
*dev
,
1716 const struct nlattr
*nla
)
1718 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1721 if (dev
&& !__in_dev_get_rtnl(dev
))
1722 return -EAFNOSUPPORT
;
1724 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
, NULL
);
1728 if (tb
[IFLA_INET_CONF
]) {
1729 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1730 int cfgid
= nla_type(a
);
1735 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1743 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1745 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1746 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1750 return -EAFNOSUPPORT
;
1752 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
, NULL
) < 0)
1755 if (tb
[IFLA_INET_CONF
]) {
1756 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1757 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1763 static int inet_netconf_msgsize_devconf(int type
)
1765 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1766 + nla_total_size(4); /* NETCONFA_IFINDEX */
1769 if (type
== NETCONFA_ALL
)
1772 if (all
|| type
== NETCONFA_FORWARDING
)
1773 size
+= nla_total_size(4);
1774 if (all
|| type
== NETCONFA_RP_FILTER
)
1775 size
+= nla_total_size(4);
1776 if (all
|| type
== NETCONFA_MC_FORWARDING
)
1777 size
+= nla_total_size(4);
1778 if (all
|| type
== NETCONFA_PROXY_NEIGH
)
1779 size
+= nla_total_size(4);
1780 if (all
|| type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
)
1781 size
+= nla_total_size(4);
1786 static int inet_netconf_fill_devconf(struct sk_buff
*skb
, int ifindex
,
1787 struct ipv4_devconf
*devconf
, u32 portid
,
1788 u32 seq
, int event
, unsigned int flags
,
1791 struct nlmsghdr
*nlh
;
1792 struct netconfmsg
*ncm
;
1795 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1800 if (type
== NETCONFA_ALL
)
1803 ncm
= nlmsg_data(nlh
);
1804 ncm
->ncm_family
= AF_INET
;
1806 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, ifindex
) < 0)
1807 goto nla_put_failure
;
1812 if ((all
|| type
== NETCONFA_FORWARDING
) &&
1813 nla_put_s32(skb
, NETCONFA_FORWARDING
,
1814 IPV4_DEVCONF(*devconf
, FORWARDING
)) < 0)
1815 goto nla_put_failure
;
1816 if ((all
|| type
== NETCONFA_RP_FILTER
) &&
1817 nla_put_s32(skb
, NETCONFA_RP_FILTER
,
1818 IPV4_DEVCONF(*devconf
, RP_FILTER
)) < 0)
1819 goto nla_put_failure
;
1820 if ((all
|| type
== NETCONFA_MC_FORWARDING
) &&
1821 nla_put_s32(skb
, NETCONFA_MC_FORWARDING
,
1822 IPV4_DEVCONF(*devconf
, MC_FORWARDING
)) < 0)
1823 goto nla_put_failure
;
1824 if ((all
|| type
== NETCONFA_PROXY_NEIGH
) &&
1825 nla_put_s32(skb
, NETCONFA_PROXY_NEIGH
,
1826 IPV4_DEVCONF(*devconf
, PROXY_ARP
)) < 0)
1827 goto nla_put_failure
;
1828 if ((all
|| type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
) &&
1829 nla_put_s32(skb
, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
1830 IPV4_DEVCONF(*devconf
, IGNORE_ROUTES_WITH_LINKDOWN
)) < 0)
1831 goto nla_put_failure
;
1834 nlmsg_end(skb
, nlh
);
1838 nlmsg_cancel(skb
, nlh
);
1842 void inet_netconf_notify_devconf(struct net
*net
, int event
, int type
,
1843 int ifindex
, struct ipv4_devconf
*devconf
)
1845 struct sk_buff
*skb
;
1848 skb
= nlmsg_new(inet_netconf_msgsize_devconf(type
), GFP_KERNEL
);
1852 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
, 0, 0,
1855 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1856 WARN_ON(err
== -EMSGSIZE
);
1860 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_NETCONF
, NULL
, GFP_KERNEL
);
1864 rtnl_set_sk_err(net
, RTNLGRP_IPV4_NETCONF
, err
);
1867 static const struct nla_policy devconf_ipv4_policy
[NETCONFA_MAX
+1] = {
1868 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1869 [NETCONFA_FORWARDING
] = { .len
= sizeof(int) },
1870 [NETCONFA_RP_FILTER
] = { .len
= sizeof(int) },
1871 [NETCONFA_PROXY_NEIGH
] = { .len
= sizeof(int) },
1872 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
] = { .len
= sizeof(int) },
1875 static int inet_netconf_get_devconf(struct sk_buff
*in_skb
,
1876 struct nlmsghdr
*nlh
,
1877 struct netlink_ext_ack
*extack
)
1879 struct net
*net
= sock_net(in_skb
->sk
);
1880 struct nlattr
*tb
[NETCONFA_MAX
+1];
1881 struct netconfmsg
*ncm
;
1882 struct sk_buff
*skb
;
1883 struct ipv4_devconf
*devconf
;
1884 struct in_device
*in_dev
;
1885 struct net_device
*dev
;
1889 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1890 devconf_ipv4_policy
, extack
);
1895 if (!tb
[NETCONFA_IFINDEX
])
1898 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1900 case NETCONFA_IFINDEX_ALL
:
1901 devconf
= net
->ipv4
.devconf_all
;
1903 case NETCONFA_IFINDEX_DEFAULT
:
1904 devconf
= net
->ipv4
.devconf_dflt
;
1907 dev
= __dev_get_by_index(net
, ifindex
);
1910 in_dev
= __in_dev_get_rtnl(dev
);
1913 devconf
= &in_dev
->cnf
;
1918 skb
= nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL
), GFP_KERNEL
);
1922 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
,
1923 NETLINK_CB(in_skb
).portid
,
1924 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1927 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1928 WARN_ON(err
== -EMSGSIZE
);
1932 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1937 static int inet_netconf_dump_devconf(struct sk_buff
*skb
,
1938 struct netlink_callback
*cb
)
1940 struct net
*net
= sock_net(skb
->sk
);
1943 struct net_device
*dev
;
1944 struct in_device
*in_dev
;
1945 struct hlist_head
*head
;
1948 s_idx
= idx
= cb
->args
[1];
1950 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1952 head
= &net
->dev_index_head
[h
];
1954 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1956 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1959 in_dev
= __in_dev_get_rcu(dev
);
1963 if (inet_netconf_fill_devconf(skb
, dev
->ifindex
,
1965 NETLINK_CB(cb
->skb
).portid
,
1969 NETCONFA_ALL
) < 0) {
1973 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1979 if (h
== NETDEV_HASHENTRIES
) {
1980 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_ALL
,
1981 net
->ipv4
.devconf_all
,
1982 NETLINK_CB(cb
->skb
).portid
,
1984 RTM_NEWNETCONF
, NLM_F_MULTI
,
1990 if (h
== NETDEV_HASHENTRIES
+ 1) {
1991 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_DEFAULT
,
1992 net
->ipv4
.devconf_dflt
,
1993 NETLINK_CB(cb
->skb
).portid
,
1995 RTM_NEWNETCONF
, NLM_F_MULTI
,
2008 #ifdef CONFIG_SYSCTL
2010 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
2012 struct net_device
*dev
;
2015 for_each_netdev_rcu(net
, dev
) {
2016 struct in_device
*in_dev
;
2018 in_dev
= __in_dev_get_rcu(dev
);
2019 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
2020 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
2025 /* called with RTNL locked */
2026 static void inet_forward_change(struct net
*net
)
2028 struct net_device
*dev
;
2029 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
2031 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
2032 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
2033 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2034 NETCONFA_FORWARDING
,
2035 NETCONFA_IFINDEX_ALL
,
2036 net
->ipv4
.devconf_all
);
2037 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2038 NETCONFA_FORWARDING
,
2039 NETCONFA_IFINDEX_DEFAULT
,
2040 net
->ipv4
.devconf_dflt
);
2042 for_each_netdev(net
, dev
) {
2043 struct in_device
*in_dev
;
2046 dev_disable_lro(dev
);
2048 in_dev
= __in_dev_get_rtnl(dev
);
2050 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
2051 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2052 NETCONFA_FORWARDING
,
2053 dev
->ifindex
, &in_dev
->cnf
);
2058 static int devinet_conf_ifindex(struct net
*net
, struct ipv4_devconf
*cnf
)
2060 if (cnf
== net
->ipv4
.devconf_dflt
)
2061 return NETCONFA_IFINDEX_DEFAULT
;
2062 else if (cnf
== net
->ipv4
.devconf_all
)
2063 return NETCONFA_IFINDEX_ALL
;
2065 struct in_device
*idev
2066 = container_of(cnf
, struct in_device
, cnf
);
2067 return idev
->dev
->ifindex
;
2071 static int devinet_conf_proc(struct ctl_table
*ctl
, int write
,
2072 void __user
*buffer
,
2073 size_t *lenp
, loff_t
*ppos
)
2075 int old_value
= *(int *)ctl
->data
;
2076 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2077 int new_value
= *(int *)ctl
->data
;
2080 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2081 struct net
*net
= ctl
->extra2
;
2082 int i
= (int *)ctl
->data
- cnf
->data
;
2085 set_bit(i
, cnf
->state
);
2087 if (cnf
== net
->ipv4
.devconf_dflt
)
2088 devinet_copy_dflt_conf(net
, i
);
2089 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1 ||
2090 i
== IPV4_DEVCONF_ROUTE_LOCALNET
- 1)
2091 if ((new_value
== 0) && (old_value
!= 0))
2092 rt_cache_flush(net
);
2094 if (i
== IPV4_DEVCONF_RP_FILTER
- 1 &&
2095 new_value
!= old_value
) {
2096 ifindex
= devinet_conf_ifindex(net
, cnf
);
2097 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2101 if (i
== IPV4_DEVCONF_PROXY_ARP
- 1 &&
2102 new_value
!= old_value
) {
2103 ifindex
= devinet_conf_ifindex(net
, cnf
);
2104 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2105 NETCONFA_PROXY_NEIGH
,
2108 if (i
== IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN
- 1 &&
2109 new_value
!= old_value
) {
2110 ifindex
= devinet_conf_ifindex(net
, cnf
);
2111 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2112 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
2120 static int devinet_sysctl_forward(struct ctl_table
*ctl
, int write
,
2121 void __user
*buffer
,
2122 size_t *lenp
, loff_t
*ppos
)
2124 int *valp
= ctl
->data
;
2127 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2129 if (write
&& *valp
!= val
) {
2130 struct net
*net
= ctl
->extra2
;
2132 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
2133 if (!rtnl_trylock()) {
2134 /* Restore the original values before restarting */
2137 return restart_syscall();
2139 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
2140 inet_forward_change(net
);
2142 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2143 struct in_device
*idev
=
2144 container_of(cnf
, struct in_device
, cnf
);
2146 dev_disable_lro(idev
->dev
);
2147 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2148 NETCONFA_FORWARDING
,
2153 rt_cache_flush(net
);
2155 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2156 NETCONFA_FORWARDING
,
2157 NETCONFA_IFINDEX_DEFAULT
,
2158 net
->ipv4
.devconf_dflt
);
2164 static int ipv4_doint_and_flush(struct ctl_table
*ctl
, int write
,
2165 void __user
*buffer
,
2166 size_t *lenp
, loff_t
*ppos
)
2168 int *valp
= ctl
->data
;
2170 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2171 struct net
*net
= ctl
->extra2
;
2173 if (write
&& *valp
!= val
)
2174 rt_cache_flush(net
);
2179 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2182 .data = ipv4_devconf.data + \
2183 IPV4_DEVCONF_ ## attr - 1, \
2184 .maxlen = sizeof(int), \
2186 .proc_handler = proc, \
2187 .extra1 = &ipv4_devconf, \
2190 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2191 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2193 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2194 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2196 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2197 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2199 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2200 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2202 static struct devinet_sysctl_table
{
2203 struct ctl_table_header
*sysctl_header
;
2204 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
2205 } devinet_sysctl
= {
2207 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
2208 devinet_sysctl_forward
),
2209 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
2211 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
2212 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
2213 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
2214 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
2215 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
2216 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
2217 "accept_source_route"),
2218 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
2219 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
2220 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
2221 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
2222 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
2223 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
2224 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
2225 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
2226 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
2227 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
2228 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
2229 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
2230 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
2231 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION
,
2232 "force_igmp_version"),
2233 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL
,
2234 "igmpv2_unsolicited_report_interval"),
2235 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL
,
2236 "igmpv3_unsolicited_report_interval"),
2237 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN
,
2238 "ignore_routes_with_linkdown"),
2239 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP
,
2240 "drop_gratuitous_arp"),
2242 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
2243 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
2244 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
2245 "promote_secondaries"),
2246 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET
,
2248 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST
,
2249 "drop_unicast_in_l2_multicast"),
2253 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
2254 int ifindex
, struct ipv4_devconf
*p
)
2257 struct devinet_sysctl_table
*t
;
2258 char path
[sizeof("net/ipv4/conf/") + IFNAMSIZ
];
2260 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
2264 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
2265 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
2266 t
->devinet_vars
[i
].extra1
= p
;
2267 t
->devinet_vars
[i
].extra2
= net
;
2270 snprintf(path
, sizeof(path
), "net/ipv4/conf/%s", dev_name
);
2272 t
->sysctl_header
= register_net_sysctl(net
, path
, t
->devinet_vars
);
2273 if (!t
->sysctl_header
)
2278 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
, NETCONFA_ALL
,
2288 static void __devinet_sysctl_unregister(struct net
*net
,
2289 struct ipv4_devconf
*cnf
, int ifindex
)
2291 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
2295 unregister_net_sysctl_table(t
->sysctl_header
);
2299 inet_netconf_notify_devconf(net
, RTM_DELNETCONF
, 0, ifindex
, NULL
);
2302 static int devinet_sysctl_register(struct in_device
*idev
)
2306 if (!sysctl_dev_name_is_allowed(idev
->dev
->name
))
2309 err
= neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, NULL
);
2312 err
= __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
2313 idev
->dev
->ifindex
, &idev
->cnf
);
2315 neigh_sysctl_unregister(idev
->arp_parms
);
2319 static void devinet_sysctl_unregister(struct in_device
*idev
)
2321 struct net
*net
= dev_net(idev
->dev
);
2323 __devinet_sysctl_unregister(net
, &idev
->cnf
, idev
->dev
->ifindex
);
2324 neigh_sysctl_unregister(idev
->arp_parms
);
2327 static struct ctl_table ctl_forward_entry
[] = {
2329 .procname
= "ip_forward",
2330 .data
= &ipv4_devconf
.data
[
2331 IPV4_DEVCONF_FORWARDING
- 1],
2332 .maxlen
= sizeof(int),
2334 .proc_handler
= devinet_sysctl_forward
,
2335 .extra1
= &ipv4_devconf
,
2336 .extra2
= &init_net
,
2342 static __net_init
int devinet_init_net(struct net
*net
)
2345 struct ipv4_devconf
*all
, *dflt
;
2346 #ifdef CONFIG_SYSCTL
2347 struct ctl_table
*tbl
= ctl_forward_entry
;
2348 struct ctl_table_header
*forw_hdr
;
2352 all
= &ipv4_devconf
;
2353 dflt
= &ipv4_devconf_dflt
;
2355 if (!net_eq(net
, &init_net
)) {
2356 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
2360 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
2362 goto err_alloc_dflt
;
2364 #ifdef CONFIG_SYSCTL
2365 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
2369 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
2370 tbl
[0].extra1
= all
;
2371 tbl
[0].extra2
= net
;
2375 #ifdef CONFIG_SYSCTL
2376 err
= __devinet_sysctl_register(net
, "all", NETCONFA_IFINDEX_ALL
, all
);
2380 err
= __devinet_sysctl_register(net
, "default",
2381 NETCONFA_IFINDEX_DEFAULT
, dflt
);
2386 forw_hdr
= register_net_sysctl(net
, "net/ipv4", tbl
);
2389 net
->ipv4
.forw_hdr
= forw_hdr
;
2392 net
->ipv4
.devconf_all
= all
;
2393 net
->ipv4
.devconf_dflt
= dflt
;
2396 #ifdef CONFIG_SYSCTL
2398 __devinet_sysctl_unregister(net
, dflt
, NETCONFA_IFINDEX_DEFAULT
);
2400 __devinet_sysctl_unregister(net
, all
, NETCONFA_IFINDEX_ALL
);
2402 if (tbl
!= ctl_forward_entry
)
2406 if (dflt
!= &ipv4_devconf_dflt
)
2409 if (all
!= &ipv4_devconf
)
2415 static __net_exit
void devinet_exit_net(struct net
*net
)
2417 #ifdef CONFIG_SYSCTL
2418 struct ctl_table
*tbl
;
2420 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
2421 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
2422 __devinet_sysctl_unregister(net
, net
->ipv4
.devconf_dflt
,
2423 NETCONFA_IFINDEX_DEFAULT
);
2424 __devinet_sysctl_unregister(net
, net
->ipv4
.devconf_all
,
2425 NETCONFA_IFINDEX_ALL
);
2428 kfree(net
->ipv4
.devconf_dflt
);
2429 kfree(net
->ipv4
.devconf_all
);
2432 static __net_initdata
struct pernet_operations devinet_ops
= {
2433 .init
= devinet_init_net
,
2434 .exit
= devinet_exit_net
,
2437 static struct rtnl_af_ops inet_af_ops __read_mostly
= {
2439 .fill_link_af
= inet_fill_link_af
,
2440 .get_link_af_size
= inet_get_link_af_size
,
2441 .validate_link_af
= inet_validate_link_af
,
2442 .set_link_af
= inet_set_link_af
,
2445 void __init
devinet_init(void)
2449 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
2450 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
2452 register_pernet_subsys(&devinet_ops
);
2454 register_gifconf(PF_INET
, inet_gifconf
);
2455 register_netdevice_notifier(&ip_netdev_notifier
);
2457 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
2459 rtnl_af_register(&inet_af_ops
);
2461 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, NULL
);
2462 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, NULL
);
2463 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, NULL
);
2464 rtnl_register(PF_INET
, RTM_GETNETCONF
, inet_netconf_get_devconf
,
2465 inet_netconf_dump_devconf
, NULL
);