blob: 382bc768ed565cc79bc79c8c71fa0588d2a7a78b [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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 dev->ip_ptr = NULL;
213
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
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800406struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
408 struct net_device *dev;
409 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000410
411 rcu_read_lock();
412 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (dev)
414 in_dev = in_dev_get(dev);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000415 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return in_dev;
417}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800418EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420/* Called only from RTNL semaphored context. No locks. */
421
Al Viro60cad5d2006-09-26 22:17:09 -0700422struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
423 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
425 ASSERT_RTNL();
426
427 for_primary_ifa(in_dev) {
428 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
429 return ifa;
430 } endfor_ifa(in_dev);
431 return NULL;
432}
433
434static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
435{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900436 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700437 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700439 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700441 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 ASSERT_RTNL();
444
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700445 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
446 if (err < 0)
447 goto errout;
448
449 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800450 in_dev = inetdev_by_index(net, ifm->ifa_index);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700451 if (in_dev == NULL) {
452 err = -ENODEV;
453 goto errout;
454 }
455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 __in_dev_put(in_dev);
457
458 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
459 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700460 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700461 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700463
464 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
465 continue;
466
467 if (tb[IFA_ADDRESS] &&
468 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700469 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700470 continue;
471
Thomas Grafd6062cb2006-08-15 00:33:59 -0700472 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return 0;
474 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700475
476 err = -EADDRNOTAVAIL;
477errout:
478 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479}
480
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800481static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
Thomas Graf5c753972006-08-04 23:03:53 -0700483 struct nlattr *tb[IFA_MAX+1];
484 struct in_ifaddr *ifa;
485 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 struct net_device *dev;
487 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800488 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Thomas Graf5c753972006-08-04 23:03:53 -0700490 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
491 if (err < 0)
492 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Thomas Graf5c753972006-08-04 23:03:53 -0700494 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800495 err = -EINVAL;
496 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700497 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800499 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800500 err = -ENODEV;
501 if (dev == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700502 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Thomas Graf5c753972006-08-04 23:03:53 -0700504 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800505 err = -ENOBUFS;
506 if (in_dev == NULL)
Herbert Xu71e27da2007-06-04 23:36:06 -0700507 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Thomas Graf5c753972006-08-04 23:03:53 -0700509 ifa = inet_alloc_ifa();
Denis V. Lunev7b218572008-01-31 18:47:00 -0800510 if (ifa == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700511 /*
512 * A potential indev allocation can be left alive, it stays
513 * assigned to its device and is destroy with it.
514 */
Thomas Graf5c753972006-08-04 23:03:53 -0700515 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700516
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800517 ipv4_devconf_setall(in_dev);
Thomas Graf5c753972006-08-04 23:03:53 -0700518 in_dev_hold(in_dev);
519
520 if (tb[IFA_ADDRESS] == NULL)
521 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
524 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 ifa->ifa_flags = ifm->ifa_flags;
526 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700527 ifa->ifa_dev = in_dev;
528
Al Viroa7a628c2006-09-26 22:16:43 -0700529 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
530 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700531
532 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700533 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700534
Thomas Graf5c753972006-08-04 23:03:53 -0700535 if (tb[IFA_LABEL])
536 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 else
538 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
539
Thomas Graf5c753972006-08-04 23:03:53 -0700540 return ifa;
541
542errout:
543 return ERR_PTR(err);
544}
545
546static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
547{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900548 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700549 struct in_ifaddr *ifa;
550
551 ASSERT_RTNL();
552
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800553 ifa = rtm_to_ifaddr(net, nlh);
Thomas Graf5c753972006-08-04 23:03:53 -0700554 if (IS_ERR(ifa))
555 return PTR_ERR(ifa);
556
Thomas Grafd6062cb2006-08-15 00:33:59 -0700557 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
559
560/*
561 * Determine a default network mask, based on the IP address.
562 */
563
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800564static inline int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
566 int rc = -1; /* Something else, probably a multicast. */
567
Joe Perchesf97c1e02007-12-16 13:45:43 -0800568 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900569 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 else {
Al Viro714e85b2006-11-14 20:51:49 -0800571 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Al Viro714e85b2006-11-14 20:51:49 -0800573 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800575 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800577 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 rc = 24;
579 }
580
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900581 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
584
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800585int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
587 struct ifreq ifr;
588 struct sockaddr_in sin_orig;
589 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
590 struct in_device *in_dev;
591 struct in_ifaddr **ifap = NULL;
592 struct in_ifaddr *ifa = NULL;
593 struct net_device *dev;
594 char *colon;
595 int ret = -EFAULT;
596 int tryaddrmatch = 0;
597
598 /*
599 * Fetch the caller's info block into kernel space
600 */
601
602 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
603 goto out;
604 ifr.ifr_name[IFNAMSIZ - 1] = 0;
605
606 /* save original address for comparison */
607 memcpy(&sin_orig, sin, sizeof(*sin));
608
609 colon = strchr(ifr.ifr_name, ':');
610 if (colon)
611 *colon = 0;
612
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800613 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Stephen Hemminger132adf52007-03-08 20:44:43 -0800615 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 case SIOCGIFADDR: /* Get interface address */
617 case SIOCGIFBRDADDR: /* Get the broadcast address */
618 case SIOCGIFDSTADDR: /* Get the destination address */
619 case SIOCGIFNETMASK: /* Get the netmask for the interface */
620 /* Note that these ioctls will not sleep,
621 so that we do not impose a lock.
622 One day we will be forced to put shlock here (I mean SMP)
623 */
624 tryaddrmatch = (sin_orig.sin_family == AF_INET);
625 memset(sin, 0, sizeof(*sin));
626 sin->sin_family = AF_INET;
627 break;
628
629 case SIOCSIFFLAGS:
630 ret = -EACCES;
631 if (!capable(CAP_NET_ADMIN))
632 goto out;
633 break;
634 case SIOCSIFADDR: /* Set interface address (and family) */
635 case SIOCSIFBRDADDR: /* Set the broadcast address */
636 case SIOCSIFDSTADDR: /* Set the destination address */
637 case SIOCSIFNETMASK: /* Set the netmask for the interface */
638 ret = -EACCES;
639 if (!capable(CAP_NET_ADMIN))
640 goto out;
641 ret = -EINVAL;
642 if (sin->sin_family != AF_INET)
643 goto out;
644 break;
645 default:
646 ret = -EINVAL;
647 goto out;
648 }
649
650 rtnl_lock();
651
652 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800653 dev = __dev_get_by_name(net, ifr.ifr_name);
654 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 goto done;
656
657 if (colon)
658 *colon = ':';
659
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800660 in_dev = __in_dev_get_rtnl(dev);
661 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (tryaddrmatch) {
663 /* Matthias Andree */
664 /* compare label and address (4.4BSD style) */
665 /* note: we only do this for a limited set of ioctls
666 and only if the original address family was AF_INET.
667 This is checked above. */
668 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
669 ifap = &ifa->ifa_next) {
670 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
671 sin_orig.sin_addr.s_addr ==
672 ifa->ifa_address) {
673 break; /* found */
674 }
675 }
676 }
677 /* we didn't get a match, maybe the application is
678 4.3BSD-style and passed in junk so we fall back to
679 comparing just the label */
680 if (!ifa) {
681 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
682 ifap = &ifa->ifa_next)
683 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
684 break;
685 }
686 }
687
688 ret = -EADDRNOTAVAIL;
689 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
690 goto done;
691
Stephen Hemminger132adf52007-03-08 20:44:43 -0800692 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 case SIOCGIFADDR: /* Get interface address */
694 sin->sin_addr.s_addr = ifa->ifa_local;
695 goto rarok;
696
697 case SIOCGIFBRDADDR: /* Get the broadcast address */
698 sin->sin_addr.s_addr = ifa->ifa_broadcast;
699 goto rarok;
700
701 case SIOCGIFDSTADDR: /* Get the destination address */
702 sin->sin_addr.s_addr = ifa->ifa_address;
703 goto rarok;
704
705 case SIOCGIFNETMASK: /* Get the netmask for the interface */
706 sin->sin_addr.s_addr = ifa->ifa_mask;
707 goto rarok;
708
709 case SIOCSIFFLAGS:
710 if (colon) {
711 ret = -EADDRNOTAVAIL;
712 if (!ifa)
713 break;
714 ret = 0;
715 if (!(ifr.ifr_flags & IFF_UP))
716 inet_del_ifa(in_dev, ifap, 1);
717 break;
718 }
719 ret = dev_change_flags(dev, ifr.ifr_flags);
720 break;
721
722 case SIOCSIFADDR: /* Set interface address (and family) */
723 ret = -EINVAL;
724 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
725 break;
726
727 if (!ifa) {
728 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800729 ifa = inet_alloc_ifa();
730 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 break;
732 if (colon)
733 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
734 else
735 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
736 } else {
737 ret = 0;
738 if (ifa->ifa_local == sin->sin_addr.s_addr)
739 break;
740 inet_del_ifa(in_dev, ifap, 0);
741 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -0800742 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
744
745 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
746
747 if (!(dev->flags & IFF_POINTOPOINT)) {
748 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
749 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
750 if ((dev->flags & IFF_BROADCAST) &&
751 ifa->ifa_prefixlen < 31)
752 ifa->ifa_broadcast = ifa->ifa_address |
753 ~ifa->ifa_mask;
754 } else {
755 ifa->ifa_prefixlen = 32;
756 ifa->ifa_mask = inet_make_mask(32);
757 }
758 ret = inet_set_ifa(dev, ifa);
759 break;
760
761 case SIOCSIFBRDADDR: /* Set the broadcast address */
762 ret = 0;
763 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
764 inet_del_ifa(in_dev, ifap, 0);
765 ifa->ifa_broadcast = sin->sin_addr.s_addr;
766 inet_insert_ifa(ifa);
767 }
768 break;
769
770 case SIOCSIFDSTADDR: /* Set the destination address */
771 ret = 0;
772 if (ifa->ifa_address == sin->sin_addr.s_addr)
773 break;
774 ret = -EINVAL;
775 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
776 break;
777 ret = 0;
778 inet_del_ifa(in_dev, ifap, 0);
779 ifa->ifa_address = sin->sin_addr.s_addr;
780 inet_insert_ifa(ifa);
781 break;
782
783 case SIOCSIFNETMASK: /* Set the netmask for the interface */
784
785 /*
786 * The mask we set must be legal.
787 */
788 ret = -EINVAL;
789 if (bad_mask(sin->sin_addr.s_addr, 0))
790 break;
791 ret = 0;
792 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -0700793 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 inet_del_ifa(in_dev, ifap, 0);
795 ifa->ifa_mask = sin->sin_addr.s_addr;
796 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
797
798 /* See if current broadcast address matches
799 * with current netmask, then recalculate
800 * the broadcast address. Otherwise it's a
801 * funny address, so don't touch it since
802 * the user seems to know what (s)he's doing...
803 */
804 if ((dev->flags & IFF_BROADCAST) &&
805 (ifa->ifa_prefixlen < 31) &&
806 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -0500807 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 ifa->ifa_broadcast = (ifa->ifa_local |
809 ~sin->sin_addr.s_addr);
810 }
811 inet_insert_ifa(ifa);
812 }
813 break;
814 }
815done:
816 rtnl_unlock();
817out:
818 return ret;
819rarok:
820 rtnl_unlock();
821 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
822 goto out;
823}
824
825static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
826{
Herbert Xue5ed6392005-10-03 14:35:55 -0700827 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 struct in_ifaddr *ifa;
829 struct ifreq ifr;
830 int done = 0;
831
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800832 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 goto out;
834
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800835 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 if (!buf) {
837 done += sizeof(ifr);
838 continue;
839 }
840 if (len < (int) sizeof(ifr))
841 break;
842 memset(&ifr, 0, sizeof(struct ifreq));
843 if (ifa->ifa_label)
844 strcpy(ifr.ifr_name, ifa->ifa_label);
845 else
846 strcpy(ifr.ifr_name, dev->name);
847
848 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
849 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
850 ifa->ifa_local;
851
852 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
853 done = -EFAULT;
854 break;
855 }
856 buf += sizeof(struct ifreq);
857 len -= sizeof(struct ifreq);
858 done += sizeof(struct ifreq);
859 }
860out:
861 return done;
862}
863
Al Viroa61ced52006-09-26 21:27:54 -0700864__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865{
Al Viroa61ced52006-09-26 21:27:54 -0700866 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900868 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
870 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700871 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (!in_dev)
873 goto no_in_dev;
874
875 for_primary_ifa(in_dev) {
876 if (ifa->ifa_scope > scope)
877 continue;
878 if (!dst || inet_ifa_match(dst, ifa)) {
879 addr = ifa->ifa_local;
880 break;
881 }
882 if (!addr)
883 addr = ifa->ifa_local;
884 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
886 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800887 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800888no_in_dev:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
890 /* Not loopback addresses on loopback should be preferred
891 in this case. It is importnat that lo is the first interface
892 in dev_base list.
893 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800894 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800895 in_dev = __in_dev_get_rcu(dev);
896 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 continue;
898
899 for_primary_ifa(in_dev) {
900 if (ifa->ifa_scope != RT_SCOPE_LINK &&
901 ifa->ifa_scope <= scope) {
902 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800903 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 }
905 } endfor_ifa(in_dev);
906 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800907out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 return addr;
910}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800911EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Al Viro60cad5d2006-09-26 22:17:09 -0700913static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
914 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
916 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -0700917 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 for_ifa(in_dev) {
920 if (!addr &&
921 (local == ifa->ifa_local || !local) &&
922 ifa->ifa_scope <= scope) {
923 addr = ifa->ifa_local;
924 if (same)
925 break;
926 }
927 if (!same) {
928 same = (!local || inet_ifa_match(local, ifa)) &&
929 (!dst || inet_ifa_match(dst, ifa));
930 if (same && addr) {
931 if (local || !dst)
932 break;
933 /* Is the selected addr into dst subnet? */
934 if (inet_ifa_match(addr, ifa))
935 break;
936 /* No, then can we use new local src? */
937 if (ifa->ifa_scope <= scope) {
938 addr = ifa->ifa_local;
939 break;
940 }
941 /* search for large dst subnet for addr */
942 same = 0;
943 }
944 }
945 } endfor_ifa(in_dev);
946
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800947 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948}
949
950/*
951 * Confirm that local IP address exists using wildcards:
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800952 * - in_dev: only on this interface, 0=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 * - dst: only in the same subnet as dst, 0=any dst
954 * - local: address, 0=autoselect the local address
955 * - scope: maximum allowed scope value for the local address
956 */
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800957__be32 inet_confirm_addr(struct in_device *in_dev,
958 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959{
Al Viro60cad5d2006-09-26 22:17:09 -0700960 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800961 struct net_device *dev;
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800962 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800964 if (scope != RT_SCOPE_LINK)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800965 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900967 net = dev_net(in_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800969 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800970 in_dev = __in_dev_get_rcu(dev);
971 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 addr = confirm_addr_indev(in_dev, dst, local, scope);
973 if (addr)
974 break;
975 }
976 }
977 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 return addr;
980}
981
982/*
983 * Device notifier
984 */
985
986int register_inetaddr_notifier(struct notifier_block *nb)
987{
Alan Sterne041c682006-03-27 01:16:30 -0800988 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800990EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
992int unregister_inetaddr_notifier(struct notifier_block *nb)
993{
Alan Sterne041c682006-03-27 01:16:30 -0800994 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800996EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800998/* Rename ifa_labels for a device name change. Make some effort to preserve
999 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000*/
1001static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001002{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 struct in_ifaddr *ifa;
1004 int named = 0;
1005
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001006 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1007 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
1009 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001010 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001012 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001013 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001014 if (dot == NULL) {
1015 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 dot = old;
1017 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001018 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001019 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001020 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001021 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001022skip:
1023 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001024 }
1025}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
Breno Leitao06770842008-09-02 17:28:58 -07001027static inline bool inetdev_valid_mtu(unsigned mtu)
1028{
1029 return mtu >= 68;
1030}
1031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032/* Called only under RTNL semaphore */
1033
1034static int inetdev_event(struct notifier_block *this, unsigned long event,
1035 void *ptr)
1036{
1037 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -07001038 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
1040 ASSERT_RTNL();
1041
1042 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001043 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001045 if (!in_dev)
1046 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001047 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001048 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1049 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001050 }
Breno Leitao06770842008-09-02 17:28:58 -07001051 } else if (event == NETDEV_CHANGEMTU) {
1052 /* Re-enabling IP */
1053 if (inetdev_valid_mtu(dev->mtu))
1054 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 }
1056 goto out;
1057 }
1058
1059 switch (event) {
1060 case NETDEV_REGISTER:
1061 printk(KERN_DEBUG "inetdev_event: bug\n");
1062 dev->ip_ptr = NULL;
1063 break;
1064 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001065 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001067 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001068 struct in_ifaddr *ifa = inet_alloc_ifa();
1069
1070 if (ifa) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 ifa->ifa_local =
1072 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1073 ifa->ifa_prefixlen = 8;
1074 ifa->ifa_mask = inet_make_mask(8);
1075 in_dev_hold(in_dev);
1076 ifa->ifa_dev = in_dev;
1077 ifa->ifa_scope = RT_SCOPE_HOST;
1078 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1079 inet_insert_ifa(ifa);
1080 }
1081 }
1082 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001083 /* fall through */
1084 case NETDEV_CHANGEADDR:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001085 /* Send gratuitous ARP to notify of link change */
1086 if (IN_DEV_ARP_NOTIFY(in_dev)) {
1087 struct in_ifaddr *ifa = in_dev->ifa_list;
1088
1089 if (ifa)
1090 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1091 ifa->ifa_address, dev,
1092 ifa->ifa_address, NULL,
1093 dev->dev_addr, NULL);
1094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 break;
1096 case NETDEV_DOWN:
1097 ip_mc_down(in_dev);
1098 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001099 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001100 ip_mc_unmap(in_dev);
1101 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001102 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001103 ip_mc_remap(in_dev);
1104 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001106 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 break;
Breno Leitao06770842008-09-02 17:28:58 -07001108 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 case NETDEV_UNREGISTER:
1110 inetdev_destroy(in_dev);
1111 break;
1112 case NETDEV_CHANGENAME:
1113 /* Do not notify about label change, this event is
1114 * not interesting to applications using netlink.
1115 */
1116 inetdev_changename(dev, in_dev);
1117
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001118 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001119 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 break;
1121 }
1122out:
1123 return NOTIFY_DONE;
1124}
1125
1126static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001127 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128};
1129
Thomas Graf339bf982006-11-10 14:10:15 -08001130static inline size_t inet_nlmsg_size(void)
1131{
1132 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1133 + nla_total_size(4) /* IFA_ADDRESS */
1134 + nla_total_size(4) /* IFA_LOCAL */
1135 + nla_total_size(4) /* IFA_BROADCAST */
Thomas Graf339bf982006-11-10 14:10:15 -08001136 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1137}
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001140 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141{
1142 struct ifaddrmsg *ifm;
1143 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Thomas Graf47f68512006-08-04 23:04:36 -07001145 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1146 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001147 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001148
1149 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 ifm->ifa_family = AF_INET;
1151 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1152 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1153 ifm->ifa_scope = ifa->ifa_scope;
1154 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
Thomas Graf47f68512006-08-04 23:04:36 -07001156 if (ifa->ifa_address)
Al Viroa7a628c2006-09-26 22:16:43 -07001157 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
Thomas Graf47f68512006-08-04 23:04:36 -07001158
1159 if (ifa->ifa_local)
Al Viroa7a628c2006-09-26 22:16:43 -07001160 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
Thomas Graf47f68512006-08-04 23:04:36 -07001161
1162 if (ifa->ifa_broadcast)
Al Viroa7a628c2006-09-26 22:16:43 -07001163 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
Thomas Graf47f68512006-08-04 23:04:36 -07001164
Thomas Graf47f68512006-08-04 23:04:36 -07001165 if (ifa->ifa_label[0])
1166 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1167
1168 return nlmsg_end(skb, nlh);
1169
1170nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001171 nlmsg_cancel(skb, nlh);
1172 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173}
1174
1175static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1176{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001177 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001178 int h, s_h;
1179 int idx, s_idx;
1180 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 struct net_device *dev;
1182 struct in_device *in_dev;
1183 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001184 struct hlist_head *head;
1185 struct hlist_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Eric Dumazeteec4df92009-11-12 07:44:25 +00001187 s_h = cb->args[0];
1188 s_idx = idx = cb->args[1];
1189 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Eric Dumazeteec4df92009-11-12 07:44:25 +00001191 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1192 idx = 0;
1193 head = &net->dev_index_head[h];
1194 rcu_read_lock();
1195 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
1196 if (idx < s_idx)
1197 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001198 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001199 s_ip_idx = 0;
1200 in_dev = __in_dev_get_rcu(dev);
1201 if (!in_dev)
1202 goto cont;
1203
1204 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1205 ifa = ifa->ifa_next, ip_idx++) {
1206 if (ip_idx < s_ip_idx)
1207 continue;
1208 if (inet_fill_ifaddr(skb, ifa,
1209 NETLINK_CB(cb->skb).pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 cb->nlh->nlmsg_seq,
Eric Dumazeteec4df92009-11-12 07:44:25 +00001211 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1212 rcu_read_unlock();
1213 goto done;
1214 }
1215 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001216cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001217 idx++;
1218 }
1219 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 }
1221
1222done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001223 cb->args[0] = h;
1224 cb->args[1] = idx;
1225 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
1227 return skb->len;
1228}
1229
Jianjun Kong539afed2008-11-03 02:48:48 -08001230static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Thomas Grafd6062cb2006-08-15 00:33:59 -07001231 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
Thomas Graf47f68512006-08-04 23:04:36 -07001233 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001234 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1235 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001236 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001238 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001239 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001240 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001241 goto errout;
1242
1243 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001244 if (err < 0) {
1245 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1246 WARN_ON(err == -EMSGSIZE);
1247 kfree_skb(skb);
1248 goto errout;
1249 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001250 rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1251 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001252errout:
1253 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001254 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255}
1256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257#ifdef CONFIG_SYSCTL
1258
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001259static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001260{
1261 struct net_device *dev;
1262
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001263 rcu_read_lock();
1264 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001265 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001266
Herbert Xu31be3082007-06-04 23:35:37 -07001267 in_dev = __in_dev_get_rcu(dev);
1268 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001269 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001270 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001271 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07001272}
1273
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001274/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001275static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001276{
1277 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001278 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001279
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001280 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001281 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001282
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001283 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001284 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001285 if (on)
1286 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001287 rcu_read_lock();
1288 in_dev = __in_dev_get_rcu(dev);
1289 if (in_dev)
1290 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1291 rcu_read_unlock();
1292 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001293}
1294
Herbert Xu31be3082007-06-04 23:35:37 -07001295static int devinet_conf_proc(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001296 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07001297 size_t *lenp, loff_t *ppos)
1298{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001299 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Herbert Xu31be3082007-06-04 23:35:37 -07001300
1301 if (write) {
1302 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001303 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001304 int i = (int *)ctl->data - cnf->data;
1305
1306 set_bit(i, cnf->state);
1307
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001308 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001309 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001310 }
1311
1312 return ret;
1313}
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315static int devinet_sysctl_forward(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001316 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 size_t *lenp, loff_t *ppos)
1318{
1319 int *valp = ctl->data;
1320 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00001321 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001322 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
1324 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001325 struct net *net = ctl->extra2;
1326
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001327 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00001328 if (!rtnl_trylock()) {
1329 /* Restore the original values before restarting */
1330 *valp = val;
1331 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00001332 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00001333 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001334 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1335 inet_forward_change(net);
1336 } else if (*valp) {
1337 struct ipv4_devconf *cnf = ctl->extra1;
1338 struct in_device *idev =
1339 container_of(cnf, struct in_device, cnf);
1340 dev_disable_lro(idev->dev);
1341 }
1342 rtnl_unlock();
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001343 rt_cache_flush(net, 0);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001344 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 }
1346
1347 return ret;
1348}
1349
1350int ipv4_doint_and_flush(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001351 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 size_t *lenp, loff_t *ppos)
1353{
1354 int *valp = ctl->data;
1355 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001356 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001357 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 if (write && *valp != val)
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001360 rt_cache_flush(net, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361
1362 return ret;
1363}
1364
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001365#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07001366 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07001367 .procname = name, \
1368 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00001369 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001370 .maxlen = sizeof(int), \
1371 .mode = mval, \
1372 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07001373 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001374 }
1375
1376#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001377 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001378
1379#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001380 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001381
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001382#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1383 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001384
1385#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001386 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07001387
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388static struct devinet_sysctl_table {
1389 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00001390 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001391 char *dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392} devinet_sysctl = {
1393 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07001394 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001395 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07001396 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1397
1398 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1399 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1400 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1401 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1402 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1403 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1404 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00001405 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08001406 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07001407 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1408 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1409 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1410 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1411 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1412 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1413 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1414 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1415 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001416 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001417 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
Herbert Xu42f811b2007-06-04 23:34:44 -07001418
1419 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1420 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1421 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1422 "force_igmp_version"),
1423 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1424 "promote_secondaries"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426};
1427
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001428static int __devinet_sysctl_register(struct net *net, char *dev_name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001429 struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430{
1431 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001432 struct devinet_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001434#define DEVINET_CTL_PATH_DEV 3
1435
1436 struct ctl_path devinet_ctl_path[] = {
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001437 { .procname = "net", },
1438 { .procname = "ipv4", },
1439 { .procname = "conf", },
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001440 { /* to be set */ },
1441 { },
1442 };
1443
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001444 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001446 goto out;
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1449 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07001450 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001451 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 }
1453
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001454 /*
1455 * Make a copy of dev_name, because '.procname' is regarded as const
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 * by sysctl and we wouldn't want anyone to change it under our feet
1457 * (see SIOCSIFNAME).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001458 */
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001459 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1460 if (!t->dev_name)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001461 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001463 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001465 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001466 t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 if (!t->sysctl_header)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001468 goto free_procname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469
1470 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001471 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001473free_procname:
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001474 kfree(t->dev_name);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001475free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001477out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001478 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479}
1480
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001481static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1482{
1483 struct devinet_sysctl_table *t = cnf->sysctl;
1484
1485 if (t == NULL)
1486 return;
1487
1488 cnf->sysctl = NULL;
1489 unregister_sysctl_table(t->sysctl_header);
1490 kfree(t->dev_name);
1491 kfree(t);
1492}
1493
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001494static void devinet_sysctl_register(struct in_device *idev)
1495{
Eric W. Biederman54716e32010-02-14 03:27:03 +00001496 neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001497 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001498 &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001499}
1500
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001501static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001503 __devinet_sysctl_unregister(&idev->cnf);
1504 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001507static struct ctl_table ctl_forward_entry[] = {
1508 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001509 .procname = "ip_forward",
1510 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00001511 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001512 .maxlen = sizeof(int),
1513 .mode = 0644,
1514 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001515 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001516 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001517 },
1518 { },
1519};
1520
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001521static __net_initdata struct ctl_path net_ipv4_path[] = {
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001522 { .procname = "net", },
1523 { .procname = "ipv4", },
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001524 { },
1525};
Eric Dumazet2a75de02008-01-05 23:08:49 -08001526#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001527
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001528static __net_init int devinet_init_net(struct net *net)
1529{
1530 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001531 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001532#ifdef CONFIG_SYSCTL
1533 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001534 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001535#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001536
1537 err = -ENOMEM;
1538 all = &ipv4_devconf;
1539 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001540
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08001541 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001542 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1543 if (all == NULL)
1544 goto err_alloc_all;
1545
1546 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1547 if (dflt == NULL)
1548 goto err_alloc_dflt;
1549
Eric Dumazet2a75de02008-01-05 23:08:49 -08001550#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001551 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1552 if (tbl == NULL)
1553 goto err_alloc_ctl;
1554
Eric W. Biederman02291682010-02-14 03:25:51 +00001555 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001556 tbl[0].extra1 = all;
1557 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001558#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001559 }
1560
1561#ifdef CONFIG_SYSCTL
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001562 err = __devinet_sysctl_register(net, "all", all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001563 if (err < 0)
1564 goto err_reg_all;
1565
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001566 err = __devinet_sysctl_register(net, "default", dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001567 if (err < 0)
1568 goto err_reg_dflt;
1569
1570 err = -ENOMEM;
1571 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1572 if (forw_hdr == NULL)
1573 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001574 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001575#endif
1576
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001577 net->ipv4.devconf_all = all;
1578 net->ipv4.devconf_dflt = dflt;
1579 return 0;
1580
1581#ifdef CONFIG_SYSCTL
1582err_reg_ctl:
1583 __devinet_sysctl_unregister(dflt);
1584err_reg_dflt:
1585 __devinet_sysctl_unregister(all);
1586err_reg_all:
1587 if (tbl != ctl_forward_entry)
1588 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001589err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08001590#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001591 if (dflt != &ipv4_devconf_dflt)
1592 kfree(dflt);
1593err_alloc_dflt:
1594 if (all != &ipv4_devconf)
1595 kfree(all);
1596err_alloc_all:
1597 return err;
1598}
1599
1600static __net_exit void devinet_exit_net(struct net *net)
1601{
Eric Dumazet2a75de02008-01-05 23:08:49 -08001602#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001603 struct ctl_table *tbl;
1604
1605 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001606 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1607 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1608 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001609 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08001610#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001611 kfree(net->ipv4.devconf_dflt);
1612 kfree(net->ipv4.devconf_all);
1613}
1614
1615static __net_initdata struct pernet_operations devinet_ops = {
1616 .init = devinet_init_net,
1617 .exit = devinet_exit_net,
1618};
1619
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620void __init devinet_init(void)
1621{
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001622 register_pernet_subsys(&devinet_ops);
1623
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 register_gifconf(PF_INET, inet_gifconf);
1625 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07001626
1627 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1628 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1629 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630}
1631