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
)
576 struct net
*net
= sock_net(skb
->sk
);
577 struct nlattr
*tb
[IFA_MAX
+1];
578 struct in_device
*in_dev
;
579 struct ifaddrmsg
*ifm
;
580 struct in_ifaddr
*ifa
, **ifap
;
585 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
589 ifm
= nlmsg_data(nlh
);
590 in_dev
= inetdev_by_index(net
, ifm
->ifa_index
);
596 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
597 ifap
= &ifa
->ifa_next
) {
599 ifa
->ifa_local
!= nla_get_in_addr(tb
[IFA_LOCAL
]))
602 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
605 if (tb
[IFA_ADDRESS
] &&
606 (ifm
->ifa_prefixlen
!= ifa
->ifa_prefixlen
||
607 !inet_ifa_match(nla_get_in_addr(tb
[IFA_ADDRESS
]), ifa
)))
610 if (ipv4_is_multicast(ifa
->ifa_address
))
611 ip_mc_config(net
->ipv4
.mc_autojoin_sk
, false, ifa
);
612 __inet_del_ifa(in_dev
, ifap
, 1, nlh
, NETLINK_CB(skb
).portid
);
616 err
= -EADDRNOTAVAIL
;
621 #define INFINITY_LIFE_TIME 0xFFFFFFFF
623 static void check_lifetime(struct work_struct
*work
)
625 unsigned long now
, next
, next_sec
, next_sched
;
626 struct in_ifaddr
*ifa
;
627 struct hlist_node
*n
;
631 next
= round_jiffies_up(now
+ ADDR_CHECK_FREQUENCY
);
633 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++) {
634 bool change_needed
= false;
637 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[i
], hash
) {
640 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
643 /* We try to batch several events at once. */
644 age
= (now
- ifa
->ifa_tstamp
+
645 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
647 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
648 age
>= ifa
->ifa_valid_lft
) {
649 change_needed
= true;
650 } else if (ifa
->ifa_preferred_lft
==
651 INFINITY_LIFE_TIME
) {
653 } else if (age
>= ifa
->ifa_preferred_lft
) {
654 if (time_before(ifa
->ifa_tstamp
+
655 ifa
->ifa_valid_lft
* HZ
, next
))
656 next
= ifa
->ifa_tstamp
+
657 ifa
->ifa_valid_lft
* HZ
;
659 if (!(ifa
->ifa_flags
& IFA_F_DEPRECATED
))
660 change_needed
= true;
661 } else if (time_before(ifa
->ifa_tstamp
+
662 ifa
->ifa_preferred_lft
* HZ
,
664 next
= ifa
->ifa_tstamp
+
665 ifa
->ifa_preferred_lft
* HZ
;
672 hlist_for_each_entry_safe(ifa
, n
, &inet_addr_lst
[i
], hash
) {
675 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
678 /* We try to batch several events at once. */
679 age
= (now
- ifa
->ifa_tstamp
+
680 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
682 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
683 age
>= ifa
->ifa_valid_lft
) {
684 struct in_ifaddr
**ifap
;
686 for (ifap
= &ifa
->ifa_dev
->ifa_list
;
687 *ifap
!= NULL
; ifap
= &(*ifap
)->ifa_next
) {
689 inet_del_ifa(ifa
->ifa_dev
,
694 } else if (ifa
->ifa_preferred_lft
!=
695 INFINITY_LIFE_TIME
&&
696 age
>= ifa
->ifa_preferred_lft
&&
697 !(ifa
->ifa_flags
& IFA_F_DEPRECATED
)) {
698 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
699 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
705 next_sec
= round_jiffies_up(next
);
708 /* If rounded timeout is accurate enough, accept it. */
709 if (time_before(next_sec
, next
+ ADDRCONF_TIMER_FUZZ
))
710 next_sched
= next_sec
;
713 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
714 if (time_before(next_sched
, now
+ ADDRCONF_TIMER_FUZZ_MAX
))
715 next_sched
= now
+ ADDRCONF_TIMER_FUZZ_MAX
;
717 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
,
721 static void set_ifa_lifetime(struct in_ifaddr
*ifa
, __u32 valid_lft
,
724 unsigned long timeout
;
726 ifa
->ifa_flags
&= ~(IFA_F_PERMANENT
| IFA_F_DEPRECATED
);
728 timeout
= addrconf_timeout_fixup(valid_lft
, HZ
);
729 if (addrconf_finite_timeout(timeout
))
730 ifa
->ifa_valid_lft
= timeout
;
732 ifa
->ifa_flags
|= IFA_F_PERMANENT
;
734 timeout
= addrconf_timeout_fixup(prefered_lft
, HZ
);
735 if (addrconf_finite_timeout(timeout
)) {
737 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
738 ifa
->ifa_preferred_lft
= timeout
;
740 ifa
->ifa_tstamp
= jiffies
;
741 if (!ifa
->ifa_cstamp
)
742 ifa
->ifa_cstamp
= ifa
->ifa_tstamp
;
745 static struct in_ifaddr
*rtm_to_ifaddr(struct net
*net
, struct nlmsghdr
*nlh
,
746 __u32
*pvalid_lft
, __u32
*pprefered_lft
)
748 struct nlattr
*tb
[IFA_MAX
+1];
749 struct in_ifaddr
*ifa
;
750 struct ifaddrmsg
*ifm
;
751 struct net_device
*dev
;
752 struct in_device
*in_dev
;
755 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
759 ifm
= nlmsg_data(nlh
);
761 if (ifm
->ifa_prefixlen
> 32 || !tb
[IFA_LOCAL
])
764 dev
= __dev_get_by_index(net
, ifm
->ifa_index
);
769 in_dev
= __in_dev_get_rtnl(dev
);
774 ifa
= inet_alloc_ifa();
777 * A potential indev allocation can be left alive, it stays
778 * assigned to its device and is destroy with it.
782 ipv4_devconf_setall(in_dev
);
783 neigh_parms_data_state_setall(in_dev
->arp_parms
);
786 if (!tb
[IFA_ADDRESS
])
787 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
789 INIT_HLIST_NODE(&ifa
->hash
);
790 ifa
->ifa_prefixlen
= ifm
->ifa_prefixlen
;
791 ifa
->ifa_mask
= inet_make_mask(ifm
->ifa_prefixlen
);
792 ifa
->ifa_flags
= tb
[IFA_FLAGS
] ? nla_get_u32(tb
[IFA_FLAGS
]) :
794 ifa
->ifa_scope
= ifm
->ifa_scope
;
795 ifa
->ifa_dev
= in_dev
;
797 ifa
->ifa_local
= nla_get_in_addr(tb
[IFA_LOCAL
]);
798 ifa
->ifa_address
= nla_get_in_addr(tb
[IFA_ADDRESS
]);
800 if (tb
[IFA_BROADCAST
])
801 ifa
->ifa_broadcast
= nla_get_in_addr(tb
[IFA_BROADCAST
]);
804 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
806 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
808 if (tb
[IFA_CACHEINFO
]) {
809 struct ifa_cacheinfo
*ci
;
811 ci
= nla_data(tb
[IFA_CACHEINFO
]);
812 if (!ci
->ifa_valid
|| ci
->ifa_prefered
> ci
->ifa_valid
) {
816 *pvalid_lft
= ci
->ifa_valid
;
817 *pprefered_lft
= ci
->ifa_prefered
;
828 static struct in_ifaddr
*find_matching_ifa(struct in_ifaddr
*ifa
)
830 struct in_device
*in_dev
= ifa
->ifa_dev
;
831 struct in_ifaddr
*ifa1
, **ifap
;
836 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
837 ifap
= &ifa1
->ifa_next
) {
838 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
839 inet_ifa_match(ifa1
->ifa_address
, ifa
) &&
840 ifa1
->ifa_local
== ifa
->ifa_local
)
846 static int inet_rtm_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
848 struct net
*net
= sock_net(skb
->sk
);
849 struct in_ifaddr
*ifa
;
850 struct in_ifaddr
*ifa_existing
;
851 __u32 valid_lft
= INFINITY_LIFE_TIME
;
852 __u32 prefered_lft
= INFINITY_LIFE_TIME
;
856 ifa
= rtm_to_ifaddr(net
, nlh
, &valid_lft
, &prefered_lft
);
860 ifa_existing
= find_matching_ifa(ifa
);
862 /* It would be best to check for !NLM_F_CREATE here but
863 * userspace already relies on not having to provide this.
865 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
866 if (ifa
->ifa_flags
& IFA_F_MCAUTOJOIN
) {
867 int ret
= ip_mc_config(net
->ipv4
.mc_autojoin_sk
,
875 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).portid
);
879 if (nlh
->nlmsg_flags
& NLM_F_EXCL
||
880 !(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
883 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
884 cancel_delayed_work(&check_lifetime_work
);
885 queue_delayed_work(system_power_efficient_wq
,
886 &check_lifetime_work
, 0);
887 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, NETLINK_CB(skb
).portid
);
893 * Determine a default network mask, based on the IP address.
896 static int inet_abc_len(__be32 addr
)
898 int rc
= -1; /* Something else, probably a multicast. */
900 if (ipv4_is_zeronet(addr
))
903 __u32 haddr
= ntohl(addr
);
905 if (IN_CLASSA(haddr
))
907 else if (IN_CLASSB(haddr
))
909 else if (IN_CLASSC(haddr
))
917 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
920 struct sockaddr_in sin_orig
;
921 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
922 struct in_device
*in_dev
;
923 struct in_ifaddr
**ifap
= NULL
;
924 struct in_ifaddr
*ifa
= NULL
;
925 struct net_device
*dev
;
928 int tryaddrmatch
= 0;
931 * Fetch the caller's info block into kernel space
934 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
936 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
938 /* save original address for comparison */
939 memcpy(&sin_orig
, sin
, sizeof(*sin
));
941 colon
= strchr(ifr
.ifr_name
, ':');
945 dev_load(net
, ifr
.ifr_name
);
948 case SIOCGIFADDR
: /* Get interface address */
949 case SIOCGIFBRDADDR
: /* Get the broadcast address */
950 case SIOCGIFDSTADDR
: /* Get the destination address */
951 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
952 /* Note that these ioctls will not sleep,
953 so that we do not impose a lock.
954 One day we will be forced to put shlock here (I mean SMP)
956 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
957 memset(sin
, 0, sizeof(*sin
));
958 sin
->sin_family
= AF_INET
;
963 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
966 case SIOCSIFADDR
: /* Set interface address (and family) */
967 case SIOCSIFBRDADDR
: /* Set the broadcast address */
968 case SIOCSIFDSTADDR
: /* Set the destination address */
969 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
971 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
974 if (sin
->sin_family
!= AF_INET
)
985 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
992 in_dev
= __in_dev_get_rtnl(dev
);
995 /* Matthias Andree */
996 /* compare label and address (4.4BSD style) */
997 /* note: we only do this for a limited set of ioctls
998 and only if the original address family was AF_INET.
999 This is checked above. */
1000 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1001 ifap
= &ifa
->ifa_next
) {
1002 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
1003 sin_orig
.sin_addr
.s_addr
==
1009 /* we didn't get a match, maybe the application is
1010 4.3BSD-style and passed in junk so we fall back to
1011 comparing just the label */
1013 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1014 ifap
= &ifa
->ifa_next
)
1015 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
1020 ret
= -EADDRNOTAVAIL
;
1021 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
1025 case SIOCGIFADDR
: /* Get interface address */
1026 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
1029 case SIOCGIFBRDADDR
: /* Get the broadcast address */
1030 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
1033 case SIOCGIFDSTADDR
: /* Get the destination address */
1034 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
1037 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
1038 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
1043 ret
= -EADDRNOTAVAIL
;
1047 if (!(ifr
.ifr_flags
& IFF_UP
))
1048 inet_del_ifa(in_dev
, ifap
, 1);
1051 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
1054 case SIOCSIFADDR
: /* Set interface address (and family) */
1056 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1061 ifa
= inet_alloc_ifa();
1064 INIT_HLIST_NODE(&ifa
->hash
);
1066 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
1068 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1071 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
1073 inet_del_ifa(in_dev
, ifap
, 0);
1074 ifa
->ifa_broadcast
= 0;
1078 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
1080 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
1081 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
1082 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
1083 if ((dev
->flags
& IFF_BROADCAST
) &&
1084 ifa
->ifa_prefixlen
< 31)
1085 ifa
->ifa_broadcast
= ifa
->ifa_address
|
1088 ifa
->ifa_prefixlen
= 32;
1089 ifa
->ifa_mask
= inet_make_mask(32);
1091 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
, INFINITY_LIFE_TIME
);
1092 ret
= inet_set_ifa(dev
, ifa
);
1095 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1097 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
1098 inet_del_ifa(in_dev
, ifap
, 0);
1099 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
1100 inet_insert_ifa(ifa
);
1104 case SIOCSIFDSTADDR
: /* Set the destination address */
1106 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
1109 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1112 inet_del_ifa(in_dev
, ifap
, 0);
1113 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
1114 inet_insert_ifa(ifa
);
1117 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1120 * The mask we set must be legal.
1123 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
1126 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
1127 __be32 old_mask
= ifa
->ifa_mask
;
1128 inet_del_ifa(in_dev
, ifap
, 0);
1129 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
1130 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
1132 /* See if current broadcast address matches
1133 * with current netmask, then recalculate
1134 * the broadcast address. Otherwise it's a
1135 * funny address, so don't touch it since
1136 * the user seems to know what (s)he's doing...
1138 if ((dev
->flags
& IFF_BROADCAST
) &&
1139 (ifa
->ifa_prefixlen
< 31) &&
1140 (ifa
->ifa_broadcast
==
1141 (ifa
->ifa_local
|~old_mask
))) {
1142 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
1143 ~sin
->sin_addr
.s_addr
);
1145 inet_insert_ifa(ifa
);
1155 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
1159 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
1161 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1162 struct in_ifaddr
*ifa
;
1169 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1171 done
+= sizeof(ifr
);
1174 if (len
< (int) sizeof(ifr
))
1176 memset(&ifr
, 0, sizeof(struct ifreq
));
1177 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
1179 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
1180 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
1183 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
1187 buf
+= sizeof(struct ifreq
);
1188 len
-= sizeof(struct ifreq
);
1189 done
+= sizeof(struct ifreq
);
1195 static __be32
in_dev_select_addr(const struct in_device
*in_dev
,
1198 for_primary_ifa(in_dev
) {
1199 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1200 ifa
->ifa_scope
<= scope
)
1201 return ifa
->ifa_local
;
1202 } endfor_ifa(in_dev
);
1207 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
1210 struct in_device
*in_dev
;
1211 struct net
*net
= dev_net(dev
);
1215 in_dev
= __in_dev_get_rcu(dev
);
1219 for_primary_ifa(in_dev
) {
1220 if (ifa
->ifa_scope
> scope
)
1222 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
1223 addr
= ifa
->ifa_local
;
1227 addr
= ifa
->ifa_local
;
1228 } endfor_ifa(in_dev
);
1233 master_idx
= l3mdev_master_ifindex_rcu(dev
);
1235 /* For VRFs, the VRF device takes the place of the loopback device,
1236 * with addresses on it being preferred. Note in such cases the
1237 * loopback device will be among the devices that fail the master_idx
1238 * equality check in the loop below.
1241 (dev
= dev_get_by_index_rcu(net
, master_idx
)) &&
1242 (in_dev
= __in_dev_get_rcu(dev
))) {
1243 addr
= in_dev_select_addr(in_dev
, scope
);
1248 /* Not loopback addresses on loopback should be preferred
1249 in this case. It is important that lo is the first interface
1252 for_each_netdev_rcu(net
, dev
) {
1253 if (l3mdev_master_ifindex_rcu(dev
) != master_idx
)
1256 in_dev
= __in_dev_get_rcu(dev
);
1260 addr
= in_dev_select_addr(in_dev
, scope
);
1268 EXPORT_SYMBOL(inet_select_addr
);
1270 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1271 __be32 local
, int scope
)
1278 (local
== ifa
->ifa_local
|| !local
) &&
1279 ifa
->ifa_scope
<= scope
) {
1280 addr
= ifa
->ifa_local
;
1285 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1286 (!dst
|| inet_ifa_match(dst
, ifa
));
1290 /* Is the selected addr into dst subnet? */
1291 if (inet_ifa_match(addr
, ifa
))
1293 /* No, then can we use new local src? */
1294 if (ifa
->ifa_scope
<= scope
) {
1295 addr
= ifa
->ifa_local
;
1298 /* search for large dst subnet for addr */
1302 } endfor_ifa(in_dev
);
1304 return same
? addr
: 0;
1308 * Confirm that local IP address exists using wildcards:
1309 * - net: netns to check, cannot be NULL
1310 * - in_dev: only on this interface, NULL=any interface
1311 * - dst: only in the same subnet as dst, 0=any dst
1312 * - local: address, 0=autoselect the local address
1313 * - scope: maximum allowed scope value for the local address
1315 __be32
inet_confirm_addr(struct net
*net
, struct in_device
*in_dev
,
1316 __be32 dst
, __be32 local
, int scope
)
1319 struct net_device
*dev
;
1322 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1325 for_each_netdev_rcu(net
, dev
) {
1326 in_dev
= __in_dev_get_rcu(dev
);
1328 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1337 EXPORT_SYMBOL(inet_confirm_addr
);
1343 int register_inetaddr_notifier(struct notifier_block
*nb
)
1345 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1347 EXPORT_SYMBOL(register_inetaddr_notifier
);
1349 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1351 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1353 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1355 /* Rename ifa_labels for a device name change. Make some effort to preserve
1356 * existing alias numbering and to create unique labels if possible.
1358 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1360 struct in_ifaddr
*ifa
;
1363 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1364 char old
[IFNAMSIZ
], *dot
;
1366 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1367 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1370 dot
= strchr(old
, ':');
1372 sprintf(old
, ":%d", named
);
1375 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1376 strcat(ifa
->ifa_label
, dot
);
1378 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1380 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1384 static bool inetdev_valid_mtu(unsigned int mtu
)
1389 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1390 struct in_device
*in_dev
)
1393 struct in_ifaddr
*ifa
;
1395 for (ifa
= in_dev
->ifa_list
; ifa
;
1396 ifa
= ifa
->ifa_next
) {
1397 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1398 ifa
->ifa_local
, dev
,
1399 ifa
->ifa_local
, NULL
,
1400 dev
->dev_addr
, NULL
);
1404 /* Called only under RTNL semaphore */
1406 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1409 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1410 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1415 if (event
== NETDEV_REGISTER
) {
1416 in_dev
= inetdev_init(dev
);
1418 return notifier_from_errno(PTR_ERR(in_dev
));
1419 if (dev
->flags
& IFF_LOOPBACK
) {
1420 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1421 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1423 } else if (event
== NETDEV_CHANGEMTU
) {
1424 /* Re-enabling IP */
1425 if (inetdev_valid_mtu(dev
->mtu
))
1426 in_dev
= inetdev_init(dev
);
1432 case NETDEV_REGISTER
:
1433 pr_debug("%s: bug\n", __func__
);
1434 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1437 if (!inetdev_valid_mtu(dev
->mtu
))
1439 if (dev
->flags
& IFF_LOOPBACK
) {
1440 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1443 INIT_HLIST_NODE(&ifa
->hash
);
1445 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1446 ifa
->ifa_prefixlen
= 8;
1447 ifa
->ifa_mask
= inet_make_mask(8);
1448 in_dev_hold(in_dev
);
1449 ifa
->ifa_dev
= in_dev
;
1450 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1451 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1452 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
,
1453 INFINITY_LIFE_TIME
);
1454 ipv4_devconf_setall(in_dev
);
1455 neigh_parms_data_state_setall(in_dev
->arp_parms
);
1456 inet_insert_ifa(ifa
);
1461 case NETDEV_CHANGEADDR
:
1462 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1465 case NETDEV_NOTIFY_PEERS
:
1466 /* Send gratuitous ARP to notify of link change */
1467 inetdev_send_gratuitous_arp(dev
, in_dev
);
1472 case NETDEV_PRE_TYPE_CHANGE
:
1473 ip_mc_unmap(in_dev
);
1475 case NETDEV_POST_TYPE_CHANGE
:
1476 ip_mc_remap(in_dev
);
1478 case NETDEV_CHANGEMTU
:
1479 if (inetdev_valid_mtu(dev
->mtu
))
1481 /* disable IP when MTU is not enough */
1482 case NETDEV_UNREGISTER
:
1483 inetdev_destroy(in_dev
);
1485 case NETDEV_CHANGENAME
:
1486 /* Do not notify about label change, this event is
1487 * not interesting to applications using netlink.
1489 inetdev_changename(dev
, in_dev
);
1491 devinet_sysctl_unregister(in_dev
);
1492 devinet_sysctl_register(in_dev
);
1499 static struct notifier_block ip_netdev_notifier
= {
1500 .notifier_call
= inetdev_event
,
1503 static size_t inet_nlmsg_size(void)
1505 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1506 + nla_total_size(4) /* IFA_ADDRESS */
1507 + nla_total_size(4) /* IFA_LOCAL */
1508 + nla_total_size(4) /* IFA_BROADCAST */
1509 + nla_total_size(IFNAMSIZ
) /* IFA_LABEL */
1510 + nla_total_size(4) /* IFA_FLAGS */
1511 + nla_total_size(sizeof(struct ifa_cacheinfo
)); /* IFA_CACHEINFO */
1514 static inline u32
cstamp_delta(unsigned long cstamp
)
1516 return (cstamp
- INITIAL_JIFFIES
) * 100UL / HZ
;
1519 static int put_cacheinfo(struct sk_buff
*skb
, unsigned long cstamp
,
1520 unsigned long tstamp
, u32 preferred
, u32 valid
)
1522 struct ifa_cacheinfo ci
;
1524 ci
.cstamp
= cstamp_delta(cstamp
);
1525 ci
.tstamp
= cstamp_delta(tstamp
);
1526 ci
.ifa_prefered
= preferred
;
1527 ci
.ifa_valid
= valid
;
1529 return nla_put(skb
, IFA_CACHEINFO
, sizeof(ci
), &ci
);
1532 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1533 u32 portid
, u32 seq
, int event
, unsigned int flags
)
1535 struct ifaddrmsg
*ifm
;
1536 struct nlmsghdr
*nlh
;
1537 u32 preferred
, valid
;
1539 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*ifm
), flags
);
1543 ifm
= nlmsg_data(nlh
);
1544 ifm
->ifa_family
= AF_INET
;
1545 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1546 ifm
->ifa_flags
= ifa
->ifa_flags
;
1547 ifm
->ifa_scope
= ifa
->ifa_scope
;
1548 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1550 if (!(ifm
->ifa_flags
& IFA_F_PERMANENT
)) {
1551 preferred
= ifa
->ifa_preferred_lft
;
1552 valid
= ifa
->ifa_valid_lft
;
1553 if (preferred
!= INFINITY_LIFE_TIME
) {
1554 long tval
= (jiffies
- ifa
->ifa_tstamp
) / HZ
;
1556 if (preferred
> tval
)
1560 if (valid
!= INFINITY_LIFE_TIME
) {
1568 preferred
= INFINITY_LIFE_TIME
;
1569 valid
= INFINITY_LIFE_TIME
;
1571 if ((ifa
->ifa_address
&&
1572 nla_put_in_addr(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1574 nla_put_in_addr(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1575 (ifa
->ifa_broadcast
&&
1576 nla_put_in_addr(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1577 (ifa
->ifa_label
[0] &&
1578 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)) ||
1579 nla_put_u32(skb
, IFA_FLAGS
, ifa
->ifa_flags
) ||
1580 put_cacheinfo(skb
, ifa
->ifa_cstamp
, ifa
->ifa_tstamp
,
1582 goto nla_put_failure
;
1584 nlmsg_end(skb
, nlh
);
1588 nlmsg_cancel(skb
, nlh
);
1592 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1594 struct net
*net
= sock_net(skb
->sk
);
1597 int ip_idx
, s_ip_idx
;
1598 struct net_device
*dev
;
1599 struct in_device
*in_dev
;
1600 struct in_ifaddr
*ifa
;
1601 struct hlist_head
*head
;
1604 s_idx
= idx
= cb
->args
[1];
1605 s_ip_idx
= ip_idx
= cb
->args
[2];
1607 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1609 head
= &net
->dev_index_head
[h
];
1611 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1613 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1616 if (h
> s_h
|| idx
> s_idx
)
1618 in_dev
= __in_dev_get_rcu(dev
);
1622 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1623 ifa
= ifa
->ifa_next
, ip_idx
++) {
1624 if (ip_idx
< s_ip_idx
)
1626 if (inet_fill_ifaddr(skb
, ifa
,
1627 NETLINK_CB(cb
->skb
).portid
,
1629 RTM_NEWADDR
, NLM_F_MULTI
) < 0) {
1633 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1644 cb
->args
[2] = ip_idx
;
1649 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1652 struct sk_buff
*skb
;
1653 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1657 net
= dev_net(ifa
->ifa_dev
->dev
);
1658 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1662 err
= inet_fill_ifaddr(skb
, ifa
, portid
, seq
, event
, 0);
1664 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1665 WARN_ON(err
== -EMSGSIZE
);
1669 rtnl_notify(skb
, net
, portid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1673 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1676 static size_t inet_get_link_af_size(const struct net_device
*dev
,
1677 u32 ext_filter_mask
)
1679 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1684 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1687 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
,
1688 u32 ext_filter_mask
)
1690 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1697 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1701 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1702 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1707 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1708 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1711 static int inet_validate_link_af(const struct net_device
*dev
,
1712 const struct nlattr
*nla
)
1714 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1717 if (dev
&& !__in_dev_get_rtnl(dev
))
1718 return -EAFNOSUPPORT
;
1720 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
);
1724 if (tb
[IFLA_INET_CONF
]) {
1725 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1726 int cfgid
= nla_type(a
);
1731 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1739 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1741 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1742 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1746 return -EAFNOSUPPORT
;
1748 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
) < 0)
1751 if (tb
[IFLA_INET_CONF
]) {
1752 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1753 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1759 static int inet_netconf_msgsize_devconf(int type
)
1761 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1762 + nla_total_size(4); /* NETCONFA_IFINDEX */
1765 if (type
== NETCONFA_ALL
)
1768 if (all
|| type
== NETCONFA_FORWARDING
)
1769 size
+= nla_total_size(4);
1770 if (all
|| type
== NETCONFA_RP_FILTER
)
1771 size
+= nla_total_size(4);
1772 if (all
|| type
== NETCONFA_MC_FORWARDING
)
1773 size
+= nla_total_size(4);
1774 if (all
|| type
== NETCONFA_PROXY_NEIGH
)
1775 size
+= nla_total_size(4);
1776 if (all
|| type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
)
1777 size
+= nla_total_size(4);
1782 static int inet_netconf_fill_devconf(struct sk_buff
*skb
, int ifindex
,
1783 struct ipv4_devconf
*devconf
, u32 portid
,
1784 u32 seq
, int event
, unsigned int flags
,
1787 struct nlmsghdr
*nlh
;
1788 struct netconfmsg
*ncm
;
1791 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1796 if (type
== NETCONFA_ALL
)
1799 ncm
= nlmsg_data(nlh
);
1800 ncm
->ncm_family
= AF_INET
;
1802 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, ifindex
) < 0)
1803 goto nla_put_failure
;
1808 if ((all
|| type
== NETCONFA_FORWARDING
) &&
1809 nla_put_s32(skb
, NETCONFA_FORWARDING
,
1810 IPV4_DEVCONF(*devconf
, FORWARDING
)) < 0)
1811 goto nla_put_failure
;
1812 if ((all
|| type
== NETCONFA_RP_FILTER
) &&
1813 nla_put_s32(skb
, NETCONFA_RP_FILTER
,
1814 IPV4_DEVCONF(*devconf
, RP_FILTER
)) < 0)
1815 goto nla_put_failure
;
1816 if ((all
|| type
== NETCONFA_MC_FORWARDING
) &&
1817 nla_put_s32(skb
, NETCONFA_MC_FORWARDING
,
1818 IPV4_DEVCONF(*devconf
, MC_FORWARDING
)) < 0)
1819 goto nla_put_failure
;
1820 if ((all
|| type
== NETCONFA_PROXY_NEIGH
) &&
1821 nla_put_s32(skb
, NETCONFA_PROXY_NEIGH
,
1822 IPV4_DEVCONF(*devconf
, PROXY_ARP
)) < 0)
1823 goto nla_put_failure
;
1824 if ((all
|| type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
) &&
1825 nla_put_s32(skb
, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
1826 IPV4_DEVCONF(*devconf
, IGNORE_ROUTES_WITH_LINKDOWN
)) < 0)
1827 goto nla_put_failure
;
1830 nlmsg_end(skb
, nlh
);
1834 nlmsg_cancel(skb
, nlh
);
1838 void inet_netconf_notify_devconf(struct net
*net
, int event
, int type
,
1839 int ifindex
, struct ipv4_devconf
*devconf
)
1841 struct sk_buff
*skb
;
1844 skb
= nlmsg_new(inet_netconf_msgsize_devconf(type
), GFP_KERNEL
);
1848 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
, 0, 0,
1851 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1852 WARN_ON(err
== -EMSGSIZE
);
1856 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_NETCONF
, NULL
, GFP_KERNEL
);
1860 rtnl_set_sk_err(net
, RTNLGRP_IPV4_NETCONF
, err
);
1863 static const struct nla_policy devconf_ipv4_policy
[NETCONFA_MAX
+1] = {
1864 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1865 [NETCONFA_FORWARDING
] = { .len
= sizeof(int) },
1866 [NETCONFA_RP_FILTER
] = { .len
= sizeof(int) },
1867 [NETCONFA_PROXY_NEIGH
] = { .len
= sizeof(int) },
1868 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
] = { .len
= sizeof(int) },
1871 static int inet_netconf_get_devconf(struct sk_buff
*in_skb
,
1872 struct nlmsghdr
*nlh
)
1874 struct net
*net
= sock_net(in_skb
->sk
);
1875 struct nlattr
*tb
[NETCONFA_MAX
+1];
1876 struct netconfmsg
*ncm
;
1877 struct sk_buff
*skb
;
1878 struct ipv4_devconf
*devconf
;
1879 struct in_device
*in_dev
;
1880 struct net_device
*dev
;
1884 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1885 devconf_ipv4_policy
);
1890 if (!tb
[NETCONFA_IFINDEX
])
1893 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1895 case NETCONFA_IFINDEX_ALL
:
1896 devconf
= net
->ipv4
.devconf_all
;
1898 case NETCONFA_IFINDEX_DEFAULT
:
1899 devconf
= net
->ipv4
.devconf_dflt
;
1902 dev
= __dev_get_by_index(net
, ifindex
);
1905 in_dev
= __in_dev_get_rtnl(dev
);
1908 devconf
= &in_dev
->cnf
;
1913 skb
= nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL
), GFP_KERNEL
);
1917 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
,
1918 NETLINK_CB(in_skb
).portid
,
1919 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1922 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1923 WARN_ON(err
== -EMSGSIZE
);
1927 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1932 static int inet_netconf_dump_devconf(struct sk_buff
*skb
,
1933 struct netlink_callback
*cb
)
1935 struct net
*net
= sock_net(skb
->sk
);
1938 struct net_device
*dev
;
1939 struct in_device
*in_dev
;
1940 struct hlist_head
*head
;
1943 s_idx
= idx
= cb
->args
[1];
1945 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1947 head
= &net
->dev_index_head
[h
];
1949 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1951 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1954 in_dev
= __in_dev_get_rcu(dev
);
1958 if (inet_netconf_fill_devconf(skb
, dev
->ifindex
,
1960 NETLINK_CB(cb
->skb
).portid
,
1964 NETCONFA_ALL
) < 0) {
1968 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1974 if (h
== NETDEV_HASHENTRIES
) {
1975 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_ALL
,
1976 net
->ipv4
.devconf_all
,
1977 NETLINK_CB(cb
->skb
).portid
,
1979 RTM_NEWNETCONF
, NLM_F_MULTI
,
1985 if (h
== NETDEV_HASHENTRIES
+ 1) {
1986 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_DEFAULT
,
1987 net
->ipv4
.devconf_dflt
,
1988 NETLINK_CB(cb
->skb
).portid
,
1990 RTM_NEWNETCONF
, NLM_F_MULTI
,
2003 #ifdef CONFIG_SYSCTL
2005 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
2007 struct net_device
*dev
;
2010 for_each_netdev_rcu(net
, dev
) {
2011 struct in_device
*in_dev
;
2013 in_dev
= __in_dev_get_rcu(dev
);
2014 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
2015 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
2020 /* called with RTNL locked */
2021 static void inet_forward_change(struct net
*net
)
2023 struct net_device
*dev
;
2024 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
2026 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
2027 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
2028 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2029 NETCONFA_FORWARDING
,
2030 NETCONFA_IFINDEX_ALL
,
2031 net
->ipv4
.devconf_all
);
2032 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2033 NETCONFA_FORWARDING
,
2034 NETCONFA_IFINDEX_DEFAULT
,
2035 net
->ipv4
.devconf_dflt
);
2037 for_each_netdev(net
, dev
) {
2038 struct in_device
*in_dev
;
2041 dev_disable_lro(dev
);
2043 in_dev
= __in_dev_get_rtnl(dev
);
2045 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
2046 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2047 NETCONFA_FORWARDING
,
2048 dev
->ifindex
, &in_dev
->cnf
);
2053 static int devinet_conf_ifindex(struct net
*net
, struct ipv4_devconf
*cnf
)
2055 if (cnf
== net
->ipv4
.devconf_dflt
)
2056 return NETCONFA_IFINDEX_DEFAULT
;
2057 else if (cnf
== net
->ipv4
.devconf_all
)
2058 return NETCONFA_IFINDEX_ALL
;
2060 struct in_device
*idev
2061 = container_of(cnf
, struct in_device
, cnf
);
2062 return idev
->dev
->ifindex
;
2066 static int devinet_conf_proc(struct ctl_table
*ctl
, int write
,
2067 void __user
*buffer
,
2068 size_t *lenp
, loff_t
*ppos
)
2070 int old_value
= *(int *)ctl
->data
;
2071 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2072 int new_value
= *(int *)ctl
->data
;
2075 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2076 struct net
*net
= ctl
->extra2
;
2077 int i
= (int *)ctl
->data
- cnf
->data
;
2080 set_bit(i
, cnf
->state
);
2082 if (cnf
== net
->ipv4
.devconf_dflt
)
2083 devinet_copy_dflt_conf(net
, i
);
2084 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1 ||
2085 i
== IPV4_DEVCONF_ROUTE_LOCALNET
- 1)
2086 if ((new_value
== 0) && (old_value
!= 0))
2087 rt_cache_flush(net
);
2089 if (i
== IPV4_DEVCONF_RP_FILTER
- 1 &&
2090 new_value
!= old_value
) {
2091 ifindex
= devinet_conf_ifindex(net
, cnf
);
2092 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2096 if (i
== IPV4_DEVCONF_PROXY_ARP
- 1 &&
2097 new_value
!= old_value
) {
2098 ifindex
= devinet_conf_ifindex(net
, cnf
);
2099 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2100 NETCONFA_PROXY_NEIGH
,
2103 if (i
== IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN
- 1 &&
2104 new_value
!= old_value
) {
2105 ifindex
= devinet_conf_ifindex(net
, cnf
);
2106 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2107 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
2115 static int devinet_sysctl_forward(struct ctl_table
*ctl
, int write
,
2116 void __user
*buffer
,
2117 size_t *lenp
, loff_t
*ppos
)
2119 int *valp
= ctl
->data
;
2122 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2124 if (write
&& *valp
!= val
) {
2125 struct net
*net
= ctl
->extra2
;
2127 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
2128 if (!rtnl_trylock()) {
2129 /* Restore the original values before restarting */
2132 return restart_syscall();
2134 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
2135 inet_forward_change(net
);
2137 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2138 struct in_device
*idev
=
2139 container_of(cnf
, struct in_device
, cnf
);
2141 dev_disable_lro(idev
->dev
);
2142 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2143 NETCONFA_FORWARDING
,
2148 rt_cache_flush(net
);
2150 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
2151 NETCONFA_FORWARDING
,
2152 NETCONFA_IFINDEX_DEFAULT
,
2153 net
->ipv4
.devconf_dflt
);
2159 static int ipv4_doint_and_flush(struct ctl_table
*ctl
, int write
,
2160 void __user
*buffer
,
2161 size_t *lenp
, loff_t
*ppos
)
2163 int *valp
= ctl
->data
;
2165 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2166 struct net
*net
= ctl
->extra2
;
2168 if (write
&& *valp
!= val
)
2169 rt_cache_flush(net
);
2174 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2177 .data = ipv4_devconf.data + \
2178 IPV4_DEVCONF_ ## attr - 1, \
2179 .maxlen = sizeof(int), \
2181 .proc_handler = proc, \
2182 .extra1 = &ipv4_devconf, \
2185 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2186 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2188 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2189 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2191 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2192 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2194 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2195 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2197 static struct devinet_sysctl_table
{
2198 struct ctl_table_header
*sysctl_header
;
2199 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
2200 } devinet_sysctl
= {
2202 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
2203 devinet_sysctl_forward
),
2204 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
2206 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
2207 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
2208 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
2209 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
2210 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
2211 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
2212 "accept_source_route"),
2213 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
2214 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
2215 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
2216 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
2217 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
2218 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
2219 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
2220 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
2221 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
2222 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
2223 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
2224 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
2225 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
2226 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION
,
2227 "force_igmp_version"),
2228 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL
,
2229 "igmpv2_unsolicited_report_interval"),
2230 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL
,
2231 "igmpv3_unsolicited_report_interval"),
2232 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN
,
2233 "ignore_routes_with_linkdown"),
2234 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP
,
2235 "drop_gratuitous_arp"),
2237 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
2238 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
2239 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
2240 "promote_secondaries"),
2241 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET
,
2243 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST
,
2244 "drop_unicast_in_l2_multicast"),
2248 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
2249 int ifindex
, struct ipv4_devconf
*p
)
2252 struct devinet_sysctl_table
*t
;
2253 char path
[sizeof("net/ipv4/conf/") + IFNAMSIZ
];
2255 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
2259 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
2260 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
2261 t
->devinet_vars
[i
].extra1
= p
;
2262 t
->devinet_vars
[i
].extra2
= net
;
2265 snprintf(path
, sizeof(path
), "net/ipv4/conf/%s", dev_name
);
2267 t
->sysctl_header
= register_net_sysctl(net
, path
, t
->devinet_vars
);
2268 if (!t
->sysctl_header
)
2273 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
, NETCONFA_ALL
,
2283 static void __devinet_sysctl_unregister(struct net
*net
,
2284 struct ipv4_devconf
*cnf
, int ifindex
)
2286 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
2290 unregister_net_sysctl_table(t
->sysctl_header
);
2294 inet_netconf_notify_devconf(net
, RTM_DELNETCONF
, 0, ifindex
, NULL
);
2297 static int devinet_sysctl_register(struct in_device
*idev
)
2301 if (!sysctl_dev_name_is_allowed(idev
->dev
->name
))
2304 err
= neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, NULL
);
2307 err
= __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
2308 idev
->dev
->ifindex
, &idev
->cnf
);
2310 neigh_sysctl_unregister(idev
->arp_parms
);
2314 static void devinet_sysctl_unregister(struct in_device
*idev
)
2316 struct net
*net
= dev_net(idev
->dev
);
2318 __devinet_sysctl_unregister(net
, &idev
->cnf
, idev
->dev
->ifindex
);
2319 neigh_sysctl_unregister(idev
->arp_parms
);
2322 static struct ctl_table ctl_forward_entry
[] = {
2324 .procname
= "ip_forward",
2325 .data
= &ipv4_devconf
.data
[
2326 IPV4_DEVCONF_FORWARDING
- 1],
2327 .maxlen
= sizeof(int),
2329 .proc_handler
= devinet_sysctl_forward
,
2330 .extra1
= &ipv4_devconf
,
2331 .extra2
= &init_net
,
2337 static __net_init
int devinet_init_net(struct net
*net
)
2340 struct ipv4_devconf
*all
, *dflt
;
2341 #ifdef CONFIG_SYSCTL
2342 struct ctl_table
*tbl
= ctl_forward_entry
;
2343 struct ctl_table_header
*forw_hdr
;
2347 all
= &ipv4_devconf
;
2348 dflt
= &ipv4_devconf_dflt
;
2350 if (!net_eq(net
, &init_net
)) {
2351 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
2355 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
2357 goto err_alloc_dflt
;
2359 #ifdef CONFIG_SYSCTL
2360 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
2364 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
2365 tbl
[0].extra1
= all
;
2366 tbl
[0].extra2
= net
;
2370 #ifdef CONFIG_SYSCTL
2371 err
= __devinet_sysctl_register(net
, "all", NETCONFA_IFINDEX_ALL
, all
);
2375 err
= __devinet_sysctl_register(net
, "default",
2376 NETCONFA_IFINDEX_DEFAULT
, dflt
);
2381 forw_hdr
= register_net_sysctl(net
, "net/ipv4", tbl
);
2384 net
->ipv4
.forw_hdr
= forw_hdr
;
2387 net
->ipv4
.devconf_all
= all
;
2388 net
->ipv4
.devconf_dflt
= dflt
;
2391 #ifdef CONFIG_SYSCTL
2393 __devinet_sysctl_unregister(net
, dflt
, NETCONFA_IFINDEX_DEFAULT
);
2395 __devinet_sysctl_unregister(net
, all
, NETCONFA_IFINDEX_ALL
);
2397 if (tbl
!= ctl_forward_entry
)
2401 if (dflt
!= &ipv4_devconf_dflt
)
2404 if (all
!= &ipv4_devconf
)
2410 static __net_exit
void devinet_exit_net(struct net
*net
)
2412 #ifdef CONFIG_SYSCTL
2413 struct ctl_table
*tbl
;
2415 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
2416 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
2417 __devinet_sysctl_unregister(net
, net
->ipv4
.devconf_dflt
,
2418 NETCONFA_IFINDEX_DEFAULT
);
2419 __devinet_sysctl_unregister(net
, net
->ipv4
.devconf_all
,
2420 NETCONFA_IFINDEX_ALL
);
2423 kfree(net
->ipv4
.devconf_dflt
);
2424 kfree(net
->ipv4
.devconf_all
);
2427 static __net_initdata
struct pernet_operations devinet_ops
= {
2428 .init
= devinet_init_net
,
2429 .exit
= devinet_exit_net
,
2432 static struct rtnl_af_ops inet_af_ops __read_mostly
= {
2434 .fill_link_af
= inet_fill_link_af
,
2435 .get_link_af_size
= inet_get_link_af_size
,
2436 .validate_link_af
= inet_validate_link_af
,
2437 .set_link_af
= inet_set_link_af
,
2440 void __init
devinet_init(void)
2444 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
2445 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
2447 register_pernet_subsys(&devinet_ops
);
2449 register_gifconf(PF_INET
, inet_gifconf
);
2450 register_netdevice_notifier(&ip_netdev_notifier
);
2452 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
2454 rtnl_af_register(&inet_af_ops
);
2456 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, NULL
);
2457 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, NULL
);
2458 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, NULL
);
2459 rtnl_register(PF_INET
, RTM_GETNETCONF
, inet_netconf_get_devconf
,
2460 inet_netconf_dump_devconf
, NULL
);