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
) },
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
];
108 static DEFINE_SPINLOCK(inet_addr_hash_lock
);
110 static u32
inet_addr_hash(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
);
121 spin_lock(&inet_addr_hash_lock
);
122 hlist_add_head_rcu(&ifa
->hash
, &inet_addr_lst
[hash
]);
123 spin_unlock(&inet_addr_hash_lock
);
126 static void inet_hash_remove(struct in_ifaddr
*ifa
)
128 spin_lock(&inet_addr_hash_lock
);
129 hlist_del_init_rcu(&ifa
->hash
);
130 spin_unlock(&inet_addr_hash_lock
);
134 * __ip_dev_find - find the first device with a given source address.
135 * @net: the net namespace
136 * @addr: the source address
137 * @devref: if true, take a reference on the found device
139 * If a caller uses devref=false, it should be protected by RCU, or RTNL
141 struct net_device
*__ip_dev_find(struct net
*net
, __be32 addr
, bool devref
)
143 u32 hash
= inet_addr_hash(net
, addr
);
144 struct net_device
*result
= NULL
;
145 struct in_ifaddr
*ifa
;
148 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[hash
], hash
) {
149 if (ifa
->ifa_local
== addr
) {
150 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
152 if (!net_eq(dev_net(dev
), net
))
159 struct flowi4 fl4
= { .daddr
= addr
};
160 struct fib_result res
= { 0 };
161 struct fib_table
*local
;
163 /* Fallback to FIB local table so that communication
164 * over loopback subnets work.
166 local
= fib_get_table(net
, RT_TABLE_LOCAL
);
168 !fib_table_lookup(local
, &fl4
, &res
, FIB_LOOKUP_NOREF
) &&
169 res
.type
== RTN_LOCAL
)
170 result
= FIB_RES_DEV(res
);
172 if (result
&& devref
)
177 EXPORT_SYMBOL(__ip_dev_find
);
179 static void rtmsg_ifa(int event
, struct in_ifaddr
*, struct nlmsghdr
*, u32
);
181 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain
);
182 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
185 static void devinet_sysctl_register(struct in_device
*idev
);
186 static void devinet_sysctl_unregister(struct in_device
*idev
);
188 static void devinet_sysctl_register(struct in_device
*idev
)
191 static void devinet_sysctl_unregister(struct in_device
*idev
)
196 /* Locks all the inet devices. */
198 static struct in_ifaddr
*inet_alloc_ifa(void)
200 return kzalloc(sizeof(struct in_ifaddr
), GFP_KERNEL
);
203 static void inet_rcu_free_ifa(struct rcu_head
*head
)
205 struct in_ifaddr
*ifa
= container_of(head
, struct in_ifaddr
, rcu_head
);
207 in_dev_put(ifa
->ifa_dev
);
211 static void inet_free_ifa(struct in_ifaddr
*ifa
)
213 call_rcu(&ifa
->rcu_head
, inet_rcu_free_ifa
);
216 void in_dev_finish_destroy(struct in_device
*idev
)
218 struct net_device
*dev
= idev
->dev
;
220 WARN_ON(idev
->ifa_list
);
221 WARN_ON(idev
->mc_list
);
222 kfree(rcu_dereference_protected(idev
->mc_hash
, 1));
223 #ifdef NET_REFCNT_DEBUG
224 pr_debug("%s: %p=%s\n", __func__
, idev
, dev
? dev
->name
: "NIL");
228 pr_err("Freeing alive in_device %p\n", idev
);
232 EXPORT_SYMBOL(in_dev_finish_destroy
);
234 static struct in_device
*inetdev_init(struct net_device
*dev
)
236 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 devinet_sysctl_register(in_dev
);
258 ip_mc_init_dev(in_dev
);
259 if (dev
->flags
& IFF_UP
)
262 /* we can receive as soon as ip_ptr is set -- do this last */
263 rcu_assign_pointer(dev
->ip_ptr
, in_dev
);
272 static void in_dev_rcu_put(struct rcu_head
*head
)
274 struct in_device
*idev
= container_of(head
, struct in_device
, rcu_head
);
278 static void inetdev_destroy(struct in_device
*in_dev
)
280 struct in_ifaddr
*ifa
;
281 struct net_device
*dev
;
289 ip_mc_destroy_dev(in_dev
);
291 while ((ifa
= in_dev
->ifa_list
) != NULL
) {
292 inet_del_ifa(in_dev
, &in_dev
->ifa_list
, 0);
296 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
298 devinet_sysctl_unregister(in_dev
);
299 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
302 call_rcu(&in_dev
->rcu_head
, in_dev_rcu_put
);
305 int inet_addr_onlink(struct in_device
*in_dev
, __be32 a
, __be32 b
)
308 for_primary_ifa(in_dev
) {
309 if (inet_ifa_match(a
, ifa
)) {
310 if (!b
|| inet_ifa_match(b
, ifa
)) {
315 } endfor_ifa(in_dev
);
320 static void __inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
321 int destroy
, struct nlmsghdr
*nlh
, u32 portid
)
323 struct in_ifaddr
*promote
= NULL
;
324 struct in_ifaddr
*ifa
, *ifa1
= *ifap
;
325 struct in_ifaddr
*last_prim
= in_dev
->ifa_list
;
326 struct in_ifaddr
*prev_prom
= NULL
;
327 int do_promote
= IN_DEV_PROMOTE_SECONDARIES(in_dev
);
331 /* 1. Deleting primary ifaddr forces deletion all secondaries
332 * unless alias promotion is set
335 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
)) {
336 struct in_ifaddr
**ifap1
= &ifa1
->ifa_next
;
338 while ((ifa
= *ifap1
) != NULL
) {
339 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) &&
340 ifa1
->ifa_scope
<= ifa
->ifa_scope
)
343 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) ||
344 ifa1
->ifa_mask
!= ifa
->ifa_mask
||
345 !inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
346 ifap1
= &ifa
->ifa_next
;
352 inet_hash_remove(ifa
);
353 *ifap1
= ifa
->ifa_next
;
355 rtmsg_ifa(RTM_DELADDR
, ifa
, nlh
, portid
);
356 blocking_notifier_call_chain(&inetaddr_chain
,
366 /* On promotion all secondaries from subnet are changing
367 * the primary IP, we must remove all their routes silently
368 * and later to add them back with new prefsrc. Do this
369 * while all addresses are on the device list.
371 for (ifa
= promote
; ifa
; ifa
= ifa
->ifa_next
) {
372 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
373 inet_ifa_match(ifa1
->ifa_address
, ifa
))
374 fib_del_ifaddr(ifa
, ifa1
);
379 *ifap
= ifa1
->ifa_next
;
380 inet_hash_remove(ifa1
);
382 /* 3. Announce address deletion */
384 /* Send message first, then call notifier.
385 At first sight, FIB update triggered by notifier
386 will refer to already deleted ifaddr, that could confuse
387 netlink listeners. It is not true: look, gated sees
388 that route deleted and if it still thinks that ifaddr
389 is valid, it will try to restore deleted routes... Grr.
390 So that, this order is correct.
392 rtmsg_ifa(RTM_DELADDR
, ifa1
, nlh
, portid
);
393 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_DOWN
, ifa1
);
396 struct in_ifaddr
*next_sec
= promote
->ifa_next
;
399 prev_prom
->ifa_next
= promote
->ifa_next
;
400 promote
->ifa_next
= last_prim
->ifa_next
;
401 last_prim
->ifa_next
= promote
;
404 promote
->ifa_flags
&= ~IFA_F_SECONDARY
;
405 rtmsg_ifa(RTM_NEWADDR
, promote
, nlh
, portid
);
406 blocking_notifier_call_chain(&inetaddr_chain
,
408 for (ifa
= next_sec
; ifa
; ifa
= ifa
->ifa_next
) {
409 if (ifa1
->ifa_mask
!= ifa
->ifa_mask
||
410 !inet_ifa_match(ifa1
->ifa_address
, ifa
))
420 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
423 __inet_del_ifa(in_dev
, ifap
, destroy
, NULL
, 0);
426 static void check_lifetime(struct work_struct
*work
);
428 static DECLARE_DELAYED_WORK(check_lifetime_work
, check_lifetime
);
430 static int __inet_insert_ifa(struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
433 struct in_device
*in_dev
= ifa
->ifa_dev
;
434 struct in_ifaddr
*ifa1
, **ifap
, **last_primary
;
438 if (!ifa
->ifa_local
) {
443 ifa
->ifa_flags
&= ~IFA_F_SECONDARY
;
444 last_primary
= &in_dev
->ifa_list
;
446 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
447 ifap
= &ifa1
->ifa_next
) {
448 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
) &&
449 ifa
->ifa_scope
<= ifa1
->ifa_scope
)
450 last_primary
= &ifa1
->ifa_next
;
451 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
452 inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
453 if (ifa1
->ifa_local
== ifa
->ifa_local
) {
457 if (ifa1
->ifa_scope
!= ifa
->ifa_scope
) {
461 ifa
->ifa_flags
|= IFA_F_SECONDARY
;
465 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
)) {
466 net_srandom(ifa
->ifa_local
);
470 ifa
->ifa_next
= *ifap
;
473 inet_hash_insert(dev_net(in_dev
->dev
), ifa
);
475 cancel_delayed_work(&check_lifetime_work
);
476 schedule_delayed_work(&check_lifetime_work
, 0);
478 /* Send message first, then call notifier.
479 Notifier will trigger FIB update, so that
480 listeners of netlink will know about new ifaddr */
481 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, portid
);
482 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
487 static int inet_insert_ifa(struct in_ifaddr
*ifa
)
489 return __inet_insert_ifa(ifa
, NULL
, 0);
492 static int inet_set_ifa(struct net_device
*dev
, struct in_ifaddr
*ifa
)
494 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
502 ipv4_devconf_setall(in_dev
);
503 neigh_parms_data_state_setall(in_dev
->arp_parms
);
504 if (ifa
->ifa_dev
!= in_dev
) {
505 WARN_ON(ifa
->ifa_dev
);
507 ifa
->ifa_dev
= in_dev
;
509 if (ipv4_is_loopback(ifa
->ifa_local
))
510 ifa
->ifa_scope
= RT_SCOPE_HOST
;
511 return inet_insert_ifa(ifa
);
514 /* Caller must hold RCU or RTNL :
515 * We dont take a reference on found in_device
517 struct in_device
*inetdev_by_index(struct net
*net
, int ifindex
)
519 struct net_device
*dev
;
520 struct in_device
*in_dev
= NULL
;
523 dev
= dev_get_by_index_rcu(net
, ifindex
);
525 in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
529 EXPORT_SYMBOL(inetdev_by_index
);
531 /* Called only from RTNL semaphored context. No locks. */
533 struct in_ifaddr
*inet_ifa_byprefix(struct in_device
*in_dev
, __be32 prefix
,
538 for_primary_ifa(in_dev
) {
539 if (ifa
->ifa_mask
== mask
&& inet_ifa_match(prefix
, ifa
))
541 } endfor_ifa(in_dev
);
545 static int inet_rtm_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
547 struct net
*net
= sock_net(skb
->sk
);
548 struct nlattr
*tb
[IFA_MAX
+1];
549 struct in_device
*in_dev
;
550 struct ifaddrmsg
*ifm
;
551 struct in_ifaddr
*ifa
, **ifap
;
556 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
560 ifm
= nlmsg_data(nlh
);
561 in_dev
= inetdev_by_index(net
, ifm
->ifa_index
);
562 if (in_dev
== NULL
) {
567 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
568 ifap
= &ifa
->ifa_next
) {
570 ifa
->ifa_local
!= nla_get_be32(tb
[IFA_LOCAL
]))
573 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
576 if (tb
[IFA_ADDRESS
] &&
577 (ifm
->ifa_prefixlen
!= ifa
->ifa_prefixlen
||
578 !inet_ifa_match(nla_get_be32(tb
[IFA_ADDRESS
]), ifa
)))
581 __inet_del_ifa(in_dev
, ifap
, 1, nlh
, NETLINK_CB(skb
).portid
);
585 err
= -EADDRNOTAVAIL
;
590 #define INFINITY_LIFE_TIME 0xFFFFFFFF
592 static void check_lifetime(struct work_struct
*work
)
594 unsigned long now
, next
, next_sec
, next_sched
;
595 struct in_ifaddr
*ifa
;
596 struct hlist_node
*n
;
600 next
= round_jiffies_up(now
+ ADDR_CHECK_FREQUENCY
);
602 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++) {
603 bool change_needed
= false;
606 hlist_for_each_entry_rcu(ifa
, &inet_addr_lst
[i
], hash
) {
609 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
612 /* We try to batch several events at once. */
613 age
= (now
- ifa
->ifa_tstamp
+
614 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
616 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
617 age
>= ifa
->ifa_valid_lft
) {
618 change_needed
= true;
619 } else if (ifa
->ifa_preferred_lft
==
620 INFINITY_LIFE_TIME
) {
622 } else if (age
>= ifa
->ifa_preferred_lft
) {
623 if (time_before(ifa
->ifa_tstamp
+
624 ifa
->ifa_valid_lft
* HZ
, next
))
625 next
= ifa
->ifa_tstamp
+
626 ifa
->ifa_valid_lft
* HZ
;
628 if (!(ifa
->ifa_flags
& IFA_F_DEPRECATED
))
629 change_needed
= true;
630 } else if (time_before(ifa
->ifa_tstamp
+
631 ifa
->ifa_preferred_lft
* HZ
,
633 next
= ifa
->ifa_tstamp
+
634 ifa
->ifa_preferred_lft
* HZ
;
641 hlist_for_each_entry_safe(ifa
, n
, &inet_addr_lst
[i
], hash
) {
644 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
647 /* We try to batch several events at once. */
648 age
= (now
- ifa
->ifa_tstamp
+
649 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
651 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
652 age
>= ifa
->ifa_valid_lft
) {
653 struct in_ifaddr
**ifap
;
655 for (ifap
= &ifa
->ifa_dev
->ifa_list
;
656 *ifap
!= NULL
; ifap
= &(*ifap
)->ifa_next
) {
658 inet_del_ifa(ifa
->ifa_dev
,
663 } else if (ifa
->ifa_preferred_lft
!=
664 INFINITY_LIFE_TIME
&&
665 age
>= ifa
->ifa_preferred_lft
&&
666 !(ifa
->ifa_flags
& IFA_F_DEPRECATED
)) {
667 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
668 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
674 next_sec
= round_jiffies_up(next
);
677 /* If rounded timeout is accurate enough, accept it. */
678 if (time_before(next_sec
, next
+ ADDRCONF_TIMER_FUZZ
))
679 next_sched
= next_sec
;
682 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
683 if (time_before(next_sched
, now
+ ADDRCONF_TIMER_FUZZ_MAX
))
684 next_sched
= now
+ ADDRCONF_TIMER_FUZZ_MAX
;
686 schedule_delayed_work(&check_lifetime_work
, next_sched
- now
);
689 static void set_ifa_lifetime(struct in_ifaddr
*ifa
, __u32 valid_lft
,
692 unsigned long timeout
;
694 ifa
->ifa_flags
&= ~(IFA_F_PERMANENT
| IFA_F_DEPRECATED
);
696 timeout
= addrconf_timeout_fixup(valid_lft
, HZ
);
697 if (addrconf_finite_timeout(timeout
))
698 ifa
->ifa_valid_lft
= timeout
;
700 ifa
->ifa_flags
|= IFA_F_PERMANENT
;
702 timeout
= addrconf_timeout_fixup(prefered_lft
, HZ
);
703 if (addrconf_finite_timeout(timeout
)) {
705 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
706 ifa
->ifa_preferred_lft
= timeout
;
708 ifa
->ifa_tstamp
= jiffies
;
709 if (!ifa
->ifa_cstamp
)
710 ifa
->ifa_cstamp
= ifa
->ifa_tstamp
;
713 static struct in_ifaddr
*rtm_to_ifaddr(struct net
*net
, struct nlmsghdr
*nlh
,
714 __u32
*pvalid_lft
, __u32
*pprefered_lft
)
716 struct nlattr
*tb
[IFA_MAX
+1];
717 struct in_ifaddr
*ifa
;
718 struct ifaddrmsg
*ifm
;
719 struct net_device
*dev
;
720 struct in_device
*in_dev
;
723 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
727 ifm
= nlmsg_data(nlh
);
729 if (ifm
->ifa_prefixlen
> 32 || tb
[IFA_LOCAL
] == NULL
)
732 dev
= __dev_get_by_index(net
, ifm
->ifa_index
);
737 in_dev
= __in_dev_get_rtnl(dev
);
742 ifa
= inet_alloc_ifa();
745 * A potential indev allocation can be left alive, it stays
746 * assigned to its device and is destroy with it.
750 ipv4_devconf_setall(in_dev
);
751 neigh_parms_data_state_setall(in_dev
->arp_parms
);
754 if (tb
[IFA_ADDRESS
] == NULL
)
755 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
757 INIT_HLIST_NODE(&ifa
->hash
);
758 ifa
->ifa_prefixlen
= ifm
->ifa_prefixlen
;
759 ifa
->ifa_mask
= inet_make_mask(ifm
->ifa_prefixlen
);
760 ifa
->ifa_flags
= ifm
->ifa_flags
;
761 ifa
->ifa_scope
= ifm
->ifa_scope
;
762 ifa
->ifa_dev
= in_dev
;
764 ifa
->ifa_local
= nla_get_be32(tb
[IFA_LOCAL
]);
765 ifa
->ifa_address
= nla_get_be32(tb
[IFA_ADDRESS
]);
767 if (tb
[IFA_BROADCAST
])
768 ifa
->ifa_broadcast
= nla_get_be32(tb
[IFA_BROADCAST
]);
771 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
773 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
775 if (tb
[IFA_CACHEINFO
]) {
776 struct ifa_cacheinfo
*ci
;
778 ci
= nla_data(tb
[IFA_CACHEINFO
]);
779 if (!ci
->ifa_valid
|| ci
->ifa_prefered
> ci
->ifa_valid
) {
783 *pvalid_lft
= ci
->ifa_valid
;
784 *pprefered_lft
= ci
->ifa_prefered
;
795 static struct in_ifaddr
*find_matching_ifa(struct in_ifaddr
*ifa
)
797 struct in_device
*in_dev
= ifa
->ifa_dev
;
798 struct in_ifaddr
*ifa1
, **ifap
;
803 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
804 ifap
= &ifa1
->ifa_next
) {
805 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
806 inet_ifa_match(ifa1
->ifa_address
, ifa
) &&
807 ifa1
->ifa_local
== ifa
->ifa_local
)
813 static int inet_rtm_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
815 struct net
*net
= sock_net(skb
->sk
);
816 struct in_ifaddr
*ifa
;
817 struct in_ifaddr
*ifa_existing
;
818 __u32 valid_lft
= INFINITY_LIFE_TIME
;
819 __u32 prefered_lft
= INFINITY_LIFE_TIME
;
823 ifa
= rtm_to_ifaddr(net
, nlh
, &valid_lft
, &prefered_lft
);
827 ifa_existing
= find_matching_ifa(ifa
);
829 /* It would be best to check for !NLM_F_CREATE here but
830 * userspace alreay relies on not having to provide this.
832 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
833 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).portid
);
837 if (nlh
->nlmsg_flags
& NLM_F_EXCL
||
838 !(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
841 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
842 cancel_delayed_work(&check_lifetime_work
);
843 schedule_delayed_work(&check_lifetime_work
, 0);
844 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, NETLINK_CB(skb
).portid
);
845 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
851 * Determine a default network mask, based on the IP address.
854 static int inet_abc_len(__be32 addr
)
856 int rc
= -1; /* Something else, probably a multicast. */
858 if (ipv4_is_zeronet(addr
))
861 __u32 haddr
= ntohl(addr
);
863 if (IN_CLASSA(haddr
))
865 else if (IN_CLASSB(haddr
))
867 else if (IN_CLASSC(haddr
))
875 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
878 struct sockaddr_in sin_orig
;
879 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
880 struct in_device
*in_dev
;
881 struct in_ifaddr
**ifap
= NULL
;
882 struct in_ifaddr
*ifa
= NULL
;
883 struct net_device
*dev
;
886 int tryaddrmatch
= 0;
889 * Fetch the caller's info block into kernel space
892 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
894 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
896 /* save original address for comparison */
897 memcpy(&sin_orig
, sin
, sizeof(*sin
));
899 colon
= strchr(ifr
.ifr_name
, ':');
903 dev_load(net
, ifr
.ifr_name
);
906 case SIOCGIFADDR
: /* Get interface address */
907 case SIOCGIFBRDADDR
: /* Get the broadcast address */
908 case SIOCGIFDSTADDR
: /* Get the destination address */
909 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
910 /* Note that these ioctls will not sleep,
911 so that we do not impose a lock.
912 One day we will be forced to put shlock here (I mean SMP)
914 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
915 memset(sin
, 0, sizeof(*sin
));
916 sin
->sin_family
= AF_INET
;
921 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
924 case SIOCSIFADDR
: /* Set interface address (and family) */
925 case SIOCSIFBRDADDR
: /* Set the broadcast address */
926 case SIOCSIFDSTADDR
: /* Set the destination address */
927 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
929 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
932 if (sin
->sin_family
!= AF_INET
)
943 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
950 in_dev
= __in_dev_get_rtnl(dev
);
953 /* Matthias Andree */
954 /* compare label and address (4.4BSD style) */
955 /* note: we only do this for a limited set of ioctls
956 and only if the original address family was AF_INET.
957 This is checked above. */
958 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
959 ifap
= &ifa
->ifa_next
) {
960 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
961 sin_orig
.sin_addr
.s_addr
==
967 /* we didn't get a match, maybe the application is
968 4.3BSD-style and passed in junk so we fall back to
969 comparing just the label */
971 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
972 ifap
= &ifa
->ifa_next
)
973 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
978 ret
= -EADDRNOTAVAIL
;
979 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
983 case SIOCGIFADDR
: /* Get interface address */
984 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
987 case SIOCGIFBRDADDR
: /* Get the broadcast address */
988 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
991 case SIOCGIFDSTADDR
: /* Get the destination address */
992 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
995 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
996 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
1001 ret
= -EADDRNOTAVAIL
;
1005 if (!(ifr
.ifr_flags
& IFF_UP
))
1006 inet_del_ifa(in_dev
, ifap
, 1);
1009 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
1012 case SIOCSIFADDR
: /* Set interface address (and family) */
1014 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1019 ifa
= inet_alloc_ifa();
1022 INIT_HLIST_NODE(&ifa
->hash
);
1024 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
1026 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1029 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
1031 inet_del_ifa(in_dev
, ifap
, 0);
1032 ifa
->ifa_broadcast
= 0;
1036 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
1038 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
1039 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
1040 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
1041 if ((dev
->flags
& IFF_BROADCAST
) &&
1042 ifa
->ifa_prefixlen
< 31)
1043 ifa
->ifa_broadcast
= ifa
->ifa_address
|
1046 ifa
->ifa_prefixlen
= 32;
1047 ifa
->ifa_mask
= inet_make_mask(32);
1049 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
, INFINITY_LIFE_TIME
);
1050 ret
= inet_set_ifa(dev
, ifa
);
1053 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1055 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
1056 inet_del_ifa(in_dev
, ifap
, 0);
1057 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
1058 inet_insert_ifa(ifa
);
1062 case SIOCSIFDSTADDR
: /* Set the destination address */
1064 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
1067 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1070 inet_del_ifa(in_dev
, ifap
, 0);
1071 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
1072 inet_insert_ifa(ifa
);
1075 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1078 * The mask we set must be legal.
1081 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
1084 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
1085 __be32 old_mask
= ifa
->ifa_mask
;
1086 inet_del_ifa(in_dev
, ifap
, 0);
1087 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
1088 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
1090 /* See if current broadcast address matches
1091 * with current netmask, then recalculate
1092 * the broadcast address. Otherwise it's a
1093 * funny address, so don't touch it since
1094 * the user seems to know what (s)he's doing...
1096 if ((dev
->flags
& IFF_BROADCAST
) &&
1097 (ifa
->ifa_prefixlen
< 31) &&
1098 (ifa
->ifa_broadcast
==
1099 (ifa
->ifa_local
|~old_mask
))) {
1100 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
1101 ~sin
->sin_addr
.s_addr
);
1103 inet_insert_ifa(ifa
);
1113 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
1117 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
1119 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1120 struct in_ifaddr
*ifa
;
1127 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1129 done
+= sizeof(ifr
);
1132 if (len
< (int) sizeof(ifr
))
1134 memset(&ifr
, 0, sizeof(struct ifreq
));
1135 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
1137 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
1138 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
1141 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
1145 buf
+= sizeof(struct ifreq
);
1146 len
-= sizeof(struct ifreq
);
1147 done
+= sizeof(struct ifreq
);
1153 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
1156 struct in_device
*in_dev
;
1157 struct net
*net
= dev_net(dev
);
1160 in_dev
= __in_dev_get_rcu(dev
);
1164 for_primary_ifa(in_dev
) {
1165 if (ifa
->ifa_scope
> scope
)
1167 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
1168 addr
= ifa
->ifa_local
;
1172 addr
= ifa
->ifa_local
;
1173 } endfor_ifa(in_dev
);
1179 /* Not loopback addresses on loopback should be preferred
1180 in this case. It is importnat that lo is the first interface
1183 for_each_netdev_rcu(net
, dev
) {
1184 in_dev
= __in_dev_get_rcu(dev
);
1188 for_primary_ifa(in_dev
) {
1189 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1190 ifa
->ifa_scope
<= scope
) {
1191 addr
= ifa
->ifa_local
;
1194 } endfor_ifa(in_dev
);
1200 EXPORT_SYMBOL(inet_select_addr
);
1202 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1203 __be32 local
, int scope
)
1210 (local
== ifa
->ifa_local
|| !local
) &&
1211 ifa
->ifa_scope
<= scope
) {
1212 addr
= ifa
->ifa_local
;
1217 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1218 (!dst
|| inet_ifa_match(dst
, ifa
));
1222 /* Is the selected addr into dst subnet? */
1223 if (inet_ifa_match(addr
, ifa
))
1225 /* No, then can we use new local src? */
1226 if (ifa
->ifa_scope
<= scope
) {
1227 addr
= ifa
->ifa_local
;
1230 /* search for large dst subnet for addr */
1234 } endfor_ifa(in_dev
);
1236 return same
? addr
: 0;
1240 * Confirm that local IP address exists using wildcards:
1241 * - in_dev: only on this interface, 0=any interface
1242 * - dst: only in the same subnet as dst, 0=any dst
1243 * - local: address, 0=autoselect the local address
1244 * - scope: maximum allowed scope value for the local address
1246 __be32
inet_confirm_addr(struct in_device
*in_dev
,
1247 __be32 dst
, __be32 local
, int scope
)
1250 struct net_device
*dev
;
1253 if (scope
!= RT_SCOPE_LINK
)
1254 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1256 net
= dev_net(in_dev
->dev
);
1258 for_each_netdev_rcu(net
, dev
) {
1259 in_dev
= __in_dev_get_rcu(dev
);
1261 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1270 EXPORT_SYMBOL(inet_confirm_addr
);
1276 int register_inetaddr_notifier(struct notifier_block
*nb
)
1278 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1280 EXPORT_SYMBOL(register_inetaddr_notifier
);
1282 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1284 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1286 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1288 /* Rename ifa_labels for a device name change. Make some effort to preserve
1289 * existing alias numbering and to create unique labels if possible.
1291 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1293 struct in_ifaddr
*ifa
;
1296 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1297 char old
[IFNAMSIZ
], *dot
;
1299 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1300 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1303 dot
= strchr(old
, ':');
1305 sprintf(old
, ":%d", named
);
1308 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1309 strcat(ifa
->ifa_label
, dot
);
1311 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1313 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1317 static bool inetdev_valid_mtu(unsigned int mtu
)
1322 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1323 struct in_device
*in_dev
)
1326 struct in_ifaddr
*ifa
;
1328 for (ifa
= in_dev
->ifa_list
; ifa
;
1329 ifa
= ifa
->ifa_next
) {
1330 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1331 ifa
->ifa_local
, dev
,
1332 ifa
->ifa_local
, NULL
,
1333 dev
->dev_addr
, NULL
);
1337 /* Called only under RTNL semaphore */
1339 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1342 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1343 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1348 if (event
== NETDEV_REGISTER
) {
1349 in_dev
= inetdev_init(dev
);
1351 return notifier_from_errno(-ENOMEM
);
1352 if (dev
->flags
& IFF_LOOPBACK
) {
1353 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1354 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1356 } else if (event
== NETDEV_CHANGEMTU
) {
1357 /* Re-enabling IP */
1358 if (inetdev_valid_mtu(dev
->mtu
))
1359 in_dev
= inetdev_init(dev
);
1365 case NETDEV_REGISTER
:
1366 pr_debug("%s: bug\n", __func__
);
1367 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1370 if (!inetdev_valid_mtu(dev
->mtu
))
1372 if (dev
->flags
& IFF_LOOPBACK
) {
1373 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1376 INIT_HLIST_NODE(&ifa
->hash
);
1378 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1379 ifa
->ifa_prefixlen
= 8;
1380 ifa
->ifa_mask
= inet_make_mask(8);
1381 in_dev_hold(in_dev
);
1382 ifa
->ifa_dev
= in_dev
;
1383 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1384 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1385 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
,
1386 INFINITY_LIFE_TIME
);
1387 inet_insert_ifa(ifa
);
1392 case NETDEV_CHANGEADDR
:
1393 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1396 case NETDEV_NOTIFY_PEERS
:
1397 /* Send gratuitous ARP to notify of link change */
1398 inetdev_send_gratuitous_arp(dev
, in_dev
);
1403 case NETDEV_PRE_TYPE_CHANGE
:
1404 ip_mc_unmap(in_dev
);
1406 case NETDEV_POST_TYPE_CHANGE
:
1407 ip_mc_remap(in_dev
);
1409 case NETDEV_CHANGEMTU
:
1410 if (inetdev_valid_mtu(dev
->mtu
))
1412 /* disable IP when MTU is not enough */
1413 case NETDEV_UNREGISTER
:
1414 inetdev_destroy(in_dev
);
1416 case NETDEV_CHANGENAME
:
1417 /* Do not notify about label change, this event is
1418 * not interesting to applications using netlink.
1420 inetdev_changename(dev
, in_dev
);
1422 devinet_sysctl_unregister(in_dev
);
1423 devinet_sysctl_register(in_dev
);
1430 static struct notifier_block ip_netdev_notifier
= {
1431 .notifier_call
= inetdev_event
,
1434 static size_t inet_nlmsg_size(void)
1436 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1437 + nla_total_size(4) /* IFA_ADDRESS */
1438 + nla_total_size(4) /* IFA_LOCAL */
1439 + nla_total_size(4) /* IFA_BROADCAST */
1440 + nla_total_size(IFNAMSIZ
); /* IFA_LABEL */
1443 static inline u32
cstamp_delta(unsigned long cstamp
)
1445 return (cstamp
- INITIAL_JIFFIES
) * 100UL / HZ
;
1448 static int put_cacheinfo(struct sk_buff
*skb
, unsigned long cstamp
,
1449 unsigned long tstamp
, u32 preferred
, u32 valid
)
1451 struct ifa_cacheinfo ci
;
1453 ci
.cstamp
= cstamp_delta(cstamp
);
1454 ci
.tstamp
= cstamp_delta(tstamp
);
1455 ci
.ifa_prefered
= preferred
;
1456 ci
.ifa_valid
= valid
;
1458 return nla_put(skb
, IFA_CACHEINFO
, sizeof(ci
), &ci
);
1461 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1462 u32 portid
, u32 seq
, int event
, unsigned int flags
)
1464 struct ifaddrmsg
*ifm
;
1465 struct nlmsghdr
*nlh
;
1466 u32 preferred
, valid
;
1468 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*ifm
), flags
);
1472 ifm
= nlmsg_data(nlh
);
1473 ifm
->ifa_family
= AF_INET
;
1474 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1475 ifm
->ifa_flags
= ifa
->ifa_flags
;
1476 ifm
->ifa_scope
= ifa
->ifa_scope
;
1477 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1479 if (!(ifm
->ifa_flags
& IFA_F_PERMANENT
)) {
1480 preferred
= ifa
->ifa_preferred_lft
;
1481 valid
= ifa
->ifa_valid_lft
;
1482 if (preferred
!= INFINITY_LIFE_TIME
) {
1483 long tval
= (jiffies
- ifa
->ifa_tstamp
) / HZ
;
1485 if (preferred
> tval
)
1489 if (valid
!= INFINITY_LIFE_TIME
) {
1497 preferred
= INFINITY_LIFE_TIME
;
1498 valid
= INFINITY_LIFE_TIME
;
1500 if ((ifa
->ifa_address
&&
1501 nla_put_be32(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1503 nla_put_be32(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1504 (ifa
->ifa_broadcast
&&
1505 nla_put_be32(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1506 (ifa
->ifa_label
[0] &&
1507 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)) ||
1508 put_cacheinfo(skb
, ifa
->ifa_cstamp
, ifa
->ifa_tstamp
,
1510 goto nla_put_failure
;
1512 return nlmsg_end(skb
, nlh
);
1515 nlmsg_cancel(skb
, nlh
);
1519 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1521 struct net
*net
= sock_net(skb
->sk
);
1524 int ip_idx
, s_ip_idx
;
1525 struct net_device
*dev
;
1526 struct in_device
*in_dev
;
1527 struct in_ifaddr
*ifa
;
1528 struct hlist_head
*head
;
1531 s_idx
= idx
= cb
->args
[1];
1532 s_ip_idx
= ip_idx
= cb
->args
[2];
1534 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1536 head
= &net
->dev_index_head
[h
];
1538 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1540 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1543 if (h
> s_h
|| idx
> s_idx
)
1545 in_dev
= __in_dev_get_rcu(dev
);
1549 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1550 ifa
= ifa
->ifa_next
, ip_idx
++) {
1551 if (ip_idx
< s_ip_idx
)
1553 if (inet_fill_ifaddr(skb
, ifa
,
1554 NETLINK_CB(cb
->skb
).portid
,
1556 RTM_NEWADDR
, NLM_F_MULTI
) <= 0) {
1560 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1571 cb
->args
[2] = ip_idx
;
1576 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1579 struct sk_buff
*skb
;
1580 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1584 net
= dev_net(ifa
->ifa_dev
->dev
);
1585 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1589 err
= inet_fill_ifaddr(skb
, ifa
, portid
, seq
, event
, 0);
1591 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1592 WARN_ON(err
== -EMSGSIZE
);
1596 rtnl_notify(skb
, net
, portid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1600 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1603 static size_t inet_get_link_af_size(const struct net_device
*dev
)
1605 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1610 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1613 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
)
1615 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1622 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1626 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1627 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1632 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1633 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1636 static int inet_validate_link_af(const struct net_device
*dev
,
1637 const struct nlattr
*nla
)
1639 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1642 if (dev
&& !__in_dev_get_rtnl(dev
))
1643 return -EAFNOSUPPORT
;
1645 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
);
1649 if (tb
[IFLA_INET_CONF
]) {
1650 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1651 int cfgid
= nla_type(a
);
1656 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1664 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1666 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1667 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1671 return -EAFNOSUPPORT
;
1673 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
) < 0)
1676 if (tb
[IFLA_INET_CONF
]) {
1677 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1678 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1684 static int inet_netconf_msgsize_devconf(int type
)
1686 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1687 + nla_total_size(4); /* NETCONFA_IFINDEX */
1689 /* type -1 is used for ALL */
1690 if (type
== -1 || type
== NETCONFA_FORWARDING
)
1691 size
+= nla_total_size(4);
1692 if (type
== -1 || type
== NETCONFA_RP_FILTER
)
1693 size
+= nla_total_size(4);
1694 if (type
== -1 || type
== NETCONFA_MC_FORWARDING
)
1695 size
+= nla_total_size(4);
1700 static int inet_netconf_fill_devconf(struct sk_buff
*skb
, int ifindex
,
1701 struct ipv4_devconf
*devconf
, u32 portid
,
1702 u32 seq
, int event
, unsigned int flags
,
1705 struct nlmsghdr
*nlh
;
1706 struct netconfmsg
*ncm
;
1708 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1713 ncm
= nlmsg_data(nlh
);
1714 ncm
->ncm_family
= AF_INET
;
1716 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, ifindex
) < 0)
1717 goto nla_put_failure
;
1719 /* type -1 is used for ALL */
1720 if ((type
== -1 || type
== NETCONFA_FORWARDING
) &&
1721 nla_put_s32(skb
, NETCONFA_FORWARDING
,
1722 IPV4_DEVCONF(*devconf
, FORWARDING
)) < 0)
1723 goto nla_put_failure
;
1724 if ((type
== -1 || type
== NETCONFA_RP_FILTER
) &&
1725 nla_put_s32(skb
, NETCONFA_RP_FILTER
,
1726 IPV4_DEVCONF(*devconf
, RP_FILTER
)) < 0)
1727 goto nla_put_failure
;
1728 if ((type
== -1 || type
== NETCONFA_MC_FORWARDING
) &&
1729 nla_put_s32(skb
, NETCONFA_MC_FORWARDING
,
1730 IPV4_DEVCONF(*devconf
, MC_FORWARDING
)) < 0)
1731 goto nla_put_failure
;
1733 return nlmsg_end(skb
, nlh
);
1736 nlmsg_cancel(skb
, nlh
);
1740 void inet_netconf_notify_devconf(struct net
*net
, int type
, int ifindex
,
1741 struct ipv4_devconf
*devconf
)
1743 struct sk_buff
*skb
;
1746 skb
= nlmsg_new(inet_netconf_msgsize_devconf(type
), GFP_ATOMIC
);
1750 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
, 0, 0,
1751 RTM_NEWNETCONF
, 0, type
);
1753 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1754 WARN_ON(err
== -EMSGSIZE
);
1758 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_NETCONF
, NULL
, GFP_ATOMIC
);
1762 rtnl_set_sk_err(net
, RTNLGRP_IPV4_NETCONF
, err
);
1765 static const struct nla_policy devconf_ipv4_policy
[NETCONFA_MAX
+1] = {
1766 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1767 [NETCONFA_FORWARDING
] = { .len
= sizeof(int) },
1768 [NETCONFA_RP_FILTER
] = { .len
= sizeof(int) },
1771 static int inet_netconf_get_devconf(struct sk_buff
*in_skb
,
1772 struct nlmsghdr
*nlh
)
1774 struct net
*net
= sock_net(in_skb
->sk
);
1775 struct nlattr
*tb
[NETCONFA_MAX
+1];
1776 struct netconfmsg
*ncm
;
1777 struct sk_buff
*skb
;
1778 struct ipv4_devconf
*devconf
;
1779 struct in_device
*in_dev
;
1780 struct net_device
*dev
;
1784 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1785 devconf_ipv4_policy
);
1790 if (!tb
[NETCONFA_IFINDEX
])
1793 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1795 case NETCONFA_IFINDEX_ALL
:
1796 devconf
= net
->ipv4
.devconf_all
;
1798 case NETCONFA_IFINDEX_DEFAULT
:
1799 devconf
= net
->ipv4
.devconf_dflt
;
1802 dev
= __dev_get_by_index(net
, ifindex
);
1805 in_dev
= __in_dev_get_rtnl(dev
);
1808 devconf
= &in_dev
->cnf
;
1813 skb
= nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC
);
1817 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
,
1818 NETLINK_CB(in_skb
).portid
,
1819 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1822 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1823 WARN_ON(err
== -EMSGSIZE
);
1827 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1832 static int inet_netconf_dump_devconf(struct sk_buff
*skb
,
1833 struct netlink_callback
*cb
)
1835 struct net
*net
= sock_net(skb
->sk
);
1838 struct net_device
*dev
;
1839 struct in_device
*in_dev
;
1840 struct hlist_head
*head
;
1843 s_idx
= idx
= cb
->args
[1];
1845 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1847 head
= &net
->dev_index_head
[h
];
1849 cb
->seq
= atomic_read(&net
->ipv4
.dev_addr_genid
) ^
1851 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1854 in_dev
= __in_dev_get_rcu(dev
);
1858 if (inet_netconf_fill_devconf(skb
, dev
->ifindex
,
1860 NETLINK_CB(cb
->skb
).portid
,
1868 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1874 if (h
== NETDEV_HASHENTRIES
) {
1875 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_ALL
,
1876 net
->ipv4
.devconf_all
,
1877 NETLINK_CB(cb
->skb
).portid
,
1879 RTM_NEWNETCONF
, NLM_F_MULTI
,
1885 if (h
== NETDEV_HASHENTRIES
+ 1) {
1886 if (inet_netconf_fill_devconf(skb
, NETCONFA_IFINDEX_DEFAULT
,
1887 net
->ipv4
.devconf_dflt
,
1888 NETLINK_CB(cb
->skb
).portid
,
1890 RTM_NEWNETCONF
, NLM_F_MULTI
,
1903 #ifdef CONFIG_SYSCTL
1905 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
1907 struct net_device
*dev
;
1910 for_each_netdev_rcu(net
, dev
) {
1911 struct in_device
*in_dev
;
1913 in_dev
= __in_dev_get_rcu(dev
);
1914 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
1915 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
1920 /* called with RTNL locked */
1921 static void inet_forward_change(struct net
*net
)
1923 struct net_device
*dev
;
1924 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
1926 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
1927 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
1928 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1929 NETCONFA_IFINDEX_ALL
,
1930 net
->ipv4
.devconf_all
);
1931 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1932 NETCONFA_IFINDEX_DEFAULT
,
1933 net
->ipv4
.devconf_dflt
);
1935 for_each_netdev(net
, dev
) {
1936 struct in_device
*in_dev
;
1938 dev_disable_lro(dev
);
1940 in_dev
= __in_dev_get_rcu(dev
);
1942 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
1943 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1944 dev
->ifindex
, &in_dev
->cnf
);
1950 static int devinet_conf_proc(struct ctl_table
*ctl
, int write
,
1951 void __user
*buffer
,
1952 size_t *lenp
, loff_t
*ppos
)
1954 int old_value
= *(int *)ctl
->data
;
1955 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1956 int new_value
= *(int *)ctl
->data
;
1959 struct ipv4_devconf
*cnf
= ctl
->extra1
;
1960 struct net
*net
= ctl
->extra2
;
1961 int i
= (int *)ctl
->data
- cnf
->data
;
1963 set_bit(i
, cnf
->state
);
1965 if (cnf
== net
->ipv4
.devconf_dflt
)
1966 devinet_copy_dflt_conf(net
, i
);
1967 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1 ||
1968 i
== IPV4_DEVCONF_ROUTE_LOCALNET
- 1)
1969 if ((new_value
== 0) && (old_value
!= 0))
1970 rt_cache_flush(net
);
1971 if (i
== IPV4_DEVCONF_RP_FILTER
- 1 &&
1972 new_value
!= old_value
) {
1975 if (cnf
== net
->ipv4
.devconf_dflt
)
1976 ifindex
= NETCONFA_IFINDEX_DEFAULT
;
1977 else if (cnf
== net
->ipv4
.devconf_all
)
1978 ifindex
= NETCONFA_IFINDEX_ALL
;
1980 struct in_device
*idev
=
1981 container_of(cnf
, struct in_device
,
1983 ifindex
= idev
->dev
->ifindex
;
1985 inet_netconf_notify_devconf(net
, NETCONFA_RP_FILTER
,
1993 static int devinet_sysctl_forward(struct ctl_table
*ctl
, int write
,
1994 void __user
*buffer
,
1995 size_t *lenp
, loff_t
*ppos
)
1997 int *valp
= ctl
->data
;
2000 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2002 if (write
&& *valp
!= val
) {
2003 struct net
*net
= ctl
->extra2
;
2005 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
2006 if (!rtnl_trylock()) {
2007 /* Restore the original values before restarting */
2010 return restart_syscall();
2012 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
2013 inet_forward_change(net
);
2015 struct ipv4_devconf
*cnf
= ctl
->extra1
;
2016 struct in_device
*idev
=
2017 container_of(cnf
, struct in_device
, cnf
);
2019 dev_disable_lro(idev
->dev
);
2020 inet_netconf_notify_devconf(net
,
2021 NETCONFA_FORWARDING
,
2026 rt_cache_flush(net
);
2028 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
2029 NETCONFA_IFINDEX_DEFAULT
,
2030 net
->ipv4
.devconf_dflt
);
2036 static int ipv4_doint_and_flush(struct ctl_table
*ctl
, int write
,
2037 void __user
*buffer
,
2038 size_t *lenp
, loff_t
*ppos
)
2040 int *valp
= ctl
->data
;
2042 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
2043 struct net
*net
= ctl
->extra2
;
2045 if (write
&& *valp
!= val
)
2046 rt_cache_flush(net
);
2051 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2054 .data = ipv4_devconf.data + \
2055 IPV4_DEVCONF_ ## attr - 1, \
2056 .maxlen = sizeof(int), \
2058 .proc_handler = proc, \
2059 .extra1 = &ipv4_devconf, \
2062 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2063 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2065 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2066 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2068 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2069 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2071 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2072 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2074 static struct devinet_sysctl_table
{
2075 struct ctl_table_header
*sysctl_header
;
2076 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
2077 } devinet_sysctl
= {
2079 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
2080 devinet_sysctl_forward
),
2081 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
2083 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
2084 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
2085 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
2086 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
2087 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
2088 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
2089 "accept_source_route"),
2090 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
2091 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
2092 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
2093 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
2094 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
2095 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
2096 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
2097 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
2098 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
2099 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
2100 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
2101 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
2102 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
2103 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION
,
2104 "force_igmp_version"),
2105 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL
,
2106 "igmpv2_unsolicited_report_interval"),
2107 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL
,
2108 "igmpv3_unsolicited_report_interval"),
2110 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
2111 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
2112 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
2113 "promote_secondaries"),
2114 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET
,
2119 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
2120 struct ipv4_devconf
*p
)
2123 struct devinet_sysctl_table
*t
;
2124 char path
[sizeof("net/ipv4/conf/") + IFNAMSIZ
];
2126 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
2130 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
2131 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
2132 t
->devinet_vars
[i
].extra1
= p
;
2133 t
->devinet_vars
[i
].extra2
= net
;
2136 snprintf(path
, sizeof(path
), "net/ipv4/conf/%s", dev_name
);
2138 t
->sysctl_header
= register_net_sysctl(net
, path
, t
->devinet_vars
);
2139 if (!t
->sysctl_header
)
2151 static void __devinet_sysctl_unregister(struct ipv4_devconf
*cnf
)
2153 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
2159 unregister_net_sysctl_table(t
->sysctl_header
);
2163 static void devinet_sysctl_register(struct in_device
*idev
)
2165 neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, NULL
);
2166 __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
2170 static void devinet_sysctl_unregister(struct in_device
*idev
)
2172 __devinet_sysctl_unregister(&idev
->cnf
);
2173 neigh_sysctl_unregister(idev
->arp_parms
);
2176 static struct ctl_table ctl_forward_entry
[] = {
2178 .procname
= "ip_forward",
2179 .data
= &ipv4_devconf
.data
[
2180 IPV4_DEVCONF_FORWARDING
- 1],
2181 .maxlen
= sizeof(int),
2183 .proc_handler
= devinet_sysctl_forward
,
2184 .extra1
= &ipv4_devconf
,
2185 .extra2
= &init_net
,
2191 static __net_init
int devinet_init_net(struct net
*net
)
2194 struct ipv4_devconf
*all
, *dflt
;
2195 #ifdef CONFIG_SYSCTL
2196 struct ctl_table
*tbl
= ctl_forward_entry
;
2197 struct ctl_table_header
*forw_hdr
;
2201 all
= &ipv4_devconf
;
2202 dflt
= &ipv4_devconf_dflt
;
2204 if (!net_eq(net
, &init_net
)) {
2205 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
2209 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
2211 goto err_alloc_dflt
;
2213 #ifdef CONFIG_SYSCTL
2214 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
2218 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
2219 tbl
[0].extra1
= all
;
2220 tbl
[0].extra2
= net
;
2224 #ifdef CONFIG_SYSCTL
2225 err
= __devinet_sysctl_register(net
, "all", all
);
2229 err
= __devinet_sysctl_register(net
, "default", dflt
);
2234 forw_hdr
= register_net_sysctl(net
, "net/ipv4", tbl
);
2235 if (forw_hdr
== NULL
)
2237 net
->ipv4
.forw_hdr
= forw_hdr
;
2240 net
->ipv4
.devconf_all
= all
;
2241 net
->ipv4
.devconf_dflt
= dflt
;
2244 #ifdef CONFIG_SYSCTL
2246 __devinet_sysctl_unregister(dflt
);
2248 __devinet_sysctl_unregister(all
);
2250 if (tbl
!= ctl_forward_entry
)
2254 if (dflt
!= &ipv4_devconf_dflt
)
2257 if (all
!= &ipv4_devconf
)
2263 static __net_exit
void devinet_exit_net(struct net
*net
)
2265 #ifdef CONFIG_SYSCTL
2266 struct ctl_table
*tbl
;
2268 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
2269 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
2270 __devinet_sysctl_unregister(net
->ipv4
.devconf_dflt
);
2271 __devinet_sysctl_unregister(net
->ipv4
.devconf_all
);
2274 kfree(net
->ipv4
.devconf_dflt
);
2275 kfree(net
->ipv4
.devconf_all
);
2278 static __net_initdata
struct pernet_operations devinet_ops
= {
2279 .init
= devinet_init_net
,
2280 .exit
= devinet_exit_net
,
2283 static struct rtnl_af_ops inet_af_ops
= {
2285 .fill_link_af
= inet_fill_link_af
,
2286 .get_link_af_size
= inet_get_link_af_size
,
2287 .validate_link_af
= inet_validate_link_af
,
2288 .set_link_af
= inet_set_link_af
,
2291 void __init
devinet_init(void)
2295 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
2296 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
2298 register_pernet_subsys(&devinet_ops
);
2300 register_gifconf(PF_INET
, inet_gifconf
);
2301 register_netdevice_notifier(&ip_netdev_notifier
);
2303 schedule_delayed_work(&check_lifetime_work
, 0);
2305 rtnl_af_register(&inet_af_ops
);
2307 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, NULL
);
2308 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, NULL
);
2309 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, NULL
);
2310 rtnl_register(PF_INET
, RTM_GETNETCONF
, inet_netconf_get_devconf
,
2311 inet_netconf_dump_devconf
, NULL
);