?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs/bad_inode.c 64bit fix
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / ipv4 / devinet.c
blob73a62007e36e9add5868a5c19b9f6105a9135ba7
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 #include <linux/config.h>
31
32 #include <asm/uaccess.h>
33 #include <asm/system.h>
34 #include <linux/bitops.h>
35 #include <linux/capability.h>
36 #include <linux/module.h>
37 #include <linux/types.h>
38 #include <linux/kernel.h>
39 #include <linux/sched.h>
40 #include <linux/string.h>
41 #include <linux/mm.h>
42 #include <linux/socket.h>
43 #include <linux/sockios.h>
44 #include <linux/in.h>
45 #include <linux/errno.h>
46 #include <linux/interrupt.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
67 struct ipv4_devconf ipv4_devconf = {
68 .accept_redirects = 1,
69 .send_redirects = 1,
70 .secure_redirects = 1,
71 .shared_media = 1,
72 };
73
74 static struct ipv4_devconf ipv4_devconf_dflt = {
75 .accept_redirects = 1,
76 .send_redirects = 1,
77 .secure_redirects = 1,
78 .shared_media = 1,
79 .accept_source_route = 1,
80 };
81
82 static void rtmsg_ifa(int event, struct in_ifaddr *);
83
84 static struct notifier_block *inetaddr_chain;
85 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
86 int destroy);
87 #ifdef CONFIG_SYSCTL
88 static void devinet_sysctl_register(struct in_device *in_dev,
89 struct ipv4_devconf *p);
90 static void devinet_sysctl_unregister(struct ipv4_devconf *p);
91 #endif
92
93 /* Locks all the inet devices. */
94
95 static struct in_ifaddr *inet_alloc_ifa(void)
96 {
97 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL);
98
99 if (ifa) {
100 memset(ifa, 0, sizeof(*ifa));
101 INIT_RCU_HEAD(&ifa->rcu_head);
102 }
103
104 return ifa;
105 }
106
107 static void inet_rcu_free_ifa(struct rcu_head *head)
108 {
109 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
110 if (ifa->ifa_dev)
111 in_dev_put(ifa->ifa_dev);
112 kfree(ifa);
113 }
114
115 static inline void inet_free_ifa(struct in_ifaddr *ifa)
116 {
117 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
118 }
119
120 void in_dev_finish_destroy(struct in_device *idev)
121 {
122 struct net_device *dev = idev->dev;
123
124 BUG_TRAP(!idev->ifa_list);
125 BUG_TRAP(!idev->mc_list);
126 #ifdef NET_REFCNT_DEBUG
127 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
128 idev, dev ? dev->name : "NIL");
129 #endif
130 dev_put(dev);
131 if (!idev->dead)
132 printk("Freeing alive in_device %p\n", idev);
133 else {
134 kfree(idev);
135 }
136 }
137
138 struct in_device *inetdev_init(struct net_device *dev)
139 {
140 struct in_device *in_dev;
141
142 ASSERT_RTNL();
143
144 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL);
145 if (!in_dev)
146 goto out;
147 memset(in_dev, 0, sizeof(*in_dev));
148 INIT_RCU_HEAD(&in_dev->rcu_head);
149 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
150 in_dev->cnf.sysctl = NULL;
151 in_dev->dev = dev;
152 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
153 goto out_kfree;
154 /* Reference in_dev->dev */
155 dev_hold(dev);
156 #ifdef CONFIG_SYSCTL
157 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
158 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
159 #endif
160
161 /* Account for reference dev->ip_ptr (below) */
162 in_dev_hold(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);
170 out:
171 /* we can receive as soon as ip_ptr is set -- do this last */
172 rcu_assign_pointer(dev->ip_ptr, in_dev);
173 return in_dev;
174 out_kfree:
175 kfree(in_dev);
176 in_dev = NULL;
177 goto out;
178 }
179
180 static void in_dev_rcu_put(struct rcu_head *head)
181 {
182 struct in_device *idev = container_of(head, struct in_device, rcu_head);
183 in_dev_put(idev);
184 }
185
186 static void inetdev_destroy(struct in_device *in_dev)
187 {
188 struct in_ifaddr *ifa;
189 struct net_device *dev;
190
191 ASSERT_RTNL();
192
193 dev = in_dev->dev;
194 if (dev == &loopback_dev)
195 return;
196
197 in_dev->dead = 1;
198
199 ip_mc_destroy_dev(in_dev);
200
201 while ((ifa = in_dev->ifa_list) != NULL) {
202 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
203 inet_free_ifa(ifa);
204 }
205
206 #ifdef CONFIG_SYSCTL
207 devinet_sysctl_unregister(&in_dev->cnf);
208 #endif
209
210 dev->ip_ptr = NULL;
211
212 #ifdef CONFIG_SYSCTL
213 neigh_sysctl_unregister(in_dev->arp_parms);
214 #endif
215 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
216 arp_ifdown(dev);
217
218 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
219 }
220
221 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
222 {
223 rcu_read_lock();
224 for_primary_ifa(in_dev) {
225 if (inet_ifa_match(a, ifa)) {
226 if (!b || inet_ifa_match(b, ifa)) {
227 rcu_read_unlock();
228 return 1;
229 }
230 }
231 } endfor_ifa(in_dev);
232 rcu_read_unlock();
233 return 0;
234 }
235
236 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
237 int destroy)
238 {
239 struct in_ifaddr *promote = NULL;
240 struct in_ifaddr *ifa, *ifa1 = *ifap;
241 struct in_ifaddr *last_prim = in_dev->ifa_list;
242 struct in_ifaddr *prev_prom = NULL;
243 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
244
245 ASSERT_RTNL();
246
247 /* 1. Deleting primary ifaddr forces deletion all secondaries
248 * unless alias promotion is set
249 **/
250
251 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
252 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
253
254 while ((ifa = *ifap1) != NULL) {
255 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
256 ifa1->ifa_scope <= ifa->ifa_scope)
257 last_prim = ifa;
258
259 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
260 ifa1->ifa_mask != ifa->ifa_mask ||
261 !inet_ifa_match(ifa1->ifa_address, ifa)) {
262 ifap1 = &ifa->ifa_next;
263 prev_prom = ifa;
264 continue;
265 }
266
267 if (!do_promote) {
268 *ifap1 = ifa->ifa_next;
269
270 rtmsg_ifa(RTM_DELADDR, ifa);
271 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
272 inet_free_ifa(ifa);
273 } else {
274 promote = ifa;
275 break;
276 }
277 }
278 }
279
280 /* 2. Unlink it */
281
282 *ifap = ifa1->ifa_next;
283
284 /* 3. Announce address deletion */
285
286 /* Send message first, then call notifier.
287 At first sight, FIB update triggered by notifier
288 will refer to already deleted ifaddr, that could confuse
289 netlink listeners. It is not true: look, gated sees
290 that route deleted and if it still thinks that ifaddr
291 is valid, it will try to restore deleted routes... Grr.
292 So that, this order is correct.
293 */
294 rtmsg_ifa(RTM_DELADDR, ifa1);
295 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
296
297 if (promote) {
298
299 if (prev_prom) {
300 prev_prom->ifa_next = promote->ifa_next;
301 promote->ifa_next = last_prim->ifa_next;
302 last_prim->ifa_next = promote;
303 }
304
305 promote->ifa_flags &= ~IFA_F_SECONDARY;
306 rtmsg_ifa(RTM_NEWADDR, promote);
307 notifier_call_chain(&inetaddr_chain, NETDEV_UP, promote);
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);
321 }
322 }
323
324 static 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);
370 notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
371
372 return 0;
373 }
374
375 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
376 {
377 struct in_device *in_dev = __in_dev_get_rtnl(dev);
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
398 struct 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
412 struct 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
424 static 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 }
452 out:
453 return -EADDRNOTAVAIL;
454 }
455
456 static 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;
475 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) {
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);
505 out:
506 return rc;
507 }
508
509 /*
510 * Determine a default network mask, based on the IP address.
511 */
512
513 static __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
534 int 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
610 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
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) {
741 u32 old_mask = ifa->ifa_mask;
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 ==
755 (ifa->ifa_local|~old_mask))) {
756 ifa->ifa_broadcast = (ifa->ifa_local |
757 ~sin->sin_addr.s_addr);
758 }
759 inet_insert_ifa(ifa);
760 }
761 break;
762 }
763 done:
764 rtnl_unlock();
765 out:
766 return ret;
767 rarok:
768 rtnl_unlock();
769 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
770 goto out;
771 }
772
773 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
774 {
775 struct in_device *in_dev = __in_dev_get_rtnl(dev);
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 }
808 out:
809 return done;
810 }
811
812 u32 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();
818 in_dev = __in_dev_get_rcu(dev);
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);
832 no_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) {
845 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
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 }
856 out_unlock_both:
857 read_unlock(&dev_base_lock);
858 rcu_read_unlock();
859 out:
860 return addr;
861 }
862
863 static 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 */
907 u32 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();
914 if ((in_dev = __in_dev_get_rcu(dev)))
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) {
924 if ((in_dev = __in_dev_get_rcu(dev))) {
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
940 int register_inetaddr_notifier(struct notifier_block *nb)
941 {
942 return notifier_chain_register(&inetaddr_chain, nb);
943 }
944
945 int unregister_inetaddr_notifier(struct notifier_block *nb)
946 {
947 return notifier_chain_unregister(&inetaddr_chain, nb);
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 */
953 static 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
980 static int inetdev_event(struct notifier_block *this, unsigned long event,
981 void *ptr)
982 {
983 struct net_device *dev = ptr;
984 struct in_device *in_dev = __in_dev_get_rtnl(dev);
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 }
1048 out:
1049 return NOTIFY_DONE;
1050 }
1051
1052 static struct notifier_block ip_netdev_notifier = {
1053 .notifier_call =inetdev_event,
1054 };
1055
1056 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1057 u32 pid, u32 seq, int event, unsigned int flags)
1058 {
1059 struct ifaddrmsg *ifm;
1060 struct nlmsghdr *nlh;
1061 unsigned char *b = skb->tail;
1062
1063 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*ifm), flags);
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
1083 nlmsg_failure:
1084 rtattr_failure:
1085 skb_trim(skb, b - skb->data);
1086 return -1;
1087 }
1088
1089 static 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();
1105 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
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,
1116 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1117 rcu_read_unlock();
1118 goto done;
1119 }
1120 }
1121 rcu_read_unlock();
1122 }
1123
1124 done:
1125 read_unlock(&dev_base_lock);
1126 cb->args[0] = idx;
1127 cb->args[1] = ip_idx;
1128
1129 return skb->len;
1130 }
1131
1132 static 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)
1138 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS);
1139 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) {
1140 kfree_skb(skb);
1141 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL);
1142 } else {
1143 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL);
1144 }
1145 }
1146
1147 static 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, },
1155 #ifdef CONFIG_IP_MULTIPLE_TABLES
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, },
1159 #endif
1160 };
1161
1162 #ifdef CONFIG_SYSCTL
1163
1164 void 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();
1176 in_dev = __in_dev_get_rcu(dev);
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
1186 static 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
1204 int 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
1218 int 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
1260 static 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),
1394 .mode = 0644,
1395 .proc_handler = &proc_dointvec,
1396 },
1397 {
1398 .ctl_name = NET_IPV4_CONF_NOXFRM,
1399 .procname = "disable_xfrm",
1400 .data = &ipv4_devconf.no_xfrm,
1401 .maxlen = sizeof(int),
1402 .mode = 0644,
1403 .proc_handler = &ipv4_doint_and_flush,
1404 .strategy = &ipv4_doint_and_flush_strategy,
1405 },
1406 {
1407 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1408 .procname = "disable_policy",
1409 .data = &ipv4_devconf.no_policy,
1410 .maxlen = sizeof(int),
1411 .mode = 0644,
1412 .proc_handler = &ipv4_doint_and_flush,
1413 .strategy = &ipv4_doint_and_flush_strategy,
1414 },
1415 {
1416 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1417 .procname = "force_igmp_version",
1418 .data = &ipv4_devconf.force_igmp_version,
1419 .maxlen = sizeof(int),
1420 .mode = 0644,
1421 .proc_handler = &ipv4_doint_and_flush,
1422 .strategy = &ipv4_doint_and_flush_strategy,
1423 },
1424 {
1425 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1426 .procname = "promote_secondaries",
1427 .data = &ipv4_devconf.promote_secondaries,
1428 .maxlen = sizeof(int),
1429 .mode = 0644,
1430 .proc_handler = &ipv4_doint_and_flush,
1431 .strategy = &ipv4_doint_and_flush_strategy,
1432 },
1433 },
1434 .devinet_dev = {
1435 {
1436 .ctl_name = NET_PROTO_CONF_ALL,
1437 .procname = "all",
1438 .mode = 0555,
1439 .child = devinet_sysctl.devinet_vars,
1440 },
1441 },
1442 .devinet_conf_dir = {
1443 {
1444 .ctl_name = NET_IPV4_CONF,
1445 .procname = "conf",
1446 .mode = 0555,
1447 .child = devinet_sysctl.devinet_dev,
1448 },
1449 },
1450 .devinet_proto_dir = {
1451 {
1452 .ctl_name = NET_IPV4,
1453 .procname = "ipv4",
1454 .mode = 0555,
1455 .child = devinet_sysctl.devinet_conf_dir,
1456 },
1457 },
1458 .devinet_root_dir = {
1459 {
1460 .ctl_name = CTL_NET,
1461 .procname = "net",
1462 .mode = 0555,
1463 .child = devinet_sysctl.devinet_proto_dir,
1464 },
1465 },
1466 };
1467
1468 static void devinet_sysctl_register(struct in_device *in_dev,
1469 struct ipv4_devconf *p)
1470 {
1471 int i;
1472 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1473 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1474 char *dev_name = NULL;
1475
1476 if (!t)
1477 return;
1478 memcpy(t, &devinet_sysctl, sizeof(*t));
1479 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1480 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1481 t->devinet_vars[i].de = NULL;
1482 }
1483
1484 if (dev) {
1485 dev_name = dev->name;
1486 t->devinet_dev[0].ctl_name = dev->ifindex;
1487 } else {
1488 dev_name = "default";
1489 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1490 }
1491
1492 /*
1493 * Make a copy of dev_name, because '.procname' is regarded as const
1494 * by sysctl and we wouldn't want anyone to change it under our feet
1495 * (see SIOCSIFNAME).
1496 */
1497 dev_name = kstrdup(dev_name, GFP_KERNEL);
1498 if (!dev_name)
1499 goto free;
1500
1501 t->devinet_dev[0].procname = dev_name;
1502 t->devinet_dev[0].child = t->devinet_vars;
1503 t->devinet_dev[0].de = NULL;
1504 t->devinet_conf_dir[0].child = t->devinet_dev;
1505 t->devinet_conf_dir[0].de = NULL;
1506 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1507 t->devinet_proto_dir[0].de = NULL;
1508 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1509 t->devinet_root_dir[0].de = NULL;
1510
1511 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1512 if (!t->sysctl_header)
1513 goto free_procname;
1514
1515 p->sysctl = t;
1516 return;
1517
1518 /* error path */
1519 free_procname:
1520 kfree(dev_name);
1521 free:
1522 kfree(t);
1523 return;
1524 }
1525
1526 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1527 {
1528 if (p->sysctl) {
1529 struct devinet_sysctl_table *t = p->sysctl;
1530 p->sysctl = NULL;
1531 unregister_sysctl_table(t->sysctl_header);
1532 kfree(t->devinet_dev[0].procname);
1533 kfree(t);
1534 }
1535 }
1536 #endif
1537
1538 void __init devinet_init(void)
1539 {
1540 register_gifconf(PF_INET, inet_gifconf);
1541 register_netdevice_notifier(&ip_netdev_notifier);
1542 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1543 #ifdef CONFIG_SYSCTL
1544 devinet_sysctl.sysctl_header =
1545 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1546 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1547 #endif
1548 }
1549
1550 EXPORT_SYMBOL(devinet_ioctl);
1551 EXPORT_SYMBOL(in_dev_finish_destroy);
1552 EXPORT_SYMBOL(inet_select_addr);
1553 EXPORT_SYMBOL(inetdev_by_index);
1554 EXPORT_SYMBOL(register_inetaddr_notifier);
1555 EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree