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,
79 static struct ipv4_devconf ipv4_devconf_dflt
= {
81 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
82 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
83 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
84 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
85 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE
- 1] = 1,
89 #define IPV4_DEVCONF_DFLT(net, attr) \
90 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
92 static const struct nla_policy ifa_ipv4_policy
[IFA_MAX
+1] = {
93 [IFA_LOCAL
] = { .type
= NLA_U32
},
94 [IFA_ADDRESS
] = { .type
= NLA_U32
},
95 [IFA_BROADCAST
] = { .type
= NLA_U32
},
96 [IFA_LABEL
] = { .type
= NLA_STRING
, .len
= IFNAMSIZ
- 1 },
97 [IFA_CACHEINFO
] = { .len
= sizeof(struct ifa_cacheinfo
) },
100 #define IN4_ADDR_HSIZE_SHIFT 8
101 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
103 static struct hlist_head inet_addr_lst
[IN4_ADDR_HSIZE
];
104 static DEFINE_SPINLOCK(inet_addr_hash_lock
);
106 static u32
inet_addr_hash(struct net
*net
, __be32 addr
)
108 u32 val
= (__force u32
) addr
^ net_hash_mix(net
);
110 return hash_32(val
, IN4_ADDR_HSIZE_SHIFT
);
113 static void inet_hash_insert(struct net
*net
, struct in_ifaddr
*ifa
)
115 u32 hash
= inet_addr_hash(net
, ifa
->ifa_local
);
117 spin_lock(&inet_addr_hash_lock
);
118 hlist_add_head_rcu(&ifa
->hash
, &inet_addr_lst
[hash
]);
119 spin_unlock(&inet_addr_hash_lock
);
122 static void inet_hash_remove(struct in_ifaddr
*ifa
)
124 spin_lock(&inet_addr_hash_lock
);
125 hlist_del_init_rcu(&ifa
->hash
);
126 spin_unlock(&inet_addr_hash_lock
);
130 * __ip_dev_find - find the first device with a given source address.
131 * @net: the net namespace
132 * @addr: the source address
133 * @devref: if true, take a reference on the found device
135 * If a caller uses devref=false, it should be protected by RCU, or RTNL
137 struct net_device
*__ip_dev_find(struct net
*net
, __be32 addr
, bool devref
)
139 u32 hash
= inet_addr_hash(net
, addr
);
140 struct net_device
*result
= NULL
;
141 struct in_ifaddr
*ifa
;
142 struct hlist_node
*node
;
145 hlist_for_each_entry_rcu(ifa
, node
, &inet_addr_lst
[hash
], hash
) {
146 if (ifa
->ifa_local
== addr
) {
147 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
149 if (!net_eq(dev_net(dev
), net
))
156 struct flowi4 fl4
= { .daddr
= addr
};
157 struct fib_result res
= { 0 };
158 struct fib_table
*local
;
160 /* Fallback to FIB local table so that communication
161 * over loopback subnets work.
163 local
= fib_get_table(net
, RT_TABLE_LOCAL
);
165 !fib_table_lookup(local
, &fl4
, &res
, FIB_LOOKUP_NOREF
) &&
166 res
.type
== RTN_LOCAL
)
167 result
= FIB_RES_DEV(res
);
169 if (result
&& devref
)
174 EXPORT_SYMBOL(__ip_dev_find
);
176 static void rtmsg_ifa(int event
, struct in_ifaddr
*, struct nlmsghdr
*, u32
);
178 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain
);
179 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
182 static void devinet_sysctl_register(struct in_device
*idev
);
183 static void devinet_sysctl_unregister(struct in_device
*idev
);
185 static void devinet_sysctl_register(struct in_device
*idev
)
188 static void devinet_sysctl_unregister(struct in_device
*idev
)
193 /* Locks all the inet devices. */
195 static struct in_ifaddr
*inet_alloc_ifa(void)
197 return kzalloc(sizeof(struct in_ifaddr
), GFP_KERNEL
);
200 static void inet_rcu_free_ifa(struct rcu_head
*head
)
202 struct in_ifaddr
*ifa
= container_of(head
, struct in_ifaddr
, rcu_head
);
204 in_dev_put(ifa
->ifa_dev
);
208 static void inet_free_ifa(struct in_ifaddr
*ifa
)
210 call_rcu(&ifa
->rcu_head
, inet_rcu_free_ifa
);
213 void in_dev_finish_destroy(struct in_device
*idev
)
215 struct net_device
*dev
= idev
->dev
;
217 WARN_ON(idev
->ifa_list
);
218 WARN_ON(idev
->mc_list
);
219 #ifdef NET_REFCNT_DEBUG
220 pr_debug("%s: %p=%s\n", __func__
, idev
, dev
? dev
->name
: "NIL");
224 pr_err("Freeing alive in_device %p\n", idev
);
228 EXPORT_SYMBOL(in_dev_finish_destroy
);
230 static struct in_device
*inetdev_init(struct net_device
*dev
)
232 struct in_device
*in_dev
;
236 in_dev
= kzalloc(sizeof(*in_dev
), GFP_KERNEL
);
239 memcpy(&in_dev
->cnf
, dev_net(dev
)->ipv4
.devconf_dflt
,
240 sizeof(in_dev
->cnf
));
241 in_dev
->cnf
.sysctl
= NULL
;
243 in_dev
->arp_parms
= neigh_parms_alloc(dev
, &arp_tbl
);
244 if (!in_dev
->arp_parms
)
246 if (IPV4_DEVCONF(in_dev
->cnf
, FORWARDING
))
247 dev_disable_lro(dev
);
248 /* Reference in_dev->dev */
250 /* Account for reference dev->ip_ptr (below) */
253 devinet_sysctl_register(in_dev
);
254 ip_mc_init_dev(in_dev
);
255 if (dev
->flags
& IFF_UP
)
258 /* we can receive as soon as ip_ptr is set -- do this last */
259 rcu_assign_pointer(dev
->ip_ptr
, in_dev
);
268 static void in_dev_rcu_put(struct rcu_head
*head
)
270 struct in_device
*idev
= container_of(head
, struct in_device
, rcu_head
);
274 static void inetdev_destroy(struct in_device
*in_dev
)
276 struct in_ifaddr
*ifa
;
277 struct net_device
*dev
;
285 ip_mc_destroy_dev(in_dev
);
287 while ((ifa
= in_dev
->ifa_list
) != NULL
) {
288 inet_del_ifa(in_dev
, &in_dev
->ifa_list
, 0);
292 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
294 devinet_sysctl_unregister(in_dev
);
295 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
298 call_rcu(&in_dev
->rcu_head
, in_dev_rcu_put
);
301 int inet_addr_onlink(struct in_device
*in_dev
, __be32 a
, __be32 b
)
304 for_primary_ifa(in_dev
) {
305 if (inet_ifa_match(a
, ifa
)) {
306 if (!b
|| inet_ifa_match(b
, ifa
)) {
311 } endfor_ifa(in_dev
);
316 static void __inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
317 int destroy
, struct nlmsghdr
*nlh
, u32 portid
)
319 struct in_ifaddr
*promote
= NULL
;
320 struct in_ifaddr
*ifa
, *ifa1
= *ifap
;
321 struct in_ifaddr
*last_prim
= in_dev
->ifa_list
;
322 struct in_ifaddr
*prev_prom
= NULL
;
323 int do_promote
= IN_DEV_PROMOTE_SECONDARIES(in_dev
);
327 /* 1. Deleting primary ifaddr forces deletion all secondaries
328 * unless alias promotion is set
331 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
)) {
332 struct in_ifaddr
**ifap1
= &ifa1
->ifa_next
;
334 while ((ifa
= *ifap1
) != NULL
) {
335 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) &&
336 ifa1
->ifa_scope
<= ifa
->ifa_scope
)
339 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) ||
340 ifa1
->ifa_mask
!= ifa
->ifa_mask
||
341 !inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
342 ifap1
= &ifa
->ifa_next
;
348 inet_hash_remove(ifa
);
349 *ifap1
= ifa
->ifa_next
;
351 rtmsg_ifa(RTM_DELADDR
, ifa
, nlh
, portid
);
352 blocking_notifier_call_chain(&inetaddr_chain
,
362 /* On promotion all secondaries from subnet are changing
363 * the primary IP, we must remove all their routes silently
364 * and later to add them back with new prefsrc. Do this
365 * while all addresses are on the device list.
367 for (ifa
= promote
; ifa
; ifa
= ifa
->ifa_next
) {
368 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
369 inet_ifa_match(ifa1
->ifa_address
, ifa
))
370 fib_del_ifaddr(ifa
, ifa1
);
375 *ifap
= ifa1
->ifa_next
;
376 inet_hash_remove(ifa1
);
378 /* 3. Announce address deletion */
380 /* Send message first, then call notifier.
381 At first sight, FIB update triggered by notifier
382 will refer to already deleted ifaddr, that could confuse
383 netlink listeners. It is not true: look, gated sees
384 that route deleted and if it still thinks that ifaddr
385 is valid, it will try to restore deleted routes... Grr.
386 So that, this order is correct.
388 rtmsg_ifa(RTM_DELADDR
, ifa1
, nlh
, portid
);
389 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_DOWN
, ifa1
);
392 struct in_ifaddr
*next_sec
= promote
->ifa_next
;
395 prev_prom
->ifa_next
= promote
->ifa_next
;
396 promote
->ifa_next
= last_prim
->ifa_next
;
397 last_prim
->ifa_next
= promote
;
400 promote
->ifa_flags
&= ~IFA_F_SECONDARY
;
401 rtmsg_ifa(RTM_NEWADDR
, promote
, nlh
, portid
);
402 blocking_notifier_call_chain(&inetaddr_chain
,
404 for (ifa
= next_sec
; ifa
; ifa
= ifa
->ifa_next
) {
405 if (ifa1
->ifa_mask
!= ifa
->ifa_mask
||
406 !inet_ifa_match(ifa1
->ifa_address
, ifa
))
416 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
419 __inet_del_ifa(in_dev
, ifap
, destroy
, NULL
, 0);
422 static void check_lifetime(struct work_struct
*work
);
424 static DECLARE_DELAYED_WORK(check_lifetime_work
, check_lifetime
);
426 static int __inet_insert_ifa(struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
429 struct in_device
*in_dev
= ifa
->ifa_dev
;
430 struct in_ifaddr
*ifa1
, **ifap
, **last_primary
;
434 if (!ifa
->ifa_local
) {
439 ifa
->ifa_flags
&= ~IFA_F_SECONDARY
;
440 last_primary
= &in_dev
->ifa_list
;
442 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
443 ifap
= &ifa1
->ifa_next
) {
444 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
) &&
445 ifa
->ifa_scope
<= ifa1
->ifa_scope
)
446 last_primary
= &ifa1
->ifa_next
;
447 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
448 inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
449 if (ifa1
->ifa_local
== ifa
->ifa_local
) {
453 if (ifa1
->ifa_scope
!= ifa
->ifa_scope
) {
457 ifa
->ifa_flags
|= IFA_F_SECONDARY
;
461 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
)) {
462 net_srandom(ifa
->ifa_local
);
466 ifa
->ifa_next
= *ifap
;
469 inet_hash_insert(dev_net(in_dev
->dev
), ifa
);
471 cancel_delayed_work(&check_lifetime_work
);
472 schedule_delayed_work(&check_lifetime_work
, 0);
474 /* Send message first, then call notifier.
475 Notifier will trigger FIB update, so that
476 listeners of netlink will know about new ifaddr */
477 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, portid
);
478 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
483 static int inet_insert_ifa(struct in_ifaddr
*ifa
)
485 return __inet_insert_ifa(ifa
, NULL
, 0);
488 static int inet_set_ifa(struct net_device
*dev
, struct in_ifaddr
*ifa
)
490 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
498 ipv4_devconf_setall(in_dev
);
499 if (ifa
->ifa_dev
!= in_dev
) {
500 WARN_ON(ifa
->ifa_dev
);
502 ifa
->ifa_dev
= in_dev
;
504 if (ipv4_is_loopback(ifa
->ifa_local
))
505 ifa
->ifa_scope
= RT_SCOPE_HOST
;
506 return inet_insert_ifa(ifa
);
509 /* Caller must hold RCU or RTNL :
510 * We dont take a reference on found in_device
512 struct in_device
*inetdev_by_index(struct net
*net
, int ifindex
)
514 struct net_device
*dev
;
515 struct in_device
*in_dev
= NULL
;
518 dev
= dev_get_by_index_rcu(net
, ifindex
);
520 in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
524 EXPORT_SYMBOL(inetdev_by_index
);
526 /* Called only from RTNL semaphored context. No locks. */
528 struct in_ifaddr
*inet_ifa_byprefix(struct in_device
*in_dev
, __be32 prefix
,
533 for_primary_ifa(in_dev
) {
534 if (ifa
->ifa_mask
== mask
&& inet_ifa_match(prefix
, ifa
))
536 } endfor_ifa(in_dev
);
540 static int inet_rtm_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
542 struct net
*net
= sock_net(skb
->sk
);
543 struct nlattr
*tb
[IFA_MAX
+1];
544 struct in_device
*in_dev
;
545 struct ifaddrmsg
*ifm
;
546 struct in_ifaddr
*ifa
, **ifap
;
551 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
555 ifm
= nlmsg_data(nlh
);
556 in_dev
= inetdev_by_index(net
, ifm
->ifa_index
);
557 if (in_dev
== NULL
) {
562 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
563 ifap
= &ifa
->ifa_next
) {
565 ifa
->ifa_local
!= nla_get_be32(tb
[IFA_LOCAL
]))
568 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
571 if (tb
[IFA_ADDRESS
] &&
572 (ifm
->ifa_prefixlen
!= ifa
->ifa_prefixlen
||
573 !inet_ifa_match(nla_get_be32(tb
[IFA_ADDRESS
]), ifa
)))
576 __inet_del_ifa(in_dev
, ifap
, 1, nlh
, NETLINK_CB(skb
).portid
);
580 err
= -EADDRNOTAVAIL
;
585 #define INFINITY_LIFE_TIME 0xFFFFFFFF
587 static void check_lifetime(struct work_struct
*work
)
589 unsigned long now
, next
, next_sec
, next_sched
;
590 struct in_ifaddr
*ifa
;
591 struct hlist_node
*node
;
595 next
= round_jiffies_up(now
+ ADDR_CHECK_FREQUENCY
);
598 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++) {
599 hlist_for_each_entry_rcu(ifa
, node
,
600 &inet_addr_lst
[i
], hash
) {
603 if (ifa
->ifa_flags
& IFA_F_PERMANENT
)
606 /* We try to batch several events at once. */
607 age
= (now
- ifa
->ifa_tstamp
+
608 ADDRCONF_TIMER_FUZZ_MINUS
) / HZ
;
610 if (ifa
->ifa_valid_lft
!= INFINITY_LIFE_TIME
&&
611 age
>= ifa
->ifa_valid_lft
) {
612 struct in_ifaddr
**ifap
;
615 for (ifap
= &ifa
->ifa_dev
->ifa_list
;
616 *ifap
!= NULL
; ifap
= &ifa
->ifa_next
) {
618 inet_del_ifa(ifa
->ifa_dev
,
622 } else if (ifa
->ifa_preferred_lft
==
623 INFINITY_LIFE_TIME
) {
625 } else if (age
>= ifa
->ifa_preferred_lft
) {
626 if (time_before(ifa
->ifa_tstamp
+
627 ifa
->ifa_valid_lft
* HZ
, next
))
628 next
= ifa
->ifa_tstamp
+
629 ifa
->ifa_valid_lft
* HZ
;
631 if (!(ifa
->ifa_flags
& IFA_F_DEPRECATED
)) {
632 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
633 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
635 } else if (time_before(ifa
->ifa_tstamp
+
636 ifa
->ifa_preferred_lft
* HZ
,
638 next
= ifa
->ifa_tstamp
+
639 ifa
->ifa_preferred_lft
* HZ
;
645 next_sec
= round_jiffies_up(next
);
648 /* If rounded timeout is accurate enough, accept it. */
649 if (time_before(next_sec
, next
+ ADDRCONF_TIMER_FUZZ
))
650 next_sched
= next_sec
;
653 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
654 if (time_before(next_sched
, now
+ ADDRCONF_TIMER_FUZZ_MAX
))
655 next_sched
= now
+ ADDRCONF_TIMER_FUZZ_MAX
;
657 schedule_delayed_work(&check_lifetime_work
, next_sched
- now
);
660 static void set_ifa_lifetime(struct in_ifaddr
*ifa
, __u32 valid_lft
,
663 unsigned long timeout
;
665 ifa
->ifa_flags
&= ~(IFA_F_PERMANENT
| IFA_F_DEPRECATED
);
667 timeout
= addrconf_timeout_fixup(valid_lft
, HZ
);
668 if (addrconf_finite_timeout(timeout
))
669 ifa
->ifa_valid_lft
= timeout
;
671 ifa
->ifa_flags
|= IFA_F_PERMANENT
;
673 timeout
= addrconf_timeout_fixup(prefered_lft
, HZ
);
674 if (addrconf_finite_timeout(timeout
)) {
676 ifa
->ifa_flags
|= IFA_F_DEPRECATED
;
677 ifa
->ifa_preferred_lft
= timeout
;
679 ifa
->ifa_tstamp
= jiffies
;
680 if (!ifa
->ifa_cstamp
)
681 ifa
->ifa_cstamp
= ifa
->ifa_tstamp
;
684 static struct in_ifaddr
*rtm_to_ifaddr(struct net
*net
, struct nlmsghdr
*nlh
,
685 __u32
*pvalid_lft
, __u32
*pprefered_lft
)
687 struct nlattr
*tb
[IFA_MAX
+1];
688 struct in_ifaddr
*ifa
;
689 struct ifaddrmsg
*ifm
;
690 struct net_device
*dev
;
691 struct in_device
*in_dev
;
694 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
698 ifm
= nlmsg_data(nlh
);
700 if (ifm
->ifa_prefixlen
> 32 || tb
[IFA_LOCAL
] == NULL
)
703 dev
= __dev_get_by_index(net
, ifm
->ifa_index
);
708 in_dev
= __in_dev_get_rtnl(dev
);
713 ifa
= inet_alloc_ifa();
716 * A potential indev allocation can be left alive, it stays
717 * assigned to its device and is destroy with it.
721 ipv4_devconf_setall(in_dev
);
724 if (tb
[IFA_ADDRESS
] == NULL
)
725 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
727 INIT_HLIST_NODE(&ifa
->hash
);
728 ifa
->ifa_prefixlen
= ifm
->ifa_prefixlen
;
729 ifa
->ifa_mask
= inet_make_mask(ifm
->ifa_prefixlen
);
730 ifa
->ifa_flags
= ifm
->ifa_flags
;
731 ifa
->ifa_scope
= ifm
->ifa_scope
;
732 ifa
->ifa_dev
= in_dev
;
734 ifa
->ifa_local
= nla_get_be32(tb
[IFA_LOCAL
]);
735 ifa
->ifa_address
= nla_get_be32(tb
[IFA_ADDRESS
]);
737 if (tb
[IFA_BROADCAST
])
738 ifa
->ifa_broadcast
= nla_get_be32(tb
[IFA_BROADCAST
]);
741 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
743 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
745 if (tb
[IFA_CACHEINFO
]) {
746 struct ifa_cacheinfo
*ci
;
748 ci
= nla_data(tb
[IFA_CACHEINFO
]);
749 if (!ci
->ifa_valid
|| ci
->ifa_prefered
> ci
->ifa_valid
) {
753 *pvalid_lft
= ci
->ifa_valid
;
754 *pprefered_lft
= ci
->ifa_prefered
;
763 static struct in_ifaddr
*find_matching_ifa(struct in_ifaddr
*ifa
)
765 struct in_device
*in_dev
= ifa
->ifa_dev
;
766 struct in_ifaddr
*ifa1
, **ifap
;
771 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
772 ifap
= &ifa1
->ifa_next
) {
773 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
774 inet_ifa_match(ifa1
->ifa_address
, ifa
) &&
775 ifa1
->ifa_local
== ifa
->ifa_local
)
781 static int inet_rtm_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
783 struct net
*net
= sock_net(skb
->sk
);
784 struct in_ifaddr
*ifa
;
785 struct in_ifaddr
*ifa_existing
;
786 __u32 valid_lft
= INFINITY_LIFE_TIME
;
787 __u32 prefered_lft
= INFINITY_LIFE_TIME
;
791 ifa
= rtm_to_ifaddr(net
, nlh
, &valid_lft
, &prefered_lft
);
795 ifa_existing
= find_matching_ifa(ifa
);
797 /* It would be best to check for !NLM_F_CREATE here but
798 * userspace alreay relies on not having to provide this.
800 set_ifa_lifetime(ifa
, valid_lft
, prefered_lft
);
801 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).portid
);
805 if (nlh
->nlmsg_flags
& NLM_F_EXCL
||
806 !(nlh
->nlmsg_flags
& NLM_F_REPLACE
))
809 set_ifa_lifetime(ifa_existing
, valid_lft
, prefered_lft
);
815 * Determine a default network mask, based on the IP address.
818 static int inet_abc_len(__be32 addr
)
820 int rc
= -1; /* Something else, probably a multicast. */
822 if (ipv4_is_zeronet(addr
))
825 __u32 haddr
= ntohl(addr
);
827 if (IN_CLASSA(haddr
))
829 else if (IN_CLASSB(haddr
))
831 else if (IN_CLASSC(haddr
))
839 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
842 struct sockaddr_in sin_orig
;
843 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
844 struct in_device
*in_dev
;
845 struct in_ifaddr
**ifap
= NULL
;
846 struct in_ifaddr
*ifa
= NULL
;
847 struct net_device
*dev
;
850 int tryaddrmatch
= 0;
853 * Fetch the caller's info block into kernel space
856 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
858 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
860 /* save original address for comparison */
861 memcpy(&sin_orig
, sin
, sizeof(*sin
));
863 colon
= strchr(ifr
.ifr_name
, ':');
867 dev_load(net
, ifr
.ifr_name
);
870 case SIOCGIFADDR
: /* Get interface address */
871 case SIOCGIFBRDADDR
: /* Get the broadcast address */
872 case SIOCGIFDSTADDR
: /* Get the destination address */
873 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
874 /* Note that these ioctls will not sleep,
875 so that we do not impose a lock.
876 One day we will be forced to put shlock here (I mean SMP)
878 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
879 memset(sin
, 0, sizeof(*sin
));
880 sin
->sin_family
= AF_INET
;
885 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
888 case SIOCSIFADDR
: /* Set interface address (and family) */
889 case SIOCSIFBRDADDR
: /* Set the broadcast address */
890 case SIOCSIFDSTADDR
: /* Set the destination address */
891 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
893 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
896 if (sin
->sin_family
!= AF_INET
)
907 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
914 in_dev
= __in_dev_get_rtnl(dev
);
917 /* Matthias Andree */
918 /* compare label and address (4.4BSD style) */
919 /* note: we only do this for a limited set of ioctls
920 and only if the original address family was AF_INET.
921 This is checked above. */
922 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
923 ifap
= &ifa
->ifa_next
) {
924 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
925 sin_orig
.sin_addr
.s_addr
==
931 /* we didn't get a match, maybe the application is
932 4.3BSD-style and passed in junk so we fall back to
933 comparing just the label */
935 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
936 ifap
= &ifa
->ifa_next
)
937 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
942 ret
= -EADDRNOTAVAIL
;
943 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
947 case SIOCGIFADDR
: /* Get interface address */
948 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
951 case SIOCGIFBRDADDR
: /* Get the broadcast address */
952 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
955 case SIOCGIFDSTADDR
: /* Get the destination address */
956 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
959 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
960 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
965 ret
= -EADDRNOTAVAIL
;
969 if (!(ifr
.ifr_flags
& IFF_UP
))
970 inet_del_ifa(in_dev
, ifap
, 1);
973 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
976 case SIOCSIFADDR
: /* Set interface address (and family) */
978 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
983 ifa
= inet_alloc_ifa();
986 INIT_HLIST_NODE(&ifa
->hash
);
988 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
990 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
993 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
995 inet_del_ifa(in_dev
, ifap
, 0);
996 ifa
->ifa_broadcast
= 0;
1000 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
1002 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
1003 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
1004 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
1005 if ((dev
->flags
& IFF_BROADCAST
) &&
1006 ifa
->ifa_prefixlen
< 31)
1007 ifa
->ifa_broadcast
= ifa
->ifa_address
|
1010 ifa
->ifa_prefixlen
= 32;
1011 ifa
->ifa_mask
= inet_make_mask(32);
1013 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
, INFINITY_LIFE_TIME
);
1014 ret
= inet_set_ifa(dev
, ifa
);
1017 case SIOCSIFBRDADDR
: /* Set the broadcast address */
1019 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
1020 inet_del_ifa(in_dev
, ifap
, 0);
1021 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
1022 inet_insert_ifa(ifa
);
1026 case SIOCSIFDSTADDR
: /* Set the destination address */
1028 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
1031 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
1034 inet_del_ifa(in_dev
, ifap
, 0);
1035 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
1036 inet_insert_ifa(ifa
);
1039 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
1042 * The mask we set must be legal.
1045 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
1048 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
1049 __be32 old_mask
= ifa
->ifa_mask
;
1050 inet_del_ifa(in_dev
, ifap
, 0);
1051 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
1052 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
1054 /* See if current broadcast address matches
1055 * with current netmask, then recalculate
1056 * the broadcast address. Otherwise it's a
1057 * funny address, so don't touch it since
1058 * the user seems to know what (s)he's doing...
1060 if ((dev
->flags
& IFF_BROADCAST
) &&
1061 (ifa
->ifa_prefixlen
< 31) &&
1062 (ifa
->ifa_broadcast
==
1063 (ifa
->ifa_local
|~old_mask
))) {
1064 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
1065 ~sin
->sin_addr
.s_addr
);
1067 inet_insert_ifa(ifa
);
1077 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
1081 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
1083 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1084 struct in_ifaddr
*ifa
;
1091 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1093 done
+= sizeof(ifr
);
1096 if (len
< (int) sizeof(ifr
))
1098 memset(&ifr
, 0, sizeof(struct ifreq
));
1100 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
1102 strcpy(ifr
.ifr_name
, dev
->name
);
1104 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
1105 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
1108 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
1112 buf
+= sizeof(struct ifreq
);
1113 len
-= sizeof(struct ifreq
);
1114 done
+= sizeof(struct ifreq
);
1120 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
1123 struct in_device
*in_dev
;
1124 struct net
*net
= dev_net(dev
);
1127 in_dev
= __in_dev_get_rcu(dev
);
1131 for_primary_ifa(in_dev
) {
1132 if (ifa
->ifa_scope
> scope
)
1134 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
1135 addr
= ifa
->ifa_local
;
1139 addr
= ifa
->ifa_local
;
1140 } endfor_ifa(in_dev
);
1146 /* Not loopback addresses on loopback should be preferred
1147 in this case. It is importnat that lo is the first interface
1150 for_each_netdev_rcu(net
, dev
) {
1151 in_dev
= __in_dev_get_rcu(dev
);
1155 for_primary_ifa(in_dev
) {
1156 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1157 ifa
->ifa_scope
<= scope
) {
1158 addr
= ifa
->ifa_local
;
1161 } endfor_ifa(in_dev
);
1167 EXPORT_SYMBOL(inet_select_addr
);
1169 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1170 __be32 local
, int scope
)
1177 (local
== ifa
->ifa_local
|| !local
) &&
1178 ifa
->ifa_scope
<= scope
) {
1179 addr
= ifa
->ifa_local
;
1184 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1185 (!dst
|| inet_ifa_match(dst
, ifa
));
1189 /* Is the selected addr into dst subnet? */
1190 if (inet_ifa_match(addr
, ifa
))
1192 /* No, then can we use new local src? */
1193 if (ifa
->ifa_scope
<= scope
) {
1194 addr
= ifa
->ifa_local
;
1197 /* search for large dst subnet for addr */
1201 } endfor_ifa(in_dev
);
1203 return same
? addr
: 0;
1207 * Confirm that local IP address exists using wildcards:
1208 * - in_dev: only on this interface, 0=any interface
1209 * - dst: only in the same subnet as dst, 0=any dst
1210 * - local: address, 0=autoselect the local address
1211 * - scope: maximum allowed scope value for the local address
1213 __be32
inet_confirm_addr(struct in_device
*in_dev
,
1214 __be32 dst
, __be32 local
, int scope
)
1217 struct net_device
*dev
;
1220 if (scope
!= RT_SCOPE_LINK
)
1221 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1223 net
= dev_net(in_dev
->dev
);
1225 for_each_netdev_rcu(net
, dev
) {
1226 in_dev
= __in_dev_get_rcu(dev
);
1228 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1237 EXPORT_SYMBOL(inet_confirm_addr
);
1243 int register_inetaddr_notifier(struct notifier_block
*nb
)
1245 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1247 EXPORT_SYMBOL(register_inetaddr_notifier
);
1249 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1251 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1253 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1255 /* Rename ifa_labels for a device name change. Make some effort to preserve
1256 * existing alias numbering and to create unique labels if possible.
1258 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1260 struct in_ifaddr
*ifa
;
1263 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1264 char old
[IFNAMSIZ
], *dot
;
1266 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1267 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1270 dot
= strchr(old
, ':');
1272 sprintf(old
, ":%d", named
);
1275 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1276 strcat(ifa
->ifa_label
, dot
);
1278 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1280 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1284 static bool inetdev_valid_mtu(unsigned int mtu
)
1289 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1290 struct in_device
*in_dev
)
1293 struct in_ifaddr
*ifa
;
1295 for (ifa
= in_dev
->ifa_list
; ifa
;
1296 ifa
= ifa
->ifa_next
) {
1297 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1298 ifa
->ifa_local
, dev
,
1299 ifa
->ifa_local
, NULL
,
1300 dev
->dev_addr
, NULL
);
1304 /* Called only under RTNL semaphore */
1306 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1309 struct net_device
*dev
= ptr
;
1310 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1315 if (event
== NETDEV_REGISTER
) {
1316 in_dev
= inetdev_init(dev
);
1318 return notifier_from_errno(-ENOMEM
);
1319 if (dev
->flags
& IFF_LOOPBACK
) {
1320 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1321 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1323 } else if (event
== NETDEV_CHANGEMTU
) {
1324 /* Re-enabling IP */
1325 if (inetdev_valid_mtu(dev
->mtu
))
1326 in_dev
= inetdev_init(dev
);
1332 case NETDEV_REGISTER
:
1333 pr_debug("%s: bug\n", __func__
);
1334 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1337 if (!inetdev_valid_mtu(dev
->mtu
))
1339 if (dev
->flags
& IFF_LOOPBACK
) {
1340 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1343 INIT_HLIST_NODE(&ifa
->hash
);
1345 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1346 ifa
->ifa_prefixlen
= 8;
1347 ifa
->ifa_mask
= inet_make_mask(8);
1348 in_dev_hold(in_dev
);
1349 ifa
->ifa_dev
= in_dev
;
1350 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1351 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1352 set_ifa_lifetime(ifa
, INFINITY_LIFE_TIME
,
1353 INFINITY_LIFE_TIME
);
1354 inet_insert_ifa(ifa
);
1359 case NETDEV_CHANGEADDR
:
1360 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1363 case NETDEV_NOTIFY_PEERS
:
1364 /* Send gratuitous ARP to notify of link change */
1365 inetdev_send_gratuitous_arp(dev
, in_dev
);
1370 case NETDEV_PRE_TYPE_CHANGE
:
1371 ip_mc_unmap(in_dev
);
1373 case NETDEV_POST_TYPE_CHANGE
:
1374 ip_mc_remap(in_dev
);
1376 case NETDEV_CHANGEMTU
:
1377 if (inetdev_valid_mtu(dev
->mtu
))
1379 /* disable IP when MTU is not enough */
1380 case NETDEV_UNREGISTER
:
1381 inetdev_destroy(in_dev
);
1383 case NETDEV_CHANGENAME
:
1384 /* Do not notify about label change, this event is
1385 * not interesting to applications using netlink.
1387 inetdev_changename(dev
, in_dev
);
1389 devinet_sysctl_unregister(in_dev
);
1390 devinet_sysctl_register(in_dev
);
1397 static struct notifier_block ip_netdev_notifier
= {
1398 .notifier_call
= inetdev_event
,
1401 static size_t inet_nlmsg_size(void)
1403 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1404 + nla_total_size(4) /* IFA_ADDRESS */
1405 + nla_total_size(4) /* IFA_LOCAL */
1406 + nla_total_size(4) /* IFA_BROADCAST */
1407 + nla_total_size(IFNAMSIZ
); /* IFA_LABEL */
1410 static inline u32
cstamp_delta(unsigned long cstamp
)
1412 return (cstamp
- INITIAL_JIFFIES
) * 100UL / HZ
;
1415 static int put_cacheinfo(struct sk_buff
*skb
, unsigned long cstamp
,
1416 unsigned long tstamp
, u32 preferred
, u32 valid
)
1418 struct ifa_cacheinfo ci
;
1420 ci
.cstamp
= cstamp_delta(cstamp
);
1421 ci
.tstamp
= cstamp_delta(tstamp
);
1422 ci
.ifa_prefered
= preferred
;
1423 ci
.ifa_valid
= valid
;
1425 return nla_put(skb
, IFA_CACHEINFO
, sizeof(ci
), &ci
);
1428 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1429 u32 portid
, u32 seq
, int event
, unsigned int flags
)
1431 struct ifaddrmsg
*ifm
;
1432 struct nlmsghdr
*nlh
;
1433 u32 preferred
, valid
;
1435 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*ifm
), flags
);
1439 ifm
= nlmsg_data(nlh
);
1440 ifm
->ifa_family
= AF_INET
;
1441 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1442 ifm
->ifa_flags
= ifa
->ifa_flags
;
1443 ifm
->ifa_scope
= ifa
->ifa_scope
;
1444 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1446 if (!(ifm
->ifa_flags
& IFA_F_PERMANENT
)) {
1447 preferred
= ifa
->ifa_preferred_lft
;
1448 valid
= ifa
->ifa_valid_lft
;
1449 if (preferred
!= INFINITY_LIFE_TIME
) {
1450 long tval
= (jiffies
- ifa
->ifa_tstamp
) / HZ
;
1452 if (preferred
> tval
)
1456 if (valid
!= INFINITY_LIFE_TIME
) {
1464 preferred
= INFINITY_LIFE_TIME
;
1465 valid
= INFINITY_LIFE_TIME
;
1467 if ((ifa
->ifa_address
&&
1468 nla_put_be32(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1470 nla_put_be32(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1471 (ifa
->ifa_broadcast
&&
1472 nla_put_be32(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1473 (ifa
->ifa_label
[0] &&
1474 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)) ||
1475 put_cacheinfo(skb
, ifa
->ifa_cstamp
, ifa
->ifa_tstamp
,
1477 goto nla_put_failure
;
1479 return nlmsg_end(skb
, nlh
);
1482 nlmsg_cancel(skb
, nlh
);
1486 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1488 struct net
*net
= sock_net(skb
->sk
);
1491 int ip_idx
, s_ip_idx
;
1492 struct net_device
*dev
;
1493 struct in_device
*in_dev
;
1494 struct in_ifaddr
*ifa
;
1495 struct hlist_head
*head
;
1496 struct hlist_node
*node
;
1499 s_idx
= idx
= cb
->args
[1];
1500 s_ip_idx
= ip_idx
= cb
->args
[2];
1502 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1504 head
= &net
->dev_index_head
[h
];
1506 hlist_for_each_entry_rcu(dev
, node
, head
, index_hlist
) {
1509 if (h
> s_h
|| idx
> s_idx
)
1511 in_dev
= __in_dev_get_rcu(dev
);
1515 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1516 ifa
= ifa
->ifa_next
, ip_idx
++) {
1517 if (ip_idx
< s_ip_idx
)
1519 if (inet_fill_ifaddr(skb
, ifa
,
1520 NETLINK_CB(cb
->skb
).portid
,
1522 RTM_NEWADDR
, NLM_F_MULTI
) <= 0) {
1536 cb
->args
[2] = ip_idx
;
1541 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1544 struct sk_buff
*skb
;
1545 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1549 net
= dev_net(ifa
->ifa_dev
->dev
);
1550 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1554 err
= inet_fill_ifaddr(skb
, ifa
, portid
, seq
, event
, 0);
1556 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1557 WARN_ON(err
== -EMSGSIZE
);
1561 rtnl_notify(skb
, net
, portid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1565 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1568 static size_t inet_get_link_af_size(const struct net_device
*dev
)
1570 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1575 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1578 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
)
1580 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1587 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1591 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1592 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1597 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1598 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1601 static int inet_validate_link_af(const struct net_device
*dev
,
1602 const struct nlattr
*nla
)
1604 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1607 if (dev
&& !__in_dev_get_rtnl(dev
))
1608 return -EAFNOSUPPORT
;
1610 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
);
1614 if (tb
[IFLA_INET_CONF
]) {
1615 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1616 int cfgid
= nla_type(a
);
1621 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1629 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1631 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1632 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1636 return -EAFNOSUPPORT
;
1638 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
) < 0)
1641 if (tb
[IFLA_INET_CONF
]) {
1642 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1643 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1649 static int inet_netconf_msgsize_devconf(int type
)
1651 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1652 + nla_total_size(4); /* NETCONFA_IFINDEX */
1654 /* type -1 is used for ALL */
1655 if (type
== -1 || type
== NETCONFA_FORWARDING
)
1656 size
+= nla_total_size(4);
1657 if (type
== -1 || type
== NETCONFA_RP_FILTER
)
1658 size
+= nla_total_size(4);
1659 if (type
== -1 || type
== NETCONFA_MC_FORWARDING
)
1660 size
+= nla_total_size(4);
1665 static int inet_netconf_fill_devconf(struct sk_buff
*skb
, int ifindex
,
1666 struct ipv4_devconf
*devconf
, u32 portid
,
1667 u32 seq
, int event
, unsigned int flags
,
1670 struct nlmsghdr
*nlh
;
1671 struct netconfmsg
*ncm
;
1673 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1678 ncm
= nlmsg_data(nlh
);
1679 ncm
->ncm_family
= AF_INET
;
1681 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, ifindex
) < 0)
1682 goto nla_put_failure
;
1684 /* type -1 is used for ALL */
1685 if ((type
== -1 || type
== NETCONFA_FORWARDING
) &&
1686 nla_put_s32(skb
, NETCONFA_FORWARDING
,
1687 IPV4_DEVCONF(*devconf
, FORWARDING
)) < 0)
1688 goto nla_put_failure
;
1689 if ((type
== -1 || type
== NETCONFA_RP_FILTER
) &&
1690 nla_put_s32(skb
, NETCONFA_RP_FILTER
,
1691 IPV4_DEVCONF(*devconf
, RP_FILTER
)) < 0)
1692 goto nla_put_failure
;
1693 if ((type
== -1 || type
== NETCONFA_MC_FORWARDING
) &&
1694 nla_put_s32(skb
, NETCONFA_MC_FORWARDING
,
1695 IPV4_DEVCONF(*devconf
, MC_FORWARDING
)) < 0)
1696 goto nla_put_failure
;
1698 return nlmsg_end(skb
, nlh
);
1701 nlmsg_cancel(skb
, nlh
);
1705 void inet_netconf_notify_devconf(struct net
*net
, int type
, int ifindex
,
1706 struct ipv4_devconf
*devconf
)
1708 struct sk_buff
*skb
;
1711 skb
= nlmsg_new(inet_netconf_msgsize_devconf(type
), GFP_ATOMIC
);
1715 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
, 0, 0,
1716 RTM_NEWNETCONF
, 0, type
);
1718 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1719 WARN_ON(err
== -EMSGSIZE
);
1723 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_NETCONF
, NULL
, GFP_ATOMIC
);
1727 rtnl_set_sk_err(net
, RTNLGRP_IPV4_NETCONF
, err
);
1730 static const struct nla_policy devconf_ipv4_policy
[NETCONFA_MAX
+1] = {
1731 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1732 [NETCONFA_FORWARDING
] = { .len
= sizeof(int) },
1733 [NETCONFA_RP_FILTER
] = { .len
= sizeof(int) },
1736 static int inet_netconf_get_devconf(struct sk_buff
*in_skb
,
1737 struct nlmsghdr
*nlh
,
1740 struct net
*net
= sock_net(in_skb
->sk
);
1741 struct nlattr
*tb
[NETCONFA_MAX
+1];
1742 struct netconfmsg
*ncm
;
1743 struct sk_buff
*skb
;
1744 struct ipv4_devconf
*devconf
;
1745 struct in_device
*in_dev
;
1746 struct net_device
*dev
;
1750 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1751 devconf_ipv4_policy
);
1756 if (!tb
[NETCONFA_IFINDEX
])
1759 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1761 case NETCONFA_IFINDEX_ALL
:
1762 devconf
= net
->ipv4
.devconf_all
;
1764 case NETCONFA_IFINDEX_DEFAULT
:
1765 devconf
= net
->ipv4
.devconf_dflt
;
1768 dev
= __dev_get_by_index(net
, ifindex
);
1771 in_dev
= __in_dev_get_rtnl(dev
);
1774 devconf
= &in_dev
->cnf
;
1779 skb
= nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC
);
1783 err
= inet_netconf_fill_devconf(skb
, ifindex
, devconf
,
1784 NETLINK_CB(in_skb
).portid
,
1785 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1788 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1789 WARN_ON(err
== -EMSGSIZE
);
1793 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1798 #ifdef CONFIG_SYSCTL
1800 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
1802 struct net_device
*dev
;
1805 for_each_netdev_rcu(net
, dev
) {
1806 struct in_device
*in_dev
;
1808 in_dev
= __in_dev_get_rcu(dev
);
1809 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
1810 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
1815 /* called with RTNL locked */
1816 static void inet_forward_change(struct net
*net
)
1818 struct net_device
*dev
;
1819 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
1821 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
1822 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
1823 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1824 NETCONFA_IFINDEX_ALL
,
1825 net
->ipv4
.devconf_all
);
1826 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1827 NETCONFA_IFINDEX_DEFAULT
,
1828 net
->ipv4
.devconf_dflt
);
1830 for_each_netdev(net
, dev
) {
1831 struct in_device
*in_dev
;
1833 dev_disable_lro(dev
);
1835 in_dev
= __in_dev_get_rcu(dev
);
1837 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
1838 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1839 dev
->ifindex
, &in_dev
->cnf
);
1845 static int devinet_conf_proc(ctl_table
*ctl
, int write
,
1846 void __user
*buffer
,
1847 size_t *lenp
, loff_t
*ppos
)
1849 int old_value
= *(int *)ctl
->data
;
1850 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1851 int new_value
= *(int *)ctl
->data
;
1854 struct ipv4_devconf
*cnf
= ctl
->extra1
;
1855 struct net
*net
= ctl
->extra2
;
1856 int i
= (int *)ctl
->data
- cnf
->data
;
1858 set_bit(i
, cnf
->state
);
1860 if (cnf
== net
->ipv4
.devconf_dflt
)
1861 devinet_copy_dflt_conf(net
, i
);
1862 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1 ||
1863 i
== IPV4_DEVCONF_ROUTE_LOCALNET
- 1)
1864 if ((new_value
== 0) && (old_value
!= 0))
1865 rt_cache_flush(net
);
1866 if (i
== IPV4_DEVCONF_RP_FILTER
- 1 &&
1867 new_value
!= old_value
) {
1870 if (cnf
== net
->ipv4
.devconf_dflt
)
1871 ifindex
= NETCONFA_IFINDEX_DEFAULT
;
1872 else if (cnf
== net
->ipv4
.devconf_all
)
1873 ifindex
= NETCONFA_IFINDEX_ALL
;
1875 struct in_device
*idev
=
1876 container_of(cnf
, struct in_device
,
1878 ifindex
= idev
->dev
->ifindex
;
1880 inet_netconf_notify_devconf(net
, NETCONFA_RP_FILTER
,
1888 static int devinet_sysctl_forward(ctl_table
*ctl
, int write
,
1889 void __user
*buffer
,
1890 size_t *lenp
, loff_t
*ppos
)
1892 int *valp
= ctl
->data
;
1895 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1897 if (write
&& *valp
!= val
) {
1898 struct net
*net
= ctl
->extra2
;
1900 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
1901 if (!rtnl_trylock()) {
1902 /* Restore the original values before restarting */
1905 return restart_syscall();
1907 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
1908 inet_forward_change(net
);
1910 struct ipv4_devconf
*cnf
= ctl
->extra1
;
1911 struct in_device
*idev
=
1912 container_of(cnf
, struct in_device
, cnf
);
1914 dev_disable_lro(idev
->dev
);
1915 inet_netconf_notify_devconf(net
,
1916 NETCONFA_FORWARDING
,
1921 rt_cache_flush(net
);
1923 inet_netconf_notify_devconf(net
, NETCONFA_FORWARDING
,
1924 NETCONFA_IFINDEX_DEFAULT
,
1925 net
->ipv4
.devconf_dflt
);
1931 static int ipv4_doint_and_flush(ctl_table
*ctl
, int write
,
1932 void __user
*buffer
,
1933 size_t *lenp
, loff_t
*ppos
)
1935 int *valp
= ctl
->data
;
1937 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1938 struct net
*net
= ctl
->extra2
;
1940 if (write
&& *valp
!= val
)
1941 rt_cache_flush(net
);
1946 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
1949 .data = ipv4_devconf.data + \
1950 IPV4_DEVCONF_ ## attr - 1, \
1951 .maxlen = sizeof(int), \
1953 .proc_handler = proc, \
1954 .extra1 = &ipv4_devconf, \
1957 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1958 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
1960 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1961 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
1963 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1964 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
1966 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1967 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
1969 static struct devinet_sysctl_table
{
1970 struct ctl_table_header
*sysctl_header
;
1971 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
1972 } devinet_sysctl
= {
1974 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
1975 devinet_sysctl_forward
),
1976 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
1978 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
1979 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
1980 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
1981 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
1982 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
1983 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
1984 "accept_source_route"),
1985 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
1986 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
1987 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
1988 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
1989 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
1990 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
1991 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
1992 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
1993 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
1994 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
1995 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
1996 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
1997 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
1999 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
2000 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
2001 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION
,
2002 "force_igmp_version"),
2003 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
2004 "promote_secondaries"),
2005 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET
,
2010 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
2011 struct ipv4_devconf
*p
)
2014 struct devinet_sysctl_table
*t
;
2015 char path
[sizeof("net/ipv4/conf/") + IFNAMSIZ
];
2017 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
2021 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
2022 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
2023 t
->devinet_vars
[i
].extra1
= p
;
2024 t
->devinet_vars
[i
].extra2
= net
;
2027 snprintf(path
, sizeof(path
), "net/ipv4/conf/%s", dev_name
);
2029 t
->sysctl_header
= register_net_sysctl(net
, path
, t
->devinet_vars
);
2030 if (!t
->sysctl_header
)
2042 static void __devinet_sysctl_unregister(struct ipv4_devconf
*cnf
)
2044 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
2050 unregister_net_sysctl_table(t
->sysctl_header
);
2054 static void devinet_sysctl_register(struct in_device
*idev
)
2056 neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, "ipv4", NULL
);
2057 __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
2061 static void devinet_sysctl_unregister(struct in_device
*idev
)
2063 __devinet_sysctl_unregister(&idev
->cnf
);
2064 neigh_sysctl_unregister(idev
->arp_parms
);
2067 static struct ctl_table ctl_forward_entry
[] = {
2069 .procname
= "ip_forward",
2070 .data
= &ipv4_devconf
.data
[
2071 IPV4_DEVCONF_FORWARDING
- 1],
2072 .maxlen
= sizeof(int),
2074 .proc_handler
= devinet_sysctl_forward
,
2075 .extra1
= &ipv4_devconf
,
2076 .extra2
= &init_net
,
2082 static __net_init
int devinet_init_net(struct net
*net
)
2085 struct ipv4_devconf
*all
, *dflt
;
2086 #ifdef CONFIG_SYSCTL
2087 struct ctl_table
*tbl
= ctl_forward_entry
;
2088 struct ctl_table_header
*forw_hdr
;
2092 all
= &ipv4_devconf
;
2093 dflt
= &ipv4_devconf_dflt
;
2095 if (!net_eq(net
, &init_net
)) {
2096 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
2100 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
2102 goto err_alloc_dflt
;
2104 #ifdef CONFIG_SYSCTL
2105 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
2109 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
2110 tbl
[0].extra1
= all
;
2111 tbl
[0].extra2
= net
;
2115 #ifdef CONFIG_SYSCTL
2116 err
= __devinet_sysctl_register(net
, "all", all
);
2120 err
= __devinet_sysctl_register(net
, "default", dflt
);
2125 forw_hdr
= register_net_sysctl(net
, "net/ipv4", tbl
);
2126 if (forw_hdr
== NULL
)
2128 net
->ipv4
.forw_hdr
= forw_hdr
;
2131 net
->ipv4
.devconf_all
= all
;
2132 net
->ipv4
.devconf_dflt
= dflt
;
2135 #ifdef CONFIG_SYSCTL
2137 __devinet_sysctl_unregister(dflt
);
2139 __devinet_sysctl_unregister(all
);
2141 if (tbl
!= ctl_forward_entry
)
2145 if (dflt
!= &ipv4_devconf_dflt
)
2148 if (all
!= &ipv4_devconf
)
2154 static __net_exit
void devinet_exit_net(struct net
*net
)
2156 #ifdef CONFIG_SYSCTL
2157 struct ctl_table
*tbl
;
2159 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
2160 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
2161 __devinet_sysctl_unregister(net
->ipv4
.devconf_dflt
);
2162 __devinet_sysctl_unregister(net
->ipv4
.devconf_all
);
2165 kfree(net
->ipv4
.devconf_dflt
);
2166 kfree(net
->ipv4
.devconf_all
);
2169 static __net_initdata
struct pernet_operations devinet_ops
= {
2170 .init
= devinet_init_net
,
2171 .exit
= devinet_exit_net
,
2174 static struct rtnl_af_ops inet_af_ops
= {
2176 .fill_link_af
= inet_fill_link_af
,
2177 .get_link_af_size
= inet_get_link_af_size
,
2178 .validate_link_af
= inet_validate_link_af
,
2179 .set_link_af
= inet_set_link_af
,
2182 void __init
devinet_init(void)
2186 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
2187 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
2189 register_pernet_subsys(&devinet_ops
);
2191 register_gifconf(PF_INET
, inet_gifconf
);
2192 register_netdevice_notifier(&ip_netdev_notifier
);
2194 schedule_delayed_work(&check_lifetime_work
, 0);
2196 rtnl_af_register(&inet_af_ops
);
2198 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, NULL
);
2199 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, NULL
);
2200 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, NULL
);
2201 rtnl_register(PF_INET
, RTM_GETNETCONF
, inet_netconf_get_devconf
,