]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/ipv4/devinet.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] capable/capability.h (fs/)
[net-next-2.6.git] / net / ipv4 / devinet.c
CommitLineData
1da177e4
LT		 1/*
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
02c30a84 12 * Authors: Ross Biro
1da177e4
LT		 13 * 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
30#include <linux/config.h>
31
32#include <asm/uaccess.h>
33#include <asm/system.h>
34#include <linux/bitops.h>
35#include <linux/module.h>
36#include <linux/types.h>
37#include <linux/kernel.h>
38#include <linux/sched.h>
39#include <linux/string.h>
40#include <linux/mm.h>
41#include <linux/socket.h>
42#include <linux/sockios.h>
43#include <linux/in.h>
44#include <linux/errno.h>
45#include <linux/interrupt.h>
46#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>
51#include <linux/rtnetlink.h>
52#include <linux/init.h>
53#include <linux/notifier.h>
54#include <linux/inetdevice.h>
55#include <linux/igmp.h>
56#ifdef CONFIG_SYSCTL
57#include <linux/sysctl.h>
58#endif
59#include <linux/kmod.h>
60
14c85021 61#include <net/arp.h>
1da177e4
LT		 62#include <net/ip.h>
63#include <net/route.h>
64#include <net/ip_fib.h>
65
66struct ipv4_devconf ipv4_devconf = {
67 .accept_redirects = 1,
68 .send_redirects = 1,
69 .secure_redirects = 1,
70 .shared_media = 1,
71};
72
73static struct ipv4_devconf ipv4_devconf_dflt = {
74 .accept_redirects = 1,
75 .send_redirects = 1,
76 .secure_redirects = 1,
77 .shared_media = 1,
78 .accept_source_route = 1,
79};
80
81static void rtmsg_ifa(int event, struct in_ifaddr *);
82
83static struct notifier_block *inetaddr_chain;
84static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
85 int destroy);
86#ifdef CONFIG_SYSCTL
87static void devinet_sysctl_register(struct in_device *in_dev,
88 struct ipv4_devconf *p);
89static void devinet_sysctl_unregister(struct ipv4_devconf *p);
90#endif
91
92/* Locks all the inet devices. */
93
94static struct in_ifaddr *inet_alloc_ifa(void)
95{
96 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL);
97
98 if (ifa) {
99 memset(ifa, 0, sizeof(*ifa));
100 INIT_RCU_HEAD(&ifa->rcu_head);
101 }
102
103 return ifa;
104}
105
106static void inet_rcu_free_ifa(struct rcu_head *head)
107{
108 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
109 if (ifa->ifa_dev)
110 in_dev_put(ifa->ifa_dev);
111 kfree(ifa);
112}
113
114static inline void inet_free_ifa(struct in_ifaddr *ifa)
115{
116 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
117}
118
119void in_dev_finish_destroy(struct in_device *idev)
120{
121 struct net_device *dev = idev->dev;
122
123 BUG_TRAP(!idev->ifa_list);
124 BUG_TRAP(!idev->mc_list);
125#ifdef NET_REFCNT_DEBUG
126 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
127 idev, dev ? dev->name : "NIL");
128#endif
129 dev_put(dev);
130 if (!idev->dead)
131 printk("Freeing alive in_device %p\n", idev);
132 else {
133 kfree(idev);
134 }
135}
136
137struct in_device *inetdev_init(struct net_device *dev)
138{
139 struct in_device *in_dev;
140
141 ASSERT_RTNL();
142
143 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL);
144 if (!in_dev)
145 goto out;
146 memset(in_dev, 0, sizeof(*in_dev));
147 INIT_RCU_HEAD(&in_dev->rcu_head);
148 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
149 in_dev->cnf.sysctl = NULL;
150 in_dev->dev = dev;
151 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
152 goto out_kfree;
153 /* Reference in_dev->dev */
154 dev_hold(dev);
155#ifdef CONFIG_SYSCTL
156 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
157 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
158#endif
159
160 /* Account for reference dev->ip_ptr */
161 in_dev_hold(in_dev);
162 rcu_assign_pointer(dev->ip_ptr, in_dev);
163
164#ifdef CONFIG_SYSCTL
165 devinet_sysctl_register(in_dev, &in_dev->cnf);
166#endif
167 ip_mc_init_dev(in_dev);
168 if (dev->flags & IFF_UP)
169 ip_mc_up(in_dev);
170out:
171 return in_dev;
172out_kfree:
173 kfree(in_dev);
174 in_dev = NULL;
175 goto out;
176}
177
178static void in_dev_rcu_put(struct rcu_head *head)
179{
180 struct in_device *idev = container_of(head, struct in_device, rcu_head);
181 in_dev_put(idev);
182}
183
184static void inetdev_destroy(struct in_device *in_dev)
185{
186 struct in_ifaddr *ifa;
187 struct net_device *dev;
188
189 ASSERT_RTNL();
190
191 dev = in_dev->dev;
192 if (dev == &loopback_dev)
193 return;
194
195 in_dev->dead = 1;
196
197 ip_mc_destroy_dev(in_dev);
198
199 while ((ifa = in_dev->ifa_list) != NULL) {
200 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
201 inet_free_ifa(ifa);
202 }
203
204#ifdef CONFIG_SYSCTL
205 devinet_sysctl_unregister(&in_dev->cnf);
206#endif
207
208 dev->ip_ptr = NULL;
209
210#ifdef CONFIG_SYSCTL
211 neigh_sysctl_unregister(in_dev->arp_parms);
212#endif
213 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
214 arp_ifdown(dev);
215
216 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
217}
218
219int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
220{
221 rcu_read_lock();
222 for_primary_ifa(in_dev) {
223 if (inet_ifa_match(a, ifa)) {
224 if (!b || inet_ifa_match(b, ifa)) {
225 rcu_read_unlock();
226 return 1;
227 }
228 }
229 } endfor_ifa(in_dev);
230 rcu_read_unlock();
231 return 0;
232}
233
234static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
235 int destroy)
236{
8f937c60 237 struct in_ifaddr *promote = NULL;
0ff60a45
JHS		 238 struct in_ifaddr *ifa, *ifa1 = *ifap;
239 struct in_ifaddr *last_prim = in_dev->ifa_list;
240 struct in_ifaddr *prev_prom = NULL;
241 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
1da177e4
LT		 242
243 ASSERT_RTNL();
244
8f937c60
HW		 245 /* 1. Deleting primary ifaddr forces deletion all secondaries
246 * unless alias promotion is set
247 **/
1da177e4
LT		 248
249 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
1da177e4
LT		 250 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
251
252 while ((ifa = *ifap1) != NULL) {
0ff60a45
JHS		 253 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
254 ifa1->ifa_scope <= ifa->ifa_scope)
255 last_prim = ifa;
256
1da177e4
LT		 257 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
258 ifa1->ifa_mask != ifa->ifa_mask ||
259 !inet_ifa_match(ifa1->ifa_address, ifa)) {
260 ifap1 = &ifa->ifa_next;
0ff60a45 261 prev_prom = ifa;
1da177e4
LT		 262 continue;
263 }
264
0ff60a45 265 if (!do_promote) {
8f937c60 266 *ifap1 = ifa->ifa_next;
1da177e4 267
8f937c60
HW		 268 rtmsg_ifa(RTM_DELADDR, ifa);
269 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
270 inet_free_ifa(ifa);
271 } else {
272 promote = ifa;
273 break;
274 }
1da177e4
LT		 275 }
276 }
277
278 /* 2. Unlink it */
279
280 *ifap = ifa1->ifa_next;
281
282 /* 3. Announce address deletion */
283
284 /* Send message first, then call notifier.
285 At first sight, FIB update triggered by notifier
286 will refer to already deleted ifaddr, that could confuse
287 netlink listeners. It is not true: look, gated sees
288 that route deleted and if it still thinks that ifaddr
289 is valid, it will try to restore deleted routes... Grr.
290 So that, this order is correct.
291 */
292 rtmsg_ifa(RTM_DELADDR, ifa1);
293 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
1da177e4 294
0ff60a45
JHS		 295 if (promote) {
296
297 if (prev_prom) {
298 prev_prom->ifa_next = promote->ifa_next;
299 promote->ifa_next = last_prim->ifa_next;
300 last_prim->ifa_next = promote;
301 }
8f937c60 302
8f937c60
HW		 303 promote->ifa_flags &= ~IFA_F_SECONDARY;
304 rtmsg_ifa(RTM_NEWADDR, promote);
305 notifier_call_chain(&inetaddr_chain, NETDEV_UP, promote);
0ff60a45
JHS		 306 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
307 if (ifa1->ifa_mask != ifa->ifa_mask ||
308 !inet_ifa_match(ifa1->ifa_address, ifa))
309 continue;
310 fib_add_ifaddr(ifa);
311 }
312
313 }
314 if (destroy) {
315 inet_free_ifa(ifa1);
316
317 if (!in_dev->ifa_list)
318 inetdev_destroy(in_dev);
8f937c60 319 }
1da177e4
LT		 320}
321
322static int inet_insert_ifa(struct in_ifaddr *ifa)
323{
324 struct in_device *in_dev = ifa->ifa_dev;
325 struct in_ifaddr *ifa1, **ifap, **last_primary;
326
327 ASSERT_RTNL();
328
329 if (!ifa->ifa_local) {
330 inet_free_ifa(ifa);
331 return 0;
332 }
333
334 ifa->ifa_flags &= ~IFA_F_SECONDARY;
335 last_primary = &in_dev->ifa_list;
336
337 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
338 ifap = &ifa1->ifa_next) {
339 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
340 ifa->ifa_scope <= ifa1->ifa_scope)
341 last_primary = &ifa1->ifa_next;
342 if (ifa1->ifa_mask == ifa->ifa_mask &&
343 inet_ifa_match(ifa1->ifa_address, ifa)) {
344 if (ifa1->ifa_local == ifa->ifa_local) {
345 inet_free_ifa(ifa);
346 return -EEXIST;
347 }
348 if (ifa1->ifa_scope != ifa->ifa_scope) {
349 inet_free_ifa(ifa);
350 return -EINVAL;
351 }
352 ifa->ifa_flags |= IFA_F_SECONDARY;
353 }
354 }
355
356 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
357 net_srandom(ifa->ifa_local);
358 ifap = last_primary;
359 }
360
361 ifa->ifa_next = *ifap;
362 *ifap = ifa;
363
364 /* Send message first, then call notifier.
365 Notifier will trigger FIB update, so that
366 listeners of netlink will know about new ifaddr */
367 rtmsg_ifa(RTM_NEWADDR, ifa);
368 notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
369
370 return 0;
371}
372
373static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
374{
e5ed6399 375 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1da177e4
LT		 376
377 ASSERT_RTNL();
378
379 if (!in_dev) {
380 in_dev = inetdev_init(dev);
381 if (!in_dev) {
382 inet_free_ifa(ifa);
383 return -ENOBUFS;
384 }
385 }
386 if (ifa->ifa_dev != in_dev) {
387 BUG_TRAP(!ifa->ifa_dev);
388 in_dev_hold(in_dev);
389 ifa->ifa_dev = in_dev;
390 }
391 if (LOOPBACK(ifa->ifa_local))
392 ifa->ifa_scope = RT_SCOPE_HOST;
393 return inet_insert_ifa(ifa);
394}
395
396struct in_device *inetdev_by_index(int ifindex)
397{
398 struct net_device *dev;
399 struct in_device *in_dev = NULL;
400 read_lock(&dev_base_lock);
401 dev = __dev_get_by_index(ifindex);
402 if (dev)
403 in_dev = in_dev_get(dev);
404 read_unlock(&dev_base_lock);
405 return in_dev;
406}
407
408/* Called only from RTNL semaphored context. No locks. */
409
410struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
411 u32 mask)
412{
413 ASSERT_RTNL();
414
415 for_primary_ifa(in_dev) {
416 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
417 return ifa;
418 } endfor_ifa(in_dev);
419 return NULL;
420}
421
422static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
423{
424 struct rtattr **rta = arg;
425 struct in_device *in_dev;
426 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
427 struct in_ifaddr *ifa, **ifap;
428
429 ASSERT_RTNL();
430
431 if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL)
432 goto out;
433 __in_dev_put(in_dev);
434
435 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
436 ifap = &ifa->ifa_next) {
437 if ((rta[IFA_LOCAL - 1] &&
438 memcmp(RTA_DATA(rta[IFA_LOCAL - 1]),
439 &ifa->ifa_local, 4)) ||
440 (rta[IFA_LABEL - 1] &&
441 rtattr_strcmp(rta[IFA_LABEL - 1], ifa->ifa_label)) ||
442 (rta[IFA_ADDRESS - 1] &&
443 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
444 !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]),
445 ifa))))
446 continue;
447 inet_del_ifa(in_dev, ifap, 1);
448 return 0;
449 }
450out:
451 return -EADDRNOTAVAIL;
452}
453
454static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
455{
456 struct rtattr **rta = arg;
457 struct net_device *dev;
458 struct in_device *in_dev;
459 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
460 struct in_ifaddr *ifa;
461 int rc = -EINVAL;
462
463 ASSERT_RTNL();
464
465 if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1])
466 goto out;
467
468 rc = -ENODEV;
469 if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL)
470 goto out;
471
472 rc = -ENOBUFS;
e5ed6399 473 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) {
1da177e4
LT		 474 in_dev = inetdev_init(dev);
475 if (!in_dev)
476 goto out;
477 }
478
479 if ((ifa = inet_alloc_ifa()) == NULL)
480 goto out;
481
482 if (!rta[IFA_ADDRESS - 1])
483 rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1];
484 memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4);
485 memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4);
486 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
487 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
488 if (rta[IFA_BROADCAST - 1])
489 memcpy(&ifa->ifa_broadcast,
490 RTA_DATA(rta[IFA_BROADCAST - 1]), 4);
491 if (rta[IFA_ANYCAST - 1])
492 memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4);
493 ifa->ifa_flags = ifm->ifa_flags;
494 ifa->ifa_scope = ifm->ifa_scope;
495 in_dev_hold(in_dev);
496 ifa->ifa_dev = in_dev;
497 if (rta[IFA_LABEL - 1])
498 rtattr_strlcpy(ifa->ifa_label, rta[IFA_LABEL - 1], IFNAMSIZ);
499 else
500 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
501
502 rc = inet_insert_ifa(ifa);
503out:
504 return rc;
505}
506
507/*
508 * Determine a default network mask, based on the IP address.
509 */
510
511static __inline__ int inet_abc_len(u32 addr)
512{
513 int rc = -1; /* Something else, probably a multicast. */
514
515 if (ZERONET(addr))
516 rc = 0;
517 else {
518 addr = ntohl(addr);
519
520 if (IN_CLASSA(addr))
521 rc = 8;
522 else if (IN_CLASSB(addr))
523 rc = 16;
524 else if (IN_CLASSC(addr))
525 rc = 24;
526 }
527
528 return rc;
529}
530
531
532int devinet_ioctl(unsigned int cmd, void __user *arg)
533{
534 struct ifreq ifr;
535 struct sockaddr_in sin_orig;
536 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
537 struct in_device *in_dev;
538 struct in_ifaddr **ifap = NULL;
539 struct in_ifaddr *ifa = NULL;
540 struct net_device *dev;
541 char *colon;
542 int ret = -EFAULT;
543 int tryaddrmatch = 0;
544
545 /*
546 * Fetch the caller's info block into kernel space
547 */
548
549 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
550 goto out;
551 ifr.ifr_name[IFNAMSIZ - 1] = 0;
552
553 /* save original address for comparison */
554 memcpy(&sin_orig, sin, sizeof(*sin));
555
556 colon = strchr(ifr.ifr_name, ':');
557 if (colon)
558 *colon = 0;
559
560#ifdef CONFIG_KMOD
561 dev_load(ifr.ifr_name);
562#endif
563
564 switch(cmd) {
565 case SIOCGIFADDR: /* Get interface address */
566 case SIOCGIFBRDADDR: /* Get the broadcast address */
567 case SIOCGIFDSTADDR: /* Get the destination address */
568 case SIOCGIFNETMASK: /* Get the netmask for the interface */
569 /* Note that these ioctls will not sleep,
570 so that we do not impose a lock.
571 One day we will be forced to put shlock here (I mean SMP)
572 */
573 tryaddrmatch = (sin_orig.sin_family == AF_INET);
574 memset(sin, 0, sizeof(*sin));
575 sin->sin_family = AF_INET;
576 break;
577
578 case SIOCSIFFLAGS:
579 ret = -EACCES;
580 if (!capable(CAP_NET_ADMIN))
581 goto out;
582 break;
583 case SIOCSIFADDR: /* Set interface address (and family) */
584 case SIOCSIFBRDADDR: /* Set the broadcast address */
585 case SIOCSIFDSTADDR: /* Set the destination address */
586 case SIOCSIFNETMASK: /* Set the netmask for the interface */
587 ret = -EACCES;
588 if (!capable(CAP_NET_ADMIN))
589 goto out;
590 ret = -EINVAL;
591 if (sin->sin_family != AF_INET)
592 goto out;
593 break;
594 default:
595 ret = -EINVAL;
596 goto out;
597 }
598
599 rtnl_lock();
600
601 ret = -ENODEV;
602 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
603 goto done;
604
605 if (colon)
606 *colon = ':';
607
e5ed6399 608 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
1da177e4
LT		 609 if (tryaddrmatch) {
610 /* Matthias Andree */
611 /* compare label and address (4.4BSD style) */
612 /* note: we only do this for a limited set of ioctls
613 and only if the original address family was AF_INET.
614 This is checked above. */
615 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
616 ifap = &ifa->ifa_next) {
617 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
618 sin_orig.sin_addr.s_addr ==
619 ifa->ifa_address) {
620 break; /* found */
621 }
622 }
623 }
624 /* we didn't get a match, maybe the application is
625 4.3BSD-style and passed in junk so we fall back to
626 comparing just the label */
627 if (!ifa) {
628 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
629 ifap = &ifa->ifa_next)
630 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
631 break;
632 }
633 }
634
635 ret = -EADDRNOTAVAIL;
636 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
637 goto done;
638
639 switch(cmd) {
640 case SIOCGIFADDR: /* Get interface address */
641 sin->sin_addr.s_addr = ifa->ifa_local;
642 goto rarok;
643
644 case SIOCGIFBRDADDR: /* Get the broadcast address */
645 sin->sin_addr.s_addr = ifa->ifa_broadcast;
646 goto rarok;
647
648 case SIOCGIFDSTADDR: /* Get the destination address */
649 sin->sin_addr.s_addr = ifa->ifa_address;
650 goto rarok;
651
652 case SIOCGIFNETMASK: /* Get the netmask for the interface */
653 sin->sin_addr.s_addr = ifa->ifa_mask;
654 goto rarok;
655
656 case SIOCSIFFLAGS:
657 if (colon) {
658 ret = -EADDRNOTAVAIL;
659 if (!ifa)
660 break;
661 ret = 0;
662 if (!(ifr.ifr_flags & IFF_UP))
663 inet_del_ifa(in_dev, ifap, 1);
664 break;
665 }
666 ret = dev_change_flags(dev, ifr.ifr_flags);
667 break;
668
669 case SIOCSIFADDR: /* Set interface address (and family) */
670 ret = -EINVAL;
671 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
672 break;
673
674 if (!ifa) {
675 ret = -ENOBUFS;
676 if ((ifa = inet_alloc_ifa()) == NULL)
677 break;
678 if (colon)
679 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
680 else
681 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
682 } else {
683 ret = 0;
684 if (ifa->ifa_local == sin->sin_addr.s_addr)
685 break;
686 inet_del_ifa(in_dev, ifap, 0);
687 ifa->ifa_broadcast = 0;
688 ifa->ifa_anycast = 0;
689 }
690
691 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
692
693 if (!(dev->flags & IFF_POINTOPOINT)) {
694 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
695 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
696 if ((dev->flags & IFF_BROADCAST) &&
697 ifa->ifa_prefixlen < 31)
698 ifa->ifa_broadcast = ifa->ifa_address |
699 ~ifa->ifa_mask;
700 } else {
701 ifa->ifa_prefixlen = 32;
702 ifa->ifa_mask = inet_make_mask(32);
703 }
704 ret = inet_set_ifa(dev, ifa);
705 break;
706
707 case SIOCSIFBRDADDR: /* Set the broadcast address */
708 ret = 0;
709 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
710 inet_del_ifa(in_dev, ifap, 0);
711 ifa->ifa_broadcast = sin->sin_addr.s_addr;
712 inet_insert_ifa(ifa);
713 }
714 break;
715
716 case SIOCSIFDSTADDR: /* Set the destination address */
717 ret = 0;
718 if (ifa->ifa_address == sin->sin_addr.s_addr)
719 break;
720 ret = -EINVAL;
721 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
722 break;
723 ret = 0;
724 inet_del_ifa(in_dev, ifap, 0);
725 ifa->ifa_address = sin->sin_addr.s_addr;
726 inet_insert_ifa(ifa);
727 break;
728
729 case SIOCSIFNETMASK: /* Set the netmask for the interface */
730
731 /*
732 * The mask we set must be legal.
733 */
734 ret = -EINVAL;
735 if (bad_mask(sin->sin_addr.s_addr, 0))
736 break;
737 ret = 0;
738 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
dcab5e1e 739 u32 old_mask = ifa->ifa_mask;
1da177e4
LT		 740 inet_del_ifa(in_dev, ifap, 0);
741 ifa->ifa_mask = sin->sin_addr.s_addr;
742 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
743
744 /* See if current broadcast address matches
745 * with current netmask, then recalculate
746 * the broadcast address. Otherwise it's a
747 * funny address, so don't touch it since
748 * the user seems to know what (s)he's doing...
749 */
750 if ((dev->flags & IFF_BROADCAST) &&
751 (ifa->ifa_prefixlen < 31) &&
752 (ifa->ifa_broadcast ==
dcab5e1e 753 (ifa->ifa_local|~old_mask))) {
1da177e4
LT		 754 ifa->ifa_broadcast = (ifa->ifa_local |
755 ~sin->sin_addr.s_addr);
756 }
757 inet_insert_ifa(ifa);
758 }
759 break;
760 }
761done:
762 rtnl_unlock();
763out:
764 return ret;
765rarok:
766 rtnl_unlock();
767 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
768 goto out;
769}
770
771static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
772{
e5ed6399 773 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1da177e4
LT		 774 struct in_ifaddr *ifa;
775 struct ifreq ifr;
776 int done = 0;
777
778 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
779 goto out;
780
781 for (; ifa; ifa = ifa->ifa_next) {
782 if (!buf) {
783 done += sizeof(ifr);
784 continue;
785 }
786 if (len < (int) sizeof(ifr))
787 break;
788 memset(&ifr, 0, sizeof(struct ifreq));
789 if (ifa->ifa_label)
790 strcpy(ifr.ifr_name, ifa->ifa_label);
791 else
792 strcpy(ifr.ifr_name, dev->name);
793
794 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
795 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
796 ifa->ifa_local;
797
798 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
799 done = -EFAULT;
800 break;
801 }
802 buf += sizeof(struct ifreq);
803 len -= sizeof(struct ifreq);
804 done += sizeof(struct ifreq);
805 }
806out:
807 return done;
808}
809
810u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
811{
812 u32 addr = 0;
813 struct in_device *in_dev;
814
815 rcu_read_lock();
e5ed6399 816 in_dev = __in_dev_get_rcu(dev);
1da177e4
LT		 817 if (!in_dev)
818 goto no_in_dev;
819
820 for_primary_ifa(in_dev) {
821 if (ifa->ifa_scope > scope)
822 continue;
823 if (!dst || inet_ifa_match(dst, ifa)) {
824 addr = ifa->ifa_local;
825 break;
826 }
827 if (!addr)
828 addr = ifa->ifa_local;
829 } endfor_ifa(in_dev);
830no_in_dev:
831 rcu_read_unlock();
832
833 if (addr)
834 goto out;
835
836 /* Not loopback addresses on loopback should be preferred
837 in this case. It is importnat that lo is the first interface
838 in dev_base list.
839 */
840 read_lock(&dev_base_lock);
841 rcu_read_lock();
842 for (dev = dev_base; dev; dev = dev->next) {
e5ed6399 843 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
1da177e4
LT		 844 continue;
845
846 for_primary_ifa(in_dev) {
847 if (ifa->ifa_scope != RT_SCOPE_LINK &&
848 ifa->ifa_scope <= scope) {
849 addr = ifa->ifa_local;
850 goto out_unlock_both;
851 }
852 } endfor_ifa(in_dev);
853 }
854out_unlock_both:
855 read_unlock(&dev_base_lock);
856 rcu_read_unlock();
857out:
858 return addr;
859}
860
861static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
862 u32 local, int scope)
863{
864 int same = 0;
865 u32 addr = 0;
866
867 for_ifa(in_dev) {
868 if (!addr &&
869 (local == ifa->ifa_local || !local) &&
870 ifa->ifa_scope <= scope) {
871 addr = ifa->ifa_local;
872 if (same)
873 break;
874 }
875 if (!same) {
876 same = (!local || inet_ifa_match(local, ifa)) &&
877 (!dst || inet_ifa_match(dst, ifa));
878 if (same && addr) {
879 if (local || !dst)
880 break;
881 /* Is the selected addr into dst subnet? */
882 if (inet_ifa_match(addr, ifa))
883 break;
884 /* No, then can we use new local src? */
885 if (ifa->ifa_scope <= scope) {
886 addr = ifa->ifa_local;
887 break;
888 }
889 /* search for large dst subnet for addr */
890 same = 0;
891 }
892 }
893 } endfor_ifa(in_dev);
894
895 return same? addr : 0;
896}
897
898/*
899 * Confirm that local IP address exists using wildcards:
900 * - dev: only on this interface, 0=any interface
901 * - dst: only in the same subnet as dst, 0=any dst
902 * - local: address, 0=autoselect the local address
903 * - scope: maximum allowed scope value for the local address
904 */
905u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
906{
907 u32 addr = 0;
908 struct in_device *in_dev;
909
910 if (dev) {
911 rcu_read_lock();
e5ed6399 912 if ((in_dev = __in_dev_get_rcu(dev)))
1da177e4
LT		 913 addr = confirm_addr_indev(in_dev, dst, local, scope);
914 rcu_read_unlock();
915
916 return addr;
917 }
918
919 read_lock(&dev_base_lock);
920 rcu_read_lock();
921 for (dev = dev_base; dev; dev = dev->next) {
e5ed6399 922 if ((in_dev = __in_dev_get_rcu(dev))) {
1da177e4
LT		 923 addr = confirm_addr_indev(in_dev, dst, local, scope);
924 if (addr)
925 break;
926 }
927 }
928 rcu_read_unlock();
929 read_unlock(&dev_base_lock);
930
931 return addr;
932}
933
934/*
935 * Device notifier
936 */
937
938int register_inetaddr_notifier(struct notifier_block *nb)
939{
940 return notifier_chain_register(&inetaddr_chain, nb);
941}
942
943int unregister_inetaddr_notifier(struct notifier_block *nb)
944{
945 return notifier_chain_unregister(&inetaddr_chain, nb);
946}
947
948/* Rename ifa_labels for a device name change. Make some effort to preserve existing
949 * alias numbering and to create unique labels if possible.
950*/
951static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
952{
953 struct in_ifaddr *ifa;
954 int named = 0;
955
956 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
957 char old[IFNAMSIZ], *dot;
958
959 memcpy(old, ifa->ifa_label, IFNAMSIZ);
960 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
961 if (named++ == 0)
962 continue;
963 dot = strchr(ifa->ifa_label, ':');
964 if (dot == NULL) {
965 sprintf(old, ":%d", named);
966 dot = old;
967 }
968 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
969 strcat(ifa->ifa_label, dot);
970 } else {
971 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
972 }
973 }
974}
975
976/* Called only under RTNL semaphore */
977
978static int inetdev_event(struct notifier_block *this, unsigned long event,
979 void *ptr)
980{
981 struct net_device *dev = ptr;
e5ed6399 982 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1da177e4
LT		 983
984 ASSERT_RTNL();
985
986 if (!in_dev) {
987 if (event == NETDEV_REGISTER && dev == &loopback_dev) {
988 in_dev = inetdev_init(dev);
989 if (!in_dev)
990 panic("devinet: Failed to create loopback\n");
991 in_dev->cnf.no_xfrm = 1;
992 in_dev->cnf.no_policy = 1;
993 }
994 goto out;
995 }
996
997 switch (event) {
998 case NETDEV_REGISTER:
999 printk(KERN_DEBUG "inetdev_event: bug\n");
1000 dev->ip_ptr = NULL;
1001 break;
1002 case NETDEV_UP:
1003 if (dev->mtu < 68)
1004 break;
1005 if (dev == &loopback_dev) {
1006 struct in_ifaddr *ifa;
1007 if ((ifa = inet_alloc_ifa()) != NULL) {
1008 ifa->ifa_local =
1009 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1010 ifa->ifa_prefixlen = 8;
1011 ifa->ifa_mask = inet_make_mask(8);
1012 in_dev_hold(in_dev);
1013 ifa->ifa_dev = in_dev;
1014 ifa->ifa_scope = RT_SCOPE_HOST;
1015 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1016 inet_insert_ifa(ifa);
1017 }
1018 }
1019 ip_mc_up(in_dev);
1020 break;
1021 case NETDEV_DOWN:
1022 ip_mc_down(in_dev);
1023 break;
1024 case NETDEV_CHANGEMTU:
1025 if (dev->mtu >= 68)
1026 break;
1027 /* MTU falled under 68, disable IP */
1028 case NETDEV_UNREGISTER:
1029 inetdev_destroy(in_dev);
1030 break;
1031 case NETDEV_CHANGENAME:
1032 /* Do not notify about label change, this event is
1033 * not interesting to applications using netlink.
1034 */
1035 inetdev_changename(dev, in_dev);
1036
1037#ifdef CONFIG_SYSCTL
1038 devinet_sysctl_unregister(&in_dev->cnf);
1039 neigh_sysctl_unregister(in_dev->arp_parms);
1040 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1041 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1042 devinet_sysctl_register(in_dev, &in_dev->cnf);
1043#endif
1044 break;
1045 }
1046out:
1047 return NOTIFY_DONE;
1048}
1049
1050static struct notifier_block ip_netdev_notifier = {
1051 .notifier_call =inetdev_event,
1052};
1053
1054static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
b6544c0b 1055 u32 pid, u32 seq, int event, unsigned int flags)
1da177e4
LT		 1056{
1057 struct ifaddrmsg *ifm;
1058 struct nlmsghdr *nlh;
1059 unsigned char *b = skb->tail;
1060
b6544c0b 1061 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*ifm), flags);
1da177e4
LT		 1062 ifm = NLMSG_DATA(nlh);
1063 ifm->ifa_family = AF_INET;
1064 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1065 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1066 ifm->ifa_scope = ifa->ifa_scope;
1067 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1068 if (ifa->ifa_address)
1069 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
1070 if (ifa->ifa_local)
1071 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
1072 if (ifa->ifa_broadcast)
1073 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
1074 if (ifa->ifa_anycast)
1075 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
1076 if (ifa->ifa_label[0])
1077 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
1078 nlh->nlmsg_len = skb->tail - b;
1079 return skb->len;
1080
1081nlmsg_failure:
1082rtattr_failure:
1083 skb_trim(skb, b - skb->data);
1084 return -1;
1085}
1086
1087static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1088{
1089 int idx, ip_idx;
1090 struct net_device *dev;
1091 struct in_device *in_dev;
1092 struct in_ifaddr *ifa;
1093 int s_ip_idx, s_idx = cb->args[0];
1094
1095 s_ip_idx = ip_idx = cb->args[1];
1096 read_lock(&dev_base_lock);
1097 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1098 if (idx < s_idx)
1099 continue;
1100 if (idx > s_idx)
1101 s_ip_idx = 0;
1102 rcu_read_lock();
e5ed6399 1103 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
1da177e4
LT		 1104 rcu_read_unlock();
1105 continue;
1106 }
1107
1108 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1109 ifa = ifa->ifa_next, ip_idx++) {
1110 if (ip_idx < s_ip_idx)
1111 continue;
1112 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1113 cb->nlh->nlmsg_seq,
b6544c0b 1114 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1da177e4
LT		 1115 rcu_read_unlock();
1116 goto done;
1117 }
1118 }
1119 rcu_read_unlock();
1120 }
1121
1122done:
1123 read_unlock(&dev_base_lock);
1124 cb->args[0] = idx;
1125 cb->args[1] = ip_idx;
1126
1127 return skb->len;
1128}
1129
1130static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1131{
1132 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
1133 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);
1134
1135 if (!skb)
ac6d439d 1136 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS);
9ed19f33 1137 else if (inet_fill_ifaddr(skb, ifa, current->pid, 0, event, 0) < 0) {
1da177e4 1138 kfree_skb(skb);
ac6d439d 1139 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL);
1da177e4 1140 } else {
ac6d439d 1141 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL);
1da177e4
LT		 1142 }
1143}
1144
db46edc6
TG		 1145static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = {
1146 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, },
1147 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, },
1148 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, },
1149 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, },
1150 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, },
1151 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute,
1152 .dumpit = inet_dump_fib, },
1da177e4 1153#ifdef CONFIG_IP_MULTIPLE_TABLES
db46edc6
TG		 1154 [RTM_NEWRULE - RTM_BASE] = { .doit = inet_rtm_newrule, },
1155 [RTM_DELRULE - RTM_BASE] = { .doit = inet_rtm_delrule, },
1156 [RTM_GETRULE - RTM_BASE] = { .dumpit = inet_dump_rules, },
1da177e4
LT		 1157#endif
1158};
1159
1160#ifdef CONFIG_SYSCTL
1161
1162void inet_forward_change(void)
1163{
1164 struct net_device *dev;
1165 int on = ipv4_devconf.forwarding;
1166
1167 ipv4_devconf.accept_redirects = !on;
1168 ipv4_devconf_dflt.forwarding = on;
1169
1170 read_lock(&dev_base_lock);
1171 for (dev = dev_base; dev; dev = dev->next) {
1172 struct in_device *in_dev;
1173 rcu_read_lock();
e5ed6399 1174 in_dev = __in_dev_get_rcu(dev);
1da177e4
LT		 1175 if (in_dev)
1176 in_dev->cnf.forwarding = on;
1177 rcu_read_unlock();
1178 }
1179 read_unlock(&dev_base_lock);
1180
1181 rt_cache_flush(0);
1182}
1183
1184static int devinet_sysctl_forward(ctl_table *ctl, int write,
1185 struct file* filp, void __user *buffer,
1186 size_t *lenp, loff_t *ppos)
1187{
1188 int *valp = ctl->data;
1189 int val = *valp;
1190 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1191
1192 if (write && *valp != val) {
1193 if (valp == &ipv4_devconf.forwarding)
1194 inet_forward_change();
1195 else if (valp != &ipv4_devconf_dflt.forwarding)
1196 rt_cache_flush(0);
1197 }
1198
1199 return ret;
1200}
1201
1202int ipv4_doint_and_flush(ctl_table *ctl, int write,
1203 struct file* filp, void __user *buffer,
1204 size_t *lenp, loff_t *ppos)
1205{
1206 int *valp = ctl->data;
1207 int val = *valp;
1208 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1209
1210 if (write && *valp != val)
1211 rt_cache_flush(0);
1212
1213 return ret;
1214}
1215
1216int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1217 void __user *oldval, size_t __user *oldlenp,
1218 void __user *newval, size_t newlen,
1219 void **context)
1220{
1221 int *valp = table->data;
1222 int new;
1223
1224 if (!newval || !newlen)
1225 return 0;
1226
1227 if (newlen != sizeof(int))
1228 return -EINVAL;
1229
1230 if (get_user(new, (int __user *)newval))
1231 return -EFAULT;
1232
1233 if (new == *valp)
1234 return 0;
1235
1236 if (oldval && oldlenp) {
1237 size_t len;
1238
1239 if (get_user(len, oldlenp))
1240 return -EFAULT;
1241
1242 if (len) {
1243 if (len > table->maxlen)
1244 len = table->maxlen;
1245 if (copy_to_user(oldval, valp, len))
1246 return -EFAULT;
1247 if (put_user(len, oldlenp))
1248 return -EFAULT;
1249 }
1250 }
1251
1252 *valp = new;
1253 rt_cache_flush(0);
1254 return 1;
1255}
1256
1257
1258static struct devinet_sysctl_table {
1259 struct ctl_table_header *sysctl_header;
1260 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1261 ctl_table devinet_dev[2];
1262 ctl_table devinet_conf_dir[2];
1263 ctl_table devinet_proto_dir[2];
1264 ctl_table devinet_root_dir[2];
1265} devinet_sysctl = {
1266 .devinet_vars = {
1267 {
1268 .ctl_name = NET_IPV4_CONF_FORWARDING,
1269 .procname = "forwarding",
1270 .data = &ipv4_devconf.forwarding,
1271 .maxlen = sizeof(int),
1272 .mode = 0644,
1273 .proc_handler = &devinet_sysctl_forward,
1274 },
1275 {
1276 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1277 .procname = "mc_forwarding",
1278 .data = &ipv4_devconf.mc_forwarding,
1279 .maxlen = sizeof(int),
1280 .mode = 0444,
1281 .proc_handler = &proc_dointvec,
1282 },
1283 {
1284 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1285 .procname = "accept_redirects",
1286 .data = &ipv4_devconf.accept_redirects,
1287 .maxlen = sizeof(int),
1288 .mode = 0644,
1289 .proc_handler = &proc_dointvec,
1290 },
1291 {
1292 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1293 .procname = "secure_redirects",
1294 .data = &ipv4_devconf.secure_redirects,
1295 .maxlen = sizeof(int),
1296 .mode = 0644,
1297 .proc_handler = &proc_dointvec,
1298 },
1299 {
1300 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1301 .procname = "shared_media",
1302 .data = &ipv4_devconf.shared_media,
1303 .maxlen = sizeof(int),
1304 .mode = 0644,
1305 .proc_handler = &proc_dointvec,
1306 },
1307 {
1308 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1309 .procname = "rp_filter",
1310 .data = &ipv4_devconf.rp_filter,
1311 .maxlen = sizeof(int),
1312 .mode = 0644,
1313 .proc_handler = &proc_dointvec,
1314 },
1315 {
1316 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1317 .procname = "send_redirects",
1318 .data = &ipv4_devconf.send_redirects,
1319 .maxlen = sizeof(int),
1320 .mode = 0644,
1321 .proc_handler = &proc_dointvec,
1322 },
1323 {
1324 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1325 .procname = "accept_source_route",
1326 .data = &ipv4_devconf.accept_source_route,
1327 .maxlen = sizeof(int),
1328 .mode = 0644,
1329 .proc_handler = &proc_dointvec,
1330 },
1331 {
1332 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1333 .procname = "proxy_arp",
1334 .data = &ipv4_devconf.proxy_arp,
1335 .maxlen = sizeof(int),
1336 .mode = 0644,
1337 .proc_handler = &proc_dointvec,
1338 },
1339 {
1340 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1341 .procname = "medium_id",
1342 .data = &ipv4_devconf.medium_id,
1343 .maxlen = sizeof(int),
1344 .mode = 0644,
1345 .proc_handler = &proc_dointvec,
1346 },
1347 {
1348 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1349 .procname = "bootp_relay",
1350 .data = &ipv4_devconf.bootp_relay,
1351 .maxlen = sizeof(int),
1352 .mode = 0644,
1353 .proc_handler = &proc_dointvec,
1354 },
1355 {
1356 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1357 .procname = "log_martians",
1358 .data = &ipv4_devconf.log_martians,
1359 .maxlen = sizeof(int),
1360 .mode = 0644,
1361 .proc_handler = &proc_dointvec,
1362 },
1363 {
1364 .ctl_name = NET_IPV4_CONF_TAG,
1365 .procname = "tag",
1366 .data = &ipv4_devconf.tag,
1367 .maxlen = sizeof(int),
1368 .mode = 0644,
1369 .proc_handler = &proc_dointvec,
1370 },
1371 {
1372 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1373 .procname = "arp_filter",
1374 .data = &ipv4_devconf.arp_filter,
1375 .maxlen = sizeof(int),
1376 .mode = 0644,
1377 .proc_handler = &proc_dointvec,
1378 },
1379 {
1380 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1381 .procname = "arp_announce",
1382 .data = &ipv4_devconf.arp_announce,
1383 .maxlen = sizeof(int),
1384 .mode = 0644,
1385 .proc_handler = &proc_dointvec,
1386 },
1387 {
1388 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1389 .procname = "arp_ignore",
1390 .data = &ipv4_devconf.arp_ignore,
1391 .maxlen = sizeof(int),
1392 .mode = 0644,
1393 .proc_handler = &proc_dointvec,
1394 },
1395 {
1396 .ctl_name = NET_IPV4_CONF_NOXFRM,
1397 .procname = "disable_xfrm",
1398 .data = &ipv4_devconf.no_xfrm,
1399 .maxlen = sizeof(int),
1400 .mode = 0644,
1401 .proc_handler = &ipv4_doint_and_flush,
1402 .strategy = &ipv4_doint_and_flush_strategy,
1403 },
1404 {
1405 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1406 .procname = "disable_policy",
1407 .data = &ipv4_devconf.no_policy,
1408 .maxlen = sizeof(int),
1409 .mode = 0644,
1410 .proc_handler = &ipv4_doint_and_flush,
1411 .strategy = &ipv4_doint_and_flush_strategy,
1412 },
1413 {
1414 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1415 .procname = "force_igmp_version",
1416 .data = &ipv4_devconf.force_igmp_version,
1417 .maxlen = sizeof(int),
1418 .mode = 0644,
8f937c60
HW		 1419 .proc_handler = &ipv4_doint_and_flush,
1420 .strategy = &ipv4_doint_and_flush_strategy,
1421 },
1422 {
1423 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1424 .procname = "promote_secondaries",
1425 .data = &ipv4_devconf.promote_secondaries,
1426 .maxlen = sizeof(int),
1427 .mode = 0644,
1da177e4
LT		 1428 .proc_handler = &ipv4_doint_and_flush,
1429 .strategy = &ipv4_doint_and_flush_strategy,
1430 },
1431 },
1432 .devinet_dev = {
1433 {
1434 .ctl_name = NET_PROTO_CONF_ALL,
1435 .procname = "all",
1436 .mode = 0555,
1437 .child = devinet_sysctl.devinet_vars,
1438 },
1439 },
1440 .devinet_conf_dir = {
1441 {
1442 .ctl_name = NET_IPV4_CONF,
1443 .procname = "conf",
1444 .mode = 0555,
1445 .child = devinet_sysctl.devinet_dev,
1446 },
1447 },
1448 .devinet_proto_dir = {
1449 {
1450 .ctl_name = NET_IPV4,
1451 .procname = "ipv4",
1452 .mode = 0555,
1453 .child = devinet_sysctl.devinet_conf_dir,
1454 },
1455 },
1456 .devinet_root_dir = {
1457 {
1458 .ctl_name = CTL_NET,
1459 .procname = "net",
1460 .mode = 0555,
1461 .child = devinet_sysctl.devinet_proto_dir,
1462 },
1463 },
1464};
1465
1466static void devinet_sysctl_register(struct in_device *in_dev,
1467 struct ipv4_devconf *p)
1468{
1469 int i;
1470 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1471 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1472 char *dev_name = NULL;
1473
1474 if (!t)
1475 return;
1476 memcpy(t, &devinet_sysctl, sizeof(*t));
1477 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1478 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1479 t->devinet_vars[i].de = NULL;
1480 }
1481
1482 if (dev) {
1483 dev_name = dev->name;
1484 t->devinet_dev[0].ctl_name = dev->ifindex;
1485 } else {
1486 dev_name = "default";
1487 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1488 }
1489
1490 /*
1491 * Make a copy of dev_name, because '.procname' is regarded as const
1492 * by sysctl and we wouldn't want anyone to change it under our feet
1493 * (see SIOCSIFNAME).
1494 */
543537bd 1495 dev_name = kstrdup(dev_name, GFP_KERNEL);
1da177e4
LT		 1496 if (!dev_name)
1497 goto free;
1498
1499 t->devinet_dev[0].procname = dev_name;
1500 t->devinet_dev[0].child = t->devinet_vars;
1501 t->devinet_dev[0].de = NULL;
1502 t->devinet_conf_dir[0].child = t->devinet_dev;
1503 t->devinet_conf_dir[0].de = NULL;
1504 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1505 t->devinet_proto_dir[0].de = NULL;
1506 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1507 t->devinet_root_dir[0].de = NULL;
1508
1509 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1510 if (!t->sysctl_header)
1511 goto free_procname;
1512
1513 p->sysctl = t;
1514 return;
1515
1516 /* error path */
1517 free_procname:
1518 kfree(dev_name);
1519 free:
1520 kfree(t);
1521 return;
1522}
1523
1524static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1525{
1526 if (p->sysctl) {
1527 struct devinet_sysctl_table *t = p->sysctl;
1528 p->sysctl = NULL;
1529 unregister_sysctl_table(t->sysctl_header);
1530 kfree(t->devinet_dev[0].procname);
1531 kfree(t);
1532 }
1533}
1534#endif
1535
1536void __init devinet_init(void)
1537{
1538 register_gifconf(PF_INET, inet_gifconf);
1539 register_netdevice_notifier(&ip_netdev_notifier);
1540 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1541#ifdef CONFIG_SYSCTL
1542 devinet_sysctl.sysctl_header =
1543 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1544 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1545#endif
1546}
1547
1548EXPORT_SYMBOL(devinet_ioctl);
1549EXPORT_SYMBOL(in_dev_finish_destroy);
1550EXPORT_SYMBOL(inet_select_addr);
1551EXPORT_SYMBOL(inetdev_by_index);
1552EXPORT_SYMBOL(register_inetaddr_notifier);
1553EXPORT_SYMBOL(unregister_inetaddr_notifier);
Clone of davem's net-next-2.6 tree