blob: dc94b0316b783fd1c1985e407fb0339782c66df5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NET3 IP device support routines.
3 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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.
8 *
9 * Derived from the IP parts of dev.c 1.0.19
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
13 *
14 * Additional Authors:
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
17 *
18 * Changes:
19 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
20 * lists.
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
25 * if no match found.
26 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include <asm/uaccess.h>
30#include <asm/system.h>
31#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080032#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/module.h>
34#include <linux/types.h>
35#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/string.h>
37#include <linux/mm.h>
38#include <linux/socket.h>
39#include <linux/sockios.h>
40#include <linux/in.h>
41#include <linux/errno.h>
42#include <linux/interrupt.h>
Thomas Graf18237302006-08-04 23:04:54 -070043#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/init.h>
50#include <linux/notifier.h>
51#include <linux/inetdevice.h>
52#include <linux/igmp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090053#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#ifdef CONFIG_SYSCTL
55#include <linux/sysctl.h>
56#endif
57#include <linux/kmod.h>
58
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020059#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#include <net/ip.h>
61#include <net/route.h>
62#include <net/ip_fib.h>
Thomas Graf63f34442007-03-22 11:55:17 -070063#include <net/rtnetlink.h>
Pavel Emelyanov752d14d2007-12-16 13:31:47 -080064#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Adrian Bunk0027ba82008-01-31 17:17:31 -080066static struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070067 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000068 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
69 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
70 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
71 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
Herbert Xu42f811b2007-06-04 23:34:44 -070072 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070073};
74
75static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070076 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000077 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
78 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
79 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
80 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
81 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
Herbert Xu42f811b2007-06-04 23:34:44 -070082 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070083};
84
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -080085#define IPV4_DEVCONF_DFLT(net, attr) \
86 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
Herbert Xu42f811b2007-06-04 23:34:44 -070087
Patrick McHardyef7c79e2007-06-05 12:38:30 -070088static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
Thomas Graf5c753972006-08-04 23:03:53 -070089 [IFA_LOCAL] = { .type = NLA_U32 },
90 [IFA_ADDRESS] = { .type = NLA_U32 },
91 [IFA_BROADCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -070092 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Thomas Graf5c753972006-08-04 23:03:53 -070093};
94
Thomas Grafd6062cb2006-08-15 00:33:59 -070095static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Alan Sterne041c682006-03-27 01:16:30 -080097static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
99 int destroy);
100#ifdef CONFIG_SYSCTL
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100101static void devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800102static void devinet_sysctl_unregister(struct in_device *idev);
103#else
104static inline void devinet_sysctl_register(struct in_device *idev)
105{
106}
107static inline void devinet_sysctl_unregister(struct in_device *idev)
108{
109}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#endif
111
112/* Locks all the inet devices. */
113
114static struct in_ifaddr *inet_alloc_ifa(void)
115{
Alexey Dobriyan93adcc82008-10-28 13:25:09 -0700116 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117}
118
119static void inet_rcu_free_ifa(struct rcu_head *head)
120{
121 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
122 if (ifa->ifa_dev)
123 in_dev_put(ifa->ifa_dev);
124 kfree(ifa);
125}
126
127static inline void inet_free_ifa(struct in_ifaddr *ifa)
128{
129 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
130}
131
132void in_dev_finish_destroy(struct in_device *idev)
133{
134 struct net_device *dev = idev->dev;
135
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700136 WARN_ON(idev->ifa_list);
137 WARN_ON(idev->mc_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138#ifdef NET_REFCNT_DEBUG
139 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
140 idev, dev ? dev->name : "NIL");
141#endif
142 dev_put(dev);
143 if (!idev->dead)
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800144 pr_err("Freeing alive in_device %p\n", idev);
145 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 kfree(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800148EXPORT_SYMBOL(in_dev_finish_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Herbert Xu71e27da2007-06-04 23:36:06 -0700150static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 struct in_device *in_dev;
153
154 ASSERT_RTNL();
155
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700156 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (!in_dev)
158 goto out;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900159 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800160 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 in_dev->cnf.sysctl = NULL;
162 in_dev->dev = dev;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800163 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
164 if (!in_dev->arp_parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 goto out_kfree;
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700166 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
167 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 /* Reference in_dev->dev */
169 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800170 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100173 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 ip_mc_init_dev(in_dev);
175 if (dev->flags & IFF_UP)
176 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800177
David L Stevens30c4cf52007-01-04 12:31:14 -0800178 /* we can receive as soon as ip_ptr is set -- do this last */
179 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800180out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return in_dev;
182out_kfree:
183 kfree(in_dev);
184 in_dev = NULL;
185 goto out;
186}
187
188static void in_dev_rcu_put(struct rcu_head *head)
189{
190 struct in_device *idev = container_of(head, struct in_device, rcu_head);
191 in_dev_put(idev);
192}
193
194static void inetdev_destroy(struct in_device *in_dev)
195{
196 struct in_ifaddr *ifa;
197 struct net_device *dev;
198
199 ASSERT_RTNL();
200
201 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203 in_dev->dead = 1;
204
205 ip_mc_destroy_dev(in_dev);
206
207 while ((ifa = in_dev->ifa_list) != NULL) {
208 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
209 inet_free_ifa(ifa);
210 }
211
Eric Dumazet95ae6b22010-09-15 04:04:31 +0000212 rcu_assign_pointer(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800214 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
216 arp_ifdown(dev);
217
218 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
219}
220
Al Viroff428d72006-09-26 22:13:35 -0700221int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
223 rcu_read_lock();
224 for_primary_ifa(in_dev) {
225 if (inet_ifa_match(a, ifa)) {
226 if (!b || inet_ifa_match(b, ifa)) {
227 rcu_read_unlock();
228 return 1;
229 }
230 }
231 } endfor_ifa(in_dev);
232 rcu_read_unlock();
233 return 0;
234}
235
Thomas Grafd6062cb2006-08-15 00:33:59 -0700236static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
237 int destroy, struct nlmsghdr *nlh, u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
Harald Welte8f937c62005-05-29 20:23:46 -0700239 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800240 struct in_ifaddr *ifa, *ifa1 = *ifap;
241 struct in_ifaddr *last_prim = in_dev->ifa_list;
242 struct in_ifaddr *prev_prom = NULL;
243 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 ASSERT_RTNL();
246
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900247 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700248 * unless alias promotion is set
249 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
253
254 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900255 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800256 ifa1->ifa_scope <= ifa->ifa_scope)
257 last_prim = ifa;
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
260 ifa1->ifa_mask != ifa->ifa_mask ||
261 !inet_ifa_match(ifa1->ifa_address, ifa)) {
262 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800263 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 continue;
265 }
266
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800267 if (!do_promote) {
Harald Welte8f937c62005-05-29 20:23:46 -0700268 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Thomas Grafd6062cb2006-08-15 00:33:59 -0700270 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800271 blocking_notifier_call_chain(&inetaddr_chain,
272 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700273 inet_free_ifa(ifa);
274 } else {
275 promote = ifa;
276 break;
277 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
279 }
280
281 /* 2. Unlink it */
282
283 *ifap = ifa1->ifa_next;
284
285 /* 3. Announce address deletion */
286
287 /* Send message first, then call notifier.
288 At first sight, FIB update triggered by notifier
289 will refer to already deleted ifaddr, that could confuse
290 netlink listeners. It is not true: look, gated sees
291 that route deleted and if it still thinks that ifaddr
292 is valid, it will try to restore deleted routes... Grr.
293 So that, this order is correct.
294 */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700295 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800296 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800297
298 if (promote) {
299
300 if (prev_prom) {
301 prev_prom->ifa_next = promote->ifa_next;
302 promote->ifa_next = last_prim->ifa_next;
303 last_prim->ifa_next = promote;
304 }
305
306 promote->ifa_flags &= ~IFA_F_SECONDARY;
Thomas Grafd6062cb2006-08-15 00:33:59 -0700307 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800308 blocking_notifier_call_chain(&inetaddr_chain,
309 NETDEV_UP, promote);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800310 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
311 if (ifa1->ifa_mask != ifa->ifa_mask ||
312 !inet_ifa_match(ifa1->ifa_address, ifa))
313 continue;
314 fib_add_ifaddr(ifa);
315 }
316
317 }
Herbert Xu63630972007-06-07 18:35:38 -0700318 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320}
321
Thomas Grafd6062cb2006-08-15 00:33:59 -0700322static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
323 int destroy)
324{
325 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
326}
327
328static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
329 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 struct in_device *in_dev = ifa->ifa_dev;
332 struct in_ifaddr *ifa1, **ifap, **last_primary;
333
334 ASSERT_RTNL();
335
336 if (!ifa->ifa_local) {
337 inet_free_ifa(ifa);
338 return 0;
339 }
340
341 ifa->ifa_flags &= ~IFA_F_SECONDARY;
342 last_primary = &in_dev->ifa_list;
343
344 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
345 ifap = &ifa1->ifa_next) {
346 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
347 ifa->ifa_scope <= ifa1->ifa_scope)
348 last_primary = &ifa1->ifa_next;
349 if (ifa1->ifa_mask == ifa->ifa_mask &&
350 inet_ifa_match(ifa1->ifa_address, ifa)) {
351 if (ifa1->ifa_local == ifa->ifa_local) {
352 inet_free_ifa(ifa);
353 return -EEXIST;
354 }
355 if (ifa1->ifa_scope != ifa->ifa_scope) {
356 inet_free_ifa(ifa);
357 return -EINVAL;
358 }
359 ifa->ifa_flags |= IFA_F_SECONDARY;
360 }
361 }
362
363 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
364 net_srandom(ifa->ifa_local);
365 ifap = last_primary;
366 }
367
368 ifa->ifa_next = *ifap;
369 *ifap = ifa;
370
371 /* Send message first, then call notifier.
372 Notifier will trigger FIB update, so that
373 listeners of netlink will know about new ifaddr */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700374 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800375 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 return 0;
378}
379
Thomas Grafd6062cb2006-08-15 00:33:59 -0700380static int inet_insert_ifa(struct in_ifaddr *ifa)
381{
382 return __inet_insert_ifa(ifa, NULL, 0);
383}
384
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
386{
Herbert Xue5ed6392005-10-03 14:35:55 -0700387 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 ASSERT_RTNL();
390
391 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700392 inet_free_ifa(ifa);
393 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700395 ipv4_devconf_setall(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700397 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 in_dev_hold(in_dev);
399 ifa->ifa_dev = in_dev;
400 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800401 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 ifa->ifa_scope = RT_SCOPE_HOST;
403 return inet_insert_ifa(ifa);
404}
405
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000406/* Caller must hold RCU or RTNL :
407 * We dont take a reference on found in_device
408 */
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800409struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
411 struct net_device *dev;
412 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000413
414 rcu_read_lock();
415 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 if (dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000417 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000418 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 return in_dev;
420}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800421EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
423/* Called only from RTNL semaphored context. No locks. */
424
Al Viro60cad5d2006-09-26 22:17:09 -0700425struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
426 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
428 ASSERT_RTNL();
429
430 for_primary_ifa(in_dev) {
431 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
432 return ifa;
433 } endfor_ifa(in_dev);
434 return NULL;
435}
436
437static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
438{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900439 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700440 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700442 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700444 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 ASSERT_RTNL();
447
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700448 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
449 if (err < 0)
450 goto errout;
451
452 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800453 in_dev = inetdev_by_index(net, ifm->ifa_index);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700454 if (in_dev == NULL) {
455 err = -ENODEV;
456 goto errout;
457 }
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
460 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700461 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700462 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700464
465 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
466 continue;
467
468 if (tb[IFA_ADDRESS] &&
469 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700470 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700471 continue;
472
Thomas Grafd6062cb2006-08-15 00:33:59 -0700473 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return 0;
475 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700476
477 err = -EADDRNOTAVAIL;
478errout:
479 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480}
481
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800482static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
Thomas Graf5c753972006-08-04 23:03:53 -0700484 struct nlattr *tb[IFA_MAX+1];
485 struct in_ifaddr *ifa;
486 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 struct net_device *dev;
488 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800489 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Thomas Graf5c753972006-08-04 23:03:53 -0700491 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
492 if (err < 0)
493 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Thomas Graf5c753972006-08-04 23:03:53 -0700495 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800496 err = -EINVAL;
497 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700498 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800500 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800501 err = -ENODEV;
502 if (dev == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700503 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Thomas Graf5c753972006-08-04 23:03:53 -0700505 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800506 err = -ENOBUFS;
507 if (in_dev == NULL)
Herbert Xu71e27da2007-06-04 23:36:06 -0700508 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Thomas Graf5c753972006-08-04 23:03:53 -0700510 ifa = inet_alloc_ifa();
Denis V. Lunev7b218572008-01-31 18:47:00 -0800511 if (ifa == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700512 /*
513 * A potential indev allocation can be left alive, it stays
514 * assigned to its device and is destroy with it.
515 */
Thomas Graf5c753972006-08-04 23:03:53 -0700516 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700517
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800518 ipv4_devconf_setall(in_dev);
Thomas Graf5c753972006-08-04 23:03:53 -0700519 in_dev_hold(in_dev);
520
521 if (tb[IFA_ADDRESS] == NULL)
522 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
525 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 ifa->ifa_flags = ifm->ifa_flags;
527 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700528 ifa->ifa_dev = in_dev;
529
Al Viroa7a628c2006-09-26 22:16:43 -0700530 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
531 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700532
533 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700534 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700535
Thomas Graf5c753972006-08-04 23:03:53 -0700536 if (tb[IFA_LABEL])
537 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 else
539 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
540
Thomas Graf5c753972006-08-04 23:03:53 -0700541 return ifa;
542
543errout:
544 return ERR_PTR(err);
545}
546
547static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
548{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900549 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700550 struct in_ifaddr *ifa;
551
552 ASSERT_RTNL();
553
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800554 ifa = rtm_to_ifaddr(net, nlh);
Thomas Graf5c753972006-08-04 23:03:53 -0700555 if (IS_ERR(ifa))
556 return PTR_ERR(ifa);
557
Thomas Grafd6062cb2006-08-15 00:33:59 -0700558 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559}
560
561/*
562 * Determine a default network mask, based on the IP address.
563 */
564
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800565static inline int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{
567 int rc = -1; /* Something else, probably a multicast. */
568
Joe Perchesf97c1e02007-12-16 13:45:43 -0800569 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900570 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 else {
Al Viro714e85b2006-11-14 20:51:49 -0800572 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Al Viro714e85b2006-11-14 20:51:49 -0800574 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800576 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800578 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 rc = 24;
580 }
581
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900582 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583}
584
585
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800586int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 struct ifreq ifr;
589 struct sockaddr_in sin_orig;
590 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
591 struct in_device *in_dev;
592 struct in_ifaddr **ifap = NULL;
593 struct in_ifaddr *ifa = NULL;
594 struct net_device *dev;
595 char *colon;
596 int ret = -EFAULT;
597 int tryaddrmatch = 0;
598
599 /*
600 * Fetch the caller's info block into kernel space
601 */
602
603 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
604 goto out;
605 ifr.ifr_name[IFNAMSIZ - 1] = 0;
606
607 /* save original address for comparison */
608 memcpy(&sin_orig, sin, sizeof(*sin));
609
610 colon = strchr(ifr.ifr_name, ':');
611 if (colon)
612 *colon = 0;
613
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800614 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
Stephen Hemminger132adf52007-03-08 20:44:43 -0800616 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 case SIOCGIFADDR: /* Get interface address */
618 case SIOCGIFBRDADDR: /* Get the broadcast address */
619 case SIOCGIFDSTADDR: /* Get the destination address */
620 case SIOCGIFNETMASK: /* Get the netmask for the interface */
621 /* Note that these ioctls will not sleep,
622 so that we do not impose a lock.
623 One day we will be forced to put shlock here (I mean SMP)
624 */
625 tryaddrmatch = (sin_orig.sin_family == AF_INET);
626 memset(sin, 0, sizeof(*sin));
627 sin->sin_family = AF_INET;
628 break;
629
630 case SIOCSIFFLAGS:
631 ret = -EACCES;
632 if (!capable(CAP_NET_ADMIN))
633 goto out;
634 break;
635 case SIOCSIFADDR: /* Set interface address (and family) */
636 case SIOCSIFBRDADDR: /* Set the broadcast address */
637 case SIOCSIFDSTADDR: /* Set the destination address */
638 case SIOCSIFNETMASK: /* Set the netmask for the interface */
639 ret = -EACCES;
640 if (!capable(CAP_NET_ADMIN))
641 goto out;
642 ret = -EINVAL;
643 if (sin->sin_family != AF_INET)
644 goto out;
645 break;
646 default:
647 ret = -EINVAL;
648 goto out;
649 }
650
651 rtnl_lock();
652
653 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800654 dev = __dev_get_by_name(net, ifr.ifr_name);
655 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 goto done;
657
658 if (colon)
659 *colon = ':';
660
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800661 in_dev = __in_dev_get_rtnl(dev);
662 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (tryaddrmatch) {
664 /* Matthias Andree */
665 /* compare label and address (4.4BSD style) */
666 /* note: we only do this for a limited set of ioctls
667 and only if the original address family was AF_INET.
668 This is checked above. */
669 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
670 ifap = &ifa->ifa_next) {
671 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
672 sin_orig.sin_addr.s_addr ==
673 ifa->ifa_address) {
674 break; /* found */
675 }
676 }
677 }
678 /* we didn't get a match, maybe the application is
679 4.3BSD-style and passed in junk so we fall back to
680 comparing just the label */
681 if (!ifa) {
682 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
683 ifap = &ifa->ifa_next)
684 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
685 break;
686 }
687 }
688
689 ret = -EADDRNOTAVAIL;
690 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
691 goto done;
692
Stephen Hemminger132adf52007-03-08 20:44:43 -0800693 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 case SIOCGIFADDR: /* Get interface address */
695 sin->sin_addr.s_addr = ifa->ifa_local;
696 goto rarok;
697
698 case SIOCGIFBRDADDR: /* Get the broadcast address */
699 sin->sin_addr.s_addr = ifa->ifa_broadcast;
700 goto rarok;
701
702 case SIOCGIFDSTADDR: /* Get the destination address */
703 sin->sin_addr.s_addr = ifa->ifa_address;
704 goto rarok;
705
706 case SIOCGIFNETMASK: /* Get the netmask for the interface */
707 sin->sin_addr.s_addr = ifa->ifa_mask;
708 goto rarok;
709
710 case SIOCSIFFLAGS:
711 if (colon) {
712 ret = -EADDRNOTAVAIL;
713 if (!ifa)
714 break;
715 ret = 0;
716 if (!(ifr.ifr_flags & IFF_UP))
717 inet_del_ifa(in_dev, ifap, 1);
718 break;
719 }
720 ret = dev_change_flags(dev, ifr.ifr_flags);
721 break;
722
723 case SIOCSIFADDR: /* Set interface address (and family) */
724 ret = -EINVAL;
725 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
726 break;
727
728 if (!ifa) {
729 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800730 ifa = inet_alloc_ifa();
731 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 break;
733 if (colon)
734 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
735 else
736 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
737 } else {
738 ret = 0;
739 if (ifa->ifa_local == sin->sin_addr.s_addr)
740 break;
741 inet_del_ifa(in_dev, ifap, 0);
742 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -0800743 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 }
745
746 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
747
748 if (!(dev->flags & IFF_POINTOPOINT)) {
749 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
750 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
751 if ((dev->flags & IFF_BROADCAST) &&
752 ifa->ifa_prefixlen < 31)
753 ifa->ifa_broadcast = ifa->ifa_address |
754 ~ifa->ifa_mask;
755 } else {
756 ifa->ifa_prefixlen = 32;
757 ifa->ifa_mask = inet_make_mask(32);
758 }
759 ret = inet_set_ifa(dev, ifa);
760 break;
761
762 case SIOCSIFBRDADDR: /* Set the broadcast address */
763 ret = 0;
764 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
765 inet_del_ifa(in_dev, ifap, 0);
766 ifa->ifa_broadcast = sin->sin_addr.s_addr;
767 inet_insert_ifa(ifa);
768 }
769 break;
770
771 case SIOCSIFDSTADDR: /* Set the destination address */
772 ret = 0;
773 if (ifa->ifa_address == sin->sin_addr.s_addr)
774 break;
775 ret = -EINVAL;
776 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
777 break;
778 ret = 0;
779 inet_del_ifa(in_dev, ifap, 0);
780 ifa->ifa_address = sin->sin_addr.s_addr;
781 inet_insert_ifa(ifa);
782 break;
783
784 case SIOCSIFNETMASK: /* Set the netmask for the interface */
785
786 /*
787 * The mask we set must be legal.
788 */
789 ret = -EINVAL;
790 if (bad_mask(sin->sin_addr.s_addr, 0))
791 break;
792 ret = 0;
793 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -0700794 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 inet_del_ifa(in_dev, ifap, 0);
796 ifa->ifa_mask = sin->sin_addr.s_addr;
797 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
798
799 /* See if current broadcast address matches
800 * with current netmask, then recalculate
801 * the broadcast address. Otherwise it's a
802 * funny address, so don't touch it since
803 * the user seems to know what (s)he's doing...
804 */
805 if ((dev->flags & IFF_BROADCAST) &&
806 (ifa->ifa_prefixlen < 31) &&
807 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -0500808 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 ifa->ifa_broadcast = (ifa->ifa_local |
810 ~sin->sin_addr.s_addr);
811 }
812 inet_insert_ifa(ifa);
813 }
814 break;
815 }
816done:
817 rtnl_unlock();
818out:
819 return ret;
820rarok:
821 rtnl_unlock();
822 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
823 goto out;
824}
825
826static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
827{
Herbert Xue5ed6392005-10-03 14:35:55 -0700828 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 struct in_ifaddr *ifa;
830 struct ifreq ifr;
831 int done = 0;
832
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800833 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 goto out;
835
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800836 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 if (!buf) {
838 done += sizeof(ifr);
839 continue;
840 }
841 if (len < (int) sizeof(ifr))
842 break;
843 memset(&ifr, 0, sizeof(struct ifreq));
844 if (ifa->ifa_label)
845 strcpy(ifr.ifr_name, ifa->ifa_label);
846 else
847 strcpy(ifr.ifr_name, dev->name);
848
849 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
850 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
851 ifa->ifa_local;
852
853 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
854 done = -EFAULT;
855 break;
856 }
857 buf += sizeof(struct ifreq);
858 len -= sizeof(struct ifreq);
859 done += sizeof(struct ifreq);
860 }
861out:
862 return done;
863}
864
Al Viroa61ced52006-09-26 21:27:54 -0700865__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
Al Viroa61ced52006-09-26 21:27:54 -0700867 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900869 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
871 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700872 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 if (!in_dev)
874 goto no_in_dev;
875
876 for_primary_ifa(in_dev) {
877 if (ifa->ifa_scope > scope)
878 continue;
879 if (!dst || inet_ifa_match(dst, ifa)) {
880 addr = ifa->ifa_local;
881 break;
882 }
883 if (!addr)
884 addr = ifa->ifa_local;
885 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800888 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800889no_in_dev:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
891 /* Not loopback addresses on loopback should be preferred
892 in this case. It is importnat that lo is the first interface
893 in dev_base list.
894 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800895 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800896 in_dev = __in_dev_get_rcu(dev);
897 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 continue;
899
900 for_primary_ifa(in_dev) {
901 if (ifa->ifa_scope != RT_SCOPE_LINK &&
902 ifa->ifa_scope <= scope) {
903 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800904 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 }
906 } endfor_ifa(in_dev);
907 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800908out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 return addr;
911}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800912EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Al Viro60cad5d2006-09-26 22:17:09 -0700914static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
915 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
917 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -0700918 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920 for_ifa(in_dev) {
921 if (!addr &&
922 (local == ifa->ifa_local || !local) &&
923 ifa->ifa_scope <= scope) {
924 addr = ifa->ifa_local;
925 if (same)
926 break;
927 }
928 if (!same) {
929 same = (!local || inet_ifa_match(local, ifa)) &&
930 (!dst || inet_ifa_match(dst, ifa));
931 if (same && addr) {
932 if (local || !dst)
933 break;
934 /* Is the selected addr into dst subnet? */
935 if (inet_ifa_match(addr, ifa))
936 break;
937 /* No, then can we use new local src? */
938 if (ifa->ifa_scope <= scope) {
939 addr = ifa->ifa_local;
940 break;
941 }
942 /* search for large dst subnet for addr */
943 same = 0;
944 }
945 }
946 } endfor_ifa(in_dev);
947
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800948 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949}
950
951/*
952 * Confirm that local IP address exists using wildcards:
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800953 * - in_dev: only on this interface, 0=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 * - dst: only in the same subnet as dst, 0=any dst
955 * - local: address, 0=autoselect the local address
956 * - scope: maximum allowed scope value for the local address
957 */
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800958__be32 inet_confirm_addr(struct in_device *in_dev,
959 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
Al Viro60cad5d2006-09-26 22:17:09 -0700961 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800962 struct net_device *dev;
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800963 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800965 if (scope != RT_SCOPE_LINK)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800966 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900968 net = dev_net(in_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800970 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800971 in_dev = __in_dev_get_rcu(dev);
972 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 addr = confirm_addr_indev(in_dev, dst, local, scope);
974 if (addr)
975 break;
976 }
977 }
978 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 return addr;
981}
982
983/*
984 * Device notifier
985 */
986
987int register_inetaddr_notifier(struct notifier_block *nb)
988{
Alan Sterne041c682006-03-27 01:16:30 -0800989 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800991EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993int unregister_inetaddr_notifier(struct notifier_block *nb)
994{
Alan Sterne041c682006-03-27 01:16:30 -0800995 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800997EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800999/* Rename ifa_labels for a device name change. Make some effort to preserve
1000 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001*/
1002static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001003{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 struct in_ifaddr *ifa;
1005 int named = 0;
1006
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001007 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1008 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
1010 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001011 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001013 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001014 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001015 if (dot == NULL) {
1016 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 dot = old;
1018 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001019 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001020 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001021 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001022 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001023skip:
1024 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001025 }
1026}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
Breno Leitao06770842008-09-02 17:28:58 -07001028static inline bool inetdev_valid_mtu(unsigned mtu)
1029{
1030 return mtu >= 68;
1031}
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033/* Called only under RTNL semaphore */
1034
1035static int inetdev_event(struct notifier_block *this, unsigned long event,
1036 void *ptr)
1037{
1038 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -07001039 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
1041 ASSERT_RTNL();
1042
1043 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001044 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001046 if (!in_dev)
1047 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001048 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001049 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1050 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001051 }
Breno Leitao06770842008-09-02 17:28:58 -07001052 } else if (event == NETDEV_CHANGEMTU) {
1053 /* Re-enabling IP */
1054 if (inetdev_valid_mtu(dev->mtu))
1055 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 }
1057 goto out;
1058 }
1059
1060 switch (event) {
1061 case NETDEV_REGISTER:
1062 printk(KERN_DEBUG "inetdev_event: bug\n");
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001063 rcu_assign_pointer(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 break;
1065 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001066 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001068 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001069 struct in_ifaddr *ifa = inet_alloc_ifa();
1070
1071 if (ifa) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 ifa->ifa_local =
1073 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1074 ifa->ifa_prefixlen = 8;
1075 ifa->ifa_mask = inet_make_mask(8);
1076 in_dev_hold(in_dev);
1077 ifa->ifa_dev = in_dev;
1078 ifa->ifa_scope = RT_SCOPE_HOST;
1079 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1080 inet_insert_ifa(ifa);
1081 }
1082 }
1083 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001084 /* fall through */
Ian Campbell06c46482010-05-26 00:09:42 +00001085 case NETDEV_NOTIFY_PEERS:
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001086 case NETDEV_CHANGEADDR:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001087 /* Send gratuitous ARP to notify of link change */
1088 if (IN_DEV_ARP_NOTIFY(in_dev)) {
1089 struct in_ifaddr *ifa = in_dev->ifa_list;
1090
1091 if (ifa)
1092 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1093 ifa->ifa_address, dev,
1094 ifa->ifa_address, NULL,
1095 dev->dev_addr, NULL);
1096 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 break;
1098 case NETDEV_DOWN:
1099 ip_mc_down(in_dev);
1100 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001101 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001102 ip_mc_unmap(in_dev);
1103 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001104 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001105 ip_mc_remap(in_dev);
1106 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001108 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 break;
Breno Leitao06770842008-09-02 17:28:58 -07001110 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 case NETDEV_UNREGISTER:
1112 inetdev_destroy(in_dev);
1113 break;
1114 case NETDEV_CHANGENAME:
1115 /* Do not notify about label change, this event is
1116 * not interesting to applications using netlink.
1117 */
1118 inetdev_changename(dev, in_dev);
1119
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001120 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001121 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 break;
1123 }
1124out:
1125 return NOTIFY_DONE;
1126}
1127
1128static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001129 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130};
1131
Thomas Graf339bf982006-11-10 14:10:15 -08001132static inline size_t inet_nlmsg_size(void)
1133{
1134 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1135 + nla_total_size(4) /* IFA_ADDRESS */
1136 + nla_total_size(4) /* IFA_LOCAL */
1137 + nla_total_size(4) /* IFA_BROADCAST */
Thomas Graf339bf982006-11-10 14:10:15 -08001138 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1139}
1140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001142 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143{
1144 struct ifaddrmsg *ifm;
1145 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Thomas Graf47f68512006-08-04 23:04:36 -07001147 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1148 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001149 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001150
1151 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 ifm->ifa_family = AF_INET;
1153 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1154 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1155 ifm->ifa_scope = ifa->ifa_scope;
1156 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
Thomas Graf47f68512006-08-04 23:04:36 -07001158 if (ifa->ifa_address)
Al Viroa7a628c2006-09-26 22:16:43 -07001159 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
Thomas Graf47f68512006-08-04 23:04:36 -07001160
1161 if (ifa->ifa_local)
Al Viroa7a628c2006-09-26 22:16:43 -07001162 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
Thomas Graf47f68512006-08-04 23:04:36 -07001163
1164 if (ifa->ifa_broadcast)
Al Viroa7a628c2006-09-26 22:16:43 -07001165 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
Thomas Graf47f68512006-08-04 23:04:36 -07001166
Thomas Graf47f68512006-08-04 23:04:36 -07001167 if (ifa->ifa_label[0])
1168 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1169
1170 return nlmsg_end(skb, nlh);
1171
1172nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001173 nlmsg_cancel(skb, nlh);
1174 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175}
1176
1177static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1178{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001179 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001180 int h, s_h;
1181 int idx, s_idx;
1182 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 struct net_device *dev;
1184 struct in_device *in_dev;
1185 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001186 struct hlist_head *head;
1187 struct hlist_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188
Eric Dumazeteec4df92009-11-12 07:44:25 +00001189 s_h = cb->args[0];
1190 s_idx = idx = cb->args[1];
1191 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Eric Dumazeteec4df92009-11-12 07:44:25 +00001193 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1194 idx = 0;
1195 head = &net->dev_index_head[h];
1196 rcu_read_lock();
1197 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
1198 if (idx < s_idx)
1199 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001200 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001201 s_ip_idx = 0;
1202 in_dev = __in_dev_get_rcu(dev);
1203 if (!in_dev)
1204 goto cont;
1205
1206 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1207 ifa = ifa->ifa_next, ip_idx++) {
1208 if (ip_idx < s_ip_idx)
1209 continue;
1210 if (inet_fill_ifaddr(skb, ifa,
1211 NETLINK_CB(cb->skb).pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 cb->nlh->nlmsg_seq,
Eric Dumazeteec4df92009-11-12 07:44:25 +00001213 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1214 rcu_read_unlock();
1215 goto done;
1216 }
1217 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001218cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001219 idx++;
1220 }
1221 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 }
1223
1224done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001225 cb->args[0] = h;
1226 cb->args[1] = idx;
1227 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
1229 return skb->len;
1230}
1231
Jianjun Kong539afed2008-11-03 02:48:48 -08001232static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Thomas Grafd6062cb2006-08-15 00:33:59 -07001233 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234{
Thomas Graf47f68512006-08-04 23:04:36 -07001235 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001236 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1237 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001238 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001240 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001241 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001242 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001243 goto errout;
1244
1245 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001246 if (err < 0) {
1247 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1248 WARN_ON(err == -EMSGSIZE);
1249 kfree_skb(skb);
1250 goto errout;
1251 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001252 rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1253 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001254errout:
1255 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001256 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257}
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259#ifdef CONFIG_SYSCTL
1260
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001261static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001262{
1263 struct net_device *dev;
1264
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001265 rcu_read_lock();
1266 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001267 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001268
Herbert Xu31be3082007-06-04 23:35:37 -07001269 in_dev = __in_dev_get_rcu(dev);
1270 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001271 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001272 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001273 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07001274}
1275
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001276/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001277static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001278{
1279 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001280 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001281
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001282 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001283 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001284
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001285 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001286 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001287 if (on)
1288 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001289 rcu_read_lock();
1290 in_dev = __in_dev_get_rcu(dev);
1291 if (in_dev)
1292 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1293 rcu_read_unlock();
1294 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001295}
1296
Herbert Xu31be3082007-06-04 23:35:37 -07001297static int devinet_conf_proc(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001298 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07001299 size_t *lenp, loff_t *ppos)
1300{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001301 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Herbert Xu31be3082007-06-04 23:35:37 -07001302
1303 if (write) {
1304 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001305 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001306 int i = (int *)ctl->data - cnf->data;
1307
1308 set_bit(i, cnf->state);
1309
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001310 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001311 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001312 }
1313
1314 return ret;
1315}
1316
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317static int devinet_sysctl_forward(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001318 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 size_t *lenp, loff_t *ppos)
1320{
1321 int *valp = ctl->data;
1322 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00001323 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001324 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
1326 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001327 struct net *net = ctl->extra2;
1328
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001329 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00001330 if (!rtnl_trylock()) {
1331 /* Restore the original values before restarting */
1332 *valp = val;
1333 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00001334 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00001335 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001336 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1337 inet_forward_change(net);
1338 } else if (*valp) {
1339 struct ipv4_devconf *cnf = ctl->extra1;
1340 struct in_device *idev =
1341 container_of(cnf, struct in_device, cnf);
1342 dev_disable_lro(idev->dev);
1343 }
1344 rtnl_unlock();
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001345 rt_cache_flush(net, 0);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 }
1348
1349 return ret;
1350}
1351
1352int ipv4_doint_and_flush(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001353 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 size_t *lenp, loff_t *ppos)
1355{
1356 int *valp = ctl->data;
1357 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001358 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001359 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
1361 if (write && *valp != val)
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001362 rt_cache_flush(net, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 return ret;
1365}
1366
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001367#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07001368 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07001369 .procname = name, \
1370 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00001371 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001372 .maxlen = sizeof(int), \
1373 .mode = mval, \
1374 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07001375 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001376 }
1377
1378#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001379 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001380
1381#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001382 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001383
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001384#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1385 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001386
1387#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001388 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07001389
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390static struct devinet_sysctl_table {
1391 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00001392 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001393 char *dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394} devinet_sysctl = {
1395 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07001396 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001397 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07001398 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1399
1400 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1401 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1402 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1403 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1404 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1405 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1406 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00001407 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08001408 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07001409 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1410 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1411 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1412 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1413 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1414 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1415 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1416 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1417 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001418 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001419 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
Herbert Xu42f811b2007-06-04 23:34:44 -07001420
1421 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1422 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1423 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1424 "force_igmp_version"),
1425 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1426 "promote_secondaries"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428};
1429
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001430static int __devinet_sysctl_register(struct net *net, char *dev_name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001431 struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432{
1433 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001434 struct devinet_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001436#define DEVINET_CTL_PATH_DEV 3
1437
1438 struct ctl_path devinet_ctl_path[] = {
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001439 { .procname = "net", },
1440 { .procname = "ipv4", },
1441 { .procname = "conf", },
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001442 { /* to be set */ },
1443 { },
1444 };
1445
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001446 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001448 goto out;
1449
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1451 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07001452 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001453 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 }
1455
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001456 /*
1457 * Make a copy of dev_name, because '.procname' is regarded as const
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 * by sysctl and we wouldn't want anyone to change it under our feet
1459 * (see SIOCSIFNAME).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001460 */
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001461 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1462 if (!t->dev_name)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001463 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001465 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001467 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001468 t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 if (!t->sysctl_header)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001470 goto free_procname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
1472 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001473 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001475free_procname:
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001476 kfree(t->dev_name);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001477free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001479out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001480 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481}
1482
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001483static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1484{
1485 struct devinet_sysctl_table *t = cnf->sysctl;
1486
1487 if (t == NULL)
1488 return;
1489
1490 cnf->sysctl = NULL;
1491 unregister_sysctl_table(t->sysctl_header);
1492 kfree(t->dev_name);
1493 kfree(t);
1494}
1495
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001496static void devinet_sysctl_register(struct in_device *idev)
1497{
Eric W. Biederman54716e32010-02-14 03:27:03 +00001498 neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001499 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001500 &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001501}
1502
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001503static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001505 __devinet_sysctl_unregister(&idev->cnf);
1506 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001509static struct ctl_table ctl_forward_entry[] = {
1510 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001511 .procname = "ip_forward",
1512 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00001513 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001514 .maxlen = sizeof(int),
1515 .mode = 0644,
1516 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001517 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001518 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001519 },
1520 { },
1521};
1522
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001523static __net_initdata struct ctl_path net_ipv4_path[] = {
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001524 { .procname = "net", },
1525 { .procname = "ipv4", },
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001526 { },
1527};
Eric Dumazet2a75de02008-01-05 23:08:49 -08001528#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001529
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001530static __net_init int devinet_init_net(struct net *net)
1531{
1532 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001533 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001534#ifdef CONFIG_SYSCTL
1535 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001536 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001537#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001538
1539 err = -ENOMEM;
1540 all = &ipv4_devconf;
1541 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001542
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08001543 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001544 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1545 if (all == NULL)
1546 goto err_alloc_all;
1547
1548 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1549 if (dflt == NULL)
1550 goto err_alloc_dflt;
1551
Eric Dumazet2a75de02008-01-05 23:08:49 -08001552#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001553 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1554 if (tbl == NULL)
1555 goto err_alloc_ctl;
1556
Eric W. Biederman02291682010-02-14 03:25:51 +00001557 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001558 tbl[0].extra1 = all;
1559 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001560#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001561 }
1562
1563#ifdef CONFIG_SYSCTL
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001564 err = __devinet_sysctl_register(net, "all", all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001565 if (err < 0)
1566 goto err_reg_all;
1567
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001568 err = __devinet_sysctl_register(net, "default", dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001569 if (err < 0)
1570 goto err_reg_dflt;
1571
1572 err = -ENOMEM;
1573 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1574 if (forw_hdr == NULL)
1575 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001576 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001577#endif
1578
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001579 net->ipv4.devconf_all = all;
1580 net->ipv4.devconf_dflt = dflt;
1581 return 0;
1582
1583#ifdef CONFIG_SYSCTL
1584err_reg_ctl:
1585 __devinet_sysctl_unregister(dflt);
1586err_reg_dflt:
1587 __devinet_sysctl_unregister(all);
1588err_reg_all:
1589 if (tbl != ctl_forward_entry)
1590 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001591err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08001592#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001593 if (dflt != &ipv4_devconf_dflt)
1594 kfree(dflt);
1595err_alloc_dflt:
1596 if (all != &ipv4_devconf)
1597 kfree(all);
1598err_alloc_all:
1599 return err;
1600}
1601
1602static __net_exit void devinet_exit_net(struct net *net)
1603{
Eric Dumazet2a75de02008-01-05 23:08:49 -08001604#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001605 struct ctl_table *tbl;
1606
1607 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001608 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1609 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1610 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001611 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08001612#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001613 kfree(net->ipv4.devconf_dflt);
1614 kfree(net->ipv4.devconf_all);
1615}
1616
1617static __net_initdata struct pernet_operations devinet_ops = {
1618 .init = devinet_init_net,
1619 .exit = devinet_exit_net,
1620};
1621
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622void __init devinet_init(void)
1623{
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001624 register_pernet_subsys(&devinet_ops);
1625
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 register_gifconf(PF_INET, inet_gifconf);
1627 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07001628
1629 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1630 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1631 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632}
1633