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 <asm/system.h>
31 #include <linux/bitops.h>
32 #include <linux/capability.h>
33 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/kernel.h>
36 #include <linux/string.h>
38 #include <linux/socket.h>
39 #include <linux/sockios.h>
41 #include <linux/errno.h>
42 #include <linux/interrupt.h>
43 #include <linux/if_addr.h>
44 #include <linux/if_ether.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/skbuff.h>
49 #include <linux/init.h>
50 #include <linux/notifier.h>
51 #include <linux/inetdevice.h>
52 #include <linux/igmp.h>
53 #include <linux/slab.h>
54 #include <linux/hash.h>
56 #include <linux/sysctl.h>
58 #include <linux/kmod.h>
62 #include <net/route.h>
63 #include <net/ip_fib.h>
64 #include <net/rtnetlink.h>
65 #include <net/net_namespace.h>
67 #include "fib_lookup.h"
69 static struct ipv4_devconf ipv4_devconf
= {
71 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
72 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
73 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
74 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
78 static struct ipv4_devconf ipv4_devconf_dflt
= {
80 [IPV4_DEVCONF_ACCEPT_REDIRECTS
- 1] = 1,
81 [IPV4_DEVCONF_SEND_REDIRECTS
- 1] = 1,
82 [IPV4_DEVCONF_SECURE_REDIRECTS
- 1] = 1,
83 [IPV4_DEVCONF_SHARED_MEDIA
- 1] = 1,
84 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE
- 1] = 1,
88 #define IPV4_DEVCONF_DFLT(net, attr) \
89 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
91 static const struct nla_policy ifa_ipv4_policy
[IFA_MAX
+1] = {
92 [IFA_LOCAL
] = { .type
= NLA_U32
},
93 [IFA_ADDRESS
] = { .type
= NLA_U32
},
94 [IFA_BROADCAST
] = { .type
= NLA_U32
},
95 [IFA_LABEL
] = { .type
= NLA_STRING
, .len
= IFNAMSIZ
- 1 },
98 /* inet_addr_hash's shifting is dependent upon this IN4_ADDR_HSIZE
99 * value. So if you change this define, make appropriate changes to
100 * inet_addr_hash as well.
102 #define IN4_ADDR_HSIZE 256
103 static struct hlist_head inet_addr_lst
[IN4_ADDR_HSIZE
];
104 static DEFINE_SPINLOCK(inet_addr_hash_lock
);
106 static inline unsigned int inet_addr_hash(struct net
*net
, __be32 addr
)
108 u32 val
= (__force u32
) addr
^ hash_ptr(net
, 8);
110 return ((val
^ (val
>> 8) ^ (val
>> 16) ^ (val
>> 24)) &
111 (IN4_ADDR_HSIZE
- 1));
114 static void inet_hash_insert(struct net
*net
, struct in_ifaddr
*ifa
)
116 unsigned int hash
= inet_addr_hash(net
, ifa
->ifa_local
);
118 spin_lock(&inet_addr_hash_lock
);
119 hlist_add_head_rcu(&ifa
->hash
, &inet_addr_lst
[hash
]);
120 spin_unlock(&inet_addr_hash_lock
);
123 static void inet_hash_remove(struct in_ifaddr
*ifa
)
125 spin_lock(&inet_addr_hash_lock
);
126 hlist_del_init_rcu(&ifa
->hash
);
127 spin_unlock(&inet_addr_hash_lock
);
131 * __ip_dev_find - find the first device with a given source address.
132 * @net: the net namespace
133 * @addr: the source address
134 * @devref: if true, take a reference on the found device
136 * If a caller uses devref=false, it should be protected by RCU, or RTNL
138 struct net_device
*__ip_dev_find(struct net
*net
, __be32 addr
, bool devref
)
140 unsigned int hash
= inet_addr_hash(net
, addr
);
141 struct net_device
*result
= NULL
;
142 struct in_ifaddr
*ifa
;
143 struct hlist_node
*node
;
146 hlist_for_each_entry_rcu(ifa
, node
, &inet_addr_lst
[hash
], hash
) {
147 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
149 if (!net_eq(dev_net(dev
), net
))
151 if (ifa
->ifa_local
== addr
) {
157 struct flowi4 fl4
= { .daddr
= addr
};
158 struct fib_result res
= { 0 };
159 struct fib_table
*local
;
161 /* Fallback to FIB local table so that communication
162 * over loopback subnets work.
164 local
= fib_get_table(net
, RT_TABLE_LOCAL
);
166 !fib_table_lookup(local
, &fl4
, &res
, FIB_LOOKUP_NOREF
) &&
167 res
.type
== RTN_LOCAL
)
168 result
= FIB_RES_DEV(res
);
170 if (result
&& devref
)
175 EXPORT_SYMBOL(__ip_dev_find
);
177 static void rtmsg_ifa(int event
, struct in_ifaddr
*, struct nlmsghdr
*, u32
);
179 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain
);
180 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
183 static void devinet_sysctl_register(struct in_device
*idev
);
184 static void devinet_sysctl_unregister(struct in_device
*idev
);
186 static inline void devinet_sysctl_register(struct in_device
*idev
)
189 static inline void devinet_sysctl_unregister(struct in_device
*idev
)
194 /* Locks all the inet devices. */
196 static struct in_ifaddr
*inet_alloc_ifa(void)
198 return kzalloc(sizeof(struct in_ifaddr
), GFP_KERNEL
);
201 static void inet_rcu_free_ifa(struct rcu_head
*head
)
203 struct in_ifaddr
*ifa
= container_of(head
, struct in_ifaddr
, rcu_head
);
205 in_dev_put(ifa
->ifa_dev
);
209 static inline void inet_free_ifa(struct in_ifaddr
*ifa
)
211 call_rcu(&ifa
->rcu_head
, inet_rcu_free_ifa
);
214 void in_dev_finish_destroy(struct in_device
*idev
)
216 struct net_device
*dev
= idev
->dev
;
218 WARN_ON(idev
->ifa_list
);
219 WARN_ON(idev
->mc_list
);
220 #ifdef NET_REFCNT_DEBUG
221 printk(KERN_DEBUG
"in_dev_finish_destroy: %p=%s\n",
222 idev
, dev
? dev
->name
: "NIL");
226 pr_err("Freeing alive in_device %p\n", idev
);
230 EXPORT_SYMBOL(in_dev_finish_destroy
);
232 static struct in_device
*inetdev_init(struct net_device
*dev
)
234 struct in_device
*in_dev
;
238 in_dev
= kzalloc(sizeof(*in_dev
), GFP_KERNEL
);
241 memcpy(&in_dev
->cnf
, dev_net(dev
)->ipv4
.devconf_dflt
,
242 sizeof(in_dev
->cnf
));
243 in_dev
->cnf
.sysctl
= NULL
;
245 in_dev
->arp_parms
= neigh_parms_alloc(dev
, &arp_tbl
);
246 if (!in_dev
->arp_parms
)
248 if (IPV4_DEVCONF(in_dev
->cnf
, FORWARDING
))
249 dev_disable_lro(dev
);
250 /* Reference in_dev->dev */
252 /* Account for reference dev->ip_ptr (below) */
255 devinet_sysctl_register(in_dev
);
256 ip_mc_init_dev(in_dev
);
257 if (dev
->flags
& IFF_UP
)
260 /* we can receive as soon as ip_ptr is set -- do this last */
261 rcu_assign_pointer(dev
->ip_ptr
, in_dev
);
270 static void in_dev_rcu_put(struct rcu_head
*head
)
272 struct in_device
*idev
= container_of(head
, struct in_device
, rcu_head
);
276 static void inetdev_destroy(struct in_device
*in_dev
)
278 struct in_ifaddr
*ifa
;
279 struct net_device
*dev
;
287 ip_mc_destroy_dev(in_dev
);
289 while ((ifa
= in_dev
->ifa_list
) != NULL
) {
290 inet_del_ifa(in_dev
, &in_dev
->ifa_list
, 0);
294 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
296 devinet_sysctl_unregister(in_dev
);
297 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
300 call_rcu(&in_dev
->rcu_head
, in_dev_rcu_put
);
303 int inet_addr_onlink(struct in_device
*in_dev
, __be32 a
, __be32 b
)
306 for_primary_ifa(in_dev
) {
307 if (inet_ifa_match(a
, ifa
)) {
308 if (!b
|| inet_ifa_match(b
, ifa
)) {
313 } endfor_ifa(in_dev
);
318 static void __inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
319 int destroy
, struct nlmsghdr
*nlh
, u32 pid
)
321 struct in_ifaddr
*promote
= NULL
;
322 struct in_ifaddr
*ifa
, *ifa1
= *ifap
;
323 struct in_ifaddr
*last_prim
= in_dev
->ifa_list
;
324 struct in_ifaddr
*prev_prom
= NULL
;
325 int do_promote
= IN_DEV_PROMOTE_SECONDARIES(in_dev
);
329 /* 1. Deleting primary ifaddr forces deletion all secondaries
330 * unless alias promotion is set
333 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
)) {
334 struct in_ifaddr
**ifap1
= &ifa1
->ifa_next
;
336 while ((ifa
= *ifap1
) != NULL
) {
337 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) &&
338 ifa1
->ifa_scope
<= ifa
->ifa_scope
)
341 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
) ||
342 ifa1
->ifa_mask
!= ifa
->ifa_mask
||
343 !inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
344 ifap1
= &ifa
->ifa_next
;
350 inet_hash_remove(ifa
);
351 *ifap1
= ifa
->ifa_next
;
353 rtmsg_ifa(RTM_DELADDR
, ifa
, nlh
, pid
);
354 blocking_notifier_call_chain(&inetaddr_chain
,
364 /* On promotion all secondaries from subnet are changing
365 * the primary IP, we must remove all their routes silently
366 * and later to add them back with new prefsrc. Do this
367 * while all addresses are on the device list.
369 for (ifa
= promote
; ifa
; ifa
= ifa
->ifa_next
) {
370 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
371 inet_ifa_match(ifa1
->ifa_address
, ifa
))
372 fib_del_ifaddr(ifa
, ifa1
);
377 *ifap
= ifa1
->ifa_next
;
378 inet_hash_remove(ifa1
);
380 /* 3. Announce address deletion */
382 /* Send message first, then call notifier.
383 At first sight, FIB update triggered by notifier
384 will refer to already deleted ifaddr, that could confuse
385 netlink listeners. It is not true: look, gated sees
386 that route deleted and if it still thinks that ifaddr
387 is valid, it will try to restore deleted routes... Grr.
388 So that, this order is correct.
390 rtmsg_ifa(RTM_DELADDR
, ifa1
, nlh
, pid
);
391 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_DOWN
, ifa1
);
394 struct in_ifaddr
*next_sec
= promote
->ifa_next
;
397 prev_prom
->ifa_next
= promote
->ifa_next
;
398 promote
->ifa_next
= last_prim
->ifa_next
;
399 last_prim
->ifa_next
= promote
;
402 promote
->ifa_flags
&= ~IFA_F_SECONDARY
;
403 rtmsg_ifa(RTM_NEWADDR
, promote
, nlh
, pid
);
404 blocking_notifier_call_chain(&inetaddr_chain
,
406 for (ifa
= next_sec
; ifa
; ifa
= ifa
->ifa_next
) {
407 if (ifa1
->ifa_mask
!= ifa
->ifa_mask
||
408 !inet_ifa_match(ifa1
->ifa_address
, ifa
))
418 static void inet_del_ifa(struct in_device
*in_dev
, struct in_ifaddr
**ifap
,
421 __inet_del_ifa(in_dev
, ifap
, destroy
, NULL
, 0);
424 static int __inet_insert_ifa(struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
427 struct in_device
*in_dev
= ifa
->ifa_dev
;
428 struct in_ifaddr
*ifa1
, **ifap
, **last_primary
;
432 if (!ifa
->ifa_local
) {
437 ifa
->ifa_flags
&= ~IFA_F_SECONDARY
;
438 last_primary
= &in_dev
->ifa_list
;
440 for (ifap
= &in_dev
->ifa_list
; (ifa1
= *ifap
) != NULL
;
441 ifap
= &ifa1
->ifa_next
) {
442 if (!(ifa1
->ifa_flags
& IFA_F_SECONDARY
) &&
443 ifa
->ifa_scope
<= ifa1
->ifa_scope
)
444 last_primary
= &ifa1
->ifa_next
;
445 if (ifa1
->ifa_mask
== ifa
->ifa_mask
&&
446 inet_ifa_match(ifa1
->ifa_address
, ifa
)) {
447 if (ifa1
->ifa_local
== ifa
->ifa_local
) {
451 if (ifa1
->ifa_scope
!= ifa
->ifa_scope
) {
455 ifa
->ifa_flags
|= IFA_F_SECONDARY
;
459 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
)) {
460 net_srandom(ifa
->ifa_local
);
464 ifa
->ifa_next
= *ifap
;
467 inet_hash_insert(dev_net(in_dev
->dev
), ifa
);
469 /* Send message first, then call notifier.
470 Notifier will trigger FIB update, so that
471 listeners of netlink will know about new ifaddr */
472 rtmsg_ifa(RTM_NEWADDR
, ifa
, nlh
, pid
);
473 blocking_notifier_call_chain(&inetaddr_chain
, NETDEV_UP
, ifa
);
478 static int inet_insert_ifa(struct in_ifaddr
*ifa
)
480 return __inet_insert_ifa(ifa
, NULL
, 0);
483 static int inet_set_ifa(struct net_device
*dev
, struct in_ifaddr
*ifa
)
485 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
493 ipv4_devconf_setall(in_dev
);
494 if (ifa
->ifa_dev
!= in_dev
) {
495 WARN_ON(ifa
->ifa_dev
);
497 ifa
->ifa_dev
= in_dev
;
499 if (ipv4_is_loopback(ifa
->ifa_local
))
500 ifa
->ifa_scope
= RT_SCOPE_HOST
;
501 return inet_insert_ifa(ifa
);
504 /* Caller must hold RCU or RTNL :
505 * We dont take a reference on found in_device
507 struct in_device
*inetdev_by_index(struct net
*net
, int ifindex
)
509 struct net_device
*dev
;
510 struct in_device
*in_dev
= NULL
;
513 dev
= dev_get_by_index_rcu(net
, ifindex
);
515 in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
519 EXPORT_SYMBOL(inetdev_by_index
);
521 /* Called only from RTNL semaphored context. No locks. */
523 struct in_ifaddr
*inet_ifa_byprefix(struct in_device
*in_dev
, __be32 prefix
,
528 for_primary_ifa(in_dev
) {
529 if (ifa
->ifa_mask
== mask
&& inet_ifa_match(prefix
, ifa
))
531 } endfor_ifa(in_dev
);
535 static int inet_rtm_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
537 struct net
*net
= sock_net(skb
->sk
);
538 struct nlattr
*tb
[IFA_MAX
+1];
539 struct in_device
*in_dev
;
540 struct ifaddrmsg
*ifm
;
541 struct in_ifaddr
*ifa
, **ifap
;
546 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
550 ifm
= nlmsg_data(nlh
);
551 in_dev
= inetdev_by_index(net
, ifm
->ifa_index
);
552 if (in_dev
== NULL
) {
557 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
558 ifap
= &ifa
->ifa_next
) {
560 ifa
->ifa_local
!= nla_get_be32(tb
[IFA_LOCAL
]))
563 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
566 if (tb
[IFA_ADDRESS
] &&
567 (ifm
->ifa_prefixlen
!= ifa
->ifa_prefixlen
||
568 !inet_ifa_match(nla_get_be32(tb
[IFA_ADDRESS
]), ifa
)))
571 __inet_del_ifa(in_dev
, ifap
, 1, nlh
, NETLINK_CB(skb
).pid
);
575 err
= -EADDRNOTAVAIL
;
580 static struct in_ifaddr
*rtm_to_ifaddr(struct net
*net
, struct nlmsghdr
*nlh
)
582 struct nlattr
*tb
[IFA_MAX
+1];
583 struct in_ifaddr
*ifa
;
584 struct ifaddrmsg
*ifm
;
585 struct net_device
*dev
;
586 struct in_device
*in_dev
;
589 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, ifa_ipv4_policy
);
593 ifm
= nlmsg_data(nlh
);
595 if (ifm
->ifa_prefixlen
> 32 || tb
[IFA_LOCAL
] == NULL
)
598 dev
= __dev_get_by_index(net
, ifm
->ifa_index
);
603 in_dev
= __in_dev_get_rtnl(dev
);
608 ifa
= inet_alloc_ifa();
611 * A potential indev allocation can be left alive, it stays
612 * assigned to its device and is destroy with it.
616 ipv4_devconf_setall(in_dev
);
619 if (tb
[IFA_ADDRESS
] == NULL
)
620 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
622 INIT_HLIST_NODE(&ifa
->hash
);
623 ifa
->ifa_prefixlen
= ifm
->ifa_prefixlen
;
624 ifa
->ifa_mask
= inet_make_mask(ifm
->ifa_prefixlen
);
625 ifa
->ifa_flags
= ifm
->ifa_flags
;
626 ifa
->ifa_scope
= ifm
->ifa_scope
;
627 ifa
->ifa_dev
= in_dev
;
629 ifa
->ifa_local
= nla_get_be32(tb
[IFA_LOCAL
]);
630 ifa
->ifa_address
= nla_get_be32(tb
[IFA_ADDRESS
]);
632 if (tb
[IFA_BROADCAST
])
633 ifa
->ifa_broadcast
= nla_get_be32(tb
[IFA_BROADCAST
]);
636 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
638 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
646 static int inet_rtm_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
648 struct net
*net
= sock_net(skb
->sk
);
649 struct in_ifaddr
*ifa
;
653 ifa
= rtm_to_ifaddr(net
, nlh
);
657 return __inet_insert_ifa(ifa
, nlh
, NETLINK_CB(skb
).pid
);
661 * Determine a default network mask, based on the IP address.
664 static inline int inet_abc_len(__be32 addr
)
666 int rc
= -1; /* Something else, probably a multicast. */
668 if (ipv4_is_zeronet(addr
))
671 __u32 haddr
= ntohl(addr
);
673 if (IN_CLASSA(haddr
))
675 else if (IN_CLASSB(haddr
))
677 else if (IN_CLASSC(haddr
))
685 int devinet_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
688 struct sockaddr_in sin_orig
;
689 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&ifr
.ifr_addr
;
690 struct in_device
*in_dev
;
691 struct in_ifaddr
**ifap
= NULL
;
692 struct in_ifaddr
*ifa
= NULL
;
693 struct net_device
*dev
;
696 int tryaddrmatch
= 0;
699 * Fetch the caller's info block into kernel space
702 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
704 ifr
.ifr_name
[IFNAMSIZ
- 1] = 0;
706 /* save original address for comparison */
707 memcpy(&sin_orig
, sin
, sizeof(*sin
));
709 colon
= strchr(ifr
.ifr_name
, ':');
713 dev_load(net
, ifr
.ifr_name
);
716 case SIOCGIFADDR
: /* Get interface address */
717 case SIOCGIFBRDADDR
: /* Get the broadcast address */
718 case SIOCGIFDSTADDR
: /* Get the destination address */
719 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
720 /* Note that these ioctls will not sleep,
721 so that we do not impose a lock.
722 One day we will be forced to put shlock here (I mean SMP)
724 tryaddrmatch
= (sin_orig
.sin_family
== AF_INET
);
725 memset(sin
, 0, sizeof(*sin
));
726 sin
->sin_family
= AF_INET
;
731 if (!capable(CAP_NET_ADMIN
))
734 case SIOCSIFADDR
: /* Set interface address (and family) */
735 case SIOCSIFBRDADDR
: /* Set the broadcast address */
736 case SIOCSIFDSTADDR
: /* Set the destination address */
737 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
739 if (!capable(CAP_NET_ADMIN
))
742 if (sin
->sin_family
!= AF_INET
)
753 dev
= __dev_get_by_name(net
, ifr
.ifr_name
);
760 in_dev
= __in_dev_get_rtnl(dev
);
763 /* Matthias Andree */
764 /* compare label and address (4.4BSD style) */
765 /* note: we only do this for a limited set of ioctls
766 and only if the original address family was AF_INET.
767 This is checked above. */
768 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
769 ifap
= &ifa
->ifa_next
) {
770 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
) &&
771 sin_orig
.sin_addr
.s_addr
==
777 /* we didn't get a match, maybe the application is
778 4.3BSD-style and passed in junk so we fall back to
779 comparing just the label */
781 for (ifap
= &in_dev
->ifa_list
; (ifa
= *ifap
) != NULL
;
782 ifap
= &ifa
->ifa_next
)
783 if (!strcmp(ifr
.ifr_name
, ifa
->ifa_label
))
788 ret
= -EADDRNOTAVAIL
;
789 if (!ifa
&& cmd
!= SIOCSIFADDR
&& cmd
!= SIOCSIFFLAGS
)
793 case SIOCGIFADDR
: /* Get interface address */
794 sin
->sin_addr
.s_addr
= ifa
->ifa_local
;
797 case SIOCGIFBRDADDR
: /* Get the broadcast address */
798 sin
->sin_addr
.s_addr
= ifa
->ifa_broadcast
;
801 case SIOCGIFDSTADDR
: /* Get the destination address */
802 sin
->sin_addr
.s_addr
= ifa
->ifa_address
;
805 case SIOCGIFNETMASK
: /* Get the netmask for the interface */
806 sin
->sin_addr
.s_addr
= ifa
->ifa_mask
;
811 ret
= -EADDRNOTAVAIL
;
815 if (!(ifr
.ifr_flags
& IFF_UP
))
816 inet_del_ifa(in_dev
, ifap
, 1);
819 ret
= dev_change_flags(dev
, ifr
.ifr_flags
);
822 case SIOCSIFADDR
: /* Set interface address (and family) */
824 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
829 ifa
= inet_alloc_ifa();
830 INIT_HLIST_NODE(&ifa
->hash
);
834 memcpy(ifa
->ifa_label
, ifr
.ifr_name
, IFNAMSIZ
);
836 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
839 if (ifa
->ifa_local
== sin
->sin_addr
.s_addr
)
841 inet_del_ifa(in_dev
, ifap
, 0);
842 ifa
->ifa_broadcast
= 0;
846 ifa
->ifa_address
= ifa
->ifa_local
= sin
->sin_addr
.s_addr
;
848 if (!(dev
->flags
& IFF_POINTOPOINT
)) {
849 ifa
->ifa_prefixlen
= inet_abc_len(ifa
->ifa_address
);
850 ifa
->ifa_mask
= inet_make_mask(ifa
->ifa_prefixlen
);
851 if ((dev
->flags
& IFF_BROADCAST
) &&
852 ifa
->ifa_prefixlen
< 31)
853 ifa
->ifa_broadcast
= ifa
->ifa_address
|
856 ifa
->ifa_prefixlen
= 32;
857 ifa
->ifa_mask
= inet_make_mask(32);
859 ret
= inet_set_ifa(dev
, ifa
);
862 case SIOCSIFBRDADDR
: /* Set the broadcast address */
864 if (ifa
->ifa_broadcast
!= sin
->sin_addr
.s_addr
) {
865 inet_del_ifa(in_dev
, ifap
, 0);
866 ifa
->ifa_broadcast
= sin
->sin_addr
.s_addr
;
867 inet_insert_ifa(ifa
);
871 case SIOCSIFDSTADDR
: /* Set the destination address */
873 if (ifa
->ifa_address
== sin
->sin_addr
.s_addr
)
876 if (inet_abc_len(sin
->sin_addr
.s_addr
) < 0)
879 inet_del_ifa(in_dev
, ifap
, 0);
880 ifa
->ifa_address
= sin
->sin_addr
.s_addr
;
881 inet_insert_ifa(ifa
);
884 case SIOCSIFNETMASK
: /* Set the netmask for the interface */
887 * The mask we set must be legal.
890 if (bad_mask(sin
->sin_addr
.s_addr
, 0))
893 if (ifa
->ifa_mask
!= sin
->sin_addr
.s_addr
) {
894 __be32 old_mask
= ifa
->ifa_mask
;
895 inet_del_ifa(in_dev
, ifap
, 0);
896 ifa
->ifa_mask
= sin
->sin_addr
.s_addr
;
897 ifa
->ifa_prefixlen
= inet_mask_len(ifa
->ifa_mask
);
899 /* See if current broadcast address matches
900 * with current netmask, then recalculate
901 * the broadcast address. Otherwise it's a
902 * funny address, so don't touch it since
903 * the user seems to know what (s)he's doing...
905 if ((dev
->flags
& IFF_BROADCAST
) &&
906 (ifa
->ifa_prefixlen
< 31) &&
907 (ifa
->ifa_broadcast
==
908 (ifa
->ifa_local
|~old_mask
))) {
909 ifa
->ifa_broadcast
= (ifa
->ifa_local
|
910 ~sin
->sin_addr
.s_addr
);
912 inet_insert_ifa(ifa
);
922 ret
= copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)) ? -EFAULT
: 0;
926 static int inet_gifconf(struct net_device
*dev
, char __user
*buf
, int len
)
928 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
929 struct in_ifaddr
*ifa
;
936 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
941 if (len
< (int) sizeof(ifr
))
943 memset(&ifr
, 0, sizeof(struct ifreq
));
945 strcpy(ifr
.ifr_name
, ifa
->ifa_label
);
947 strcpy(ifr
.ifr_name
, dev
->name
);
949 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_family
= AF_INET
;
950 (*(struct sockaddr_in
*)&ifr
.ifr_addr
).sin_addr
.s_addr
=
953 if (copy_to_user(buf
, &ifr
, sizeof(struct ifreq
))) {
957 buf
+= sizeof(struct ifreq
);
958 len
-= sizeof(struct ifreq
);
959 done
+= sizeof(struct ifreq
);
965 __be32
inet_select_addr(const struct net_device
*dev
, __be32 dst
, int scope
)
968 struct in_device
*in_dev
;
969 struct net
*net
= dev_net(dev
);
972 in_dev
= __in_dev_get_rcu(dev
);
976 for_primary_ifa(in_dev
) {
977 if (ifa
->ifa_scope
> scope
)
979 if (!dst
|| inet_ifa_match(dst
, ifa
)) {
980 addr
= ifa
->ifa_local
;
984 addr
= ifa
->ifa_local
;
985 } endfor_ifa(in_dev
);
991 /* Not loopback addresses on loopback should be preferred
992 in this case. It is importnat that lo is the first interface
995 for_each_netdev_rcu(net
, dev
) {
996 in_dev
= __in_dev_get_rcu(dev
);
1000 for_primary_ifa(in_dev
) {
1001 if (ifa
->ifa_scope
!= RT_SCOPE_LINK
&&
1002 ifa
->ifa_scope
<= scope
) {
1003 addr
= ifa
->ifa_local
;
1006 } endfor_ifa(in_dev
);
1012 EXPORT_SYMBOL(inet_select_addr
);
1014 static __be32
confirm_addr_indev(struct in_device
*in_dev
, __be32 dst
,
1015 __be32 local
, int scope
)
1022 (local
== ifa
->ifa_local
|| !local
) &&
1023 ifa
->ifa_scope
<= scope
) {
1024 addr
= ifa
->ifa_local
;
1029 same
= (!local
|| inet_ifa_match(local
, ifa
)) &&
1030 (!dst
|| inet_ifa_match(dst
, ifa
));
1034 /* Is the selected addr into dst subnet? */
1035 if (inet_ifa_match(addr
, ifa
))
1037 /* No, then can we use new local src? */
1038 if (ifa
->ifa_scope
<= scope
) {
1039 addr
= ifa
->ifa_local
;
1042 /* search for large dst subnet for addr */
1046 } endfor_ifa(in_dev
);
1048 return same
? addr
: 0;
1052 * Confirm that local IP address exists using wildcards:
1053 * - in_dev: only on this interface, 0=any interface
1054 * - dst: only in the same subnet as dst, 0=any dst
1055 * - local: address, 0=autoselect the local address
1056 * - scope: maximum allowed scope value for the local address
1058 __be32
inet_confirm_addr(struct in_device
*in_dev
,
1059 __be32 dst
, __be32 local
, int scope
)
1062 struct net_device
*dev
;
1065 if (scope
!= RT_SCOPE_LINK
)
1066 return confirm_addr_indev(in_dev
, dst
, local
, scope
);
1068 net
= dev_net(in_dev
->dev
);
1070 for_each_netdev_rcu(net
, dev
) {
1071 in_dev
= __in_dev_get_rcu(dev
);
1073 addr
= confirm_addr_indev(in_dev
, dst
, local
, scope
);
1082 EXPORT_SYMBOL(inet_confirm_addr
);
1088 int register_inetaddr_notifier(struct notifier_block
*nb
)
1090 return blocking_notifier_chain_register(&inetaddr_chain
, nb
);
1092 EXPORT_SYMBOL(register_inetaddr_notifier
);
1094 int unregister_inetaddr_notifier(struct notifier_block
*nb
)
1096 return blocking_notifier_chain_unregister(&inetaddr_chain
, nb
);
1098 EXPORT_SYMBOL(unregister_inetaddr_notifier
);
1100 /* Rename ifa_labels for a device name change. Make some effort to preserve
1101 * existing alias numbering and to create unique labels if possible.
1103 static void inetdev_changename(struct net_device
*dev
, struct in_device
*in_dev
)
1105 struct in_ifaddr
*ifa
;
1108 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1109 char old
[IFNAMSIZ
], *dot
;
1111 memcpy(old
, ifa
->ifa_label
, IFNAMSIZ
);
1112 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1115 dot
= strchr(old
, ':');
1117 sprintf(old
, ":%d", named
);
1120 if (strlen(dot
) + strlen(dev
->name
) < IFNAMSIZ
)
1121 strcat(ifa
->ifa_label
, dot
);
1123 strcpy(ifa
->ifa_label
+ (IFNAMSIZ
- strlen(dot
) - 1), dot
);
1125 rtmsg_ifa(RTM_NEWADDR
, ifa
, NULL
, 0);
1129 static inline bool inetdev_valid_mtu(unsigned mtu
)
1134 static void inetdev_send_gratuitous_arp(struct net_device
*dev
,
1135 struct in_device
*in_dev
)
1138 struct in_ifaddr
*ifa
;
1140 for (ifa
= in_dev
->ifa_list
; ifa
;
1141 ifa
= ifa
->ifa_next
) {
1142 arp_send(ARPOP_REQUEST
, ETH_P_ARP
,
1143 ifa
->ifa_local
, dev
,
1144 ifa
->ifa_local
, NULL
,
1145 dev
->dev_addr
, NULL
);
1149 /* Called only under RTNL semaphore */
1151 static int inetdev_event(struct notifier_block
*this, unsigned long event
,
1154 struct net_device
*dev
= ptr
;
1155 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1160 if (event
== NETDEV_REGISTER
) {
1161 in_dev
= inetdev_init(dev
);
1163 return notifier_from_errno(-ENOMEM
);
1164 if (dev
->flags
& IFF_LOOPBACK
) {
1165 IN_DEV_CONF_SET(in_dev
, NOXFRM
, 1);
1166 IN_DEV_CONF_SET(in_dev
, NOPOLICY
, 1);
1168 } else if (event
== NETDEV_CHANGEMTU
) {
1169 /* Re-enabling IP */
1170 if (inetdev_valid_mtu(dev
->mtu
))
1171 in_dev
= inetdev_init(dev
);
1177 case NETDEV_REGISTER
:
1178 printk(KERN_DEBUG
"inetdev_event: bug\n");
1179 RCU_INIT_POINTER(dev
->ip_ptr
, NULL
);
1182 if (!inetdev_valid_mtu(dev
->mtu
))
1184 if (dev
->flags
& IFF_LOOPBACK
) {
1185 struct in_ifaddr
*ifa
= inet_alloc_ifa();
1188 INIT_HLIST_NODE(&ifa
->hash
);
1190 ifa
->ifa_address
= htonl(INADDR_LOOPBACK
);
1191 ifa
->ifa_prefixlen
= 8;
1192 ifa
->ifa_mask
= inet_make_mask(8);
1193 in_dev_hold(in_dev
);
1194 ifa
->ifa_dev
= in_dev
;
1195 ifa
->ifa_scope
= RT_SCOPE_HOST
;
1196 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
1197 inet_insert_ifa(ifa
);
1202 case NETDEV_CHANGEADDR
:
1203 if (!IN_DEV_ARP_NOTIFY(in_dev
))
1206 case NETDEV_NOTIFY_PEERS
:
1207 /* Send gratuitous ARP to notify of link change */
1208 inetdev_send_gratuitous_arp(dev
, in_dev
);
1213 case NETDEV_PRE_TYPE_CHANGE
:
1214 ip_mc_unmap(in_dev
);
1216 case NETDEV_POST_TYPE_CHANGE
:
1217 ip_mc_remap(in_dev
);
1219 case NETDEV_CHANGEMTU
:
1220 if (inetdev_valid_mtu(dev
->mtu
))
1222 /* disable IP when MTU is not enough */
1223 case NETDEV_UNREGISTER
:
1224 inetdev_destroy(in_dev
);
1226 case NETDEV_CHANGENAME
:
1227 /* Do not notify about label change, this event is
1228 * not interesting to applications using netlink.
1230 inetdev_changename(dev
, in_dev
);
1232 devinet_sysctl_unregister(in_dev
);
1233 devinet_sysctl_register(in_dev
);
1240 static struct notifier_block ip_netdev_notifier
= {
1241 .notifier_call
= inetdev_event
,
1244 static inline size_t inet_nlmsg_size(void)
1246 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
1247 + nla_total_size(4) /* IFA_ADDRESS */
1248 + nla_total_size(4) /* IFA_LOCAL */
1249 + nla_total_size(4) /* IFA_BROADCAST */
1250 + nla_total_size(IFNAMSIZ
); /* IFA_LABEL */
1253 static int inet_fill_ifaddr(struct sk_buff
*skb
, struct in_ifaddr
*ifa
,
1254 u32 pid
, u32 seq
, int event
, unsigned int flags
)
1256 struct ifaddrmsg
*ifm
;
1257 struct nlmsghdr
*nlh
;
1259 nlh
= nlmsg_put(skb
, pid
, seq
, event
, sizeof(*ifm
), flags
);
1263 ifm
= nlmsg_data(nlh
);
1264 ifm
->ifa_family
= AF_INET
;
1265 ifm
->ifa_prefixlen
= ifa
->ifa_prefixlen
;
1266 ifm
->ifa_flags
= ifa
->ifa_flags
|IFA_F_PERMANENT
;
1267 ifm
->ifa_scope
= ifa
->ifa_scope
;
1268 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
1270 if ((ifa
->ifa_address
&&
1271 nla_put_be32(skb
, IFA_ADDRESS
, ifa
->ifa_address
)) ||
1273 nla_put_be32(skb
, IFA_LOCAL
, ifa
->ifa_local
)) ||
1274 (ifa
->ifa_broadcast
&&
1275 nla_put_be32(skb
, IFA_BROADCAST
, ifa
->ifa_broadcast
)) ||
1276 (ifa
->ifa_label
[0] &&
1277 nla_put_string(skb
, IFA_LABEL
, ifa
->ifa_label
)))
1278 goto nla_put_failure
;
1280 return nlmsg_end(skb
, nlh
);
1283 nlmsg_cancel(skb
, nlh
);
1287 static int inet_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1289 struct net
*net
= sock_net(skb
->sk
);
1292 int ip_idx
, s_ip_idx
;
1293 struct net_device
*dev
;
1294 struct in_device
*in_dev
;
1295 struct in_ifaddr
*ifa
;
1296 struct hlist_head
*head
;
1297 struct hlist_node
*node
;
1300 s_idx
= idx
= cb
->args
[1];
1301 s_ip_idx
= ip_idx
= cb
->args
[2];
1303 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1305 head
= &net
->dev_index_head
[h
];
1307 hlist_for_each_entry_rcu(dev
, node
, head
, index_hlist
) {
1310 if (h
> s_h
|| idx
> s_idx
)
1312 in_dev
= __in_dev_get_rcu(dev
);
1316 for (ifa
= in_dev
->ifa_list
, ip_idx
= 0; ifa
;
1317 ifa
= ifa
->ifa_next
, ip_idx
++) {
1318 if (ip_idx
< s_ip_idx
)
1320 if (inet_fill_ifaddr(skb
, ifa
,
1321 NETLINK_CB(cb
->skb
).pid
,
1323 RTM_NEWADDR
, NLM_F_MULTI
) <= 0) {
1337 cb
->args
[2] = ip_idx
;
1342 static void rtmsg_ifa(int event
, struct in_ifaddr
*ifa
, struct nlmsghdr
*nlh
,
1345 struct sk_buff
*skb
;
1346 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
1350 net
= dev_net(ifa
->ifa_dev
->dev
);
1351 skb
= nlmsg_new(inet_nlmsg_size(), GFP_KERNEL
);
1355 err
= inet_fill_ifaddr(skb
, ifa
, pid
, seq
, event
, 0);
1357 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1358 WARN_ON(err
== -EMSGSIZE
);
1362 rtnl_notify(skb
, net
, pid
, RTNLGRP_IPV4_IFADDR
, nlh
, GFP_KERNEL
);
1366 rtnl_set_sk_err(net
, RTNLGRP_IPV4_IFADDR
, err
);
1369 static size_t inet_get_link_af_size(const struct net_device
*dev
)
1371 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1376 return nla_total_size(IPV4_DEVCONF_MAX
* 4); /* IFLA_INET_CONF */
1379 static int inet_fill_link_af(struct sk_buff
*skb
, const struct net_device
*dev
)
1381 struct in_device
*in_dev
= rcu_dereference_rtnl(dev
->ip_ptr
);
1388 nla
= nla_reserve(skb
, IFLA_INET_CONF
, IPV4_DEVCONF_MAX
* 4);
1392 for (i
= 0; i
< IPV4_DEVCONF_MAX
; i
++)
1393 ((u32
*) nla_data(nla
))[i
] = in_dev
->cnf
.data
[i
];
1398 static const struct nla_policy inet_af_policy
[IFLA_INET_MAX
+1] = {
1399 [IFLA_INET_CONF
] = { .type
= NLA_NESTED
},
1402 static int inet_validate_link_af(const struct net_device
*dev
,
1403 const struct nlattr
*nla
)
1405 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1408 if (dev
&& !__in_dev_get_rtnl(dev
))
1409 return -EAFNOSUPPORT
;
1411 err
= nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, inet_af_policy
);
1415 if (tb
[IFLA_INET_CONF
]) {
1416 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
) {
1417 int cfgid
= nla_type(a
);
1422 if (cfgid
<= 0 || cfgid
> IPV4_DEVCONF_MAX
)
1430 static int inet_set_link_af(struct net_device
*dev
, const struct nlattr
*nla
)
1432 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
1433 struct nlattr
*a
, *tb
[IFLA_INET_MAX
+1];
1437 return -EAFNOSUPPORT
;
1439 if (nla_parse_nested(tb
, IFLA_INET_MAX
, nla
, NULL
) < 0)
1442 if (tb
[IFLA_INET_CONF
]) {
1443 nla_for_each_nested(a
, tb
[IFLA_INET_CONF
], rem
)
1444 ipv4_devconf_set(in_dev
, nla_type(a
), nla_get_u32(a
));
1450 #ifdef CONFIG_SYSCTL
1452 static void devinet_copy_dflt_conf(struct net
*net
, int i
)
1454 struct net_device
*dev
;
1457 for_each_netdev_rcu(net
, dev
) {
1458 struct in_device
*in_dev
;
1460 in_dev
= __in_dev_get_rcu(dev
);
1461 if (in_dev
&& !test_bit(i
, in_dev
->cnf
.state
))
1462 in_dev
->cnf
.data
[i
] = net
->ipv4
.devconf_dflt
->data
[i
];
1467 /* called with RTNL locked */
1468 static void inet_forward_change(struct net
*net
)
1470 struct net_device
*dev
;
1471 int on
= IPV4_DEVCONF_ALL(net
, FORWARDING
);
1473 IPV4_DEVCONF_ALL(net
, ACCEPT_REDIRECTS
) = !on
;
1474 IPV4_DEVCONF_DFLT(net
, FORWARDING
) = on
;
1476 for_each_netdev(net
, dev
) {
1477 struct in_device
*in_dev
;
1479 dev_disable_lro(dev
);
1481 in_dev
= __in_dev_get_rcu(dev
);
1483 IN_DEV_CONF_SET(in_dev
, FORWARDING
, on
);
1488 static int devinet_conf_proc(ctl_table
*ctl
, int write
,
1489 void __user
*buffer
,
1490 size_t *lenp
, loff_t
*ppos
)
1492 int old_value
= *(int *)ctl
->data
;
1493 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1494 int new_value
= *(int *)ctl
->data
;
1497 struct ipv4_devconf
*cnf
= ctl
->extra1
;
1498 struct net
*net
= ctl
->extra2
;
1499 int i
= (int *)ctl
->data
- cnf
->data
;
1501 set_bit(i
, cnf
->state
);
1503 if (cnf
== net
->ipv4
.devconf_dflt
)
1504 devinet_copy_dflt_conf(net
, i
);
1505 if (i
== IPV4_DEVCONF_ACCEPT_LOCAL
- 1)
1506 if ((new_value
== 0) && (old_value
!= 0))
1507 rt_cache_flush(net
, 0);
1513 static int devinet_sysctl_forward(ctl_table
*ctl
, int write
,
1514 void __user
*buffer
,
1515 size_t *lenp
, loff_t
*ppos
)
1517 int *valp
= ctl
->data
;
1520 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1522 if (write
&& *valp
!= val
) {
1523 struct net
*net
= ctl
->extra2
;
1525 if (valp
!= &IPV4_DEVCONF_DFLT(net
, FORWARDING
)) {
1526 if (!rtnl_trylock()) {
1527 /* Restore the original values before restarting */
1530 return restart_syscall();
1532 if (valp
== &IPV4_DEVCONF_ALL(net
, FORWARDING
)) {
1533 inet_forward_change(net
);
1535 struct ipv4_devconf
*cnf
= ctl
->extra1
;
1536 struct in_device
*idev
=
1537 container_of(cnf
, struct in_device
, cnf
);
1538 dev_disable_lro(idev
->dev
);
1541 rt_cache_flush(net
, 0);
1548 static int ipv4_doint_and_flush(ctl_table
*ctl
, int write
,
1549 void __user
*buffer
,
1550 size_t *lenp
, loff_t
*ppos
)
1552 int *valp
= ctl
->data
;
1554 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1555 struct net
*net
= ctl
->extra2
;
1557 if (write
&& *valp
!= val
)
1558 rt_cache_flush(net
, 0);
1563 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
1566 .data = ipv4_devconf.data + \
1567 IPV4_DEVCONF_ ## attr - 1, \
1568 .maxlen = sizeof(int), \
1570 .proc_handler = proc, \
1571 .extra1 = &ipv4_devconf, \
1574 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1575 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
1577 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1578 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
1580 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1581 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
1583 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1584 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
1586 static struct devinet_sysctl_table
{
1587 struct ctl_table_header
*sysctl_header
;
1588 struct ctl_table devinet_vars
[__IPV4_DEVCONF_MAX
];
1590 } devinet_sysctl
= {
1592 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING
, "forwarding",
1593 devinet_sysctl_forward
),
1594 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING
, "mc_forwarding"),
1596 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS
, "accept_redirects"),
1597 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS
, "secure_redirects"),
1598 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA
, "shared_media"),
1599 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER
, "rp_filter"),
1600 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS
, "send_redirects"),
1601 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE
,
1602 "accept_source_route"),
1603 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL
, "accept_local"),
1604 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK
, "src_valid_mark"),
1605 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP
, "proxy_arp"),
1606 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID
, "medium_id"),
1607 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY
, "bootp_relay"),
1608 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS
, "log_martians"),
1609 DEVINET_SYSCTL_RW_ENTRY(TAG
, "tag"),
1610 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER
, "arp_filter"),
1611 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE
, "arp_announce"),
1612 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE
, "arp_ignore"),
1613 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT
, "arp_accept"),
1614 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY
, "arp_notify"),
1615 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN
, "proxy_arp_pvlan"),
1617 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM
, "disable_xfrm"),
1618 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY
, "disable_policy"),
1619 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION
,
1620 "force_igmp_version"),
1621 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES
,
1622 "promote_secondaries"),
1626 static int __devinet_sysctl_register(struct net
*net
, char *dev_name
,
1627 struct ipv4_devconf
*p
)
1630 struct devinet_sysctl_table
*t
;
1632 #define DEVINET_CTL_PATH_DEV 3
1634 struct ctl_path devinet_ctl_path
[] = {
1635 { .procname
= "net", },
1636 { .procname
= "ipv4", },
1637 { .procname
= "conf", },
1638 { /* to be set */ },
1642 t
= kmemdup(&devinet_sysctl
, sizeof(*t
), GFP_KERNEL
);
1646 for (i
= 0; i
< ARRAY_SIZE(t
->devinet_vars
) - 1; i
++) {
1647 t
->devinet_vars
[i
].data
+= (char *)p
- (char *)&ipv4_devconf
;
1648 t
->devinet_vars
[i
].extra1
= p
;
1649 t
->devinet_vars
[i
].extra2
= net
;
1653 * Make a copy of dev_name, because '.procname' is regarded as const
1654 * by sysctl and we wouldn't want anyone to change it under our feet
1655 * (see SIOCSIFNAME).
1657 t
->dev_name
= kstrdup(dev_name
, GFP_KERNEL
);
1661 devinet_ctl_path
[DEVINET_CTL_PATH_DEV
].procname
= t
->dev_name
;
1663 t
->sysctl_header
= register_net_sysctl_table(net
, devinet_ctl_path
,
1665 if (!t
->sysctl_header
)
1679 static void __devinet_sysctl_unregister(struct ipv4_devconf
*cnf
)
1681 struct devinet_sysctl_table
*t
= cnf
->sysctl
;
1687 unregister_net_sysctl_table(t
->sysctl_header
);
1692 static void devinet_sysctl_register(struct in_device
*idev
)
1694 neigh_sysctl_register(idev
->dev
, idev
->arp_parms
, "ipv4", NULL
);
1695 __devinet_sysctl_register(dev_net(idev
->dev
), idev
->dev
->name
,
1699 static void devinet_sysctl_unregister(struct in_device
*idev
)
1701 __devinet_sysctl_unregister(&idev
->cnf
);
1702 neigh_sysctl_unregister(idev
->arp_parms
);
1705 static struct ctl_table ctl_forward_entry
[] = {
1707 .procname
= "ip_forward",
1708 .data
= &ipv4_devconf
.data
[
1709 IPV4_DEVCONF_FORWARDING
- 1],
1710 .maxlen
= sizeof(int),
1712 .proc_handler
= devinet_sysctl_forward
,
1713 .extra1
= &ipv4_devconf
,
1714 .extra2
= &init_net
,
1719 static __net_initdata
struct ctl_path net_ipv4_path
[] = {
1720 { .procname
= "net", },
1721 { .procname
= "ipv4", },
1726 static __net_init
int devinet_init_net(struct net
*net
)
1729 struct ipv4_devconf
*all
, *dflt
;
1730 #ifdef CONFIG_SYSCTL
1731 struct ctl_table
*tbl
= ctl_forward_entry
;
1732 struct ctl_table_header
*forw_hdr
;
1736 all
= &ipv4_devconf
;
1737 dflt
= &ipv4_devconf_dflt
;
1739 if (!net_eq(net
, &init_net
)) {
1740 all
= kmemdup(all
, sizeof(ipv4_devconf
), GFP_KERNEL
);
1744 dflt
= kmemdup(dflt
, sizeof(ipv4_devconf_dflt
), GFP_KERNEL
);
1746 goto err_alloc_dflt
;
1748 #ifdef CONFIG_SYSCTL
1749 tbl
= kmemdup(tbl
, sizeof(ctl_forward_entry
), GFP_KERNEL
);
1753 tbl
[0].data
= &all
->data
[IPV4_DEVCONF_FORWARDING
- 1];
1754 tbl
[0].extra1
= all
;
1755 tbl
[0].extra2
= net
;
1759 #ifdef CONFIG_SYSCTL
1760 err
= __devinet_sysctl_register(net
, "all", all
);
1764 err
= __devinet_sysctl_register(net
, "default", dflt
);
1769 forw_hdr
= register_net_sysctl_table(net
, net_ipv4_path
, tbl
);
1770 if (forw_hdr
== NULL
)
1772 net
->ipv4
.forw_hdr
= forw_hdr
;
1775 net
->ipv4
.devconf_all
= all
;
1776 net
->ipv4
.devconf_dflt
= dflt
;
1779 #ifdef CONFIG_SYSCTL
1781 __devinet_sysctl_unregister(dflt
);
1783 __devinet_sysctl_unregister(all
);
1785 if (tbl
!= ctl_forward_entry
)
1789 if (dflt
!= &ipv4_devconf_dflt
)
1792 if (all
!= &ipv4_devconf
)
1798 static __net_exit
void devinet_exit_net(struct net
*net
)
1800 #ifdef CONFIG_SYSCTL
1801 struct ctl_table
*tbl
;
1803 tbl
= net
->ipv4
.forw_hdr
->ctl_table_arg
;
1804 unregister_net_sysctl_table(net
->ipv4
.forw_hdr
);
1805 __devinet_sysctl_unregister(net
->ipv4
.devconf_dflt
);
1806 __devinet_sysctl_unregister(net
->ipv4
.devconf_all
);
1809 kfree(net
->ipv4
.devconf_dflt
);
1810 kfree(net
->ipv4
.devconf_all
);
1813 static __net_initdata
struct pernet_operations devinet_ops
= {
1814 .init
= devinet_init_net
,
1815 .exit
= devinet_exit_net
,
1818 static struct rtnl_af_ops inet_af_ops
= {
1820 .fill_link_af
= inet_fill_link_af
,
1821 .get_link_af_size
= inet_get_link_af_size
,
1822 .validate_link_af
= inet_validate_link_af
,
1823 .set_link_af
= inet_set_link_af
,
1826 void __init
devinet_init(void)
1830 for (i
= 0; i
< IN4_ADDR_HSIZE
; i
++)
1831 INIT_HLIST_HEAD(&inet_addr_lst
[i
]);
1833 register_pernet_subsys(&devinet_ops
);
1835 register_gifconf(PF_INET
, inet_gifconf
);
1836 register_netdevice_notifier(&ip_netdev_notifier
);
1838 rtnl_af_register(&inet_af_ops
);
1840 rtnl_register(PF_INET
, RTM_NEWADDR
, inet_rtm_newaddr
, NULL
, NULL
);
1841 rtnl_register(PF_INET
, RTM_DELADDR
, inet_rtm_deladdr
, NULL
, NULL
);
1842 rtnl_register(PF_INET
, RTM_GETADDR
, NULL
, inet_dump_ifaddr
, NULL
);