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 <asm/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/string.h>
37 #include <linux/socket.h>
38 #include <linux/sockios.h>
40 #include <linux/errno.h>
41 #include <linux/interrupt.h>
42 #include <linux/if_addr.h>
43 #include <linux/if_ether.h>
44 #include <linux/inet.h>
45 #include <linux/netdevice.h>
46 #include <linux/etherdevice.h>
47 #include <linux/skbuff.h>
48 #include <linux/init.h>
49 #include <linux/notifier.h>
50 #include <linux/inetdevice.h>
51 #include <linux/igmp.h>
52 #include <linux/slab.h>
53 #include <linux/hash.h>
55 #include <linux/sysctl.h>
57 #include <linux/kmod.h>
58 #include <linux/netconf.h>
62 #include <net/route.h>
63 #include <net/ip_fib.h>
64 #include <net/rtnetlink.h>
65 #include <net/net_namespace.h>
66 #include <net/addrconf.h>
68 #include "fib_lookup.h"
70 static struct ipv4_devconf ipv4_devconf
= {
72 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
73 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
74 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
75 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
76 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL
- 1] = 10000 /*ms*/,
77 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL
- 1] = 1000 /*ms*/,
81 static struct ipv4_devconf ipv4_devconf_dflt
= {
83 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
84 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
85 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
86 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
87 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE
- 1] = 1,
88 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL
- 1] = 10000 /*ms*/,
89 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL
- 1] = 1000 /*ms*/,
93 #define IPV4_DEVCONF_DFLT(net, attr) \
94 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
96 static const struct nla_policy ifa_ipv4_policy
[IFA_MAX
+1] = {
97 [IFA_LOCAL
] = { .type
= NLA_U32
},
98 [IFA_ADDRESS
] = { .type
= NLA_U32
},
99 [IFA_BROADCAST
] = { .type
= NLA_U32
},
100 [IFA_LABEL
] = { .type
= NLA_STRING
, .len
= IFNAMSIZ
- 1 },
101 [IFA_CACHEINFO
] = { .len
= sizeof(struct ifa_cacheinfo
) },
102 [IFA_FLAGS
] = { .type
= NLA_U32
},
105 #define IN4_ADDR_HSIZE_SHIFT 8
106 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
108 static struct hlist_head inet_addr_lst
[IN4_ADDR_HSIZE
];
110 static u32
inet_addr_hash(const struct net
*net
, __be32 addr
)
112 u32 val
= (__force u32
) addr
^ net_hash_mix(net
);
114 return hash_32(val
, IN4_ADDR_HSIZE_SHIFT
);
117 static void inet_hash_insert(struct net
*net
, struct in_ifaddr
*ifa
)
119 u32 hash
= inet_addr_hash(net
, ifa
->ifa_local
);
122 hlist_add_head_rcu(&ifa
->hash
, &inet_addr_lst
[hash
]);
125 static void inet_hash_remove(struct in_ifaddr
*ifa
)
128 hlist_del_init_rcu(&ifa
->hash
);
132 * __ip_dev_find - find the first device with a given source address.
133 * @net: the net namespace
134 * @addr: the source address
135 * @devref: if true, take a reference on the found device
137 * If a caller uses devref=false, it should be protected by RCU, or RTNL
139 struct net_device
*__ip_dev_find(struct net
*net
, __be32 addr
, bool devref
)
141 u32 hash
= inet_addr_hash(net
, addr
);
142 struct net_device
*result
= NULL
;
143 struct in_ifaddr
*ifa
;
146 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[hash
], hash
) {
147 if (ifa
->ifa_local
== addr
) {
148 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
150 if (!net_eq(dev_net(dev
), net
))
157 struct flowi4 fl4
= { .daddr
= addr
};
158 struct fib_result res
= { 0 };
159 struct fib_table
*local
;
161 /* Fallback to FIB local table so that communication
162 * over loopback subnets work.
164 local
= fib_get_table(net
, RT_TABLE_LOCAL
);
166 !fib_table_lookup(local
, &fl4
, &res
, FIB_LOOKUP_NOREF
) &&
167 res
.type
== RTN_LOCAL
)
168 result
= FIB_RES_DEV(res
);
170 if (result
&& devref
)
175 EXPORT_SYMBOL(__ip_dev_find
);
177 static void rtmsg_ifa(int event
, struct in_ifaddr
*, struct nlmsghdr
*, u32
);
179 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain
);
180 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
183 static int devinet_sysctl_register(struct in_device
*idev
);
184 static void devinet_sysctl_unregister(struct in_device
*idev
);
186 static int devinet_sysctl_register(struct in_device
*idev
)
190 static void devinet_sysctl_unregister(struct in_device
*idev
)
195 /* Locks all the inet devices. */
197 static struct in_ifaddr
*inet_alloc_ifa(void)
199 return kzalloc(sizeof(struct in_ifaddr
), GFP_KERNEL
);
202 static void inet_rcu_free_ifa(struct rcu_head
*head
)
204 struct in_ifaddr
*ifa
= container_of(head
, struct in_ifaddr
, rcu_head
);
206 in_dev_put(ifa
->ifa_dev
);
210 static void inet_free_ifa(struct in_ifaddr
*ifa
)
212 call_rcu(&ifa
->rcu_head
, inet_rcu_free_ifa
);
215 void in_dev_finish_destroy(struct in_device
*idev
)
217 struct net_device
*dev
= idev
->dev
;
219 WARN_ON(idev
->ifa_list
);
220 WARN_ON(idev
->mc_list
);
221 kfree(rcu_dereference_protected(idev
->mc_hash
, 1));
222 #ifdef NET_REFCNT_DEBUG
223 pr_debug("%s: %p=%s\n", __func__
, idev
, dev
? dev
->name
: "NIL");
227 pr_err("Freeing alive in_device %p\n", idev
);
231 EXPORT_SYMBOL(in_dev_finish_destroy
);
233 static struct in_device
*inetdev_init(struct net_device
*dev
)
235 struct in_device
*in_dev
;
240 in_dev
= kzalloc(sizeof(*in_dev
), GFP_KERNEL
);
243 memcpy(&in_dev
->cnf
, dev_net(dev
)->ipv4
.devconf_dflt
,
244 sizeof(in_dev
->cnf
));
245 in_dev
->cnf
.sysctl
= NULL
;
247 in_dev
->arp_parms
= neigh_parms_alloc(dev
, &arp_tbl
);
248 if (!in_dev
->arp_parms
)
250 if (IPV4_DEVCONF(in_dev
->cnf
, FORWARDING
))
251 dev_disable_lro(dev
);
252 /* Reference in_dev->dev */
254 /* Account for reference dev->ip_ptr (below) */
257 err
= devinet_sysctl_register(in_dev
);
264 ip_mc_init_dev(in_dev
);
265 if (dev
->flags
& IFF_UP
)
268 /* we can receive as soon as ip_ptr is set -- do this last */
269 rcu_assign_pointer(dev
->ip_ptr
, in_dev
);
271 return in_dev
?: ERR_PTR(err
);
278 static void in_dev_rcu_put(struct rcu_head
*head
)
280 struct in_device
*idev
= container_of(head
, struct in_device
, rcu_head
);
284 static void inetdev_destroy(struct in_device
*in_dev
)
286 struct in_ifaddr
*ifa
;
287 struct net_device
*dev
;
295 ip_mc_destroy_dev(in_dev
);
297 while ((ifa
= in_dev
->ifa_list
) != NULL
) {
298 inet_del_ifa(in_dev
, &in_dev
->ifa_list
, 0);
302 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
304 devinet_sysctl_unregister(in_dev
);
305 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
308 call_rcu(&in_dev
->rcu_head
, in_dev_rcu_put
);
311 int inet_addr_onlink(struct in_device
*in_dev
, __be32 a
, __be32 b
)
314 for_primary_ifa(in_dev
) {
315 if (inet_ifa_match(a
, ifa
)) {
316 if (!b
|| inet_ifa_match(b
, ifa
)) {
321 } endfor_ifa(in_dev
);
326 static void __inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
327 int destroy
, struct nlmsghdr
*nlh
, u32 portid
)
329 struct in_ifaddr
*promote
= NULL
;
330 struct in_ifaddr
*ifa
, *ifa1
= *ifap
;
331 struct in_ifaddr
*last_prim
= in_dev
->ifa_list
;
332 struct in_ifaddr
*prev_prom
= NULL
;
333 int do_promote
= IN_DEV_PROMOTE_SECONDARIES(in_dev
);
337 /* 1. Deleting primary ifaddr forces deletion all secondaries
338 * unless alias promotion is set
341 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
)) {
342 struct in_ifaddr
**ifap1
= &ifa1
->ifa_next
;
344 while ((ifa
= *ifap1
) != NULL
) {
345 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) &&
346 ifa1
->ifa_scope
<= ifa
->ifa_scope
)
349 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) ||
350 ifa1
->ifa_mask
!= ifa
->ifa_mask
||
351 !inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
352 ifap1
= &ifa
->ifa_next
;
358 inet_hash_remove(ifa
);
359 *ifap1
= ifa
->ifa_next
;
361 rtmsg_ifa(RTM_DELADDR
, ifa
, nlh
, portid
);
362 blocking_notifier_call_chain(&inetaddr_chain
,
372 /* On promotion all secondaries from subnet are changing
373 * the primary IP, we must remove all their routes silently
374 * and later to add them back with new prefsrc. Do this
375 * while all addresses are on the device list.
377 for (ifa
= promote
; ifa
; ifa
= ifa
->ifa_next
) {
378 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
379 inet_ifa_match(ifa1
->ifa_address
, ifa
))
380 fib_del_ifaddr(ifa
, ifa1
);
385 *ifap
= ifa1
->ifa_next
;
386 inet_hash_remove(ifa1
);
388 /* 3. Announce address deletion */
390 /* Send message first, then call notifier.
391 At first sight, FIB update triggered by notifier
392 will refer to already deleted ifaddr, that could confuse
393 netlink listeners. It is not true: look, gated sees
394 that route deleted and if it still thinks that ifaddr
395 is valid, it will try to restore deleted routes... Grr.
396 So that, this order is correct.
398 rtmsg_ifa(RTM_DELADDR
, ifa1
, nlh
, portid
);
399 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_DOWN
, ifa1
);
402 struct in_ifaddr
*next_sec
= promote
->ifa_next
;
405 prev_prom
->ifa_next
= promote
->ifa_next
;
406 promote
->ifa_next
= last_prim
->ifa_next
;
407 last_prim
->ifa_next
= promote
;
410 promote
->ifa_flags
&= ~IFA_F_SECONDARY
;
411 rtmsg_ifa(RTM_NEWADDR
, promote
, nlh
, portid
);
412 blocking_notifier_call_chain(&inetaddr_chain
,
414 for (ifa
= next_sec
; ifa
; ifa
= ifa
->ifa_next
) {
415 if (ifa1
->ifa_mask
!= ifa
->ifa_mask
||
416 !inet_ifa_match(ifa1
->ifa_address
, ifa
))
426 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
429 __inet_del_ifa(in_dev
, ifap
, destroy
, NULL
, 0);
432 static void check_lifetime(struct work_struct
*work
);
434 static DECLARE_DELAYED_WORK(check_lifetime_work
, check_lifetime
);
436 static int __inet_insert_ifa(struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
439 struct in_device
*in_dev
= ifa
->ifa_dev
;
440 struct in_ifaddr
*ifa1
, **ifap
, **last_primary
;
444 if (!ifa
->ifa_local
) {
449 ifa
->ifa_flags
&= ~IFA_F_SECONDARY
;
450 last_primary
= &in_dev
->ifa_list
;
452 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
453 ifap
= &ifa1
->ifa_next
) {
454 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
) &&
455 ifa
->ifa_scope
<= ifa1
->ifa_scope
)
456 last_primary
= &ifa1
->ifa_next
;
457 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
458 inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
459 if (ifa1
->ifa_local
== ifa
->ifa_local
) {
463 if (ifa1
->ifa_scope
!= ifa
->ifa_scope
) {
467 ifa
->ifa_flags
|= IFA_F_SECONDARY
;
471 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
)) {
472 prandom_seed((__force u32
) ifa
->ifa_local
);
476 ifa
->ifa_next
= *ifap
;
479 inet_hash_insert(dev_net(in_dev
->dev
), ifa
);
481 cancel_delayed_work(&check_lifetime_work
);
482 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
484 /* Send message first, then call notifier.
485 Notifier will trigger FIB update, so that
486 listeners of netlink will know about new ifaddr */
487 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, portid
);
488 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
493 static int inet_insert_ifa(struct in_ifaddr
*ifa
)
495 return __inet_insert_ifa(ifa
, NULL
, 0);
498 static int inet_set_ifa(struct net_device
*dev
, struct in_ifaddr
*ifa
)
500 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
508 ipv4_devconf_setall(in_dev
);
509 neigh_parms_data_state_setall(in_dev
->arp_parms
);
510 if (ifa
->ifa_dev
!= in_dev
) {
511 WARN_ON(ifa
->ifa_dev
);
513 ifa
->ifa_dev
= in_dev
;
515 if (ipv4_is_loopback(ifa
->ifa_local
))
516 ifa
->ifa_scope
= RT_SCOPE_HOST
;
517 return inet_insert_ifa(ifa
);
520 /* Caller must hold RCU or RTNL :
521 * We dont take a reference on found in_device
523 struct in_device
*inetdev_by_index(struct net
*net
, int ifindex
)
525 struct net_device
*dev
;
526 struct in_device
*in_dev
= NULL
;
529 dev
= dev_get_by_index_rcu(net
, ifindex
);
531 in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
535 EXPORT_SYMBOL(inetdev_by_index
);
537 /* Called only from RTNL semaphored context. No locks. */
539 struct in_ifaddr
*inet_ifa_byprefix(struct in_device
*in_dev
, __be32 prefix
,
544 for_primary_ifa(in_dev
) {
545 if (ifa
->ifa_mask
== mask
&& inet_ifa_match(prefix
, ifa
))
547 } endfor_ifa(in_dev
);
551 static int ip_mc_config(struct sock
*sk
, bool join
, const struct in_ifaddr
*ifa
)
553 struct ip_mreqn mreq
= {
554 .imr_multiaddr
.s_addr
= ifa
->ifa_address
,
555 .imr_ifindex
= ifa
->ifa_dev
->dev
->ifindex
,
563 ret
= ip_mc_join_group(sk
, &mreq
);
565 ret
= ip_mc_leave_group(sk
, &mreq
);
571 static int inet_rtm_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
573 struct net
*net
= sock_net(skb
->sk
);
574 struct nlattr
*tb
[IFA_MAX
+1];
575 struct in_device
*in_dev
;
576 struct ifaddrmsg
*ifm
;
577 struct in_ifaddr
*ifa
, **ifap
;
582 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
586 ifm
= nlmsg_data(nlh
);
587 in_dev
= inetdev_by_index(net
, ifm
->ifa_index
);
593 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
594 ifap
= &ifa
->ifa_next
) {
596 ifa
->ifa_local
!= nla_get_in_addr(tb
[IFA_LOCAL
]))
599 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
602 if (tb
[IFA_ADDRESS
] &&
603 (ifm
->ifa_prefixlen
!= ifa
->ifa_prefixlen
||
604 !inet_ifa_match(nla_get_in_addr(tb
[IFA_ADDRESS
]), ifa
)))
607 if (ipv4_is_multicast(ifa
->ifa_address
))
608 ip_mc_config(net
->ipv4
.mc_autojoin_sk
, false, ifa
);
609 __inet_del_ifa(in_dev
, ifap
, 1, nlh
, NETLINK_CB(skb
).portid
);
613 err
= -EADDRNOTAVAIL
;
618 #define INFINITY_LIFE_TIME 0xFFFFFFFF
620 static void check_lifetime(struct work_struct
*work
)
622 unsigned long now
, next
, next_sec
, next_sched
;
623 struct in_ifaddr
*ifa
;
624 struct hlist_node
*n
;
628 next
= round_jiffies_up(now
+ ADDR_CHECK_FREQUENCY
);
630 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++) {
631 bool change_needed
= false;
634 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[i
], hash
) {
637 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
640 /* We try to batch several events at once. */
641 age
= (now
- ifa
->ifa_tstamp
+
642 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
644 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
645 age
>= ifa
->ifa_valid_lft
) {
646 change_needed
= true;
647 } else if (ifa
->ifa_preferred_lft
==
648 INFINITY_LIFE_TIME
) {
650 } else if (age
>= ifa
->ifa_preferred_lft
) {
651 if (time_before(ifa
->ifa_tstamp
+
652 ifa
->ifa_valid_lft
* HZ
, next
))
653 next
= ifa
->ifa_tstamp
+
654 ifa
->ifa_valid_lft
* HZ
;
656 if (!(ifa
->ifa_flags
& IFA_F_DEPRECATED
))
657 change_needed
= true;
658 } else if (time_before(ifa
->ifa_tstamp
+
659 ifa
->ifa_preferred_lft
* HZ
,
661 next
= ifa
->ifa_tstamp
+
662 ifa
->ifa_preferred_lft
* HZ
;
669 hlist_for_each_entry_safe(ifa
, n
, &inet_addr_lst
[i
], hash
) {
672 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
675 /* We try to batch several events at once. */
676 age
= (now
- ifa
->ifa_tstamp
+
677 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
679 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
680 age
>= ifa
->ifa_valid_lft
) {
681 struct in_ifaddr
**ifap
;
683 for (ifap
= &ifa
->ifa_dev
->ifa_list
;
684 *ifap
!= NULL
; ifap
= &(*ifap
)->ifa_next
) {
686 inet_del_ifa(ifa
->ifa_dev
,
691 } else if (ifa
->ifa_preferred_lft
!=
692 INFINITY_LIFE_TIME
&&
693 age
>= ifa
->ifa_preferred_lft
&&
694 !(ifa
->ifa_flags
& IFA_F_DEPRECATED
)) {
695 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
696 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
702 next_sec
= round_jiffies_up(next
);
705 /* If rounded timeout is accurate enough, accept it. */
706 if (time_before(next_sec
, next
+ ADDRCONF_TIMER_FUZZ
))
707 next_sched
= next_sec
;
710 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
711 if (time_before(next_sched
, now
+ ADDRCONF_TIMER_FUZZ_MAX
))
712 next_sched
= now
+ ADDRCONF_TIMER_FUZZ_MAX
;
714 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
,
718 static void set_ifa_lifetime(struct in_ifaddr
*ifa
, __u32 valid_lft
,
721 unsigned long timeout
;
723 ifa
->ifa_flags
&= ~(IFA_F_PERMANENT
| IFA_F_DEPRECATED
);
725 timeout
= addrconf_timeout_fixup(valid_lft
, HZ
);
726 if (addrconf_finite_timeout(timeout
))
727 ifa
->ifa_valid_lft
= timeout
;
729 ifa
->ifa_flags
|= IFA_F_PERMANENT
;
731 timeout
= addrconf_timeout_fixup(prefered_lft
, HZ
);
732 if (addrconf_finite_timeout(timeout
)) {
734 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
735 ifa
->ifa_preferred_lft
= timeout
;
737 ifa
->ifa_tstamp
= jiffies
;
738 if (!ifa
->ifa_cstamp
)
739 ifa
->ifa_cstamp
= ifa
->ifa_tstamp
;
742 static struct in_ifaddr
*rtm_to_ifaddr(struct net
*net
, struct nlmsghdr
*nlh
,
743 __u32
*pvalid_lft
, __u32
*pprefered_lft
)
745 struct nlattr
*tb
[IFA_MAX
+1];
746 struct in_ifaddr
*ifa
;
747 struct ifaddrmsg
*ifm
;
748 struct net_device
*dev
;
749 struct in_device
*in_dev
;
752 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
756 ifm
= nlmsg_data(nlh
);
758 if (ifm
->ifa_prefixlen
> 32 || !tb
[IFA_LOCAL
])
761 dev
= __dev_get_by_index(net
, ifm
->ifa_index
);
766 in_dev
= __in_dev_get_rtnl(dev
);
771 ifa
= inet_alloc_ifa();
774 * A potential indev allocation can be left alive, it stays
775 * assigned to its device and is destroy with it.
779 ipv4_devconf_setall(in_dev
);
780 neigh_parms_data_state_setall(in_dev
->arp_parms
);
783 if (!tb
[IFA_ADDRESS
])
784 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
786 INIT_HLIST_NODE(&ifa
->hash
);
787 ifa
->ifa_prefixlen
= ifm
->ifa_prefixlen
;
788 ifa
->ifa_mask
= inet_make_mask(ifm
->ifa_prefixlen
);
789 ifa
->ifa_flags
= tb
[IFA_FLAGS
] ? nla_get_u32(tb
[IFA_FLAGS
]) :
791 ifa
->ifa_scope
= ifm
->ifa_scope
;
792 ifa
->ifa_dev
= in_dev
;
794 ifa
->ifa_local
= nla_get_in_addr(tb
[IFA_LOCAL
]);
795 ifa
->ifa_address
= nla_get_in_addr(tb
[IFA_ADDRESS
]);
797 if (tb
[IFA_BROADCAST
])
798 ifa
->ifa_broadcast
= nla_get_in_addr(tb
[IFA_BROADCAST
]);
801 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
803 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
805 if (tb
[IFA_CACHEINFO
]) {
806 struct ifa_cacheinfo
*ci
;
808 ci
= nla_data(tb
[IFA_CACHEINFO
]);
809 if (!ci
->ifa_valid
|| ci
->ifa_prefered
> ci
->ifa_valid
) {
813 *pvalid_lft
= ci
->ifa_valid
;
814 *pprefered_lft
= ci
->ifa_prefered
;
825 static struct in_ifaddr
*find_matching_ifa(struct in_ifaddr
*ifa
)
827 struct in_device
*in_dev
= ifa
->ifa_dev
;
828 struct in_ifaddr
*ifa1
, **ifap
;
833 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
834 ifap
= &ifa1
->ifa_next
) {
835 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
836 inet_ifa_match(ifa1
->ifa_address
, ifa
) &&
837 ifa1
->ifa_local
== ifa
->ifa_local
)
843 static int inet_rtm_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
845 struct net
*net
= sock_net(skb
->sk
);
846 struct in_ifaddr
*ifa
;
847 struct in_ifaddr
*ifa_existing
;
848 __u32 valid_lft
= INFINITY_LIFE_TIME
;
849 __u32 prefered_lft
= INFINITY_LIFE_TIME
;
853 ifa
= rtm_to_ifaddr(net
, nlh
, &valid_lft
, &prefered_lft
);
857 ifa_existing
= find_matching_ifa(ifa
);
859 /* It would be best to check for !NLM_F_CREATE here but
860 * userspace already relies on not having to provide this.
862 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
863 if (ifa
->ifa_flags
& IFA_F_MCAUTOJOIN
) {
864 int ret
= ip_mc_config(net
->ipv4
.mc_autojoin_sk
,
872 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).portid
);
876 if (nlh
->nlmsg_flags
& NLM_F_EXCL
||
877 !(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
880 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
881 cancel_delayed_work(&check_lifetime_work
);
882 queue_delayed_work(system_power_efficient_wq
,
883 &check_lifetime_work
, 0);
884 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, NETLINK_CB(skb
).portid
);
890 * Determine a default network mask, based on the IP address.
893 static int inet_abc_len(__be32 addr
)
895 int rc
= -1; /* Something else, probably a multicast. */
897 if (ipv4_is_zeronet(addr
))
900 __u32 haddr
= ntohl(addr
);
902 if (IN_CLASSA(haddr
))
904 else if (IN_CLASSB(haddr
))
906 else if (IN_CLASSC(haddr
))
914 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
917 struct sockaddr_in sin_orig
;
918 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
919 struct in_device
*in_dev
;
920 struct in_ifaddr
**ifap
= NULL
;
921 struct in_ifaddr
*ifa
= NULL
;
922 struct net_device
*dev
;
925 int tryaddrmatch
= 0;
928 * Fetch the caller's info block into kernel space
931 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
933 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
935 /* save original address for comparison */
936 memcpy(&sin_orig
, sin
, sizeof(*sin
));
938 colon
= strchr(ifr
.ifr_name
, ':');
942 dev_load(net
, ifr
.ifr_name
);
945 case SIOCGIFADDR
: /* Get interface address */
946 case SIOCGIFBRDADDR
: /* Get the broadcast address */
947 case SIOCGIFDSTADDR
: /* Get the destination address */
948 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
949 /* Note that these ioctls will not sleep,
950 so that we do not impose a lock.
951 One day we will be forced to put shlock here (I mean SMP)
953 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
954 memset(sin
, 0, sizeof(*sin
));
955 sin
->sin_family
= AF_INET
;
960 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
963 case SIOCSIFADDR
: /* Set interface address (and family) */
964 case SIOCSIFBRDADDR
: /* Set the broadcast address */
965 case SIOCSIFDSTADDR
: /* Set the destination address */
966 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
968 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
971 if (sin
->sin_family
!= AF_INET
)
982 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
989 in_dev
= __in_dev_get_rtnl(dev
);
992 /* Matthias Andree */
993 /* compare label and address (4.4BSD style) */
994 /* note: we only do this for a limited set of ioctls
995 and only if the original address family was AF_INET.
996 This is checked above. */
997 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
998 ifap
= &ifa
->ifa_next
) {
999 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
1000 sin_orig
.sin_addr
.s_addr
==
1006 /* we didn't get a match, maybe the application is
1007 4.3BSD-style and passed in junk so we fall back to
1008 comparing just the label */
1010 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
1011 ifap
= &ifa
->ifa_next
)
1012 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
1017 ret
= -EADDRNOTAVAIL
;
1018 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
1022 case SIOCGIFADDR
: /* Get interface address */
1023 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
1026 case SIOCGIFBRDADDR
: /* Get the broadcast address */
1027 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
1030 case SIOCGIFDSTADDR
: /* Get the destination address */
1031 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
1034 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
1035 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
1040 ret
= -EADDRNOTAVAIL
;
1044 if (!(ifr
.ifr_flags
& IFF_UP
))
1045 inet_del_ifa(in_dev
, ifap
, 1);
1048 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
1051 case SIOCSIFADDR
: /* Set interface address (and family) */
1053 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1058 ifa
= inet_alloc_ifa();
1061 INIT_HLIST_NODE(&ifa
->hash
);
1063 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
1065 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1068 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
1070 inet_del_ifa(in_dev
, ifap
, 0);
1071 ifa
->ifa_broadcast
= 0;
1075 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
1077 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
1078 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
1079 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
1080 if ((dev
->flags
& IFF_BROADCAST
) &&
1081 ifa
->ifa_prefixlen
< 31)
1082 ifa
->ifa_broadcast
= ifa
->ifa_address
|
1085 ifa
->ifa_prefixlen
= 32;
1086 ifa
->ifa_mask
= inet_make_mask(32);
1088 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
, INFINITY_LIFE_TIME
);
1089 ret
= inet_set_ifa(dev
, ifa
);
1092 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1094 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
1095 inet_del_ifa(in_dev
, ifap
, 0);
1096 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
1097 inet_insert_ifa(ifa
);
1101 case SIOCSIFDSTADDR
: /* Set the destination address */
1103 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
1106 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1109 inet_del_ifa(in_dev
, ifap
, 0);
1110 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
1111 inet_insert_ifa(ifa
);
1114 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1117 * The mask we set must be legal.
1120 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
1123 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
1124 __be32 old_mask
= ifa
->ifa_mask
;
1125 inet_del_ifa(in_dev
, ifap
, 0);
1126 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
1127 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
1129 /* See if current broadcast address matches
1130 * with current netmask, then recalculate
1131 * the broadcast address. Otherwise it's a
1132 * funny address, so don't touch it since
1133 * the user seems to know what (s)he's doing...
1135 if ((dev
->flags
& IFF_BROADCAST
) &&
1136 (ifa
->ifa_prefixlen
< 31) &&
1137 (ifa
->ifa_broadcast
==
1138 (ifa
->ifa_local
|~old_mask
))) {
1139 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
1140 ~sin
->sin_addr
.s_addr
);
1142 inet_insert_ifa(ifa
);
1152 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
1156 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
1158 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1159 struct in_ifaddr
*ifa
;
1166 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1168 done
+= sizeof(ifr
);
1171 if (len
< (int) sizeof(ifr
))
1173 memset(&ifr
, 0, sizeof(struct ifreq
));
1174 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
1176 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
1177 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
1180 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
1184 buf
+= sizeof(struct ifreq
);
1185 len
-= sizeof(struct ifreq
);
1186 done
+= sizeof(struct ifreq
);
1192 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
1195 struct in_device
*in_dev
;
1196 struct net
*net
= dev_net(dev
);
1200 in_dev
= __in_dev_get_rcu(dev
);
1204 for_primary_ifa(in_dev
) {
1205 if (ifa
->ifa_scope
> scope
)
1207 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
1208 addr
= ifa
->ifa_local
;
1212 addr
= ifa
->ifa_local
;
1213 } endfor_ifa(in_dev
);
1218 master_idx
= l3mdev_master_ifindex_rcu(dev
);
1220 /* For VRFs, the VRF device takes the place of the loopback device,
1221 * with addresses on it being preferred. Note in such cases the
1222 * loopback device will be among the devices that fail the master_idx
1223 * equality check in the loop below.
1226 (dev
= dev_get_by_index_rcu(net
, master_idx
)) &&
1227 (in_dev
= __in_dev_get_rcu(dev
))) {
1228 for_primary_ifa(in_dev
) {
1229 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1230 ifa
->ifa_scope
<= scope
) {
1231 addr
= ifa
->ifa_local
;
1234 } endfor_ifa(in_dev
);
1237 /* Not loopback addresses on loopback should be preferred
1238 in this case. It is important that lo is the first interface
1241 for_each_netdev_rcu(net
, dev
) {
1242 if (l3mdev_master_ifindex_rcu(dev
) != master_idx
)
1245 in_dev
= __in_dev_get_rcu(dev
);
1249 for_primary_ifa(in_dev
) {
1250 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1251 ifa
->ifa_scope
<= scope
) {
1252 addr
= ifa
->ifa_local
;
1255 } endfor_ifa(in_dev
);
1261 EXPORT_SYMBOL(inet_select_addr
);
1263 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1264 __be32 local
, int scope
)
1271 (local
== ifa
->ifa_local
|| !local
) &&
1272 ifa
->ifa_scope
<= scope
) {
1273 addr
= ifa
->ifa_local
;
1278 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1279 (!dst
|| inet_ifa_match(dst
, ifa
));
1283 /* Is the selected addr into dst subnet? */
1284 if (inet_ifa_match(addr
, ifa
))
1286 /* No, then can we use new local src? */
1287 if (ifa
->ifa_scope
<= scope
) {
1288 addr
= ifa
->ifa_local
;
1291 /* search for large dst subnet for addr */
1295 } endfor_ifa(in_dev
);
1297 return same
? addr
: 0;
1301 * Confirm that local IP address exists using wildcards:
1302 * - net: netns to check, cannot be NULL
1303 * - in_dev: only on this interface, NULL=any interface
1304 * - dst: only in the same subnet as dst, 0=any dst
1305 * - local: address, 0=autoselect the local address
1306 * - scope: maximum allowed scope value for the local address
1308 __be32
inet_confirm_addr(struct net
*net
, struct in_device
*in_dev
,
1309 __be32 dst
, __be32 local
, int scope
)
1312 struct net_device
*dev
;
1315 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1318 for_each_netdev_rcu(net
, dev
) {
1319 in_dev
= __in_dev_get_rcu(dev
);
1321 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1330 EXPORT_SYMBOL(inet_confirm_addr
);
1336 int register_inetaddr_notifier(struct notifier_block
*nb
)
1338 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1340 EXPORT_SYMBOL(register_inetaddr_notifier
);
1342 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1344 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1346 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1348 /* Rename ifa_labels for a device name change. Make some effort to preserve
1349 * existing alias numbering and to create unique labels if possible.
1351 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1353 struct in_ifaddr
*ifa
;
1356 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1357 char old
[IFNAMSIZ
], *dot
;
1359 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1360 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1363 dot
= strchr(old
, ':');
1365 sprintf(old
, ":%d", named
);
1368 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1369 strcat(ifa
->ifa_label
, dot
);
1371 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1373 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1377 static bool inetdev_valid_mtu(unsigned int mtu
)
1382 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1383 struct in_device
*in_dev
)
1386 struct in_ifaddr
*ifa
;
1388 for (ifa
= in_dev
->ifa_list
; ifa
;
1389 ifa
= ifa
->ifa_next
) {
1390 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1391 ifa
->ifa_local
, dev
,
1392 ifa
->ifa_local
, NULL
,
1393 dev
->dev_addr
, NULL
);
1397 /* Called only under RTNL semaphore */
1399 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1402 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1403 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1408 if (event
== NETDEV_REGISTER
) {
1409 in_dev
= inetdev_init(dev
);
1411 return notifier_from_errno(PTR_ERR(in_dev
));
1412 if (dev
->flags
& IFF_LOOPBACK
) {
1413 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1414 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1416 } else if (event
== NETDEV_CHANGEMTU
) {
1417 /* Re-enabling IP */
1418 if (inetdev_valid_mtu(dev
->mtu
))
1419 in_dev
= inetdev_init(dev
);
1425 case NETDEV_REGISTER
:
1426 pr_debug("%s: bug\n", __func__
);
1427 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1430 if (!inetdev_valid_mtu(dev
->mtu
))
1432 if (dev
->flags
& IFF_LOOPBACK
) {
1433 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1436 INIT_HLIST_NODE(&ifa
->hash
);
1438 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1439 ifa
->ifa_prefixlen
= 8;
1440 ifa
->ifa_mask
= inet_make_mask(8);
1441 in_dev_hold(in_dev
);
1442 ifa
->ifa_dev
= in_dev
;
1443 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1444 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1445 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
,
1446 INFINITY_LIFE_TIME
);
1447 ipv4_devconf_setall(in_dev
);
1448 neigh_parms_data_state_setall(in_dev
->arp_parms
);
1449 inet_insert_ifa(ifa
);
1454 case NETDEV_CHANGEADDR
:
1455 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1458 case NETDEV_NOTIFY_PEERS
:
1459 /* Send gratuitous ARP to notify of link change */
1460 inetdev_send_gratuitous_arp(dev
, in_dev
);
1465 case NETDEV_PRE_TYPE_CHANGE
:
1466 ip_mc_unmap(in_dev
);
1468 case NETDEV_POST_TYPE_CHANGE
:
1469 ip_mc_remap(in_dev
);
1471 case NETDEV_CHANGEMTU
:
1472 if (inetdev_valid_mtu(dev
->mtu
))
1474 /* disable IP when MTU is not enough */
1475 case NETDEV_UNREGISTER
:
1476 inetdev_destroy(in_dev
);
1478 case NETDEV_CHANGENAME
:
1479 /* Do not notify about label change, this event is
1480 * not interesting to applications using netlink.
1482 inetdev_changename(dev
, in_dev
);
1484 devinet_sysctl_unregister(in_dev
);
1485 devinet_sysctl_register(in_dev
);
1492 static struct notifier_block ip_netdev_notifier
= {
1493 .notifier_call
= inetdev_event
,
1496 static size_t inet_nlmsg_size(void)
1498 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1499 + nla_total_size(4) /* IFA_ADDRESS */
1500 + nla_total_size(4) /* IFA_LOCAL */
1501 + nla_total_size(4) /* IFA_BROADCAST */
1502 + nla_total_size(IFNAMSIZ
) /* IFA_LABEL */
1503 + nla_total_size(4) /* IFA_FLAGS */
1504 + nla_total_size(sizeof(struct ifa_cacheinfo
)); /* IFA_CACHEINFO */
1507 static inline u32
cstamp_delta(unsigned long cstamp
)
1509 return (cstamp
- INITIAL_JIFFIES
) * 100UL / HZ
;
1512 static int put_cacheinfo(struct sk_buff
*skb
, unsigned long cstamp
,
1513 unsigned long tstamp
, u32 preferred
, u32 valid
)
1515 struct ifa_cacheinfo ci
;
1517 ci
.cstamp
= cstamp_delta(cstamp
);
1518 ci
.tstamp
= cstamp_delta(tstamp
);
1519 ci
.ifa_prefered
= preferred
;
1520 ci
.ifa_valid
= valid
;
1522 return nla_put(skb
, IFA_CACHEINFO
, sizeof(ci
), &ci
);
1525 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1526 u32 portid
, u32 seq
, int event
, unsigned int flags
)
1528 struct ifaddrmsg
*ifm
;
1529 struct nlmsghdr
*nlh
;
1530 u32 preferred
, valid
;
1532 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*ifm
), flags
);
1536 ifm
= nlmsg_data(nlh
);
1537 ifm
->ifa_family
= AF_INET
;
1538 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1539 ifm
->ifa_flags
= ifa
->ifa_flags
;
1540 ifm
->ifa_scope
= ifa
->ifa_scope
;
1541 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1543 if (!(ifm
->ifa_flags
& IFA_F_PERMANENT
)) {
1544 preferred
= ifa
->ifa_preferred_lft
;
1545 valid
= ifa
->ifa_valid_lft
;
1546 if (preferred
!= INFINITY_LIFE_TIME
) {
1547 long tval
= (jiffies
- ifa
->ifa_tstamp
) / HZ
;
1549 if (preferred
> tval
)
1553 if (valid
!= INFINITY_LIFE_TIME
) {
1561 preferred
= INFINITY_LIFE_TIME
;
1562 valid
= INFINITY_LIFE_TIME
;
1564 if ((ifa
->ifa_address
&&
1565 nla_put_in_addr(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1567 nla_put_in_addr(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1568 (ifa
->ifa_broadcast
&&
1569 nla_put_in_addr(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1570 (ifa
->ifa_label
[0] &&
1571 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)) ||
1572 nla_put_u32(skb
, IFA_FLAGS
, ifa
->ifa_flags
) ||
1573 put_cacheinfo(skb
, ifa
->ifa_cstamp
, ifa
->ifa_tstamp
,
1575 goto nla_put_failure
;
1577 nlmsg_end(skb
, nlh
);
1581 nlmsg_cancel(skb
, nlh
);
1585 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1587 struct net
*net
= sock_net(skb
->sk
);
1590 int ip_idx
, s_ip_idx
;
1591 struct net_device
*dev
;
1592 struct in_device
*in_dev
;
1593 struct in_ifaddr
*ifa
;
1594 struct hlist_head
*head
;
1597 s_idx
= idx
= cb
->args
[1];
1598 s_ip_idx
= ip_idx
= cb
->args
[2];
1600 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1602 head
= &net
->dev_index_head
[h
];
1604 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1606 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1609 if (h
> s_h
|| idx
> s_idx
)
1611 in_dev
= __in_dev_get_rcu(dev
);
1615 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1616 ifa
= ifa
->ifa_next
, ip_idx
++) {
1617 if (ip_idx
< s_ip_idx
)
1619 if (inet_fill_ifaddr(skb
, ifa
,
1620 NETLINK_CB(cb
->skb
).portid
,
1622 RTM_NEWADDR
, NLM_F_MULTI
) < 0) {
1626 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1637 cb
->args
[2] = ip_idx
;
1642 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1645 struct sk_buff
*skb
;
1646 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1650 net
= dev_net(ifa
->ifa_dev
->dev
);
1651 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1655 err
= inet_fill_ifaddr(skb
, ifa
, portid
, seq
, event
, 0);
1657 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1658 WARN_ON(err
== -EMSGSIZE
);
1662 rtnl_notify(skb
, net
, portid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1666 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1669 static size_t inet_get_link_af_size(const struct net_device
*dev
,
1670 u32 ext_filter_mask
)
1672 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1677 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1680 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
,
1681 u32 ext_filter_mask
)
1683 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1690 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1694 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1695 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1700 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1701 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1704 static int inet_validate_link_af(const struct net_device
*dev
,
1705 const struct nlattr
*nla
)
1707 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1710 if (dev
&& !__in_dev_get_rtnl(dev
))
1711 return -EAFNOSUPPORT
;
1713 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
);
1717 if (tb
[IFLA_INET_CONF
]) {
1718 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1719 int cfgid
= nla_type(a
);
1724 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1732 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1734 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1735 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1739 return -EAFNOSUPPORT
;
1741 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
) < 0)
1744 if (tb
[IFLA_INET_CONF
]) {
1745 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1746 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1752 static int inet_netconf_msgsize_devconf(int type
)
1754 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1755 + nla_total_size(4); /* NETCONFA_IFINDEX */
1757 /* type -1 is used for ALL */
1758 if (type
== -1 || type
== NETCONFA_FORWARDING
)
1759 size
+= nla_total_size(4);
1760 if (type
== -1 || type
== NETCONFA_RP_FILTER
)
1761 size
+= nla_total_size(4);
1762 if (type
== -1 || type
== NETCONFA_MC_FORWARDING
)
1763 size
+= nla_total_size(4);
1764 if (type
== -1 || type
== NETCONFA_PROXY_NEIGH
)
1765 size
+= nla_total_size(4);
1766 if (type
== -1 || type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
)
1767 size
+= nla_total_size(4);
1772 static int inet_netconf_fill_devconf(struct sk_buff
*skb
, int ifindex
,
1773 struct ipv4_devconf
*devconf
, u32 portid
,
1774 u32 seq
, int event
, unsigned int flags
,
1777 struct nlmsghdr
*nlh
;
1778 struct netconfmsg
*ncm
;
1780 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1785 ncm
= nlmsg_data(nlh
);
1786 ncm
->ncm_family
= AF_INET
;
1788 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, ifindex
) < 0)
1789 goto nla_put_failure
;
1791 /* type -1 is used for ALL */
1792 if ((type
== -1 || type
== NETCONFA_FORWARDING
) &&
1793 nla_put_s32(skb
, NETCONFA_FORWARDING
,
1794 IPV4_DEVCONF(*devconf
, FORWARDING
)) < 0)
1795 goto nla_put_failure
;
1796 if ((type
== -1 || type
== NETCONFA_RP_FILTER
) &&
1797 nla_put_s32(skb
, NETCONFA_RP_FILTER
,
1798 IPV4_DEVCONF(*devconf
, RP_FILTER
)) < 0)
1799 goto nla_put_failure
;
1800 if ((type
== -1 || type
== NETCONFA_MC_FORWARDING
) &&
1801 nla_put_s32(skb
, NETCONFA_MC_FORWARDING
,
1802 IPV4_DEVCONF(*devconf
, MC_FORWARDING
)) < 0)
1803 goto nla_put_failure
;
1804 if ((type
== -1 || type
== NETCONFA_PROXY_NEIGH
) &&
1805 nla_put_s32(skb
, NETCONFA_PROXY_NEIGH
,
1806 IPV4_DEVCONF(*devconf
, PROXY_ARP
)) < 0)
1807 goto nla_put_failure
;
1808 if ((type
== -1 || type
== NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
) &&
1809 nla_put_s32(skb
, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
1810 IPV4_DEVCONF(*devconf
, IGNORE_ROUTES_WITH_LINKDOWN
)) < 0)
1811 goto nla_put_failure
;
1813 nlmsg_end(skb
, nlh
);
1817 nlmsg_cancel(skb
, nlh
);
1821 void inet_netconf_notify_devconf(struct net
*net
, int type
, int ifindex
,
1822 struct ipv4_devconf
*devconf
)
1824 struct sk_buff
*skb
;
1827 skb
= nlmsg_new(inet_netconf_msgsize_devconf(type
), GFP_ATOMIC
);
1831 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
, 0, 0,
1832 RTM_NEWNETCONF
, 0, type
);
1834 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1835 WARN_ON(err
== -EMSGSIZE
);
1839 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_NETCONF
, NULL
, GFP_ATOMIC
);
1843 rtnl_set_sk_err(net
, RTNLGRP_IPV4_NETCONF
, err
);
1846 static const struct nla_policy devconf_ipv4_policy
[NETCONFA_MAX
+1] = {
1847 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1848 [NETCONFA_FORWARDING
] = { .len
= sizeof(int) },
1849 [NETCONFA_RP_FILTER
] = { .len
= sizeof(int) },
1850 [NETCONFA_PROXY_NEIGH
] = { .len
= sizeof(int) },
1851 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
] = { .len
= sizeof(int) },
1854 static int inet_netconf_get_devconf(struct sk_buff
*in_skb
,
1855 struct nlmsghdr
*nlh
)
1857 struct net
*net
= sock_net(in_skb
->sk
);
1858 struct nlattr
*tb
[NETCONFA_MAX
+1];
1859 struct netconfmsg
*ncm
;
1860 struct sk_buff
*skb
;
1861 struct ipv4_devconf
*devconf
;
1862 struct in_device
*in_dev
;
1863 struct net_device
*dev
;
1867 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1868 devconf_ipv4_policy
);
1873 if (!tb
[NETCONFA_IFINDEX
])
1876 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1878 case NETCONFA_IFINDEX_ALL
:
1879 devconf
= net
->ipv4
.devconf_all
;
1881 case NETCONFA_IFINDEX_DEFAULT
:
1882 devconf
= net
->ipv4
.devconf_dflt
;
1885 dev
= __dev_get_by_index(net
, ifindex
);
1888 in_dev
= __in_dev_get_rtnl(dev
);
1891 devconf
= &in_dev
->cnf
;
1896 skb
= nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC
);
1900 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
,
1901 NETLINK_CB(in_skb
).portid
,
1902 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1905 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1906 WARN_ON(err
== -EMSGSIZE
);
1910 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1915 static int inet_netconf_dump_devconf(struct sk_buff
*skb
,
1916 struct netlink_callback
*cb
)
1918 struct net
*net
= sock_net(skb
->sk
);
1921 struct net_device
*dev
;
1922 struct in_device
*in_dev
;
1923 struct hlist_head
*head
;
1926 s_idx
= idx
= cb
->args
[1];
1928 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1930 head
= &net
->dev_index_head
[h
];
1932 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1934 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1937 in_dev
= __in_dev_get_rcu(dev
);
1941 if (inet_netconf_fill_devconf(skb
, dev
->ifindex
,
1943 NETLINK_CB(cb
->skb
).portid
,
1951 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1957 if (h
== NETDEV_HASHENTRIES
) {
1958 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_ALL
,
1959 net
->ipv4
.devconf_all
,
1960 NETLINK_CB(cb
->skb
).portid
,
1962 RTM_NEWNETCONF
, NLM_F_MULTI
,
1968 if (h
== NETDEV_HASHENTRIES
+ 1) {
1969 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_DEFAULT
,
1970 net
->ipv4
.devconf_dflt
,
1971 NETLINK_CB(cb
->skb
).portid
,
1973 RTM_NEWNETCONF
, NLM_F_MULTI
,
1986 #ifdef CONFIG_SYSCTL
1988 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
1990 struct net_device
*dev
;
1993 for_each_netdev_rcu(net
, dev
) {
1994 struct in_device
*in_dev
;
1996 in_dev
= __in_dev_get_rcu(dev
);
1997 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
1998 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
2003 /* called with RTNL locked */
2004 static void inet_forward_change(struct net
*net
)
2006 struct net_device
*dev
;
2007 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
2009 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
2010 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
2011 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
2012 NETCONFA_IFINDEX_ALL
,
2013 net
->ipv4
.devconf_all
);
2014 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
2015 NETCONFA_IFINDEX_DEFAULT
,
2016 net
->ipv4
.devconf_dflt
);
2018 for_each_netdev(net
, dev
) {
2019 struct in_device
*in_dev
;
2021 dev_disable_lro(dev
);
2023 in_dev
= __in_dev_get_rcu(dev
);
2025 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
2026 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
2027 dev
->ifindex
, &in_dev
->cnf
);
2033 static int devinet_conf_ifindex(struct net
*net
, struct ipv4_devconf
*cnf
)
2035 if (cnf
== net
->ipv4
.devconf_dflt
)
2036 return NETCONFA_IFINDEX_DEFAULT
;
2037 else if (cnf
== net
->ipv4
.devconf_all
)
2038 return NETCONFA_IFINDEX_ALL
;
2040 struct in_device
*idev
2041 = container_of(cnf
, struct in_device
, cnf
);
2042 return idev
->dev
->ifindex
;
2046 static int devinet_conf_proc(struct ctl_table
*ctl
, int write
,
2047 void __user
*buffer
,
2048 size_t *lenp
, loff_t
*ppos
)
2050 int old_value
= *(int *)ctl
->data
;
2051 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2052 int new_value
= *(int *)ctl
->data
;
2055 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2056 struct net
*net
= ctl
->extra2
;
2057 int i
= (int *)ctl
->data
- cnf
->data
;
2060 set_bit(i
, cnf
->state
);
2062 if (cnf
== net
->ipv4
.devconf_dflt
)
2063 devinet_copy_dflt_conf(net
, i
);
2064 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1 ||
2065 i
== IPV4_DEVCONF_ROUTE_LOCALNET
- 1)
2066 if ((new_value
== 0) && (old_value
!= 0))
2067 rt_cache_flush(net
);
2069 if (i
== IPV4_DEVCONF_RP_FILTER
- 1 &&
2070 new_value
!= old_value
) {
2071 ifindex
= devinet_conf_ifindex(net
, cnf
);
2072 inet_netconf_notify_devconf(net
, NETCONFA_RP_FILTER
,
2075 if (i
== IPV4_DEVCONF_PROXY_ARP
- 1 &&
2076 new_value
!= old_value
) {
2077 ifindex
= devinet_conf_ifindex(net
, cnf
);
2078 inet_netconf_notify_devconf(net
, NETCONFA_PROXY_NEIGH
,
2081 if (i
== IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN
- 1 &&
2082 new_value
!= old_value
) {
2083 ifindex
= devinet_conf_ifindex(net
, cnf
);
2084 inet_netconf_notify_devconf(net
, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN
,
2092 static int devinet_sysctl_forward(struct ctl_table
*ctl
, int write
,
2093 void __user
*buffer
,
2094 size_t *lenp
, loff_t
*ppos
)
2096 int *valp
= ctl
->data
;
2099 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2101 if (write
&& *valp
!= val
) {
2102 struct net
*net
= ctl
->extra2
;
2104 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
2105 if (!rtnl_trylock()) {
2106 /* Restore the original values before restarting */
2109 return restart_syscall();
2111 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
2112 inet_forward_change(net
);
2114 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2115 struct in_device
*idev
=
2116 container_of(cnf
, struct in_device
, cnf
);
2118 dev_disable_lro(idev
->dev
);
2119 inet_netconf_notify_devconf(net
,
2120 NETCONFA_FORWARDING
,
2125 rt_cache_flush(net
);
2127 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
2128 NETCONFA_IFINDEX_DEFAULT
,
2129 net
->ipv4
.devconf_dflt
);
2135 static int ipv4_doint_and_flush(struct ctl_table
*ctl
, int write
,
2136 void __user
*buffer
,
2137 size_t *lenp
, loff_t
*ppos
)
2139 int *valp
= ctl
->data
;
2141 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2142 struct net
*net
= ctl
->extra2
;
2144 if (write
&& *valp
!= val
)
2145 rt_cache_flush(net
);
2150 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2153 .data = ipv4_devconf.data + \
2154 IPV4_DEVCONF_ ## attr - 1, \
2155 .maxlen = sizeof(int), \
2157 .proc_handler = proc, \
2158 .extra1 = &ipv4_devconf, \
2161 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2162 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2164 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2165 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2167 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2168 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2170 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2171 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2173 static struct devinet_sysctl_table
{
2174 struct ctl_table_header
*sysctl_header
;
2175 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
2176 } devinet_sysctl
= {
2178 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
2179 devinet_sysctl_forward
),
2180 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
2182 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
2183 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
2184 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
2185 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
2186 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
2187 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
2188 "accept_source_route"),
2189 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
2190 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
2191 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
2192 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
2193 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
2194 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
2195 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
2196 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
2197 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
2198 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
2199 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
2200 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
2201 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
2202 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION
,
2203 "force_igmp_version"),
2204 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL
,
2205 "igmpv2_unsolicited_report_interval"),
2206 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL
,
2207 "igmpv3_unsolicited_report_interval"),
2208 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN
,
2209 "ignore_routes_with_linkdown"),
2210 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP
,
2211 "drop_gratuitous_arp"),
2213 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
2214 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
2215 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
2216 "promote_secondaries"),
2217 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET
,
2219 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST
,
2220 "drop_unicast_in_l2_multicast"),
2224 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
2225 struct ipv4_devconf
*p
)
2228 struct devinet_sysctl_table
*t
;
2229 char path
[sizeof("net/ipv4/conf/") + IFNAMSIZ
];
2231 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
2235 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
2236 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
2237 t
->devinet_vars
[i
].extra1
= p
;
2238 t
->devinet_vars
[i
].extra2
= net
;
2241 snprintf(path
, sizeof(path
), "net/ipv4/conf/%s", dev_name
);
2243 t
->sysctl_header
= register_net_sysctl(net
, path
, t
->devinet_vars
);
2244 if (!t
->sysctl_header
)
2256 static void __devinet_sysctl_unregister(struct ipv4_devconf
*cnf
)
2258 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
2264 unregister_net_sysctl_table(t
->sysctl_header
);
2268 static int devinet_sysctl_register(struct in_device
*idev
)
2272 if (!sysctl_dev_name_is_allowed(idev
->dev
->name
))
2275 err
= neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, NULL
);
2278 err
= __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
2281 neigh_sysctl_unregister(idev
->arp_parms
);
2285 static void devinet_sysctl_unregister(struct in_device
*idev
)
2287 __devinet_sysctl_unregister(&idev
->cnf
);
2288 neigh_sysctl_unregister(idev
->arp_parms
);
2291 static struct ctl_table ctl_forward_entry
[] = {
2293 .procname
= "ip_forward",
2294 .data
= &ipv4_devconf
.data
[
2295 IPV4_DEVCONF_FORWARDING
- 1],
2296 .maxlen
= sizeof(int),
2298 .proc_handler
= devinet_sysctl_forward
,
2299 .extra1
= &ipv4_devconf
,
2300 .extra2
= &init_net
,
2306 static __net_init
int devinet_init_net(struct net
*net
)
2309 struct ipv4_devconf
*all
, *dflt
;
2310 #ifdef CONFIG_SYSCTL
2311 struct ctl_table
*tbl
= ctl_forward_entry
;
2312 struct ctl_table_header
*forw_hdr
;
2316 all
= &ipv4_devconf
;
2317 dflt
= &ipv4_devconf_dflt
;
2319 if (!net_eq(net
, &init_net
)) {
2320 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
2324 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
2326 goto err_alloc_dflt
;
2328 #ifdef CONFIG_SYSCTL
2329 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
2333 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
2334 tbl
[0].extra1
= all
;
2335 tbl
[0].extra2
= net
;
2339 #ifdef CONFIG_SYSCTL
2340 err
= __devinet_sysctl_register(net
, "all", all
);
2344 err
= __devinet_sysctl_register(net
, "default", dflt
);
2349 forw_hdr
= register_net_sysctl(net
, "net/ipv4", tbl
);
2352 net
->ipv4
.forw_hdr
= forw_hdr
;
2355 net
->ipv4
.devconf_all
= all
;
2356 net
->ipv4
.devconf_dflt
= dflt
;
2359 #ifdef CONFIG_SYSCTL
2361 __devinet_sysctl_unregister(dflt
);
2363 __devinet_sysctl_unregister(all
);
2365 if (tbl
!= ctl_forward_entry
)
2369 if (dflt
!= &ipv4_devconf_dflt
)
2372 if (all
!= &ipv4_devconf
)
2378 static __net_exit
void devinet_exit_net(struct net
*net
)
2380 #ifdef CONFIG_SYSCTL
2381 struct ctl_table
*tbl
;
2383 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
2384 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
2385 __devinet_sysctl_unregister(net
->ipv4
.devconf_dflt
);
2386 __devinet_sysctl_unregister(net
->ipv4
.devconf_all
);
2389 kfree(net
->ipv4
.devconf_dflt
);
2390 kfree(net
->ipv4
.devconf_all
);
2393 static __net_initdata
struct pernet_operations devinet_ops
= {
2394 .init
= devinet_init_net
,
2395 .exit
= devinet_exit_net
,
2398 static struct rtnl_af_ops inet_af_ops __read_mostly
= {
2400 .fill_link_af
= inet_fill_link_af
,
2401 .get_link_af_size
= inet_get_link_af_size
,
2402 .validate_link_af
= inet_validate_link_af
,
2403 .set_link_af
= inet_set_link_af
,
2406 void __init
devinet_init(void)
2410 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
2411 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
2413 register_pernet_subsys(&devinet_ops
);
2415 register_gifconf(PF_INET
, inet_gifconf
);
2416 register_netdevice_notifier(&ip_netdev_notifier
);
2418 queue_delayed_work(system_power_efficient_wq
, &check_lifetime_work
, 0);
2420 rtnl_af_register(&inet_af_ops
);
2422 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, NULL
);
2423 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, NULL
);
2424 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, NULL
);
2425 rtnl_register(PF_INET
, RTM_GETNETCONF
, inet_netconf_get_devconf
,
2426 inet_netconf_dump_devconf
, NULL
);