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