blob: 03db15b1030976d94bbd79ef8990821643e59705 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NET3 IP device support routines.
3 *
4 * Version: $Id: devinet.c,v 1.44 2001/10/31 21:55:54 davem Exp $
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 * Derived from the IP parts of dev.c 1.0.19
Jesper Juhl02c30a82005-05-05 16:16:16 -070012 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
14 * Mark Evans, <evansmp@uhura.aston.ac.uk>
15 *
16 * Additional Authors:
17 * Alan Cox, <gw4pts@gw4pts.ampr.org>
18 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
19 *
20 * Changes:
21 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
22 * lists.
23 * Cyrus Durgin: updated for kmod
24 * Matthias Andree: in devinet_ioctl, compare label and
25 * address (4.4BSD alias style support),
26 * fall back to comparing just the label
27 * if no match found.
28 */
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#include <asm/uaccess.h>
32#include <asm/system.h>
33#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080034#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/module.h>
36#include <linux/types.h>
37#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/string.h>
39#include <linux/mm.h>
40#include <linux/socket.h>
41#include <linux/sockios.h>
42#include <linux/in.h>
43#include <linux/errno.h>
44#include <linux/interrupt.h>
Thomas Graf18237302006-08-04 23:04:54 -070045#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/if_ether.h>
47#include <linux/inet.h>
48#include <linux/netdevice.h>
49#include <linux/etherdevice.h>
50#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <linux/init.h>
52#include <linux/notifier.h>
53#include <linux/inetdevice.h>
54#include <linux/igmp.h>
55#ifdef CONFIG_SYSCTL
56#include <linux/sysctl.h>
57#endif
58#include <linux/kmod.h>
59
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020060#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <net/ip.h>
62#include <net/route.h>
63#include <net/ip_fib.h>
Thomas Graf63f34442007-03-22 11:55:17 -070064#include <net/rtnetlink.h>
Pavel Emelyanov752d14d2007-12-16 13:31:47 -080065#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070068 .data = {
69 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
70 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
71 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
72 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
73 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070074};
75
76static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070077 .data = {
78 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
79 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
80 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
81 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
82 [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
83 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070084};
85
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -080086#define IPV4_DEVCONF_DFLT(net, attr) \
87 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
Herbert Xu42f811b2007-06-04 23:34:44 -070088
Patrick McHardyef7c79e2007-06-05 12:38:30 -070089static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
Thomas Graf5c753972006-08-04 23:03:53 -070090 [IFA_LOCAL] = { .type = NLA_U32 },
91 [IFA_ADDRESS] = { .type = NLA_U32 },
92 [IFA_BROADCAST] = { .type = NLA_U32 },
93 [IFA_ANYCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -070094 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Thomas Graf5c753972006-08-04 23:03:53 -070095};
96
Thomas Grafd6062cb2006-08-15 00:33:59 -070097static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Alan Sterne041c682006-03-27 01:16:30 -080099static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
101 int destroy);
102#ifdef CONFIG_SYSCTL
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100103static void devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800104static void devinet_sysctl_unregister(struct in_device *idev);
105#else
106static inline void devinet_sysctl_register(struct in_device *idev)
107{
108}
109static inline void devinet_sysctl_unregister(struct in_device *idev)
110{
111}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112#endif
113
114/* Locks all the inet devices. */
115
116static struct in_ifaddr *inet_alloc_ifa(void)
117{
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700118 struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120 if (ifa) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 INIT_RCU_HEAD(&ifa->rcu_head);
122 }
123
124 return ifa;
125}
126
127static void inet_rcu_free_ifa(struct rcu_head *head)
128{
129 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
130 if (ifa->ifa_dev)
131 in_dev_put(ifa->ifa_dev);
132 kfree(ifa);
133}
134
135static inline void inet_free_ifa(struct in_ifaddr *ifa)
136{
137 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
138}
139
140void in_dev_finish_destroy(struct in_device *idev)
141{
142 struct net_device *dev = idev->dev;
143
144 BUG_TRAP(!idev->ifa_list);
145 BUG_TRAP(!idev->mc_list);
146#ifdef NET_REFCNT_DEBUG
147 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
148 idev, dev ? dev->name : "NIL");
149#endif
150 dev_put(dev);
151 if (!idev->dead)
152 printk("Freeing alive in_device %p\n", idev);
153 else {
154 kfree(idev);
155 }
156}
157
Herbert Xu71e27da2007-06-04 23:36:06 -0700158static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
160 struct in_device *in_dev;
161
162 ASSERT_RTNL();
163
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700164 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 if (!in_dev)
166 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 INIT_RCU_HEAD(&in_dev->rcu_head);
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800168 memcpy(&in_dev->cnf, dev->nd_net->ipv4.devconf_dflt,
169 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 in_dev->cnf.sysctl = NULL;
171 in_dev->dev = dev;
172 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
173 goto out_kfree;
174 /* Reference in_dev->dev */
175 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800176 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100179 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 ip_mc_init_dev(in_dev);
181 if (dev->flags & IFF_UP)
182 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800183
David L Stevens30c4cf52007-01-04 12:31:14 -0800184 /* we can receive as soon as ip_ptr is set -- do this last */
185 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800186out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 return in_dev;
188out_kfree:
189 kfree(in_dev);
190 in_dev = NULL;
191 goto out;
192}
193
194static void in_dev_rcu_put(struct rcu_head *head)
195{
196 struct in_device *idev = container_of(head, struct in_device, rcu_head);
197 in_dev_put(idev);
198}
199
200static void inetdev_destroy(struct in_device *in_dev)
201{
202 struct in_ifaddr *ifa;
203 struct net_device *dev;
204
205 ASSERT_RTNL();
206
207 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
209 in_dev->dead = 1;
210
211 ip_mc_destroy_dev(in_dev);
212
213 while ((ifa = in_dev->ifa_list) != NULL) {
214 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
215 inet_free_ifa(ifa);
216 }
217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 dev->ip_ptr = NULL;
219
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800220 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
222 arp_ifdown(dev);
223
224 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
225}
226
Al Viroff428d72006-09-26 22:13:35 -0700227int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
229 rcu_read_lock();
230 for_primary_ifa(in_dev) {
231 if (inet_ifa_match(a, ifa)) {
232 if (!b || inet_ifa_match(b, ifa)) {
233 rcu_read_unlock();
234 return 1;
235 }
236 }
237 } endfor_ifa(in_dev);
238 rcu_read_unlock();
239 return 0;
240}
241
Thomas Grafd6062cb2006-08-15 00:33:59 -0700242static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
243 int destroy, struct nlmsghdr *nlh, u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Harald Welte8f937c62005-05-29 20:23:46 -0700245 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800246 struct in_ifaddr *ifa, *ifa1 = *ifap;
247 struct in_ifaddr *last_prim = in_dev->ifa_list;
248 struct in_ifaddr *prev_prom = NULL;
249 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 ASSERT_RTNL();
252
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900253 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700254 * unless alias promotion is set
255 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
259
260 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900261 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800262 ifa1->ifa_scope <= ifa->ifa_scope)
263 last_prim = ifa;
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
266 ifa1->ifa_mask != ifa->ifa_mask ||
267 !inet_ifa_match(ifa1->ifa_address, ifa)) {
268 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800269 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 continue;
271 }
272
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800273 if (!do_promote) {
Harald Welte8f937c62005-05-29 20:23:46 -0700274 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Thomas Grafd6062cb2006-08-15 00:33:59 -0700276 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800277 blocking_notifier_call_chain(&inetaddr_chain,
278 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700279 inet_free_ifa(ifa);
280 } else {
281 promote = ifa;
282 break;
283 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 }
285 }
286
287 /* 2. Unlink it */
288
289 *ifap = ifa1->ifa_next;
290
291 /* 3. Announce address deletion */
292
293 /* Send message first, then call notifier.
294 At first sight, FIB update triggered by notifier
295 will refer to already deleted ifaddr, that could confuse
296 netlink listeners. It is not true: look, gated sees
297 that route deleted and if it still thinks that ifaddr
298 is valid, it will try to restore deleted routes... Grr.
299 So that, this order is correct.
300 */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700301 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800302 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800303
304 if (promote) {
305
306 if (prev_prom) {
307 prev_prom->ifa_next = promote->ifa_next;
308 promote->ifa_next = last_prim->ifa_next;
309 last_prim->ifa_next = promote;
310 }
311
312 promote->ifa_flags &= ~IFA_F_SECONDARY;
Thomas Grafd6062cb2006-08-15 00:33:59 -0700313 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800314 blocking_notifier_call_chain(&inetaddr_chain,
315 NETDEV_UP, promote);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800316 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
317 if (ifa1->ifa_mask != ifa->ifa_mask ||
318 !inet_ifa_match(ifa1->ifa_address, ifa))
319 continue;
320 fib_add_ifaddr(ifa);
321 }
322
323 }
Herbert Xu63630972007-06-07 18:35:38 -0700324 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
Thomas Grafd6062cb2006-08-15 00:33:59 -0700328static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
329 int destroy)
330{
331 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
332}
333
334static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
335 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
337 struct in_device *in_dev = ifa->ifa_dev;
338 struct in_ifaddr *ifa1, **ifap, **last_primary;
339
340 ASSERT_RTNL();
341
342 if (!ifa->ifa_local) {
343 inet_free_ifa(ifa);
344 return 0;
345 }
346
347 ifa->ifa_flags &= ~IFA_F_SECONDARY;
348 last_primary = &in_dev->ifa_list;
349
350 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
351 ifap = &ifa1->ifa_next) {
352 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
353 ifa->ifa_scope <= ifa1->ifa_scope)
354 last_primary = &ifa1->ifa_next;
355 if (ifa1->ifa_mask == ifa->ifa_mask &&
356 inet_ifa_match(ifa1->ifa_address, ifa)) {
357 if (ifa1->ifa_local == ifa->ifa_local) {
358 inet_free_ifa(ifa);
359 return -EEXIST;
360 }
361 if (ifa1->ifa_scope != ifa->ifa_scope) {
362 inet_free_ifa(ifa);
363 return -EINVAL;
364 }
365 ifa->ifa_flags |= IFA_F_SECONDARY;
366 }
367 }
368
369 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
370 net_srandom(ifa->ifa_local);
371 ifap = last_primary;
372 }
373
374 ifa->ifa_next = *ifap;
375 *ifap = ifa;
376
377 /* Send message first, then call notifier.
378 Notifier will trigger FIB update, so that
379 listeners of netlink will know about new ifaddr */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700380 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800381 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 return 0;
384}
385
Thomas Grafd6062cb2006-08-15 00:33:59 -0700386static int inet_insert_ifa(struct in_ifaddr *ifa)
387{
388 return __inet_insert_ifa(ifa, NULL, 0);
389}
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
392{
Herbert Xue5ed6392005-10-03 14:35:55 -0700393 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 ASSERT_RTNL();
396
397 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700398 inet_free_ifa(ifa);
399 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700401 ipv4_devconf_setall(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 if (ifa->ifa_dev != in_dev) {
403 BUG_TRAP(!ifa->ifa_dev);
404 in_dev_hold(in_dev);
405 ifa->ifa_dev = in_dev;
406 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800407 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 ifa->ifa_scope = RT_SCOPE_HOST;
409 return inet_insert_ifa(ifa);
410}
411
412struct in_device *inetdev_by_index(int ifindex)
413{
414 struct net_device *dev;
415 struct in_device *in_dev = NULL;
416 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700417 dev = __dev_get_by_index(&init_net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 if (dev)
419 in_dev = in_dev_get(dev);
420 read_unlock(&dev_base_lock);
421 return in_dev;
422}
423
424/* Called only from RTNL semaphored context. No locks. */
425
Al Viro60cad5d2006-09-26 22:17:09 -0700426struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
427 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
429 ASSERT_RTNL();
430
431 for_primary_ifa(in_dev) {
432 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
433 return ifa;
434 } endfor_ifa(in_dev);
435 return NULL;
436}
437
438static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
439{
Denis V. Lunevb8542722007-12-01 00:21:31 +1100440 struct net *net = skb->sk->sk_net;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700441 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700443 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700445 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 ASSERT_RTNL();
448
Denis V. Lunevb8542722007-12-01 00:21:31 +1100449 if (net != &init_net)
450 return -EINVAL;
451
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700452 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
453 if (err < 0)
454 goto errout;
455
456 ifm = nlmsg_data(nlh);
457 in_dev = inetdev_by_index(ifm->ifa_index);
458 if (in_dev == NULL) {
459 err = -ENODEV;
460 goto errout;
461 }
462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 __in_dev_put(in_dev);
464
465 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
466 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700467 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700468 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700470
471 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
472 continue;
473
474 if (tb[IFA_ADDRESS] &&
475 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700476 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700477 continue;
478
Thomas Grafd6062cb2006-08-15 00:33:59 -0700479 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 return 0;
481 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700482
483 err = -EADDRNOTAVAIL;
484errout:
485 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486}
487
Thomas Graf5c753972006-08-04 23:03:53 -0700488static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Thomas Graf5c753972006-08-04 23:03:53 -0700490 struct nlattr *tb[IFA_MAX+1];
491 struct in_ifaddr *ifa;
492 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 struct net_device *dev;
494 struct in_device *in_dev;
Thomas Graf5c753972006-08-04 23:03:53 -0700495 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Thomas Graf5c753972006-08-04 23:03:53 -0700497 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
498 if (err < 0)
499 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Thomas Graf5c753972006-08-04 23:03:53 -0700501 ifm = nlmsg_data(nlh);
Evgeniy Polyakovc4e38f42007-03-09 13:43:24 -0800502 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) {
503 err = -EINVAL;
Thomas Graf5c753972006-08-04 23:03:53 -0700504 goto errout;
Evgeniy Polyakovc4e38f42007-03-09 13:43:24 -0800505 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Eric W. Biederman881d9662007-09-17 11:56:21 -0700507 dev = __dev_get_by_index(&init_net, ifm->ifa_index);
Thomas Graf5c753972006-08-04 23:03:53 -0700508 if (dev == NULL) {
509 err = -ENODEV;
510 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
512
Thomas Graf5c753972006-08-04 23:03:53 -0700513 in_dev = __in_dev_get_rtnl(dev);
514 if (in_dev == NULL) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700515 err = -ENOBUFS;
516 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700517 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Thomas Graf5c753972006-08-04 23:03:53 -0700519 ifa = inet_alloc_ifa();
520 if (ifa == NULL) {
521 /*
522 * A potential indev allocation can be left alive, it stays
523 * assigned to its device and is destroy with it.
524 */
525 err = -ENOBUFS;
526 goto errout;
527 }
528
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800529 ipv4_devconf_setall(in_dev);
Thomas Graf5c753972006-08-04 23:03:53 -0700530 in_dev_hold(in_dev);
531
532 if (tb[IFA_ADDRESS] == NULL)
533 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
536 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 ifa->ifa_flags = ifm->ifa_flags;
538 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700539 ifa->ifa_dev = in_dev;
540
Al Viroa7a628c2006-09-26 22:16:43 -0700541 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
542 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700543
544 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700545 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700546
547 if (tb[IFA_ANYCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700548 ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700549
550 if (tb[IFA_LABEL])
551 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 else
553 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
554
Thomas Graf5c753972006-08-04 23:03:53 -0700555 return ifa;
556
557errout:
558 return ERR_PTR(err);
559}
560
561static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
562{
Denis V. Lunevb8542722007-12-01 00:21:31 +1100563 struct net *net = skb->sk->sk_net;
Thomas Graf5c753972006-08-04 23:03:53 -0700564 struct in_ifaddr *ifa;
565
566 ASSERT_RTNL();
567
Denis V. Lunevb8542722007-12-01 00:21:31 +1100568 if (net != &init_net)
569 return -EINVAL;
570
Thomas Graf5c753972006-08-04 23:03:53 -0700571 ifa = rtm_to_ifaddr(nlh);
572 if (IS_ERR(ifa))
573 return PTR_ERR(ifa);
574
Thomas Grafd6062cb2006-08-15 00:33:59 -0700575 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
578/*
579 * Determine a default network mask, based on the IP address.
580 */
581
Al Viro714e85b2006-11-14 20:51:49 -0800582static __inline__ int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
584 int rc = -1; /* Something else, probably a multicast. */
585
Joe Perchesf97c1e02007-12-16 13:45:43 -0800586 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900587 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 else {
Al Viro714e85b2006-11-14 20:51:49 -0800589 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Al Viro714e85b2006-11-14 20:51:49 -0800591 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800593 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800595 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 rc = 24;
597 }
598
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900599 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
602
603int devinet_ioctl(unsigned int cmd, void __user *arg)
604{
605 struct ifreq ifr;
606 struct sockaddr_in sin_orig;
607 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
608 struct in_device *in_dev;
609 struct in_ifaddr **ifap = NULL;
610 struct in_ifaddr *ifa = NULL;
611 struct net_device *dev;
612 char *colon;
613 int ret = -EFAULT;
614 int tryaddrmatch = 0;
615
616 /*
617 * Fetch the caller's info block into kernel space
618 */
619
620 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
621 goto out;
622 ifr.ifr_name[IFNAMSIZ - 1] = 0;
623
624 /* save original address for comparison */
625 memcpy(&sin_orig, sin, sizeof(*sin));
626
627 colon = strchr(ifr.ifr_name, ':');
628 if (colon)
629 *colon = 0;
630
631#ifdef CONFIG_KMOD
Eric W. Biederman881d9662007-09-17 11:56:21 -0700632 dev_load(&init_net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633#endif
634
Stephen Hemminger132adf52007-03-08 20:44:43 -0800635 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 case SIOCGIFADDR: /* Get interface address */
637 case SIOCGIFBRDADDR: /* Get the broadcast address */
638 case SIOCGIFDSTADDR: /* Get the destination address */
639 case SIOCGIFNETMASK: /* Get the netmask for the interface */
640 /* Note that these ioctls will not sleep,
641 so that we do not impose a lock.
642 One day we will be forced to put shlock here (I mean SMP)
643 */
644 tryaddrmatch = (sin_orig.sin_family == AF_INET);
645 memset(sin, 0, sizeof(*sin));
646 sin->sin_family = AF_INET;
647 break;
648
649 case SIOCSIFFLAGS:
650 ret = -EACCES;
651 if (!capable(CAP_NET_ADMIN))
652 goto out;
653 break;
654 case SIOCSIFADDR: /* Set interface address (and family) */
655 case SIOCSIFBRDADDR: /* Set the broadcast address */
656 case SIOCSIFDSTADDR: /* Set the destination address */
657 case SIOCSIFNETMASK: /* Set the netmask for the interface */
658 ret = -EACCES;
659 if (!capable(CAP_NET_ADMIN))
660 goto out;
661 ret = -EINVAL;
662 if (sin->sin_family != AF_INET)
663 goto out;
664 break;
665 default:
666 ret = -EINVAL;
667 goto out;
668 }
669
670 rtnl_lock();
671
672 ret = -ENODEV;
Eric W. Biederman881d9662007-09-17 11:56:21 -0700673 if ((dev = __dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 goto done;
675
676 if (colon)
677 *colon = ':';
678
Herbert Xue5ed6392005-10-03 14:35:55 -0700679 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 if (tryaddrmatch) {
681 /* Matthias Andree */
682 /* compare label and address (4.4BSD style) */
683 /* note: we only do this for a limited set of ioctls
684 and only if the original address family was AF_INET.
685 This is checked above. */
686 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
687 ifap = &ifa->ifa_next) {
688 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
689 sin_orig.sin_addr.s_addr ==
690 ifa->ifa_address) {
691 break; /* found */
692 }
693 }
694 }
695 /* we didn't get a match, maybe the application is
696 4.3BSD-style and passed in junk so we fall back to
697 comparing just the label */
698 if (!ifa) {
699 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
700 ifap = &ifa->ifa_next)
701 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
702 break;
703 }
704 }
705
706 ret = -EADDRNOTAVAIL;
707 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
708 goto done;
709
Stephen Hemminger132adf52007-03-08 20:44:43 -0800710 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 case SIOCGIFADDR: /* Get interface address */
712 sin->sin_addr.s_addr = ifa->ifa_local;
713 goto rarok;
714
715 case SIOCGIFBRDADDR: /* Get the broadcast address */
716 sin->sin_addr.s_addr = ifa->ifa_broadcast;
717 goto rarok;
718
719 case SIOCGIFDSTADDR: /* Get the destination address */
720 sin->sin_addr.s_addr = ifa->ifa_address;
721 goto rarok;
722
723 case SIOCGIFNETMASK: /* Get the netmask for the interface */
724 sin->sin_addr.s_addr = ifa->ifa_mask;
725 goto rarok;
726
727 case SIOCSIFFLAGS:
728 if (colon) {
729 ret = -EADDRNOTAVAIL;
730 if (!ifa)
731 break;
732 ret = 0;
733 if (!(ifr.ifr_flags & IFF_UP))
734 inet_del_ifa(in_dev, ifap, 1);
735 break;
736 }
737 ret = dev_change_flags(dev, ifr.ifr_flags);
738 break;
739
740 case SIOCSIFADDR: /* Set interface address (and family) */
741 ret = -EINVAL;
742 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
743 break;
744
745 if (!ifa) {
746 ret = -ENOBUFS;
747 if ((ifa = inet_alloc_ifa()) == NULL)
748 break;
749 if (colon)
750 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
751 else
752 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
753 } else {
754 ret = 0;
755 if (ifa->ifa_local == sin->sin_addr.s_addr)
756 break;
757 inet_del_ifa(in_dev, ifap, 0);
758 ifa->ifa_broadcast = 0;
759 ifa->ifa_anycast = 0;
760 }
761
762 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
763
764 if (!(dev->flags & IFF_POINTOPOINT)) {
765 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
766 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
767 if ((dev->flags & IFF_BROADCAST) &&
768 ifa->ifa_prefixlen < 31)
769 ifa->ifa_broadcast = ifa->ifa_address |
770 ~ifa->ifa_mask;
771 } else {
772 ifa->ifa_prefixlen = 32;
773 ifa->ifa_mask = inet_make_mask(32);
774 }
775 ret = inet_set_ifa(dev, ifa);
776 break;
777
778 case SIOCSIFBRDADDR: /* Set the broadcast address */
779 ret = 0;
780 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
781 inet_del_ifa(in_dev, ifap, 0);
782 ifa->ifa_broadcast = sin->sin_addr.s_addr;
783 inet_insert_ifa(ifa);
784 }
785 break;
786
787 case SIOCSIFDSTADDR: /* Set the destination address */
788 ret = 0;
789 if (ifa->ifa_address == sin->sin_addr.s_addr)
790 break;
791 ret = -EINVAL;
792 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
793 break;
794 ret = 0;
795 inet_del_ifa(in_dev, ifap, 0);
796 ifa->ifa_address = sin->sin_addr.s_addr;
797 inet_insert_ifa(ifa);
798 break;
799
800 case SIOCSIFNETMASK: /* Set the netmask for the interface */
801
802 /*
803 * The mask we set must be legal.
804 */
805 ret = -EINVAL;
806 if (bad_mask(sin->sin_addr.s_addr, 0))
807 break;
808 ret = 0;
809 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -0700810 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 inet_del_ifa(in_dev, ifap, 0);
812 ifa->ifa_mask = sin->sin_addr.s_addr;
813 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
814
815 /* See if current broadcast address matches
816 * with current netmask, then recalculate
817 * the broadcast address. Otherwise it's a
818 * funny address, so don't touch it since
819 * the user seems to know what (s)he's doing...
820 */
821 if ((dev->flags & IFF_BROADCAST) &&
822 (ifa->ifa_prefixlen < 31) &&
823 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -0500824 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 ifa->ifa_broadcast = (ifa->ifa_local |
826 ~sin->sin_addr.s_addr);
827 }
828 inet_insert_ifa(ifa);
829 }
830 break;
831 }
832done:
833 rtnl_unlock();
834out:
835 return ret;
836rarok:
837 rtnl_unlock();
838 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
839 goto out;
840}
841
842static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
843{
Herbert Xue5ed6392005-10-03 14:35:55 -0700844 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 struct in_ifaddr *ifa;
846 struct ifreq ifr;
847 int done = 0;
848
849 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
850 goto out;
851
852 for (; ifa; ifa = ifa->ifa_next) {
853 if (!buf) {
854 done += sizeof(ifr);
855 continue;
856 }
857 if (len < (int) sizeof(ifr))
858 break;
859 memset(&ifr, 0, sizeof(struct ifreq));
860 if (ifa->ifa_label)
861 strcpy(ifr.ifr_name, ifa->ifa_label);
862 else
863 strcpy(ifr.ifr_name, dev->name);
864
865 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
866 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
867 ifa->ifa_local;
868
869 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
870 done = -EFAULT;
871 break;
872 }
873 buf += sizeof(struct ifreq);
874 len -= sizeof(struct ifreq);
875 done += sizeof(struct ifreq);
876 }
877out:
878 return done;
879}
880
Al Viroa61ced52006-09-26 21:27:54 -0700881__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
Al Viroa61ced52006-09-26 21:27:54 -0700883 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 struct in_device *in_dev;
885
886 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700887 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 if (!in_dev)
889 goto no_in_dev;
890
891 for_primary_ifa(in_dev) {
892 if (ifa->ifa_scope > scope)
893 continue;
894 if (!dst || inet_ifa_match(dst, ifa)) {
895 addr = ifa->ifa_local;
896 break;
897 }
898 if (!addr)
899 addr = ifa->ifa_local;
900 } endfor_ifa(in_dev);
901no_in_dev:
902 rcu_read_unlock();
903
904 if (addr)
905 goto out;
906
907 /* Not loopback addresses on loopback should be preferred
908 in this case. It is importnat that lo is the first interface
909 in dev_base list.
910 */
911 read_lock(&dev_base_lock);
912 rcu_read_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -0700913 for_each_netdev(&init_net, dev) {
Herbert Xue5ed6392005-10-03 14:35:55 -0700914 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 continue;
916
917 for_primary_ifa(in_dev) {
918 if (ifa->ifa_scope != RT_SCOPE_LINK &&
919 ifa->ifa_scope <= scope) {
920 addr = ifa->ifa_local;
921 goto out_unlock_both;
922 }
923 } endfor_ifa(in_dev);
924 }
925out_unlock_both:
926 read_unlock(&dev_base_lock);
927 rcu_read_unlock();
928out:
929 return addr;
930}
931
Al Viro60cad5d2006-09-26 22:17:09 -0700932static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
933 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934{
935 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -0700936 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
938 for_ifa(in_dev) {
939 if (!addr &&
940 (local == ifa->ifa_local || !local) &&
941 ifa->ifa_scope <= scope) {
942 addr = ifa->ifa_local;
943 if (same)
944 break;
945 }
946 if (!same) {
947 same = (!local || inet_ifa_match(local, ifa)) &&
948 (!dst || inet_ifa_match(dst, ifa));
949 if (same && addr) {
950 if (local || !dst)
951 break;
952 /* Is the selected addr into dst subnet? */
953 if (inet_ifa_match(addr, ifa))
954 break;
955 /* No, then can we use new local src? */
956 if (ifa->ifa_scope <= scope) {
957 addr = ifa->ifa_local;
958 break;
959 }
960 /* search for large dst subnet for addr */
961 same = 0;
962 }
963 }
964 } endfor_ifa(in_dev);
965
966 return same? addr : 0;
967}
968
969/*
970 * Confirm that local IP address exists using wildcards:
971 * - dev: only on this interface, 0=any interface
972 * - dst: only in the same subnet as dst, 0=any dst
973 * - local: address, 0=autoselect the local address
974 * - scope: maximum allowed scope value for the local address
975 */
Al Viro60cad5d2006-09-26 22:17:09 -0700976__be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
Al Viro60cad5d2006-09-26 22:17:09 -0700978 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 struct in_device *in_dev;
980
981 if (dev) {
982 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700983 if ((in_dev = __in_dev_get_rcu(dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 addr = confirm_addr_indev(in_dev, dst, local, scope);
985 rcu_read_unlock();
986
987 return addr;
988 }
989
990 read_lock(&dev_base_lock);
991 rcu_read_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -0700992 for_each_netdev(&init_net, dev) {
Herbert Xue5ed6392005-10-03 14:35:55 -0700993 if ((in_dev = __in_dev_get_rcu(dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 addr = confirm_addr_indev(in_dev, dst, local, scope);
995 if (addr)
996 break;
997 }
998 }
999 rcu_read_unlock();
1000 read_unlock(&dev_base_lock);
1001
1002 return addr;
1003}
1004
1005/*
1006 * Device notifier
1007 */
1008
1009int register_inetaddr_notifier(struct notifier_block *nb)
1010{
Alan Sterne041c682006-03-27 01:16:30 -08001011 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012}
1013
1014int unregister_inetaddr_notifier(struct notifier_block *nb)
1015{
Alan Sterne041c682006-03-27 01:16:30 -08001016 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017}
1018
1019/* Rename ifa_labels for a device name change. Make some effort to preserve existing
1020 * alias numbering and to create unique labels if possible.
1021*/
1022static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001023{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 struct in_ifaddr *ifa;
1025 int named = 0;
1026
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001027 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1028 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001031 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 if (named++ == 0)
1033 continue;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001034 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001035 if (dot == NULL) {
1036 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 dot = old;
1038 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001039 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1040 strcat(ifa->ifa_label, dot);
1041 } else {
1042 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1043 }
1044 }
1045}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
1047/* Called only under RTNL semaphore */
1048
1049static int inetdev_event(struct notifier_block *this, unsigned long event,
1050 void *ptr)
1051{
1052 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -07001053 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001055 if (dev->nd_net != &init_net)
1056 return NOTIFY_DONE;
1057
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 ASSERT_RTNL();
1059
1060 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001061 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001063 if (!in_dev)
1064 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001065 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001066 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1067 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001068 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 }
1070 goto out;
1071 }
1072
1073 switch (event) {
1074 case NETDEV_REGISTER:
1075 printk(KERN_DEBUG "inetdev_event: bug\n");
1076 dev->ip_ptr = NULL;
1077 break;
1078 case NETDEV_UP:
1079 if (dev->mtu < 68)
1080 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001081 if (dev->flags & IFF_LOOPBACK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 struct in_ifaddr *ifa;
1083 if ((ifa = inet_alloc_ifa()) != NULL) {
1084 ifa->ifa_local =
1085 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1086 ifa->ifa_prefixlen = 8;
1087 ifa->ifa_mask = inet_make_mask(8);
1088 in_dev_hold(in_dev);
1089 ifa->ifa_dev = in_dev;
1090 ifa->ifa_scope = RT_SCOPE_HOST;
1091 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1092 inet_insert_ifa(ifa);
1093 }
1094 }
1095 ip_mc_up(in_dev);
1096 break;
1097 case NETDEV_DOWN:
1098 ip_mc_down(in_dev);
1099 break;
1100 case NETDEV_CHANGEMTU:
1101 if (dev->mtu >= 68)
1102 break;
1103 /* MTU falled under 68, disable IP */
1104 case NETDEV_UNREGISTER:
1105 inetdev_destroy(in_dev);
1106 break;
1107 case NETDEV_CHANGENAME:
1108 /* Do not notify about label change, this event is
1109 * not interesting to applications using netlink.
1110 */
1111 inetdev_changename(dev, in_dev);
1112
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001113 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001114 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 break;
1116 }
1117out:
1118 return NOTIFY_DONE;
1119}
1120
1121static struct notifier_block ip_netdev_notifier = {
1122 .notifier_call =inetdev_event,
1123};
1124
Thomas Graf339bf982006-11-10 14:10:15 -08001125static inline size_t inet_nlmsg_size(void)
1126{
1127 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1128 + nla_total_size(4) /* IFA_ADDRESS */
1129 + nla_total_size(4) /* IFA_LOCAL */
1130 + nla_total_size(4) /* IFA_BROADCAST */
1131 + nla_total_size(4) /* IFA_ANYCAST */
1132 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1133}
1134
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001136 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
1138 struct ifaddrmsg *ifm;
1139 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Thomas Graf47f68512006-08-04 23:04:36 -07001141 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1142 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001143 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001144
1145 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 ifm->ifa_family = AF_INET;
1147 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1148 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1149 ifm->ifa_scope = ifa->ifa_scope;
1150 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Thomas Graf47f68512006-08-04 23:04:36 -07001152 if (ifa->ifa_address)
Al Viroa7a628c2006-09-26 22:16:43 -07001153 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
Thomas Graf47f68512006-08-04 23:04:36 -07001154
1155 if (ifa->ifa_local)
Al Viroa7a628c2006-09-26 22:16:43 -07001156 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
Thomas Graf47f68512006-08-04 23:04:36 -07001157
1158 if (ifa->ifa_broadcast)
Al Viroa7a628c2006-09-26 22:16:43 -07001159 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
Thomas Graf47f68512006-08-04 23:04:36 -07001160
1161 if (ifa->ifa_anycast)
Al Viroa7a628c2006-09-26 22:16:43 -07001162 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
Thomas Graf47f68512006-08-04 23:04:36 -07001163
1164 if (ifa->ifa_label[0])
1165 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1166
1167 return nlmsg_end(skb, nlh);
1168
1169nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001170 nlmsg_cancel(skb, nlh);
1171 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172}
1173
1174static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1175{
Denis V. Lunevb8542722007-12-01 00:21:31 +11001176 struct net *net = skb->sk->sk_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 int idx, ip_idx;
1178 struct net_device *dev;
1179 struct in_device *in_dev;
1180 struct in_ifaddr *ifa;
1181 int s_ip_idx, s_idx = cb->args[0];
1182
Denis V. Lunevb8542722007-12-01 00:21:31 +11001183 if (net != &init_net)
1184 return 0;
1185
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 s_ip_idx = ip_idx = cb->args[1];
Pavel Emelianov7562f872007-05-03 15:13:45 -07001187 idx = 0;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001188 for_each_netdev(&init_net, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 if (idx < s_idx)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001190 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 if (idx > s_idx)
1192 s_ip_idx = 0;
Patrick McHardy6313c1e2007-04-16 17:00:53 -07001193 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001194 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
1196 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1197 ifa = ifa->ifa_next, ip_idx++) {
1198 if (ip_idx < s_ip_idx)
Stephen Hemminger596e4152007-09-11 10:41:04 +02001199 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1201 cb->nlh->nlmsg_seq,
Patrick McHardy6313c1e2007-04-16 17:00:53 -07001202 RTM_NEWADDR, NLM_F_MULTI) <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001205cont:
1206 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 }
1208
1209done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 cb->args[0] = idx;
1211 cb->args[1] = ip_idx;
1212
1213 return skb->len;
1214}
1215
Thomas Grafd6062cb2006-08-15 00:33:59 -07001216static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1217 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Thomas Graf47f68512006-08-04 23:04:36 -07001219 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001220 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1221 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222
Thomas Graf339bf982006-11-10 14:10:15 -08001223 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001224 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001225 goto errout;
1226
1227 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001228 if (err < 0) {
1229 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1230 WARN_ON(err == -EMSGSIZE);
1231 kfree_skb(skb);
1232 goto errout;
1233 }
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08001234 err = rtnl_notify(skb, &init_net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
Thomas Grafd6062cb2006-08-15 00:33:59 -07001235errout:
1236 if (err < 0)
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08001237 rtnl_set_sk_err(&init_net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238}
1239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240#ifdef CONFIG_SYSCTL
1241
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001242static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001243{
1244 struct net_device *dev;
1245
1246 read_lock(&dev_base_lock);
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001247 for_each_netdev(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001248 struct in_device *in_dev;
1249 rcu_read_lock();
1250 in_dev = __in_dev_get_rcu(dev);
1251 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001252 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001253 rcu_read_unlock();
1254 }
1255 read_unlock(&dev_base_lock);
1256}
1257
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001258static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001259{
1260 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001261 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001262
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001263 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001264 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001265
1266 read_lock(&dev_base_lock);
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001267 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001268 struct in_device *in_dev;
1269 rcu_read_lock();
1270 in_dev = __in_dev_get_rcu(dev);
1271 if (in_dev)
1272 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1273 rcu_read_unlock();
1274 }
1275 read_unlock(&dev_base_lock);
1276
1277 rt_cache_flush(0);
1278}
1279
Herbert Xu31be3082007-06-04 23:35:37 -07001280static int devinet_conf_proc(ctl_table *ctl, int write,
1281 struct file* filp, void __user *buffer,
1282 size_t *lenp, loff_t *ppos)
1283{
1284 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1285
1286 if (write) {
1287 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001288 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001289 int i = (int *)ctl->data - cnf->data;
1290
1291 set_bit(i, cnf->state);
1292
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001293 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001294 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001295 }
1296
1297 return ret;
1298}
1299
1300static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1301 void __user *oldval, size_t __user *oldlenp,
1302 void __user *newval, size_t newlen)
1303{
1304 struct ipv4_devconf *cnf;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001305 struct net *net;
Herbert Xu31be3082007-06-04 23:35:37 -07001306 int *valp = table->data;
1307 int new;
1308 int i;
1309
1310 if (!newval || !newlen)
1311 return 0;
1312
1313 if (newlen != sizeof(int))
1314 return -EINVAL;
1315
1316 if (get_user(new, (int __user *)newval))
1317 return -EFAULT;
1318
1319 if (new == *valp)
1320 return 0;
1321
1322 if (oldval && oldlenp) {
1323 size_t len;
1324
1325 if (get_user(len, oldlenp))
1326 return -EFAULT;
1327
1328 if (len) {
1329 if (len > table->maxlen)
1330 len = table->maxlen;
1331 if (copy_to_user(oldval, valp, len))
1332 return -EFAULT;
1333 if (put_user(len, oldlenp))
1334 return -EFAULT;
1335 }
1336 }
1337
1338 *valp = new;
1339
1340 cnf = table->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001341 net = table->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001342 i = (int *)table->data - cnf->data;
1343
1344 set_bit(i, cnf->state);
1345
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001346 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001347 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001348
1349 return 1;
1350}
1351
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352static int devinet_sysctl_forward(ctl_table *ctl, int write,
1353 struct file* filp, void __user *buffer,
1354 size_t *lenp, loff_t *ppos)
1355{
1356 int *valp = ctl->data;
1357 int val = *valp;
1358 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1359
1360 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001361 struct net *net = ctl->extra2;
1362
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001363 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING))
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001364 inet_forward_change(net);
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001365 else if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 rt_cache_flush(0);
1367 }
1368
1369 return ret;
1370}
1371
1372int ipv4_doint_and_flush(ctl_table *ctl, int write,
1373 struct file* filp, void __user *buffer,
1374 size_t *lenp, loff_t *ppos)
1375{
1376 int *valp = ctl->data;
1377 int val = *valp;
1378 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1379
1380 if (write && *valp != val)
1381 rt_cache_flush(0);
1382
1383 return ret;
1384}
1385
1386int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1387 void __user *oldval, size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001388 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389{
Herbert Xu31be3082007-06-04 23:35:37 -07001390 int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp,
1391 newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Herbert Xu31be3082007-06-04 23:35:37 -07001393 if (ret == 1)
1394 rt_cache_flush(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
Herbert Xu31be3082007-06-04 23:35:37 -07001396 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397}
1398
1399
Herbert Xu42f811b2007-06-04 23:34:44 -07001400#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1401 { \
1402 .ctl_name = NET_IPV4_CONF_ ## attr, \
1403 .procname = name, \
1404 .data = ipv4_devconf.data + \
1405 NET_IPV4_CONF_ ## attr - 1, \
1406 .maxlen = sizeof(int), \
1407 .mode = mval, \
1408 .proc_handler = proc, \
1409 .strategy = sysctl, \
Herbert Xu31be3082007-06-04 23:35:37 -07001410 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001411 }
1412
1413#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Herbert Xu31be3082007-06-04 23:35:37 -07001414 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1415 devinet_conf_sysctl)
Herbert Xu42f811b2007-06-04 23:34:44 -07001416
1417#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Herbert Xu31be3082007-06-04 23:35:37 -07001418 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1419 devinet_conf_sysctl)
Herbert Xu42f811b2007-06-04 23:34:44 -07001420
1421#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1422 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1423
1424#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1425 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1426 ipv4_doint_and_flush_strategy)
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428static struct devinet_sysctl_table {
1429 struct ctl_table_header *sysctl_header;
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001430 struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1431 char *dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432} devinet_sysctl = {
1433 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07001434 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Herbert Xu31be3082007-06-04 23:35:37 -07001435 devinet_sysctl_forward,
1436 devinet_conf_sysctl),
Herbert Xu42f811b2007-06-04 23:34:44 -07001437 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1438
1439 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1440 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1441 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1442 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1443 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1444 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1445 "accept_source_route"),
1446 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1447 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1448 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1449 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1450 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1451 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1452 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1453 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1454 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1455
1456 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1457 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1458 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1459 "force_igmp_version"),
1460 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1461 "promote_secondaries"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463};
1464
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001465static int __devinet_sysctl_register(struct net *net, char *dev_name,
1466 int ctl_name, struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467{
1468 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001469 struct devinet_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001471#define DEVINET_CTL_PATH_DEV 3
1472
1473 struct ctl_path devinet_ctl_path[] = {
1474 { .procname = "net", .ctl_name = CTL_NET, },
1475 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1476 { .procname = "conf", .ctl_name = NET_IPV4_CONF, },
1477 { /* to be set */ },
1478 { },
1479 };
1480
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001481 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001483 goto out;
1484
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1486 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07001487 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001488 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 }
1490
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001491 /*
1492 * Make a copy of dev_name, because '.procname' is regarded as const
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 * by sysctl and we wouldn't want anyone to change it under our feet
1494 * (see SIOCSIFNAME).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001495 */
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001496 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1497 if (!t->dev_name)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001498 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001500 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1501 devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001503 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001504 t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 if (!t->sysctl_header)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001506 goto free_procname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
1508 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001509 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001511free_procname:
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001512 kfree(t->dev_name);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001513free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001515out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001516 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517}
1518
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001519static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1520{
1521 struct devinet_sysctl_table *t = cnf->sysctl;
1522
1523 if (t == NULL)
1524 return;
1525
1526 cnf->sysctl = NULL;
1527 unregister_sysctl_table(t->sysctl_header);
1528 kfree(t->dev_name);
1529 kfree(t);
1530}
1531
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001532static void devinet_sysctl_register(struct in_device *idev)
1533{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001534 neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1535 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001536 __devinet_sysctl_register(idev->dev->nd_net, idev->dev->name,
1537 idev->dev->ifindex, &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001538}
1539
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001540static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001542 __devinet_sysctl_unregister(&idev->cnf);
1543 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001546static struct ctl_table ctl_forward_entry[] = {
1547 {
1548 .ctl_name = NET_IPV4_FORWARD,
1549 .procname = "ip_forward",
1550 .data = &ipv4_devconf.data[
1551 NET_IPV4_CONF_FORWARDING - 1],
1552 .maxlen = sizeof(int),
1553 .mode = 0644,
1554 .proc_handler = devinet_sysctl_forward,
1555 .strategy = devinet_conf_sysctl,
1556 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001557 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001558 },
1559 { },
1560};
1561
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001562static __net_initdata struct ctl_path net_ipv4_path[] = {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001563 { .procname = "net", .ctl_name = CTL_NET, },
1564 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1565 { },
1566};
Eric Dumazet2a75de02008-01-05 23:08:49 -08001567#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001568
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001569static __net_init int devinet_init_net(struct net *net)
1570{
1571 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001572 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001573#ifdef CONFIG_SYSCTL
1574 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001575 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001576#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001577
1578 err = -ENOMEM;
1579 all = &ipv4_devconf;
1580 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001581
1582 if (net != &init_net) {
1583 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1584 if (all == NULL)
1585 goto err_alloc_all;
1586
1587 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1588 if (dflt == NULL)
1589 goto err_alloc_dflt;
1590
Eric Dumazet2a75de02008-01-05 23:08:49 -08001591#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001592 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1593 if (tbl == NULL)
1594 goto err_alloc_ctl;
1595
1596 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1597 tbl[0].extra1 = all;
1598 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001599#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001600 }
1601
1602#ifdef CONFIG_SYSCTL
1603 err = __devinet_sysctl_register(net, "all",
1604 NET_PROTO_CONF_ALL, all);
1605 if (err < 0)
1606 goto err_reg_all;
1607
1608 err = __devinet_sysctl_register(net, "default",
1609 NET_PROTO_CONF_DEFAULT, dflt);
1610 if (err < 0)
1611 goto err_reg_dflt;
1612
1613 err = -ENOMEM;
1614 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1615 if (forw_hdr == NULL)
1616 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001617 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001618#endif
1619
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001620 net->ipv4.devconf_all = all;
1621 net->ipv4.devconf_dflt = dflt;
1622 return 0;
1623
1624#ifdef CONFIG_SYSCTL
1625err_reg_ctl:
1626 __devinet_sysctl_unregister(dflt);
1627err_reg_dflt:
1628 __devinet_sysctl_unregister(all);
1629err_reg_all:
1630 if (tbl != ctl_forward_entry)
1631 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001632err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08001633#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001634 if (dflt != &ipv4_devconf_dflt)
1635 kfree(dflt);
1636err_alloc_dflt:
1637 if (all != &ipv4_devconf)
1638 kfree(all);
1639err_alloc_all:
1640 return err;
1641}
1642
1643static __net_exit void devinet_exit_net(struct net *net)
1644{
Eric Dumazet2a75de02008-01-05 23:08:49 -08001645#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001646 struct ctl_table *tbl;
1647
1648 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001649 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1650 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1651 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001652 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08001653#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001654 kfree(net->ipv4.devconf_dflt);
1655 kfree(net->ipv4.devconf_all);
1656}
1657
1658static __net_initdata struct pernet_operations devinet_ops = {
1659 .init = devinet_init_net,
1660 .exit = devinet_exit_net,
1661};
1662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663void __init devinet_init(void)
1664{
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001665 register_pernet_subsys(&devinet_ops);
1666
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 register_gifconf(PF_INET, inet_gifconf);
1668 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07001669
1670 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1671 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1672 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673}
1674
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675EXPORT_SYMBOL(in_dev_finish_destroy);
1676EXPORT_SYMBOL(inet_select_addr);
1677EXPORT_SYMBOL(inetdev_by_index);
1678EXPORT_SYMBOL(register_inetaddr_notifier);
1679EXPORT_SYMBOL(unregister_inetaddr_notifier);