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