blob: b12dae2b0b2dbcc527eee09a5d7309ffd4852ebc [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>
53#ifdef CONFIG_SYSCTL
54#include <linux/sysctl.h>
55#endif
56#include <linux/kmod.h>
57
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020058#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/ip.h>
60#include <net/route.h>
61#include <net/ip_fib.h>
Thomas Graf63f34442007-03-22 11:55:17 -070062#include <net/rtnetlink.h>
Pavel Emelyanov752d14d2007-12-16 13:31:47 -080063#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Adrian Bunk0027ba82008-01-31 17:17:31 -080065static struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070066 .data = {
67 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
68 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
69 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
70 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
71 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070072};
73
74static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070075 .data = {
76 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
77 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
78 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
79 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
80 [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
81 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070082};
83
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -080084#define IPV4_DEVCONF_DFLT(net, attr) \
85 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
Herbert Xu42f811b2007-06-04 23:34:44 -070086
Patrick McHardyef7c79e2007-06-05 12:38:30 -070087static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
Thomas Graf5c753972006-08-04 23:03:53 -070088 [IFA_LOCAL] = { .type = NLA_U32 },
89 [IFA_ADDRESS] = { .type = NLA_U32 },
90 [IFA_BROADCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -070091 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Thomas Graf5c753972006-08-04 23:03:53 -070092};
93
Thomas Grafd6062cb2006-08-15 00:33:59 -070094static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Alan Sterne041c682006-03-27 01:16:30 -080096static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
98 int destroy);
99#ifdef CONFIG_SYSCTL
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100100static void devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800101static void devinet_sysctl_unregister(struct in_device *idev);
102#else
103static inline void devinet_sysctl_register(struct in_device *idev)
104{
105}
106static inline void devinet_sysctl_unregister(struct in_device *idev)
107{
108}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109#endif
110
111/* Locks all the inet devices. */
112
113static struct in_ifaddr *inet_alloc_ifa(void)
114{
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700115 struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117 if (ifa) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 INIT_RCU_HEAD(&ifa->rcu_head);
119 }
120
121 return ifa;
122}
123
124static void inet_rcu_free_ifa(struct rcu_head *head)
125{
126 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
127 if (ifa->ifa_dev)
128 in_dev_put(ifa->ifa_dev);
129 kfree(ifa);
130}
131
132static inline void inet_free_ifa(struct in_ifaddr *ifa)
133{
134 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
135}
136
137void in_dev_finish_destroy(struct in_device *idev)
138{
139 struct net_device *dev = idev->dev;
140
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700141 WARN_ON(idev->ifa_list);
142 WARN_ON(idev->mc_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143#ifdef NET_REFCNT_DEBUG
144 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
145 idev, dev ? dev->name : "NIL");
146#endif
147 dev_put(dev);
148 if (!idev->dead)
149 printk("Freeing alive in_device %p\n", idev);
150 else {
151 kfree(idev);
152 }
153}
154
Herbert Xu71e27da2007-06-04 23:36:06 -0700155static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
157 struct in_device *in_dev;
158
159 ASSERT_RTNL();
160
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700161 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 if (!in_dev)
163 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 INIT_RCU_HEAD(&in_dev->rcu_head);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900165 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800166 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 in_dev->cnf.sysctl = NULL;
168 in_dev->dev = dev;
169 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
170 goto out_kfree;
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700171 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
172 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 /* Reference in_dev->dev */
174 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800175 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100178 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 ip_mc_init_dev(in_dev);
180 if (dev->flags & IFF_UP)
181 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800182
David L Stevens30c4cf52007-01-04 12:31:14 -0800183 /* we can receive as soon as ip_ptr is set -- do this last */
184 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800185out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 return in_dev;
187out_kfree:
188 kfree(in_dev);
189 in_dev = NULL;
190 goto out;
191}
192
193static void in_dev_rcu_put(struct rcu_head *head)
194{
195 struct in_device *idev = container_of(head, struct in_device, rcu_head);
196 in_dev_put(idev);
197}
198
199static void inetdev_destroy(struct in_device *in_dev)
200{
201 struct in_ifaddr *ifa;
202 struct net_device *dev;
203
204 ASSERT_RTNL();
205
206 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 in_dev->dead = 1;
209
210 ip_mc_destroy_dev(in_dev);
211
212 while ((ifa = in_dev->ifa_list) != NULL) {
213 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
214 inet_free_ifa(ifa);
215 }
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 dev->ip_ptr = NULL;
218
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800219 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
221 arp_ifdown(dev);
222
223 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
224}
225
Al Viroff428d72006-09-26 22:13:35 -0700226int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 rcu_read_lock();
229 for_primary_ifa(in_dev) {
230 if (inet_ifa_match(a, ifa)) {
231 if (!b || inet_ifa_match(b, ifa)) {
232 rcu_read_unlock();
233 return 1;
234 }
235 }
236 } endfor_ifa(in_dev);
237 rcu_read_unlock();
238 return 0;
239}
240
Thomas Grafd6062cb2006-08-15 00:33:59 -0700241static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
242 int destroy, struct nlmsghdr *nlh, u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
Harald Welte8f937c62005-05-29 20:23:46 -0700244 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800245 struct in_ifaddr *ifa, *ifa1 = *ifap;
246 struct in_ifaddr *last_prim = in_dev->ifa_list;
247 struct in_ifaddr *prev_prom = NULL;
248 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250 ASSERT_RTNL();
251
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900252 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700253 * unless alias promotion is set
254 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
258
259 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900260 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800261 ifa1->ifa_scope <= ifa->ifa_scope)
262 last_prim = ifa;
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
265 ifa1->ifa_mask != ifa->ifa_mask ||
266 !inet_ifa_match(ifa1->ifa_address, ifa)) {
267 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800268 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 continue;
270 }
271
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800272 if (!do_promote) {
Harald Welte8f937c62005-05-29 20:23:46 -0700273 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Thomas Grafd6062cb2006-08-15 00:33:59 -0700275 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800276 blocking_notifier_call_chain(&inetaddr_chain,
277 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700278 inet_free_ifa(ifa);
279 } else {
280 promote = ifa;
281 break;
282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 }
284 }
285
286 /* 2. Unlink it */
287
288 *ifap = ifa1->ifa_next;
289
290 /* 3. Announce address deletion */
291
292 /* Send message first, then call notifier.
293 At first sight, FIB update triggered by notifier
294 will refer to already deleted ifaddr, that could confuse
295 netlink listeners. It is not true: look, gated sees
296 that route deleted and if it still thinks that ifaddr
297 is valid, it will try to restore deleted routes... Grr.
298 So that, this order is correct.
299 */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700300 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800301 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800302
303 if (promote) {
304
305 if (prev_prom) {
306 prev_prom->ifa_next = promote->ifa_next;
307 promote->ifa_next = last_prim->ifa_next;
308 last_prim->ifa_next = promote;
309 }
310
311 promote->ifa_flags &= ~IFA_F_SECONDARY;
Thomas Grafd6062cb2006-08-15 00:33:59 -0700312 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800313 blocking_notifier_call_chain(&inetaddr_chain,
314 NETDEV_UP, promote);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800315 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
316 if (ifa1->ifa_mask != ifa->ifa_mask ||
317 !inet_ifa_match(ifa1->ifa_address, ifa))
318 continue;
319 fib_add_ifaddr(ifa);
320 }
321
322 }
Herbert Xu63630972007-06-07 18:35:38 -0700323 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
Thomas Grafd6062cb2006-08-15 00:33:59 -0700327static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
328 int destroy)
329{
330 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
331}
332
333static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
334 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
336 struct in_device *in_dev = ifa->ifa_dev;
337 struct in_ifaddr *ifa1, **ifap, **last_primary;
338
339 ASSERT_RTNL();
340
341 if (!ifa->ifa_local) {
342 inet_free_ifa(ifa);
343 return 0;
344 }
345
346 ifa->ifa_flags &= ~IFA_F_SECONDARY;
347 last_primary = &in_dev->ifa_list;
348
349 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
350 ifap = &ifa1->ifa_next) {
351 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
352 ifa->ifa_scope <= ifa1->ifa_scope)
353 last_primary = &ifa1->ifa_next;
354 if (ifa1->ifa_mask == ifa->ifa_mask &&
355 inet_ifa_match(ifa1->ifa_address, ifa)) {
356 if (ifa1->ifa_local == ifa->ifa_local) {
357 inet_free_ifa(ifa);
358 return -EEXIST;
359 }
360 if (ifa1->ifa_scope != ifa->ifa_scope) {
361 inet_free_ifa(ifa);
362 return -EINVAL;
363 }
364 ifa->ifa_flags |= IFA_F_SECONDARY;
365 }
366 }
367
368 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
369 net_srandom(ifa->ifa_local);
370 ifap = last_primary;
371 }
372
373 ifa->ifa_next = *ifap;
374 *ifap = ifa;
375
376 /* Send message first, then call notifier.
377 Notifier will trigger FIB update, so that
378 listeners of netlink will know about new ifaddr */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700379 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800380 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 return 0;
383}
384
Thomas Grafd6062cb2006-08-15 00:33:59 -0700385static int inet_insert_ifa(struct in_ifaddr *ifa)
386{
387 return __inet_insert_ifa(ifa, NULL, 0);
388}
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
391{
Herbert Xue5ed6392005-10-03 14:35:55 -0700392 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 ASSERT_RTNL();
395
396 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700397 inet_free_ifa(ifa);
398 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700400 ipv4_devconf_setall(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700402 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 in_dev_hold(in_dev);
404 ifa->ifa_dev = in_dev;
405 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800406 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 ifa->ifa_scope = RT_SCOPE_HOST;
408 return inet_insert_ifa(ifa);
409}
410
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800411struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
413 struct net_device *dev;
414 struct in_device *in_dev = NULL;
415 read_lock(&dev_base_lock);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800416 dev = __dev_get_by_index(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 if (dev)
418 in_dev = in_dev_get(dev);
419 read_unlock(&dev_base_lock);
420 return in_dev;
421}
422
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 __in_dev_put(in_dev);
460
461 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
462 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700463 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700464 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700466
467 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
468 continue;
469
470 if (tb[IFA_ADDRESS] &&
471 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700472 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700473 continue;
474
Thomas Grafd6062cb2006-08-15 00:33:59 -0700475 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return 0;
477 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700478
479 err = -EADDRNOTAVAIL;
480errout:
481 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
483
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800484static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
Thomas Graf5c753972006-08-04 23:03:53 -0700486 struct nlattr *tb[IFA_MAX+1];
487 struct in_ifaddr *ifa;
488 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 struct net_device *dev;
490 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800491 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Thomas Graf5c753972006-08-04 23:03:53 -0700493 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
494 if (err < 0)
495 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Thomas Graf5c753972006-08-04 23:03:53 -0700497 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800498 err = -EINVAL;
499 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700500 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800502 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800503 err = -ENODEV;
504 if (dev == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700505 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Thomas Graf5c753972006-08-04 23:03:53 -0700507 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800508 err = -ENOBUFS;
509 if (in_dev == NULL)
Herbert Xu71e27da2007-06-04 23:36:06 -0700510 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
Thomas Graf5c753972006-08-04 23:03:53 -0700512 ifa = inet_alloc_ifa();
Denis V. Lunev7b218572008-01-31 18:47:00 -0800513 if (ifa == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700514 /*
515 * A potential indev allocation can be left alive, it stays
516 * assigned to its device and is destroy with it.
517 */
Thomas Graf5c753972006-08-04 23:03:53 -0700518 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700519
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800520 ipv4_devconf_setall(in_dev);
Thomas Graf5c753972006-08-04 23:03:53 -0700521 in_dev_hold(in_dev);
522
523 if (tb[IFA_ADDRESS] == NULL)
524 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
527 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 ifa->ifa_flags = ifm->ifa_flags;
529 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700530 ifa->ifa_dev = in_dev;
531
Al Viroa7a628c2006-09-26 22:16:43 -0700532 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
533 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700534
535 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700536 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700537
Thomas Graf5c753972006-08-04 23:03:53 -0700538 if (tb[IFA_LABEL])
539 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 else
541 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
542
Thomas Graf5c753972006-08-04 23:03:53 -0700543 return ifa;
544
545errout:
546 return ERR_PTR(err);
547}
548
549static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
550{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900551 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700552 struct in_ifaddr *ifa;
553
554 ASSERT_RTNL();
555
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800556 ifa = rtm_to_ifaddr(net, nlh);
Thomas Graf5c753972006-08-04 23:03:53 -0700557 if (IS_ERR(ifa))
558 return PTR_ERR(ifa);
559
Thomas Grafd6062cb2006-08-15 00:33:59 -0700560 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561}
562
563/*
564 * Determine a default network mask, based on the IP address.
565 */
566
Al Viro714e85b2006-11-14 20:51:49 -0800567static __inline__ int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
569 int rc = -1; /* Something else, probably a multicast. */
570
Joe Perchesf97c1e02007-12-16 13:45:43 -0800571 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900572 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 else {
Al Viro714e85b2006-11-14 20:51:49 -0800574 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Al Viro714e85b2006-11-14 20:51:49 -0800576 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800578 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800580 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 rc = 24;
582 }
583
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900584 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585}
586
587
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800588int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
590 struct ifreq ifr;
591 struct sockaddr_in sin_orig;
592 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
593 struct in_device *in_dev;
594 struct in_ifaddr **ifap = NULL;
595 struct in_ifaddr *ifa = NULL;
596 struct net_device *dev;
597 char *colon;
598 int ret = -EFAULT;
599 int tryaddrmatch = 0;
600
601 /*
602 * Fetch the caller's info block into kernel space
603 */
604
605 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
606 goto out;
607 ifr.ifr_name[IFNAMSIZ - 1] = 0;
608
609 /* save original address for comparison */
610 memcpy(&sin_orig, sin, sizeof(*sin));
611
612 colon = strchr(ifr.ifr_name, ':');
613 if (colon)
614 *colon = 0;
615
616#ifdef CONFIG_KMOD
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800617 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618#endif
619
Stephen Hemminger132adf52007-03-08 20:44:43 -0800620 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 case SIOCGIFADDR: /* Get interface address */
622 case SIOCGIFBRDADDR: /* Get the broadcast address */
623 case SIOCGIFDSTADDR: /* Get the destination address */
624 case SIOCGIFNETMASK: /* Get the netmask for the interface */
625 /* Note that these ioctls will not sleep,
626 so that we do not impose a lock.
627 One day we will be forced to put shlock here (I mean SMP)
628 */
629 tryaddrmatch = (sin_orig.sin_family == AF_INET);
630 memset(sin, 0, sizeof(*sin));
631 sin->sin_family = AF_INET;
632 break;
633
634 case SIOCSIFFLAGS:
635 ret = -EACCES;
636 if (!capable(CAP_NET_ADMIN))
637 goto out;
638 break;
639 case SIOCSIFADDR: /* Set interface address (and family) */
640 case SIOCSIFBRDADDR: /* Set the broadcast address */
641 case SIOCSIFDSTADDR: /* Set the destination address */
642 case SIOCSIFNETMASK: /* Set the netmask for the interface */
643 ret = -EACCES;
644 if (!capable(CAP_NET_ADMIN))
645 goto out;
646 ret = -EINVAL;
647 if (sin->sin_family != AF_INET)
648 goto out;
649 break;
650 default:
651 ret = -EINVAL;
652 goto out;
653 }
654
655 rtnl_lock();
656
657 ret = -ENODEV;
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800658 if ((dev = __dev_get_by_name(net, ifr.ifr_name)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 goto done;
660
661 if (colon)
662 *colon = ':';
663
Herbert Xue5ed6392005-10-03 14:35:55 -0700664 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (tryaddrmatch) {
666 /* Matthias Andree */
667 /* compare label and address (4.4BSD style) */
668 /* note: we only do this for a limited set of ioctls
669 and only if the original address family was AF_INET.
670 This is checked above. */
671 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
672 ifap = &ifa->ifa_next) {
673 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
674 sin_orig.sin_addr.s_addr ==
675 ifa->ifa_address) {
676 break; /* found */
677 }
678 }
679 }
680 /* we didn't get a match, maybe the application is
681 4.3BSD-style and passed in junk so we fall back to
682 comparing just the label */
683 if (!ifa) {
684 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
685 ifap = &ifa->ifa_next)
686 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
687 break;
688 }
689 }
690
691 ret = -EADDRNOTAVAIL;
692 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
693 goto done;
694
Stephen Hemminger132adf52007-03-08 20:44:43 -0800695 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 case SIOCGIFADDR: /* Get interface address */
697 sin->sin_addr.s_addr = ifa->ifa_local;
698 goto rarok;
699
700 case SIOCGIFBRDADDR: /* Get the broadcast address */
701 sin->sin_addr.s_addr = ifa->ifa_broadcast;
702 goto rarok;
703
704 case SIOCGIFDSTADDR: /* Get the destination address */
705 sin->sin_addr.s_addr = ifa->ifa_address;
706 goto rarok;
707
708 case SIOCGIFNETMASK: /* Get the netmask for the interface */
709 sin->sin_addr.s_addr = ifa->ifa_mask;
710 goto rarok;
711
712 case SIOCSIFFLAGS:
713 if (colon) {
714 ret = -EADDRNOTAVAIL;
715 if (!ifa)
716 break;
717 ret = 0;
718 if (!(ifr.ifr_flags & IFF_UP))
719 inet_del_ifa(in_dev, ifap, 1);
720 break;
721 }
722 ret = dev_change_flags(dev, ifr.ifr_flags);
723 break;
724
725 case SIOCSIFADDR: /* Set interface address (and family) */
726 ret = -EINVAL;
727 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
728 break;
729
730 if (!ifa) {
731 ret = -ENOBUFS;
732 if ((ifa = inet_alloc_ifa()) == NULL)
733 break;
734 if (colon)
735 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
736 else
737 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
738 } else {
739 ret = 0;
740 if (ifa->ifa_local == sin->sin_addr.s_addr)
741 break;
742 inet_del_ifa(in_dev, ifap, 0);
743 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -0800744 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 }
746
747 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
748
749 if (!(dev->flags & IFF_POINTOPOINT)) {
750 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
751 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
752 if ((dev->flags & IFF_BROADCAST) &&
753 ifa->ifa_prefixlen < 31)
754 ifa->ifa_broadcast = ifa->ifa_address |
755 ~ifa->ifa_mask;
756 } else {
757 ifa->ifa_prefixlen = 32;
758 ifa->ifa_mask = inet_make_mask(32);
759 }
760 ret = inet_set_ifa(dev, ifa);
761 break;
762
763 case SIOCSIFBRDADDR: /* Set the broadcast address */
764 ret = 0;
765 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
766 inet_del_ifa(in_dev, ifap, 0);
767 ifa->ifa_broadcast = sin->sin_addr.s_addr;
768 inet_insert_ifa(ifa);
769 }
770 break;
771
772 case SIOCSIFDSTADDR: /* Set the destination address */
773 ret = 0;
774 if (ifa->ifa_address == sin->sin_addr.s_addr)
775 break;
776 ret = -EINVAL;
777 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
778 break;
779 ret = 0;
780 inet_del_ifa(in_dev, ifap, 0);
781 ifa->ifa_address = sin->sin_addr.s_addr;
782 inet_insert_ifa(ifa);
783 break;
784
785 case SIOCSIFNETMASK: /* Set the netmask for the interface */
786
787 /*
788 * The mask we set must be legal.
789 */
790 ret = -EINVAL;
791 if (bad_mask(sin->sin_addr.s_addr, 0))
792 break;
793 ret = 0;
794 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -0700795 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 inet_del_ifa(in_dev, ifap, 0);
797 ifa->ifa_mask = sin->sin_addr.s_addr;
798 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
799
800 /* See if current broadcast address matches
801 * with current netmask, then recalculate
802 * the broadcast address. Otherwise it's a
803 * funny address, so don't touch it since
804 * the user seems to know what (s)he's doing...
805 */
806 if ((dev->flags & IFF_BROADCAST) &&
807 (ifa->ifa_prefixlen < 31) &&
808 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -0500809 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 ifa->ifa_broadcast = (ifa->ifa_local |
811 ~sin->sin_addr.s_addr);
812 }
813 inet_insert_ifa(ifa);
814 }
815 break;
816 }
817done:
818 rtnl_unlock();
819out:
820 return ret;
821rarok:
822 rtnl_unlock();
823 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
824 goto out;
825}
826
827static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
828{
Herbert Xue5ed6392005-10-03 14:35:55 -0700829 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 struct in_ifaddr *ifa;
831 struct ifreq ifr;
832 int done = 0;
833
834 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
835 goto out;
836
837 for (; ifa; ifa = ifa->ifa_next) {
838 if (!buf) {
839 done += sizeof(ifr);
840 continue;
841 }
842 if (len < (int) sizeof(ifr))
843 break;
844 memset(&ifr, 0, sizeof(struct ifreq));
845 if (ifa->ifa_label)
846 strcpy(ifr.ifr_name, ifa->ifa_label);
847 else
848 strcpy(ifr.ifr_name, dev->name);
849
850 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
851 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
852 ifa->ifa_local;
853
854 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
855 done = -EFAULT;
856 break;
857 }
858 buf += sizeof(struct ifreq);
859 len -= sizeof(struct ifreq);
860 done += sizeof(struct ifreq);
861 }
862out:
863 return done;
864}
865
Al Viroa61ced52006-09-26 21:27:54 -0700866__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
Al Viroa61ced52006-09-26 21:27:54 -0700868 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900870 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700873 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 if (!in_dev)
875 goto no_in_dev;
876
877 for_primary_ifa(in_dev) {
878 if (ifa->ifa_scope > scope)
879 continue;
880 if (!dst || inet_ifa_match(dst, ifa)) {
881 addr = ifa->ifa_local;
882 break;
883 }
884 if (!addr)
885 addr = ifa->ifa_local;
886 } endfor_ifa(in_dev);
887no_in_dev:
888 rcu_read_unlock();
889
890 if (addr)
891 goto out;
892
893 /* Not loopback addresses on loopback should be preferred
894 in this case. It is importnat that lo is the first interface
895 in dev_base list.
896 */
897 read_lock(&dev_base_lock);
898 rcu_read_lock();
Denis V. Lunevc4544c72008-02-28 20:52:54 -0800899 for_each_netdev(net, dev) {
Herbert Xue5ed6392005-10-03 14:35:55 -0700900 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 continue;
902
903 for_primary_ifa(in_dev) {
904 if (ifa->ifa_scope != RT_SCOPE_LINK &&
905 ifa->ifa_scope <= scope) {
906 addr = ifa->ifa_local;
907 goto out_unlock_both;
908 }
909 } endfor_ifa(in_dev);
910 }
911out_unlock_both:
912 read_unlock(&dev_base_lock);
913 rcu_read_unlock();
914out:
915 return addr;
916}
917
Al Viro60cad5d2006-09-26 22:17:09 -0700918static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
919 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920{
921 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -0700922 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
924 for_ifa(in_dev) {
925 if (!addr &&
926 (local == ifa->ifa_local || !local) &&
927 ifa->ifa_scope <= scope) {
928 addr = ifa->ifa_local;
929 if (same)
930 break;
931 }
932 if (!same) {
933 same = (!local || inet_ifa_match(local, ifa)) &&
934 (!dst || inet_ifa_match(dst, ifa));
935 if (same && addr) {
936 if (local || !dst)
937 break;
938 /* Is the selected addr into dst subnet? */
939 if (inet_ifa_match(addr, ifa))
940 break;
941 /* No, then can we use new local src? */
942 if (ifa->ifa_scope <= scope) {
943 addr = ifa->ifa_local;
944 break;
945 }
946 /* search for large dst subnet for addr */
947 same = 0;
948 }
949 }
950 } endfor_ifa(in_dev);
951
952 return same? addr : 0;
953}
954
955/*
956 * Confirm that local IP address exists using wildcards:
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800957 * - in_dev: only on this interface, 0=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 * - dst: only in the same subnet as dst, 0=any dst
959 * - local: address, 0=autoselect the local address
960 * - scope: maximum allowed scope value for the local address
961 */
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800962__be32 inet_confirm_addr(struct in_device *in_dev,
963 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964{
Al Viro60cad5d2006-09-26 22:17:09 -0700965 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800966 struct net_device *dev;
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800967 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800969 if (scope != RT_SCOPE_LINK)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800970 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900972 net = dev_net(in_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 read_lock(&dev_base_lock);
974 rcu_read_lock();
Denis V. Lunev39a6d062008-01-14 23:06:19 -0800975 for_each_netdev(net, dev) {
Herbert Xue5ed6392005-10-03 14:35:55 -0700976 if ((in_dev = __in_dev_get_rcu(dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 addr = confirm_addr_indev(in_dev, dst, local, scope);
978 if (addr)
979 break;
980 }
981 }
982 rcu_read_unlock();
983 read_unlock(&dev_base_lock);
984
985 return addr;
986}
987
988/*
989 * Device notifier
990 */
991
992int register_inetaddr_notifier(struct notifier_block *nb)
993{
Alan Sterne041c682006-03-27 01:16:30 -0800994 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
996
997int unregister_inetaddr_notifier(struct notifier_block *nb)
998{
Alan Sterne041c682006-03-27 01:16:30 -0800999 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000}
1001
1002/* Rename ifa_labels for a device name change. Make some effort to preserve existing
1003 * alias numbering and to create unique labels if possible.
1004*/
1005static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001006{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 struct in_ifaddr *ifa;
1008 int named = 0;
1009
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001010 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1011 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
1013 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001014 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001016 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001017 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001018 if (dot == NULL) {
1019 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 dot = old;
1021 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001022 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1023 strcat(ifa->ifa_label, dot);
1024 } else {
1025 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1026 }
Thomas Graf573bf472008-06-10 15:40:04 -07001027skip:
1028 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001029 }
1030}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
Breno Leitao06770842008-09-02 17:28:58 -07001032static inline bool inetdev_valid_mtu(unsigned mtu)
1033{
1034 return mtu >= 68;
1035}
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037/* Called only under RTNL semaphore */
1038
1039static int inetdev_event(struct notifier_block *this, unsigned long event,
1040 void *ptr)
1041{
1042 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -07001043 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
1045 ASSERT_RTNL();
1046
1047 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001048 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001050 if (!in_dev)
1051 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001052 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001053 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1054 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001055 }
Breno Leitao06770842008-09-02 17:28:58 -07001056 } else if (event == NETDEV_CHANGEMTU) {
1057 /* Re-enabling IP */
1058 if (inetdev_valid_mtu(dev->mtu))
1059 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061 goto out;
1062 }
1063
1064 switch (event) {
1065 case NETDEV_REGISTER:
1066 printk(KERN_DEBUG "inetdev_event: bug\n");
1067 dev->ip_ptr = NULL;
1068 break;
1069 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001070 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001072 if (dev->flags & IFF_LOOPBACK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 struct in_ifaddr *ifa;
1074 if ((ifa = inet_alloc_ifa()) != NULL) {
1075 ifa->ifa_local =
1076 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1077 ifa->ifa_prefixlen = 8;
1078 ifa->ifa_mask = inet_make_mask(8);
1079 in_dev_hold(in_dev);
1080 ifa->ifa_dev = in_dev;
1081 ifa->ifa_scope = RT_SCOPE_HOST;
1082 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1083 inet_insert_ifa(ifa);
1084 }
1085 }
1086 ip_mc_up(in_dev);
1087 break;
1088 case NETDEV_DOWN:
1089 ip_mc_down(in_dev);
1090 break;
1091 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001092 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 break;
Breno Leitao06770842008-09-02 17:28:58 -07001094 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 case NETDEV_UNREGISTER:
1096 inetdev_destroy(in_dev);
1097 break;
1098 case NETDEV_CHANGENAME:
1099 /* Do not notify about label change, this event is
1100 * not interesting to applications using netlink.
1101 */
1102 inetdev_changename(dev, in_dev);
1103
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001104 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001105 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 break;
1107 }
1108out:
1109 return NOTIFY_DONE;
1110}
1111
1112static struct notifier_block ip_netdev_notifier = {
1113 .notifier_call =inetdev_event,
1114};
1115
Thomas Graf339bf982006-11-10 14:10:15 -08001116static inline size_t inet_nlmsg_size(void)
1117{
1118 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1119 + nla_total_size(4) /* IFA_ADDRESS */
1120 + nla_total_size(4) /* IFA_LOCAL */
1121 + nla_total_size(4) /* IFA_BROADCAST */
Thomas Graf339bf982006-11-10 14:10:15 -08001122 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1123}
1124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001126 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127{
1128 struct ifaddrmsg *ifm;
1129 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Thomas Graf47f68512006-08-04 23:04:36 -07001131 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1132 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001133 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001134
1135 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 ifm->ifa_family = AF_INET;
1137 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1138 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1139 ifm->ifa_scope = ifa->ifa_scope;
1140 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
Thomas Graf47f68512006-08-04 23:04:36 -07001142 if (ifa->ifa_address)
Al Viroa7a628c2006-09-26 22:16:43 -07001143 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
Thomas Graf47f68512006-08-04 23:04:36 -07001144
1145 if (ifa->ifa_local)
Al Viroa7a628c2006-09-26 22:16:43 -07001146 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
Thomas Graf47f68512006-08-04 23:04:36 -07001147
1148 if (ifa->ifa_broadcast)
Al Viroa7a628c2006-09-26 22:16:43 -07001149 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
Thomas Graf47f68512006-08-04 23:04:36 -07001150
Thomas Graf47f68512006-08-04 23:04:36 -07001151 if (ifa->ifa_label[0])
1152 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1153
1154 return nlmsg_end(skb, nlh);
1155
1156nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001157 nlmsg_cancel(skb, nlh);
1158 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159}
1160
1161static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1162{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001163 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 int idx, ip_idx;
1165 struct net_device *dev;
1166 struct in_device *in_dev;
1167 struct in_ifaddr *ifa;
1168 int s_ip_idx, s_idx = cb->args[0];
1169
1170 s_ip_idx = ip_idx = cb->args[1];
Pavel Emelianov7562f872007-05-03 15:13:45 -07001171 idx = 0;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001172 for_each_netdev(net, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 if (idx < s_idx)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001174 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 if (idx > s_idx)
1176 s_ip_idx = 0;
Patrick McHardy6313c1e2007-04-16 17:00:53 -07001177 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001178 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1181 ifa = ifa->ifa_next, ip_idx++) {
1182 if (ip_idx < s_ip_idx)
Stephen Hemminger596e4152007-09-11 10:41:04 +02001183 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1185 cb->nlh->nlmsg_seq,
Patrick McHardy6313c1e2007-04-16 17:00:53 -07001186 RTM_NEWADDR, NLM_F_MULTI) <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001189cont:
1190 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 }
1192
1193done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 cb->args[0] = idx;
1195 cb->args[1] = ip_idx;
1196
1197 return skb->len;
1198}
1199
Thomas Grafd6062cb2006-08-15 00:33:59 -07001200static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1201 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202{
Thomas Graf47f68512006-08-04 23:04:36 -07001203 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001204 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1205 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001206 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001208 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001209 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001210 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001211 goto errout;
1212
1213 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001214 if (err < 0) {
1215 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1216 WARN_ON(err == -EMSGSIZE);
1217 kfree_skb(skb);
1218 goto errout;
1219 }
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001220 err = rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
Thomas Grafd6062cb2006-08-15 00:33:59 -07001221errout:
1222 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001223 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224}
1225
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226#ifdef CONFIG_SYSCTL
1227
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001228static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001229{
1230 struct net_device *dev;
1231
1232 read_lock(&dev_base_lock);
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001233 for_each_netdev(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001234 struct in_device *in_dev;
1235 rcu_read_lock();
1236 in_dev = __in_dev_get_rcu(dev);
1237 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001238 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001239 rcu_read_unlock();
1240 }
1241 read_unlock(&dev_base_lock);
1242}
1243
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001244static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001245{
1246 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001247 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001248
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001249 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001250 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001251
1252 read_lock(&dev_base_lock);
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001253 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001254 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001255 if (on)
1256 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001257 rcu_read_lock();
1258 in_dev = __in_dev_get_rcu(dev);
1259 if (in_dev)
1260 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1261 rcu_read_unlock();
1262 }
1263 read_unlock(&dev_base_lock);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001264}
1265
Herbert Xu31be3082007-06-04 23:35:37 -07001266static int devinet_conf_proc(ctl_table *ctl, int write,
1267 struct file* filp, void __user *buffer,
1268 size_t *lenp, loff_t *ppos)
1269{
1270 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1271
1272 if (write) {
1273 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001274 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001275 int i = (int *)ctl->data - cnf->data;
1276
1277 set_bit(i, cnf->state);
1278
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001279 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001280 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001281 }
1282
1283 return ret;
1284}
1285
1286static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1287 void __user *oldval, size_t __user *oldlenp,
1288 void __user *newval, size_t newlen)
1289{
1290 struct ipv4_devconf *cnf;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001291 struct net *net;
Herbert Xu31be3082007-06-04 23:35:37 -07001292 int *valp = table->data;
1293 int new;
1294 int i;
1295
1296 if (!newval || !newlen)
1297 return 0;
1298
1299 if (newlen != sizeof(int))
1300 return -EINVAL;
1301
1302 if (get_user(new, (int __user *)newval))
1303 return -EFAULT;
1304
1305 if (new == *valp)
1306 return 0;
1307
1308 if (oldval && oldlenp) {
1309 size_t len;
1310
1311 if (get_user(len, oldlenp))
1312 return -EFAULT;
1313
1314 if (len) {
1315 if (len > table->maxlen)
1316 len = table->maxlen;
1317 if (copy_to_user(oldval, valp, len))
1318 return -EFAULT;
1319 if (put_user(len, oldlenp))
1320 return -EFAULT;
1321 }
1322 }
1323
1324 *valp = new;
1325
1326 cnf = table->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001327 net = table->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001328 i = (int *)table->data - cnf->data;
1329
1330 set_bit(i, cnf->state);
1331
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001332 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001333 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001334
1335 return 1;
1336}
1337
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338static int devinet_sysctl_forward(ctl_table *ctl, int write,
1339 struct file* filp, void __user *buffer,
1340 size_t *lenp, loff_t *ppos)
1341{
1342 int *valp = ctl->data;
1343 int val = *valp;
1344 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1345
1346 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001347 struct net *net = ctl->extra2;
1348
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001349 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
1350 rtnl_lock();
1351 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1352 inet_forward_change(net);
1353 } else if (*valp) {
1354 struct ipv4_devconf *cnf = ctl->extra1;
1355 struct in_device *idev =
1356 container_of(cnf, struct in_device, cnf);
1357 dev_disable_lro(idev->dev);
1358 }
1359 rtnl_unlock();
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001360 rt_cache_flush(net, 0);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001361 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 }
1363
1364 return ret;
1365}
1366
1367int ipv4_doint_and_flush(ctl_table *ctl, int write,
1368 struct file* filp, void __user *buffer,
1369 size_t *lenp, loff_t *ppos)
1370{
1371 int *valp = ctl->data;
1372 int val = *valp;
1373 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001374 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 if (write && *valp != val)
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001377 rt_cache_flush(net, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
1379 return ret;
1380}
1381
1382int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1383 void __user *oldval, size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001384 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
Herbert Xu31be3082007-06-04 23:35:37 -07001386 int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp,
1387 newval, newlen);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001388 struct net *net = table->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Herbert Xu31be3082007-06-04 23:35:37 -07001390 if (ret == 1)
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001391 rt_cache_flush(net, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Herbert Xu31be3082007-06-04 23:35:37 -07001393 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394}
1395
1396
Herbert Xu42f811b2007-06-04 23:34:44 -07001397#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1398 { \
1399 .ctl_name = NET_IPV4_CONF_ ## attr, \
1400 .procname = name, \
1401 .data = ipv4_devconf.data + \
1402 NET_IPV4_CONF_ ## attr - 1, \
1403 .maxlen = sizeof(int), \
1404 .mode = mval, \
1405 .proc_handler = proc, \
1406 .strategy = sysctl, \
Herbert Xu31be3082007-06-04 23:35:37 -07001407 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001408 }
1409
1410#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Herbert Xu31be3082007-06-04 23:35:37 -07001411 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1412 devinet_conf_sysctl)
Herbert Xu42f811b2007-06-04 23:34:44 -07001413
1414#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Herbert Xu31be3082007-06-04 23:35:37 -07001415 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1416 devinet_conf_sysctl)
Herbert Xu42f811b2007-06-04 23:34:44 -07001417
1418#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1419 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1420
1421#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1422 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1423 ipv4_doint_and_flush_strategy)
1424
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425static struct devinet_sysctl_table {
1426 struct ctl_table_header *sysctl_header;
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001427 struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1428 char *dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429} devinet_sysctl = {
1430 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07001431 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Herbert Xu31be3082007-06-04 23:35:37 -07001432 devinet_sysctl_forward,
1433 devinet_conf_sysctl),
Herbert Xu42f811b2007-06-04 23:34:44 -07001434 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1435
1436 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1437 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1438 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1439 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1440 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1441 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1442 "accept_source_route"),
1443 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1444 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1445 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1446 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1447 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1448 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1449 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1450 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1451 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1452
1453 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1454 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1455 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1456 "force_igmp_version"),
1457 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1458 "promote_secondaries"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460};
1461
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001462static int __devinet_sysctl_register(struct net *net, char *dev_name,
1463 int ctl_name, struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464{
1465 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001466 struct devinet_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001468#define DEVINET_CTL_PATH_DEV 3
1469
1470 struct ctl_path devinet_ctl_path[] = {
1471 { .procname = "net", .ctl_name = CTL_NET, },
1472 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1473 { .procname = "conf", .ctl_name = NET_IPV4_CONF, },
1474 { /* to be set */ },
1475 { },
1476 };
1477
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001478 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001480 goto out;
1481
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1483 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07001484 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001485 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 }
1487
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001488 /*
1489 * Make a copy of dev_name, because '.procname' is regarded as const
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 * by sysctl and we wouldn't want anyone to change it under our feet
1491 * (see SIOCSIFNAME).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001492 */
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001493 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1494 if (!t->dev_name)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001495 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001497 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1498 devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001500 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001501 t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 if (!t->sysctl_header)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001503 goto free_procname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
1505 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001506 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001508free_procname:
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001509 kfree(t->dev_name);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001510free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001512out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001513 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514}
1515
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001516static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1517{
1518 struct devinet_sysctl_table *t = cnf->sysctl;
1519
1520 if (t == NULL)
1521 return;
1522
1523 cnf->sysctl = NULL;
1524 unregister_sysctl_table(t->sysctl_header);
1525 kfree(t->dev_name);
1526 kfree(t);
1527}
1528
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001529static void devinet_sysctl_register(struct in_device *idev)
1530{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001531 neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1532 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001533 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001534 idev->dev->ifindex, &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001535}
1536
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001537static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001539 __devinet_sysctl_unregister(&idev->cnf);
1540 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001543static struct ctl_table ctl_forward_entry[] = {
1544 {
1545 .ctl_name = NET_IPV4_FORWARD,
1546 .procname = "ip_forward",
1547 .data = &ipv4_devconf.data[
1548 NET_IPV4_CONF_FORWARDING - 1],
1549 .maxlen = sizeof(int),
1550 .mode = 0644,
1551 .proc_handler = devinet_sysctl_forward,
1552 .strategy = devinet_conf_sysctl,
1553 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001554 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001555 },
1556 { },
1557};
1558
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001559static __net_initdata struct ctl_path net_ipv4_path[] = {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001560 { .procname = "net", .ctl_name = CTL_NET, },
1561 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1562 { },
1563};
Eric Dumazet2a75de02008-01-05 23:08:49 -08001564#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001565
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001566static __net_init int devinet_init_net(struct net *net)
1567{
1568 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001569 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001570#ifdef CONFIG_SYSCTL
1571 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001572 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001573#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001574
1575 err = -ENOMEM;
1576 all = &ipv4_devconf;
1577 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001578
1579 if (net != &init_net) {
1580 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1581 if (all == NULL)
1582 goto err_alloc_all;
1583
1584 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1585 if (dflt == NULL)
1586 goto err_alloc_dflt;
1587
Eric Dumazet2a75de02008-01-05 23:08:49 -08001588#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001589 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1590 if (tbl == NULL)
1591 goto err_alloc_ctl;
1592
1593 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1594 tbl[0].extra1 = all;
1595 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001596#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001597 }
1598
1599#ifdef CONFIG_SYSCTL
1600 err = __devinet_sysctl_register(net, "all",
1601 NET_PROTO_CONF_ALL, all);
1602 if (err < 0)
1603 goto err_reg_all;
1604
1605 err = __devinet_sysctl_register(net, "default",
1606 NET_PROTO_CONF_DEFAULT, dflt);
1607 if (err < 0)
1608 goto err_reg_dflt;
1609
1610 err = -ENOMEM;
1611 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1612 if (forw_hdr == NULL)
1613 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001614 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001615#endif
1616
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001617 net->ipv4.devconf_all = all;
1618 net->ipv4.devconf_dflt = dflt;
1619 return 0;
1620
1621#ifdef CONFIG_SYSCTL
1622err_reg_ctl:
1623 __devinet_sysctl_unregister(dflt);
1624err_reg_dflt:
1625 __devinet_sysctl_unregister(all);
1626err_reg_all:
1627 if (tbl != ctl_forward_entry)
1628 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001629err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08001630#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001631 if (dflt != &ipv4_devconf_dflt)
1632 kfree(dflt);
1633err_alloc_dflt:
1634 if (all != &ipv4_devconf)
1635 kfree(all);
1636err_alloc_all:
1637 return err;
1638}
1639
1640static __net_exit void devinet_exit_net(struct net *net)
1641{
Eric Dumazet2a75de02008-01-05 23:08:49 -08001642#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001643 struct ctl_table *tbl;
1644
1645 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001646 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1647 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1648 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001649 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08001650#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001651 kfree(net->ipv4.devconf_dflt);
1652 kfree(net->ipv4.devconf_all);
1653}
1654
1655static __net_initdata struct pernet_operations devinet_ops = {
1656 .init = devinet_init_net,
1657 .exit = devinet_exit_net,
1658};
1659
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660void __init devinet_init(void)
1661{
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001662 register_pernet_subsys(&devinet_ops);
1663
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 register_gifconf(PF_INET, inet_gifconf);
1665 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07001666
1667 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1668 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1669 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670}
1671
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672EXPORT_SYMBOL(in_dev_finish_destroy);
1673EXPORT_SYMBOL(inet_select_addr);
1674EXPORT_SYMBOL(inetdev_by_index);
1675EXPORT_SYMBOL(register_inetaddr_notifier);
1676EXPORT_SYMBOL(unregister_inetaddr_notifier);