blob: 5b77bdaa57dd2440d85e3e418215276d71605cf7 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070067 .data = {
68 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
69 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
70 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
71 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
72 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070073};
74
75static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070076 .data = {
77 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
78 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
79 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
80 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
81 [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
82 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070083};
84
Herbert Xu42f811b2007-06-04 23:34:44 -070085#define IPV4_DEVCONF_DFLT(attr) IPV4_DEVCONF(ipv4_devconf_dflt, attr)
86
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 },
91 [IFA_ANYCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -070092 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Thomas Graf5c753972006-08-04 23:03:53 -070093};
94
Thomas Grafd6062cb2006-08-15 00:33:59 -070095static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Alan Sterne041c682006-03-27 01:16:30 -080097static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
99 int destroy);
100#ifdef CONFIG_SYSCTL
101static void devinet_sysctl_register(struct in_device *in_dev,
102 struct ipv4_devconf *p);
103static void devinet_sysctl_unregister(struct ipv4_devconf *p);
104#endif
105
106/* Locks all the inet devices. */
107
108static struct in_ifaddr *inet_alloc_ifa(void)
109{
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700110 struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112 if (ifa) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 INIT_RCU_HEAD(&ifa->rcu_head);
114 }
115
116 return ifa;
117}
118
119static void inet_rcu_free_ifa(struct rcu_head *head)
120{
121 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
122 if (ifa->ifa_dev)
123 in_dev_put(ifa->ifa_dev);
124 kfree(ifa);
125}
126
127static inline void inet_free_ifa(struct in_ifaddr *ifa)
128{
129 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
130}
131
132void in_dev_finish_destroy(struct in_device *idev)
133{
134 struct net_device *dev = idev->dev;
135
136 BUG_TRAP(!idev->ifa_list);
137 BUG_TRAP(!idev->mc_list);
138#ifdef NET_REFCNT_DEBUG
139 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
140 idev, dev ? dev->name : "NIL");
141#endif
142 dev_put(dev);
143 if (!idev->dead)
144 printk("Freeing alive in_device %p\n", idev);
145 else {
146 kfree(idev);
147 }
148}
149
Herbert Xu71e27da2007-06-04 23:36:06 -0700150static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 struct in_device *in_dev;
153
154 ASSERT_RTNL();
155
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700156 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (!in_dev)
158 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 INIT_RCU_HEAD(&in_dev->rcu_head);
160 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
161 in_dev->cnf.sysctl = NULL;
162 in_dev->dev = dev;
163 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
164 goto out_kfree;
165 /* Reference in_dev->dev */
166 dev_hold(dev);
167#ifdef CONFIG_SYSCTL
168 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
169 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
170#endif
171
David L Stevens30c4cf52007-01-04 12:31:14 -0800172 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175#ifdef CONFIG_SYSCTL
176 devinet_sysctl_register(in_dev, &in_dev->cnf);
177#endif
178 ip_mc_init_dev(in_dev);
179 if (dev->flags & IFF_UP)
180 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800181
David L Stevens30c4cf52007-01-04 12:31:14 -0800182 /* we can receive as soon as ip_ptr is set -- do this last */
183 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800184out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 return in_dev;
186out_kfree:
187 kfree(in_dev);
188 in_dev = NULL;
189 goto out;
190}
191
192static void in_dev_rcu_put(struct rcu_head *head)
193{
194 struct in_device *idev = container_of(head, struct in_device, rcu_head);
195 in_dev_put(idev);
196}
197
198static void inetdev_destroy(struct in_device *in_dev)
199{
200 struct in_ifaddr *ifa;
201 struct net_device *dev;
202
203 ASSERT_RTNL();
204
205 dev = in_dev->dev;
206 if (dev == &loopback_dev)
207 return;
208
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
218#ifdef CONFIG_SYSCTL
219 devinet_sysctl_unregister(&in_dev->cnf);
220#endif
221
222 dev->ip_ptr = NULL;
223
224#ifdef CONFIG_SYSCTL
225 neigh_sysctl_unregister(in_dev->arp_parms);
226#endif
227 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
228 arp_ifdown(dev);
229
230 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
231}
232
Al Viroff428d72006-09-26 22:13:35 -0700233int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 rcu_read_lock();
236 for_primary_ifa(in_dev) {
237 if (inet_ifa_match(a, ifa)) {
238 if (!b || inet_ifa_match(b, ifa)) {
239 rcu_read_unlock();
240 return 1;
241 }
242 }
243 } endfor_ifa(in_dev);
244 rcu_read_unlock();
245 return 0;
246}
247
Thomas Grafd6062cb2006-08-15 00:33:59 -0700248static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
249 int destroy, struct nlmsghdr *nlh, u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
Harald Welte8f937c62005-05-29 20:23:46 -0700251 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800252 struct in_ifaddr *ifa, *ifa1 = *ifap;
253 struct in_ifaddr *last_prim = in_dev->ifa_list;
254 struct in_ifaddr *prev_prom = NULL;
255 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 ASSERT_RTNL();
258
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900259 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700260 * unless alias promotion is set
261 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
265
266 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900267 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800268 ifa1->ifa_scope <= ifa->ifa_scope)
269 last_prim = ifa;
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
272 ifa1->ifa_mask != ifa->ifa_mask ||
273 !inet_ifa_match(ifa1->ifa_address, ifa)) {
274 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800275 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 continue;
277 }
278
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800279 if (!do_promote) {
Harald Welte8f937c62005-05-29 20:23:46 -0700280 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Thomas Grafd6062cb2006-08-15 00:33:59 -0700282 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800283 blocking_notifier_call_chain(&inetaddr_chain,
284 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700285 inet_free_ifa(ifa);
286 } else {
287 promote = ifa;
288 break;
289 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 }
291 }
292
293 /* 2. Unlink it */
294
295 *ifap = ifa1->ifa_next;
296
297 /* 3. Announce address deletion */
298
299 /* Send message first, then call notifier.
300 At first sight, FIB update triggered by notifier
301 will refer to already deleted ifaddr, that could confuse
302 netlink listeners. It is not true: look, gated sees
303 that route deleted and if it still thinks that ifaddr
304 is valid, it will try to restore deleted routes... Grr.
305 So that, this order is correct.
306 */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700307 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800308 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800309
310 if (promote) {
311
312 if (prev_prom) {
313 prev_prom->ifa_next = promote->ifa_next;
314 promote->ifa_next = last_prim->ifa_next;
315 last_prim->ifa_next = promote;
316 }
317
318 promote->ifa_flags &= ~IFA_F_SECONDARY;
Thomas Grafd6062cb2006-08-15 00:33:59 -0700319 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800320 blocking_notifier_call_chain(&inetaddr_chain,
321 NETDEV_UP, promote);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800322 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
323 if (ifa1->ifa_mask != ifa->ifa_mask ||
324 !inet_ifa_match(ifa1->ifa_address, ifa))
325 continue;
326 fib_add_ifaddr(ifa);
327 }
328
329 }
Herbert Xu63630972007-06-07 18:35:38 -0700330 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332}
333
Thomas Grafd6062cb2006-08-15 00:33:59 -0700334static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
335 int destroy)
336{
337 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
338}
339
340static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
341 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 struct in_device *in_dev = ifa->ifa_dev;
344 struct in_ifaddr *ifa1, **ifap, **last_primary;
345
346 ASSERT_RTNL();
347
348 if (!ifa->ifa_local) {
349 inet_free_ifa(ifa);
350 return 0;
351 }
352
353 ifa->ifa_flags &= ~IFA_F_SECONDARY;
354 last_primary = &in_dev->ifa_list;
355
356 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
357 ifap = &ifa1->ifa_next) {
358 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
359 ifa->ifa_scope <= ifa1->ifa_scope)
360 last_primary = &ifa1->ifa_next;
361 if (ifa1->ifa_mask == ifa->ifa_mask &&
362 inet_ifa_match(ifa1->ifa_address, ifa)) {
363 if (ifa1->ifa_local == ifa->ifa_local) {
364 inet_free_ifa(ifa);
365 return -EEXIST;
366 }
367 if (ifa1->ifa_scope != ifa->ifa_scope) {
368 inet_free_ifa(ifa);
369 return -EINVAL;
370 }
371 ifa->ifa_flags |= IFA_F_SECONDARY;
372 }
373 }
374
375 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
376 net_srandom(ifa->ifa_local);
377 ifap = last_primary;
378 }
379
380 ifa->ifa_next = *ifap;
381 *ifap = ifa;
382
383 /* Send message first, then call notifier.
384 Notifier will trigger FIB update, so that
385 listeners of netlink will know about new ifaddr */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700386 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800387 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 return 0;
390}
391
Thomas Grafd6062cb2006-08-15 00:33:59 -0700392static int inet_insert_ifa(struct in_ifaddr *ifa)
393{
394 return __inet_insert_ifa(ifa, NULL, 0);
395}
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
398{
Herbert Xue5ed6392005-10-03 14:35:55 -0700399 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 ASSERT_RTNL();
402
403 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700404 inet_free_ifa(ifa);
405 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700407 ipv4_devconf_setall(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 if (ifa->ifa_dev != in_dev) {
409 BUG_TRAP(!ifa->ifa_dev);
410 in_dev_hold(in_dev);
411 ifa->ifa_dev = in_dev;
412 }
413 if (LOOPBACK(ifa->ifa_local))
414 ifa->ifa_scope = RT_SCOPE_HOST;
415 return inet_insert_ifa(ifa);
416}
417
418struct in_device *inetdev_by_index(int ifindex)
419{
420 struct net_device *dev;
421 struct in_device *in_dev = NULL;
422 read_lock(&dev_base_lock);
423 dev = __dev_get_by_index(ifindex);
424 if (dev)
425 in_dev = in_dev_get(dev);
426 read_unlock(&dev_base_lock);
427 return in_dev;
428}
429
430/* Called only from RTNL semaphored context. No locks. */
431
Al Viro60cad5d2006-09-26 22:17:09 -0700432struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
433 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 ASSERT_RTNL();
436
437 for_primary_ifa(in_dev) {
438 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
439 return ifa;
440 } endfor_ifa(in_dev);
441 return NULL;
442}
443
444static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
445{
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700446 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700448 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700450 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
452 ASSERT_RTNL();
453
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700454 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
455 if (err < 0)
456 goto errout;
457
458 ifm = nlmsg_data(nlh);
459 in_dev = inetdev_by_index(ifm->ifa_index);
460 if (in_dev == NULL) {
461 err = -ENODEV;
462 goto errout;
463 }
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 __in_dev_put(in_dev);
466
467 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
468 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700469 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700470 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700472
473 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
474 continue;
475
476 if (tb[IFA_ADDRESS] &&
477 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700478 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700479 continue;
480
Thomas Grafd6062cb2006-08-15 00:33:59 -0700481 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return 0;
483 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700484
485 err = -EADDRNOTAVAIL;
486errout:
487 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488}
489
Thomas Graf5c753972006-08-04 23:03:53 -0700490static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Thomas Graf5c753972006-08-04 23:03:53 -0700492 struct nlattr *tb[IFA_MAX+1];
493 struct in_ifaddr *ifa;
494 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 struct net_device *dev;
496 struct in_device *in_dev;
Thomas Graf5c753972006-08-04 23:03:53 -0700497 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Thomas Graf5c753972006-08-04 23:03:53 -0700499 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
500 if (err < 0)
501 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Thomas Graf5c753972006-08-04 23:03:53 -0700503 ifm = nlmsg_data(nlh);
Evgeniy Polyakovc4e38f42007-03-09 13:43:24 -0800504 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) {
505 err = -EINVAL;
Thomas Graf5c753972006-08-04 23:03:53 -0700506 goto errout;
Evgeniy Polyakovc4e38f42007-03-09 13:43:24 -0800507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Thomas Graf5c753972006-08-04 23:03:53 -0700509 dev = __dev_get_by_index(ifm->ifa_index);
510 if (dev == NULL) {
511 err = -ENODEV;
512 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
514
Thomas Graf5c753972006-08-04 23:03:53 -0700515 in_dev = __in_dev_get_rtnl(dev);
516 if (in_dev == NULL) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700517 err = -ENOBUFS;
518 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700519 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Herbert Xu71e27da2007-06-04 23:36:06 -0700521 ipv4_devconf_setall(in_dev);
522
Thomas Graf5c753972006-08-04 23:03:53 -0700523 ifa = inet_alloc_ifa();
524 if (ifa == NULL) {
525 /*
526 * A potential indev allocation can be left alive, it stays
527 * assigned to its device and is destroy with it.
528 */
529 err = -ENOBUFS;
530 goto errout;
531 }
532
533 in_dev_hold(in_dev);
534
535 if (tb[IFA_ADDRESS] == NULL)
536 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
537
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
539 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 ifa->ifa_flags = ifm->ifa_flags;
541 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700542 ifa->ifa_dev = in_dev;
543
Al Viroa7a628c2006-09-26 22:16:43 -0700544 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
545 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700546
547 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700548 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700549
550 if (tb[IFA_ANYCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700551 ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700552
553 if (tb[IFA_LABEL])
554 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 else
556 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
557
Thomas Graf5c753972006-08-04 23:03:53 -0700558 return ifa;
559
560errout:
561 return ERR_PTR(err);
562}
563
564static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
565{
566 struct in_ifaddr *ifa;
567
568 ASSERT_RTNL();
569
570 ifa = rtm_to_ifaddr(nlh);
571 if (IS_ERR(ifa))
572 return PTR_ERR(ifa);
573
Thomas Grafd6062cb2006-08-15 00:33:59 -0700574 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575}
576
577/*
578 * Determine a default network mask, based on the IP address.
579 */
580
Al Viro714e85b2006-11-14 20:51:49 -0800581static __inline__ int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
583 int rc = -1; /* Something else, probably a multicast. */
584
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900585 if (ZERONET(addr))
586 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 else {
Al Viro714e85b2006-11-14 20:51:49 -0800588 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
Al Viro714e85b2006-11-14 20:51:49 -0800590 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800592 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800594 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 rc = 24;
596 }
597
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900598 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
601
602int devinet_ioctl(unsigned int cmd, void __user *arg)
603{
604 struct ifreq ifr;
605 struct sockaddr_in sin_orig;
606 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
607 struct in_device *in_dev;
608 struct in_ifaddr **ifap = NULL;
609 struct in_ifaddr *ifa = NULL;
610 struct net_device *dev;
611 char *colon;
612 int ret = -EFAULT;
613 int tryaddrmatch = 0;
614
615 /*
616 * Fetch the caller's info block into kernel space
617 */
618
619 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
620 goto out;
621 ifr.ifr_name[IFNAMSIZ - 1] = 0;
622
623 /* save original address for comparison */
624 memcpy(&sin_orig, sin, sizeof(*sin));
625
626 colon = strchr(ifr.ifr_name, ':');
627 if (colon)
628 *colon = 0;
629
630#ifdef CONFIG_KMOD
631 dev_load(ifr.ifr_name);
632#endif
633
Stephen Hemminger132adf52007-03-08 20:44:43 -0800634 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 case SIOCGIFADDR: /* Get interface address */
636 case SIOCGIFBRDADDR: /* Get the broadcast address */
637 case SIOCGIFDSTADDR: /* Get the destination address */
638 case SIOCGIFNETMASK: /* Get the netmask for the interface */
639 /* Note that these ioctls will not sleep,
640 so that we do not impose a lock.
641 One day we will be forced to put shlock here (I mean SMP)
642 */
643 tryaddrmatch = (sin_orig.sin_family == AF_INET);
644 memset(sin, 0, sizeof(*sin));
645 sin->sin_family = AF_INET;
646 break;
647
648 case SIOCSIFFLAGS:
649 ret = -EACCES;
650 if (!capable(CAP_NET_ADMIN))
651 goto out;
652 break;
653 case SIOCSIFADDR: /* Set interface address (and family) */
654 case SIOCSIFBRDADDR: /* Set the broadcast address */
655 case SIOCSIFDSTADDR: /* Set the destination address */
656 case SIOCSIFNETMASK: /* Set the netmask for the interface */
657 ret = -EACCES;
658 if (!capable(CAP_NET_ADMIN))
659 goto out;
660 ret = -EINVAL;
661 if (sin->sin_family != AF_INET)
662 goto out;
663 break;
664 default:
665 ret = -EINVAL;
666 goto out;
667 }
668
669 rtnl_lock();
670
671 ret = -ENODEV;
672 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
673 goto done;
674
675 if (colon)
676 *colon = ':';
677
Herbert Xue5ed6392005-10-03 14:35:55 -0700678 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 if (tryaddrmatch) {
680 /* Matthias Andree */
681 /* compare label and address (4.4BSD style) */
682 /* note: we only do this for a limited set of ioctls
683 and only if the original address family was AF_INET.
684 This is checked above. */
685 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
686 ifap = &ifa->ifa_next) {
687 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
688 sin_orig.sin_addr.s_addr ==
689 ifa->ifa_address) {
690 break; /* found */
691 }
692 }
693 }
694 /* we didn't get a match, maybe the application is
695 4.3BSD-style and passed in junk so we fall back to
696 comparing just the label */
697 if (!ifa) {
698 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
699 ifap = &ifa->ifa_next)
700 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
701 break;
702 }
703 }
704
705 ret = -EADDRNOTAVAIL;
706 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
707 goto done;
708
Stephen Hemminger132adf52007-03-08 20:44:43 -0800709 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 case SIOCGIFADDR: /* Get interface address */
711 sin->sin_addr.s_addr = ifa->ifa_local;
712 goto rarok;
713
714 case SIOCGIFBRDADDR: /* Get the broadcast address */
715 sin->sin_addr.s_addr = ifa->ifa_broadcast;
716 goto rarok;
717
718 case SIOCGIFDSTADDR: /* Get the destination address */
719 sin->sin_addr.s_addr = ifa->ifa_address;
720 goto rarok;
721
722 case SIOCGIFNETMASK: /* Get the netmask for the interface */
723 sin->sin_addr.s_addr = ifa->ifa_mask;
724 goto rarok;
725
726 case SIOCSIFFLAGS:
727 if (colon) {
728 ret = -EADDRNOTAVAIL;
729 if (!ifa)
730 break;
731 ret = 0;
732 if (!(ifr.ifr_flags & IFF_UP))
733 inet_del_ifa(in_dev, ifap, 1);
734 break;
735 }
736 ret = dev_change_flags(dev, ifr.ifr_flags);
737 break;
738
739 case SIOCSIFADDR: /* Set interface address (and family) */
740 ret = -EINVAL;
741 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
742 break;
743
744 if (!ifa) {
745 ret = -ENOBUFS;
746 if ((ifa = inet_alloc_ifa()) == NULL)
747 break;
748 if (colon)
749 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
750 else
751 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
752 } else {
753 ret = 0;
754 if (ifa->ifa_local == sin->sin_addr.s_addr)
755 break;
756 inet_del_ifa(in_dev, ifap, 0);
757 ifa->ifa_broadcast = 0;
758 ifa->ifa_anycast = 0;
759 }
760
761 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
762
763 if (!(dev->flags & IFF_POINTOPOINT)) {
764 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
765 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
766 if ((dev->flags & IFF_BROADCAST) &&
767 ifa->ifa_prefixlen < 31)
768 ifa->ifa_broadcast = ifa->ifa_address |
769 ~ifa->ifa_mask;
770 } else {
771 ifa->ifa_prefixlen = 32;
772 ifa->ifa_mask = inet_make_mask(32);
773 }
774 ret = inet_set_ifa(dev, ifa);
775 break;
776
777 case SIOCSIFBRDADDR: /* Set the broadcast address */
778 ret = 0;
779 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
780 inet_del_ifa(in_dev, ifap, 0);
781 ifa->ifa_broadcast = sin->sin_addr.s_addr;
782 inet_insert_ifa(ifa);
783 }
784 break;
785
786 case SIOCSIFDSTADDR: /* Set the destination address */
787 ret = 0;
788 if (ifa->ifa_address == sin->sin_addr.s_addr)
789 break;
790 ret = -EINVAL;
791 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
792 break;
793 ret = 0;
794 inet_del_ifa(in_dev, ifap, 0);
795 ifa->ifa_address = sin->sin_addr.s_addr;
796 inet_insert_ifa(ifa);
797 break;
798
799 case SIOCSIFNETMASK: /* Set the netmask for the interface */
800
801 /*
802 * The mask we set must be legal.
803 */
804 ret = -EINVAL;
805 if (bad_mask(sin->sin_addr.s_addr, 0))
806 break;
807 ret = 0;
808 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -0700809 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 inet_del_ifa(in_dev, ifap, 0);
811 ifa->ifa_mask = sin->sin_addr.s_addr;
812 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
813
814 /* See if current broadcast address matches
815 * with current netmask, then recalculate
816 * the broadcast address. Otherwise it's a
817 * funny address, so don't touch it since
818 * the user seems to know what (s)he's doing...
819 */
820 if ((dev->flags & IFF_BROADCAST) &&
821 (ifa->ifa_prefixlen < 31) &&
822 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -0500823 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 ifa->ifa_broadcast = (ifa->ifa_local |
825 ~sin->sin_addr.s_addr);
826 }
827 inet_insert_ifa(ifa);
828 }
829 break;
830 }
831done:
832 rtnl_unlock();
833out:
834 return ret;
835rarok:
836 rtnl_unlock();
837 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
838 goto out;
839}
840
841static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
842{
Herbert Xue5ed6392005-10-03 14:35:55 -0700843 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 struct in_ifaddr *ifa;
845 struct ifreq ifr;
846 int done = 0;
847
848 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
849 goto out;
850
851 for (; ifa; ifa = ifa->ifa_next) {
852 if (!buf) {
853 done += sizeof(ifr);
854 continue;
855 }
856 if (len < (int) sizeof(ifr))
857 break;
858 memset(&ifr, 0, sizeof(struct ifreq));
859 if (ifa->ifa_label)
860 strcpy(ifr.ifr_name, ifa->ifa_label);
861 else
862 strcpy(ifr.ifr_name, dev->name);
863
864 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
865 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
866 ifa->ifa_local;
867
868 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
869 done = -EFAULT;
870 break;
871 }
872 buf += sizeof(struct ifreq);
873 len -= sizeof(struct ifreq);
874 done += sizeof(struct ifreq);
875 }
876out:
877 return done;
878}
879
Al Viroa61ced52006-09-26 21:27:54 -0700880__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
Al Viroa61ced52006-09-26 21:27:54 -0700882 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 struct in_device *in_dev;
884
885 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700886 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 if (!in_dev)
888 goto no_in_dev;
889
890 for_primary_ifa(in_dev) {
891 if (ifa->ifa_scope > scope)
892 continue;
893 if (!dst || inet_ifa_match(dst, ifa)) {
894 addr = ifa->ifa_local;
895 break;
896 }
897 if (!addr)
898 addr = ifa->ifa_local;
899 } endfor_ifa(in_dev);
900no_in_dev:
901 rcu_read_unlock();
902
903 if (addr)
904 goto out;
905
906 /* Not loopback addresses on loopback should be preferred
907 in this case. It is importnat that lo is the first interface
908 in dev_base list.
909 */
910 read_lock(&dev_base_lock);
911 rcu_read_lock();
Pavel Emelianov7562f872007-05-03 15:13:45 -0700912 for_each_netdev(dev) {
Herbert Xue5ed6392005-10-03 14:35:55 -0700913 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 continue;
915
916 for_primary_ifa(in_dev) {
917 if (ifa->ifa_scope != RT_SCOPE_LINK &&
918 ifa->ifa_scope <= scope) {
919 addr = ifa->ifa_local;
920 goto out_unlock_both;
921 }
922 } endfor_ifa(in_dev);
923 }
924out_unlock_both:
925 read_unlock(&dev_base_lock);
926 rcu_read_unlock();
927out:
928 return addr;
929}
930
Al Viro60cad5d2006-09-26 22:17:09 -0700931static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
932 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933{
934 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -0700935 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 for_ifa(in_dev) {
938 if (!addr &&
939 (local == ifa->ifa_local || !local) &&
940 ifa->ifa_scope <= scope) {
941 addr = ifa->ifa_local;
942 if (same)
943 break;
944 }
945 if (!same) {
946 same = (!local || inet_ifa_match(local, ifa)) &&
947 (!dst || inet_ifa_match(dst, ifa));
948 if (same && addr) {
949 if (local || !dst)
950 break;
951 /* Is the selected addr into dst subnet? */
952 if (inet_ifa_match(addr, ifa))
953 break;
954 /* No, then can we use new local src? */
955 if (ifa->ifa_scope <= scope) {
956 addr = ifa->ifa_local;
957 break;
958 }
959 /* search for large dst subnet for addr */
960 same = 0;
961 }
962 }
963 } endfor_ifa(in_dev);
964
965 return same? addr : 0;
966}
967
968/*
969 * Confirm that local IP address exists using wildcards:
970 * - dev: only on this interface, 0=any interface
971 * - dst: only in the same subnet as dst, 0=any dst
972 * - local: address, 0=autoselect the local address
973 * - scope: maximum allowed scope value for the local address
974 */
Al Viro60cad5d2006-09-26 22:17:09 -0700975__be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976{
Al Viro60cad5d2006-09-26 22:17:09 -0700977 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 struct in_device *in_dev;
979
980 if (dev) {
981 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700982 if ((in_dev = __in_dev_get_rcu(dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 addr = confirm_addr_indev(in_dev, dst, local, scope);
984 rcu_read_unlock();
985
986 return addr;
987 }
988
989 read_lock(&dev_base_lock);
990 rcu_read_lock();
Pavel Emelianov7562f872007-05-03 15:13:45 -0700991 for_each_netdev(dev) {
Herbert Xue5ed6392005-10-03 14:35:55 -0700992 if ((in_dev = __in_dev_get_rcu(dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 addr = confirm_addr_indev(in_dev, dst, local, scope);
994 if (addr)
995 break;
996 }
997 }
998 rcu_read_unlock();
999 read_unlock(&dev_base_lock);
1000
1001 return addr;
1002}
1003
1004/*
1005 * Device notifier
1006 */
1007
1008int register_inetaddr_notifier(struct notifier_block *nb)
1009{
Alan Sterne041c682006-03-27 01:16:30 -08001010 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011}
1012
1013int unregister_inetaddr_notifier(struct notifier_block *nb)
1014{
Alan Sterne041c682006-03-27 01:16:30 -08001015 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016}
1017
1018/* Rename ifa_labels for a device name change. Make some effort to preserve existing
1019 * alias numbering and to create unique labels if possible.
1020*/
1021static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001022{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 struct in_ifaddr *ifa;
1024 int named = 0;
1025
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001026 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1027 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
1029 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001030 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 if (named++ == 0)
1032 continue;
1033 dot = strchr(ifa->ifa_label, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001034 if (dot == NULL) {
1035 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 dot = old;
1037 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001038 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1039 strcat(ifa->ifa_label, dot);
1040 } else {
1041 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1042 }
1043 }
1044}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
1046/* Called only under RTNL semaphore */
1047
1048static int inetdev_event(struct notifier_block *this, unsigned long event,
1049 void *ptr)
1050{
1051 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -07001052 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
1054 ASSERT_RTNL();
1055
1056 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001057 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001059 if (!in_dev)
1060 return notifier_from_errno(-ENOMEM);
Herbert Xu8030f542007-02-22 01:53:47 +09001061 if (dev == &loopback_dev) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001062 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1063 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 }
1066 goto out;
1067 }
1068
1069 switch (event) {
1070 case NETDEV_REGISTER:
1071 printk(KERN_DEBUG "inetdev_event: bug\n");
1072 dev->ip_ptr = NULL;
1073 break;
1074 case NETDEV_UP:
1075 if (dev->mtu < 68)
1076 break;
1077 if (dev == &loopback_dev) {
1078 struct in_ifaddr *ifa;
1079 if ((ifa = inet_alloc_ifa()) != NULL) {
1080 ifa->ifa_local =
1081 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1082 ifa->ifa_prefixlen = 8;
1083 ifa->ifa_mask = inet_make_mask(8);
1084 in_dev_hold(in_dev);
1085 ifa->ifa_dev = in_dev;
1086 ifa->ifa_scope = RT_SCOPE_HOST;
1087 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1088 inet_insert_ifa(ifa);
1089 }
1090 }
1091 ip_mc_up(in_dev);
1092 break;
1093 case NETDEV_DOWN:
1094 ip_mc_down(in_dev);
1095 break;
1096 case NETDEV_CHANGEMTU:
1097 if (dev->mtu >= 68)
1098 break;
1099 /* MTU falled under 68, disable IP */
1100 case NETDEV_UNREGISTER:
1101 inetdev_destroy(in_dev);
1102 break;
1103 case NETDEV_CHANGENAME:
1104 /* Do not notify about label change, this event is
1105 * not interesting to applications using netlink.
1106 */
1107 inetdev_changename(dev, in_dev);
1108
1109#ifdef CONFIG_SYSCTL
1110 devinet_sysctl_unregister(&in_dev->cnf);
1111 neigh_sysctl_unregister(in_dev->arp_parms);
1112 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1113 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1114 devinet_sysctl_register(in_dev, &in_dev->cnf);
1115#endif
1116 break;
1117 }
1118out:
1119 return NOTIFY_DONE;
1120}
1121
1122static struct notifier_block ip_netdev_notifier = {
1123 .notifier_call =inetdev_event,
1124};
1125
Thomas Graf339bf982006-11-10 14:10:15 -08001126static inline size_t inet_nlmsg_size(void)
1127{
1128 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1129 + nla_total_size(4) /* IFA_ADDRESS */
1130 + nla_total_size(4) /* IFA_LOCAL */
1131 + nla_total_size(4) /* IFA_BROADCAST */
1132 + nla_total_size(4) /* IFA_ANYCAST */
1133 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1134}
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001137 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138{
1139 struct ifaddrmsg *ifm;
1140 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
Thomas Graf47f68512006-08-04 23:04:36 -07001142 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1143 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001144 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001145
1146 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 ifm->ifa_family = AF_INET;
1148 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1149 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1150 ifm->ifa_scope = ifa->ifa_scope;
1151 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Thomas Graf47f68512006-08-04 23:04:36 -07001153 if (ifa->ifa_address)
Al Viroa7a628c2006-09-26 22:16:43 -07001154 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
Thomas Graf47f68512006-08-04 23:04:36 -07001155
1156 if (ifa->ifa_local)
Al Viroa7a628c2006-09-26 22:16:43 -07001157 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
Thomas Graf47f68512006-08-04 23:04:36 -07001158
1159 if (ifa->ifa_broadcast)
Al Viroa7a628c2006-09-26 22:16:43 -07001160 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
Thomas Graf47f68512006-08-04 23:04:36 -07001161
1162 if (ifa->ifa_anycast)
Al Viroa7a628c2006-09-26 22:16:43 -07001163 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
Thomas Graf47f68512006-08-04 23:04:36 -07001164
1165 if (ifa->ifa_label[0])
1166 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1167
1168 return nlmsg_end(skb, nlh);
1169
1170nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001171 nlmsg_cancel(skb, nlh);
1172 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173}
1174
1175static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1176{
1177 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
1183 s_ip_idx = ip_idx = cb->args[1];
Pavel Emelianov7562f872007-05-03 15:13:45 -07001184 idx = 0;
1185 for_each_netdev(dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 if (idx < s_idx)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001187 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 if (idx > s_idx)
1189 s_ip_idx = 0;
Patrick McHardy6313c1e2007-04-16 17:00:53 -07001190 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001191 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1194 ifa = ifa->ifa_next, ip_idx++) {
1195 if (ip_idx < s_ip_idx)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001196 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1198 cb->nlh->nlmsg_seq,
Patrick McHardy6313c1e2007-04-16 17:00:53 -07001199 RTM_NEWADDR, NLM_F_MULTI) <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001202cont:
1203 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 }
1205
1206done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 cb->args[0] = idx;
1208 cb->args[1] = ip_idx;
1209
1210 return skb->len;
1211}
1212
Thomas Grafd6062cb2006-08-15 00:33:59 -07001213static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1214 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
Thomas Graf47f68512006-08-04 23:04:36 -07001216 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001217 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1218 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
Thomas Graf339bf982006-11-10 14:10:15 -08001220 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001221 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001222 goto errout;
1223
1224 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001225 if (err < 0) {
1226 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1227 WARN_ON(err == -EMSGSIZE);
1228 kfree_skb(skb);
1229 goto errout;
1230 }
Thomas Grafd6062cb2006-08-15 00:33:59 -07001231 err = rtnl_notify(skb, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1232errout:
1233 if (err < 0)
1234 rtnl_set_sk_err(RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235}
1236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237#ifdef CONFIG_SYSCTL
1238
Herbert Xu31be3082007-06-04 23:35:37 -07001239static void devinet_copy_dflt_conf(int i)
1240{
1241 struct net_device *dev;
1242
1243 read_lock(&dev_base_lock);
1244 for_each_netdev(dev) {
1245 struct in_device *in_dev;
1246 rcu_read_lock();
1247 in_dev = __in_dev_get_rcu(dev);
1248 if (in_dev && !test_bit(i, in_dev->cnf.state))
1249 in_dev->cnf.data[i] = ipv4_devconf_dflt.data[i];
1250 rcu_read_unlock();
1251 }
1252 read_unlock(&dev_base_lock);
1253}
1254
1255static int devinet_conf_proc(ctl_table *ctl, int write,
1256 struct file* filp, void __user *buffer,
1257 size_t *lenp, loff_t *ppos)
1258{
1259 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1260
1261 if (write) {
1262 struct ipv4_devconf *cnf = ctl->extra1;
1263 int i = (int *)ctl->data - cnf->data;
1264
1265 set_bit(i, cnf->state);
1266
1267 if (cnf == &ipv4_devconf_dflt)
1268 devinet_copy_dflt_conf(i);
1269 }
1270
1271 return ret;
1272}
1273
1274static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1275 void __user *oldval, size_t __user *oldlenp,
1276 void __user *newval, size_t newlen)
1277{
1278 struct ipv4_devconf *cnf;
1279 int *valp = table->data;
1280 int new;
1281 int i;
1282
1283 if (!newval || !newlen)
1284 return 0;
1285
1286 if (newlen != sizeof(int))
1287 return -EINVAL;
1288
1289 if (get_user(new, (int __user *)newval))
1290 return -EFAULT;
1291
1292 if (new == *valp)
1293 return 0;
1294
1295 if (oldval && oldlenp) {
1296 size_t len;
1297
1298 if (get_user(len, oldlenp))
1299 return -EFAULT;
1300
1301 if (len) {
1302 if (len > table->maxlen)
1303 len = table->maxlen;
1304 if (copy_to_user(oldval, valp, len))
1305 return -EFAULT;
1306 if (put_user(len, oldlenp))
1307 return -EFAULT;
1308 }
1309 }
1310
1311 *valp = new;
1312
1313 cnf = table->extra1;
1314 i = (int *)table->data - cnf->data;
1315
1316 set_bit(i, cnf->state);
1317
1318 if (cnf == &ipv4_devconf_dflt)
1319 devinet_copy_dflt_conf(i);
1320
1321 return 1;
1322}
1323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324void inet_forward_change(void)
1325{
1326 struct net_device *dev;
Herbert Xu42f811b2007-06-04 23:34:44 -07001327 int on = IPV4_DEVCONF_ALL(FORWARDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
Herbert Xu42f811b2007-06-04 23:34:44 -07001329 IPV4_DEVCONF_ALL(ACCEPT_REDIRECTS) = !on;
1330 IPV4_DEVCONF_DFLT(FORWARDING) = on;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
1332 read_lock(&dev_base_lock);
Pavel Emelianov7562f872007-05-03 15:13:45 -07001333 for_each_netdev(dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 struct in_device *in_dev;
1335 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -07001336 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 if (in_dev)
Herbert Xu42f811b2007-06-04 23:34:44 -07001338 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 rcu_read_unlock();
1340 }
1341 read_unlock(&dev_base_lock);
1342
1343 rt_cache_flush(0);
1344}
1345
1346static int devinet_sysctl_forward(ctl_table *ctl, int write,
1347 struct file* filp, void __user *buffer,
1348 size_t *lenp, loff_t *ppos)
1349{
1350 int *valp = ctl->data;
1351 int val = *valp;
1352 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1353
1354 if (write && *valp != val) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001355 if (valp == &IPV4_DEVCONF_ALL(FORWARDING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 inet_forward_change();
Herbert Xu42f811b2007-06-04 23:34:44 -07001357 else if (valp != &IPV4_DEVCONF_DFLT(FORWARDING))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 rt_cache_flush(0);
1359 }
1360
1361 return ret;
1362}
1363
1364int ipv4_doint_and_flush(ctl_table *ctl, int write,
1365 struct file* filp, void __user *buffer,
1366 size_t *lenp, loff_t *ppos)
1367{
1368 int *valp = ctl->data;
1369 int val = *valp;
1370 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1371
1372 if (write && *valp != val)
1373 rt_cache_flush(0);
1374
1375 return ret;
1376}
1377
1378int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1379 void __user *oldval, size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001380 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
Herbert Xu31be3082007-06-04 23:35:37 -07001382 int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp,
1383 newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Herbert Xu31be3082007-06-04 23:35:37 -07001385 if (ret == 1)
1386 rt_cache_flush(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Herbert Xu31be3082007-06-04 23:35:37 -07001388 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389}
1390
1391
Herbert Xu42f811b2007-06-04 23:34:44 -07001392#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1393 { \
1394 .ctl_name = NET_IPV4_CONF_ ## attr, \
1395 .procname = name, \
1396 .data = ipv4_devconf.data + \
1397 NET_IPV4_CONF_ ## attr - 1, \
1398 .maxlen = sizeof(int), \
1399 .mode = mval, \
1400 .proc_handler = proc, \
1401 .strategy = sysctl, \
Herbert Xu31be3082007-06-04 23:35:37 -07001402 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001403 }
1404
1405#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Herbert Xu31be3082007-06-04 23:35:37 -07001406 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1407 devinet_conf_sysctl)
Herbert Xu42f811b2007-06-04 23:34:44 -07001408
1409#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Herbert Xu31be3082007-06-04 23:35:37 -07001410 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1411 devinet_conf_sysctl)
Herbert Xu42f811b2007-06-04 23:34:44 -07001412
1413#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1414 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1415
1416#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1417 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1418 ipv4_doint_and_flush_strategy)
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420static struct devinet_sysctl_table {
1421 struct ctl_table_header *sysctl_header;
1422 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1423 ctl_table devinet_dev[2];
1424 ctl_table devinet_conf_dir[2];
1425 ctl_table devinet_proto_dir[2];
1426 ctl_table devinet_root_dir[2];
1427} devinet_sysctl = {
1428 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07001429 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Herbert Xu31be3082007-06-04 23:35:37 -07001430 devinet_sysctl_forward,
1431 devinet_conf_sysctl),
Herbert Xu42f811b2007-06-04 23:34:44 -07001432 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1433
1434 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1435 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1436 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1437 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1438 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1439 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1440 "accept_source_route"),
1441 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1442 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1443 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1444 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1445 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1446 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1447 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1448 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1449 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1450
1451 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1452 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1453 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1454 "force_igmp_version"),
1455 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1456 "promote_secondaries"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 },
1458 .devinet_dev = {
1459 {
1460 .ctl_name = NET_PROTO_CONF_ALL,
1461 .procname = "all",
1462 .mode = 0555,
1463 .child = devinet_sysctl.devinet_vars,
1464 },
1465 },
1466 .devinet_conf_dir = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001467 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 .ctl_name = NET_IPV4_CONF,
1469 .procname = "conf",
1470 .mode = 0555,
1471 .child = devinet_sysctl.devinet_dev,
1472 },
1473 },
1474 .devinet_proto_dir = {
1475 {
1476 .ctl_name = NET_IPV4,
1477 .procname = "ipv4",
1478 .mode = 0555,
1479 .child = devinet_sysctl.devinet_conf_dir,
1480 },
1481 },
1482 .devinet_root_dir = {
1483 {
1484 .ctl_name = CTL_NET,
1485 .procname = "net",
1486 .mode = 0555,
1487 .child = devinet_sysctl.devinet_proto_dir,
1488 },
1489 },
1490};
1491
1492static void devinet_sysctl_register(struct in_device *in_dev,
1493 struct ipv4_devconf *p)
1494{
1495 int i;
1496 struct net_device *dev = in_dev ? in_dev->dev : NULL;
Arnaldo Carvalho de Melo42e5ea462006-11-17 11:18:20 -02001497 struct devinet_sysctl_table *t = kmemdup(&devinet_sysctl, sizeof(*t),
1498 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 char *dev_name = NULL;
1500
1501 if (!t)
1502 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1504 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07001505 t->devinet_vars[i].extra1 = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 }
1507
1508 if (dev) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001509 dev_name = dev->name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 t->devinet_dev[0].ctl_name = dev->ifindex;
1511 } else {
1512 dev_name = "default";
1513 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1514 }
1515
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001516 /*
1517 * Make a copy of dev_name, because '.procname' is regarded as const
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 * by sysctl and we wouldn't want anyone to change it under our feet
1519 * (see SIOCSIFNAME).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001520 */
Paulo Marques543537b2005-06-23 00:09:02 -07001521 dev_name = kstrdup(dev_name, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 if (!dev_name)
1523 goto free;
1524
1525 t->devinet_dev[0].procname = dev_name;
1526 t->devinet_dev[0].child = t->devinet_vars;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 t->devinet_conf_dir[0].child = t->devinet_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 t->devinet_root_dir[0].child = t->devinet_proto_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08001531 t->sysctl_header = register_sysctl_table(t->devinet_root_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 if (!t->sysctl_header)
1533 goto free_procname;
1534
1535 p->sysctl = t;
1536 return;
1537
1538 /* error path */
1539 free_procname:
1540 kfree(dev_name);
1541 free:
1542 kfree(t);
1543 return;
1544}
1545
1546static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1547{
1548 if (p->sysctl) {
1549 struct devinet_sysctl_table *t = p->sysctl;
1550 p->sysctl = NULL;
1551 unregister_sysctl_table(t->sysctl_header);
1552 kfree(t->devinet_dev[0].procname);
1553 kfree(t);
1554 }
1555}
1556#endif
1557
1558void __init devinet_init(void)
1559{
1560 register_gifconf(PF_INET, inet_gifconf);
1561 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07001562
1563 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1564 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1565 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566#ifdef CONFIG_SYSCTL
1567 devinet_sysctl.sysctl_header =
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08001568 register_sysctl_table(devinet_sysctl.devinet_root_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1570#endif
1571}
1572
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573EXPORT_SYMBOL(in_dev_finish_destroy);
1574EXPORT_SYMBOL(inet_select_addr);
1575EXPORT_SYMBOL(inetdev_by_index);
1576EXPORT_SYMBOL(register_inetaddr_notifier);
1577EXPORT_SYMBOL(unregister_inetaddr_notifier);