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