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