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