?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / net / ipv4 / devinet.c
blob19464d649b464413cfe2e6aa6782a734e98eb1ab
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->nd_net->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 = skb->sk->sk_net;
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 if (net != &init_net)
450 return -EINVAL;
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(net, 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 net *net, 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;
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 err = -EINVAL;
503 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
504 goto errout;
505
506 dev = __dev_get_by_index(net, ifm->ifa_index);
507 err = -ENODEV;
508 if (dev == NULL)
509 goto errout;
510
511 in_dev = __in_dev_get_rtnl(dev);
512 err = -ENOBUFS;
513 if (in_dev == NULL)
514 goto errout;
515
516 ifa = inet_alloc_ifa();
517 if (ifa == NULL)
518 /*
519 * A potential indev allocation can be left alive, it stays
520 * assigned to its device and is destroy with it.
521 */
522 goto errout;
523
524 ipv4_devconf_setall(in_dev);
525 in_dev_hold(in_dev);
526
527 if (tb[IFA_ADDRESS] == NULL)
528 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
529
530 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
531 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
532 ifa->ifa_flags = ifm->ifa_flags;
533 ifa->ifa_scope = ifm->ifa_scope;
534 ifa->ifa_dev = in_dev;
535
536 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
537 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
538
539 if (tb[IFA_BROADCAST])
540 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
541
542 if (tb[IFA_ANYCAST])
543 ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
544
545 if (tb[IFA_LABEL])
546 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
547 else
548 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
549
550 return ifa;
551
552 errout:
553 return ERR_PTR(err);
554 }
555
556 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
557 {
558 struct net *net = skb->sk->sk_net;
559 struct in_ifaddr *ifa;
560
561 ASSERT_RTNL();
562
563 if (net != &init_net)
564 return -EINVAL;
565
566 ifa = rtm_to_ifaddr(net, nlh);
567 if (IS_ERR(ifa))
568 return PTR_ERR(ifa);
569
570 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
571 }
572
573 /*
574 * Determine a default network mask, based on the IP address.
575 */
576
577 static __inline__ int inet_abc_len(__be32 addr)
578 {
579 int rc = -1; /* Something else, probably a multicast. */
580
581 if (ipv4_is_zeronet(addr))
582 rc = 0;
583 else {
584 __u32 haddr = ntohl(addr);
585
586 if (IN_CLASSA(haddr))
587 rc = 8;
588 else if (IN_CLASSB(haddr))
589 rc = 16;
590 else if (IN_CLASSC(haddr))
591 rc = 24;
592 }
593
594 return rc;
595 }
596
597
598 int devinet_ioctl(unsigned int cmd, void __user *arg)
599 {
600 struct ifreq ifr;
601 struct sockaddr_in sin_orig;
602 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
603 struct in_device *in_dev;
604 struct in_ifaddr **ifap = NULL;
605 struct in_ifaddr *ifa = NULL;
606 struct net_device *dev;
607 char *colon;
608 int ret = -EFAULT;
609 int tryaddrmatch = 0;
610
611 /*
612 * Fetch the caller's info block into kernel space
613 */
614
615 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
616 goto out;
617 ifr.ifr_name[IFNAMSIZ - 1] = 0;
618
619 /* save original address for comparison */
620 memcpy(&sin_orig, sin, sizeof(*sin));
621
622 colon = strchr(ifr.ifr_name, ':');
623 if (colon)
624 *colon = 0;
625
626 #ifdef CONFIG_KMOD
627 dev_load(&init_net, ifr.ifr_name);
628 #endif
629
630 switch (cmd) {
631 case SIOCGIFADDR: /* Get interface address */
632 case SIOCGIFBRDADDR: /* Get the broadcast address */
633 case SIOCGIFDSTADDR: /* Get the destination address */
634 case SIOCGIFNETMASK: /* Get the netmask for the interface */
635 /* Note that these ioctls will not sleep,
636 so that we do not impose a lock.
637 One day we will be forced to put shlock here (I mean SMP)
638 */
639 tryaddrmatch = (sin_orig.sin_family == AF_INET);
640 memset(sin, 0, sizeof(*sin));
641 sin->sin_family = AF_INET;
642 break;
643
644 case SIOCSIFFLAGS:
645 ret = -EACCES;
646 if (!capable(CAP_NET_ADMIN))
647 goto out;
648 break;
649 case SIOCSIFADDR: /* Set interface address (and family) */
650 case SIOCSIFBRDADDR: /* Set the broadcast address */
651 case SIOCSIFDSTADDR: /* Set the destination address */
652 case SIOCSIFNETMASK: /* Set the netmask for the interface */
653 ret = -EACCES;
654 if (!capable(CAP_NET_ADMIN))
655 goto out;
656 ret = -EINVAL;
657 if (sin->sin_family != AF_INET)
658 goto out;
659 break;
660 default:
661 ret = -EINVAL;
662 goto out;
663 }
664
665 rtnl_lock();
666
667 ret = -ENODEV;
668 if ((dev = __dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
669 goto done;
670
671 if (colon)
672 *colon = ':';
673
674 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
675 if (tryaddrmatch) {
676 /* Matthias Andree */
677 /* compare label and address (4.4BSD style) */
678 /* note: we only do this for a limited set of ioctls
679 and only if the original address family was AF_INET.
680 This is checked above. */
681 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
682 ifap = &ifa->ifa_next) {
683 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
684 sin_orig.sin_addr.s_addr ==
685 ifa->ifa_address) {
686 break; /* found */
687 }
688 }
689 }
690 /* we didn't get a match, maybe the application is
691 4.3BSD-style and passed in junk so we fall back to
692 comparing just the label */
693 if (!ifa) {
694 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
695 ifap = &ifa->ifa_next)
696 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
697 break;
698 }
699 }
700
701 ret = -EADDRNOTAVAIL;
702 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
703 goto done;
704
705 switch (cmd) {
706 case SIOCGIFADDR: /* Get interface address */
707 sin->sin_addr.s_addr = ifa->ifa_local;
708 goto rarok;
709
710 case SIOCGIFBRDADDR: /* Get the broadcast address */
711 sin->sin_addr.s_addr = ifa->ifa_broadcast;
712 goto rarok;
713
714 case SIOCGIFDSTADDR: /* Get the destination address */
715 sin->sin_addr.s_addr = ifa->ifa_address;
716 goto rarok;
717
718 case SIOCGIFNETMASK: /* Get the netmask for the interface */
719 sin->sin_addr.s_addr = ifa->ifa_mask;
720 goto rarok;
721
722 case SIOCSIFFLAGS:
723 if (colon) {
724 ret = -EADDRNOTAVAIL;
725 if (!ifa)
726 break;
727 ret = 0;
728 if (!(ifr.ifr_flags & IFF_UP))
729 inet_del_ifa(in_dev, ifap, 1);
730 break;
731 }
732 ret = dev_change_flags(dev, ifr.ifr_flags);
733 break;
734
735 case SIOCSIFADDR: /* Set interface address (and family) */
736 ret = -EINVAL;
737 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
738 break;
739
740 if (!ifa) {
741 ret = -ENOBUFS;
742 if ((ifa = inet_alloc_ifa()) == NULL)
743 break;
744 if (colon)
745 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
746 else
747 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
748 } else {
749 ret = 0;
750 if (ifa->ifa_local == sin->sin_addr.s_addr)
751 break;
752 inet_del_ifa(in_dev, ifap, 0);
753 ifa->ifa_broadcast = 0;
754 ifa->ifa_anycast = 0;
755 <<<<<<< HEAD:net/ipv4/devinet.c
756 =======
757 ifa->ifa_scope = 0;
758 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:net/ipv4/devinet.c
759 }
760
761 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
762
763 if (!(dev->flags & IFF_POINTOPOINT)) {
764 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
765 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
766 if ((dev->flags & IFF_BROADCAST) &&
767 ifa->ifa_prefixlen < 31)
768 ifa->ifa_broadcast = ifa->ifa_address |
769 ~ifa->ifa_mask;
770 } else {
771 ifa->ifa_prefixlen = 32;
772 ifa->ifa_mask = inet_make_mask(32);
773 }
774 ret = inet_set_ifa(dev, ifa);
775 break;
776
777 case SIOCSIFBRDADDR: /* Set the broadcast address */
778 ret = 0;
779 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
780 inet_del_ifa(in_dev, ifap, 0);
781 ifa->ifa_broadcast = sin->sin_addr.s_addr;
782 inet_insert_ifa(ifa);
783 }
784 break;
785
786 case SIOCSIFDSTADDR: /* Set the destination address */
787 ret = 0;
788 if (ifa->ifa_address == sin->sin_addr.s_addr)
789 break;
790 ret = -EINVAL;
791 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
792 break;
793 ret = 0;
794 inet_del_ifa(in_dev, ifap, 0);
795 ifa->ifa_address = sin->sin_addr.s_addr;
796 inet_insert_ifa(ifa);
797 break;
798
799 case SIOCSIFNETMASK: /* Set the netmask for the interface */
800
801 /*
802 * The mask we set must be legal.
803 */
804 ret = -EINVAL;
805 if (bad_mask(sin->sin_addr.s_addr, 0))
806 break;
807 ret = 0;
808 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
809 __be32 old_mask = ifa->ifa_mask;
810 inet_del_ifa(in_dev, ifap, 0);
811 ifa->ifa_mask = sin->sin_addr.s_addr;
812 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
813
814 /* See if current broadcast address matches
815 * with current netmask, then recalculate
816 * the broadcast address. Otherwise it's a
817 * funny address, so don't touch it since
818 * the user seems to know what (s)he's doing...
819 */
820 if ((dev->flags & IFF_BROADCAST) &&
821 (ifa->ifa_prefixlen < 31) &&
822 (ifa->ifa_broadcast ==
823 (ifa->ifa_local|~old_mask))) {
824 ifa->ifa_broadcast = (ifa->ifa_local |
825 ~sin->sin_addr.s_addr);
826 }
827 inet_insert_ifa(ifa);
828 }
829 break;
830 }
831 done:
832 rtnl_unlock();
833 out:
834 return ret;
835 rarok:
836 rtnl_unlock();
837 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
838 goto out;
839 }
840
841 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
842 {
843 struct in_device *in_dev = __in_dev_get_rtnl(dev);
844 struct in_ifaddr *ifa;
845 struct ifreq ifr;
846 int done = 0;
847
848 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
849 goto out;
850
851 for (; ifa; ifa = ifa->ifa_next) {
852 if (!buf) {
853 done += sizeof(ifr);
854 continue;
855 }
856 if (len < (int) sizeof(ifr))
857 break;
858 memset(&ifr, 0, sizeof(struct ifreq));
859 if (ifa->ifa_label)
860 strcpy(ifr.ifr_name, ifa->ifa_label);
861 else
862 strcpy(ifr.ifr_name, dev->name);
863
864 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
865 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
866 ifa->ifa_local;
867
868 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
869 done = -EFAULT;
870 break;
871 }
872 buf += sizeof(struct ifreq);
873 len -= sizeof(struct ifreq);
874 done += sizeof(struct ifreq);
875 }
876 out:
877 return done;
878 }
879
880 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
881 {
882 __be32 addr = 0;
883 struct in_device *in_dev;
884
885 rcu_read_lock();
886 in_dev = __in_dev_get_rcu(dev);
887 if (!in_dev)
888 goto no_in_dev;
889
890 for_primary_ifa(in_dev) {
891 if (ifa->ifa_scope > scope)
892 continue;
893 if (!dst || inet_ifa_match(dst, ifa)) {
894 addr = ifa->ifa_local;
895 break;
896 }
897 if (!addr)
898 addr = ifa->ifa_local;
899 } endfor_ifa(in_dev);
900 no_in_dev:
901 rcu_read_unlock();
902
903 if (addr)
904 goto out;
905
906 /* Not loopback addresses on loopback should be preferred
907 in this case. It is importnat that lo is the first interface
908 in dev_base list.
909 */
910 read_lock(&dev_base_lock);
911 rcu_read_lock();
912 for_each_netdev(&init_net, dev) {
913 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
914 continue;
915
916 for_primary_ifa(in_dev) {
917 if (ifa->ifa_scope != RT_SCOPE_LINK &&
918 ifa->ifa_scope <= scope) {
919 addr = ifa->ifa_local;
920 goto out_unlock_both;
921 }
922 } endfor_ifa(in_dev);
923 }
924 out_unlock_both:
925 read_unlock(&dev_base_lock);
926 rcu_read_unlock();
927 out:
928 return addr;
929 }
930
931 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
932 __be32 local, int scope)
933 {
934 int same = 0;
935 __be32 addr = 0;
936
937 for_ifa(in_dev) {
938 if (!addr &&
939 (local == ifa->ifa_local || !local) &&
940 ifa->ifa_scope <= scope) {
941 addr = ifa->ifa_local;
942 if (same)
943 break;
944 }
945 if (!same) {
946 same = (!local || inet_ifa_match(local, ifa)) &&
947 (!dst || inet_ifa_match(dst, ifa));
948 if (same && addr) {
949 if (local || !dst)
950 break;
951 /* Is the selected addr into dst subnet? */
952 if (inet_ifa_match(addr, ifa))
953 break;
954 /* No, then can we use new local src? */
955 if (ifa->ifa_scope <= scope) {
956 addr = ifa->ifa_local;
957 break;
958 }
959 /* search for large dst subnet for addr */
960 same = 0;
961 }
962 }
963 } endfor_ifa(in_dev);
964
965 return same? addr : 0;
966 }
967
968 /*
969 * Confirm that local IP address exists using wildcards:
970 * - in_dev: only on this interface, 0=any interface
971 * - dst: only in the same subnet as dst, 0=any dst
972 * - local: address, 0=autoselect the local address
973 * - scope: maximum allowed scope value for the local address
974 */
975 __be32 inet_confirm_addr(struct in_device *in_dev,
976 __be32 dst, __be32 local, int scope)
977 {
978 __be32 addr = 0;
979 struct net_device *dev;
980 struct net *net;
981
982 if (scope != RT_SCOPE_LINK)
983 return confirm_addr_indev(in_dev, dst, local, scope);
984
985 net = in_dev->dev->nd_net;
986 read_lock(&dev_base_lock);
987 rcu_read_lock();
988 for_each_netdev(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 devinet_sysctl_unregister(in_dev);
1110 devinet_sysctl_register(in_dev);
1111 break;
1112 }
1113 out:
1114 return NOTIFY_DONE;
1115 }
1116
1117 static struct notifier_block ip_netdev_notifier = {
1118 .notifier_call =inetdev_event,
1119 };
1120
1121 static inline size_t inet_nlmsg_size(void)
1122 {
1123 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1124 + nla_total_size(4) /* IFA_ADDRESS */
1125 + nla_total_size(4) /* IFA_LOCAL */
1126 + nla_total_size(4) /* IFA_BROADCAST */
1127 + nla_total_size(4) /* IFA_ANYCAST */
1128 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1129 }
1130
1131 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1132 u32 pid, u32 seq, int event, unsigned int flags)
1133 {
1134 struct ifaddrmsg *ifm;
1135 struct nlmsghdr *nlh;
1136
1137 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1138 if (nlh == NULL)
1139 return -EMSGSIZE;
1140
1141 ifm = nlmsg_data(nlh);
1142 ifm->ifa_family = AF_INET;
1143 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1144 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1145 ifm->ifa_scope = ifa->ifa_scope;
1146 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1147
1148 if (ifa->ifa_address)
1149 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1150
1151 if (ifa->ifa_local)
1152 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1153
1154 if (ifa->ifa_broadcast)
1155 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1156
1157 if (ifa->ifa_anycast)
1158 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
1159
1160 if (ifa->ifa_label[0])
1161 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1162
1163 return nlmsg_end(skb, nlh);
1164
1165 nla_put_failure:
1166 nlmsg_cancel(skb, nlh);
1167 return -EMSGSIZE;
1168 }
1169
1170 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1171 {
1172 struct net *net = skb->sk->sk_net;
1173 int idx, ip_idx;
1174 struct net_device *dev;
1175 struct in_device *in_dev;
1176 struct in_ifaddr *ifa;
1177 int s_ip_idx, s_idx = cb->args[0];
1178
1179 if (net != &init_net)
1180 return 0;
1181
1182 s_ip_idx = ip_idx = cb->args[1];
1183 idx = 0;
1184 for_each_netdev(net, dev) {
1185 if (idx < s_idx)
1186 goto cont;
1187 if (idx > s_idx)
1188 s_ip_idx = 0;
1189 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
1190 goto cont;
1191
1192 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1193 ifa = ifa->ifa_next, ip_idx++) {
1194 if (ip_idx < s_ip_idx)
1195 continue;
1196 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1197 cb->nlh->nlmsg_seq,
1198 RTM_NEWADDR, NLM_F_MULTI) <= 0)
1199 goto done;
1200 }
1201 cont:
1202 idx++;
1203 }
1204
1205 done:
1206 cb->args[0] = idx;
1207 cb->args[1] = ip_idx;
1208
1209 return skb->len;
1210 }
1211
1212 static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1213 u32 pid)
1214 {
1215 struct sk_buff *skb;
1216 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1217 int err = -ENOBUFS;
1218 struct net *net;
1219
1220 net = ifa->ifa_dev->dev->nd_net;
1221 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1222 if (skb == NULL)
1223 goto errout;
1224
1225 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1226 if (err < 0) {
1227 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1228 WARN_ON(err == -EMSGSIZE);
1229 kfree_skb(skb);
1230 goto errout;
1231 }
1232 err = rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1233 errout:
1234 if (err < 0)
1235 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1236 }
1237
1238 #ifdef CONFIG_SYSCTL
1239
1240 static void devinet_copy_dflt_conf(struct net *net, int i)
1241 {
1242 struct net_device *dev;
1243
1244 read_lock(&dev_base_lock);
1245 for_each_netdev(net, dev) {
1246 struct in_device *in_dev;
1247 rcu_read_lock();
1248 in_dev = __in_dev_get_rcu(dev);
1249 if (in_dev && !test_bit(i, in_dev->cnf.state))
1250 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1251 rcu_read_unlock();
1252 }
1253 read_unlock(&dev_base_lock);
1254 }
1255
1256 static void inet_forward_change(struct net *net)
1257 {
1258 struct net_device *dev;
1259 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1260
1261 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1262 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1263
1264 read_lock(&dev_base_lock);
1265 for_each_netdev(net, dev) {
1266 struct in_device *in_dev;
1267 rcu_read_lock();
1268 in_dev = __in_dev_get_rcu(dev);
1269 if (in_dev)
1270 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1271 rcu_read_unlock();
1272 }
1273 read_unlock(&dev_base_lock);
1274
1275 rt_cache_flush(0);
1276 }
1277
1278 static int devinet_conf_proc(ctl_table *ctl, int write,
1279 struct file* filp, void __user *buffer,
1280 size_t *lenp, loff_t *ppos)
1281 {
1282 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1283
1284 if (write) {
1285 struct ipv4_devconf *cnf = ctl->extra1;
1286 struct net *net = ctl->extra2;
1287 int i = (int *)ctl->data - cnf->data;
1288
1289 set_bit(i, cnf->state);
1290
1291 if (cnf == net->ipv4.devconf_dflt)
1292 devinet_copy_dflt_conf(net, i);
1293 }
1294
1295 return ret;
1296 }
1297
1298 static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1299 void __user *oldval, size_t __user *oldlenp,
1300 void __user *newval, size_t newlen)
1301 {
1302 struct ipv4_devconf *cnf;
1303 struct net *net;
1304 int *valp = table->data;
1305 int new;
1306 int i;
1307
1308 if (!newval || !newlen)
1309 return 0;
1310
1311 if (newlen != sizeof(int))
1312 return -EINVAL;
1313
1314 if (get_user(new, (int __user *)newval))
1315 return -EFAULT;
1316
1317 if (new == *valp)
1318 return 0;
1319
1320 if (oldval && oldlenp) {
1321 size_t len;
1322
1323 if (get_user(len, oldlenp))
1324 return -EFAULT;
1325
1326 if (len) {
1327 if (len > table->maxlen)
1328 len = table->maxlen;
1329 if (copy_to_user(oldval, valp, len))
1330 return -EFAULT;
1331 if (put_user(len, oldlenp))
1332 return -EFAULT;
1333 }
1334 }
1335
1336 *valp = new;
1337
1338 cnf = table->extra1;
1339 net = table->extra2;
1340 i = (int *)table->data - cnf->data;
1341
1342 set_bit(i, cnf->state);
1343
1344 if (cnf == net->ipv4.devconf_dflt)
1345 devinet_copy_dflt_conf(net, i);
1346
1347 return 1;
1348 }
1349
1350 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1351 struct file* filp, void __user *buffer,
1352 size_t *lenp, loff_t *ppos)
1353 {
1354 int *valp = ctl->data;
1355 int val = *valp;
1356 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1357
1358 if (write && *valp != val) {
1359 struct net *net = ctl->extra2;
1360
1361 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING))
1362 inet_forward_change(net);
1363 else if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING))
1364 rt_cache_flush(0);
1365 }
1366
1367 return ret;
1368 }
1369
1370 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1371 struct file* filp, void __user *buffer,
1372 size_t *lenp, loff_t *ppos)
1373 {
1374 int *valp = ctl->data;
1375 int val = *valp;
1376 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1377
1378 if (write && *valp != val)
1379 rt_cache_flush(0);
1380
1381 return ret;
1382 }
1383
1384 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1385 void __user *oldval, size_t __user *oldlenp,
1386 void __user *newval, size_t newlen)
1387 {
1388 int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp,
1389 newval, newlen);
1390
1391 if (ret == 1)
1392 rt_cache_flush(0);
1393
1394 return ret;
1395 }
1396
1397
1398 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1399 { \
1400 .ctl_name = NET_IPV4_CONF_ ## attr, \
1401 .procname = name, \
1402 .data = ipv4_devconf.data + \
1403 NET_IPV4_CONF_ ## attr - 1, \
1404 .maxlen = sizeof(int), \
1405 .mode = mval, \
1406 .proc_handler = proc, \
1407 .strategy = sysctl, \
1408 .extra1 = &ipv4_devconf, \
1409 }
1410
1411 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1412 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1413 devinet_conf_sysctl)
1414
1415 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1416 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1417 devinet_conf_sysctl)
1418
1419 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1420 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1421
1422 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1423 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1424 ipv4_doint_and_flush_strategy)
1425
1426 static struct devinet_sysctl_table {
1427 struct ctl_table_header *sysctl_header;
1428 struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1429 char *dev_name;
1430 } devinet_sysctl = {
1431 .devinet_vars = {
1432 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1433 devinet_sysctl_forward,
1434 devinet_conf_sysctl),
1435 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1436
1437 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1438 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1439 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1440 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1441 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1442 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1443 "accept_source_route"),
1444 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1445 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1446 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1447 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1448 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1449 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1450 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1451 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1452 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1453
1454 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1455 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1456 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1457 "force_igmp_version"),
1458 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1459 "promote_secondaries"),
1460 },
1461 };
1462
1463 static int __devinet_sysctl_register(struct net *net, char *dev_name,
1464 int ctl_name, struct ipv4_devconf *p)
1465 {
1466 int i;
1467 struct devinet_sysctl_table *t;
1468
1469 #define DEVINET_CTL_PATH_DEV 3
1470
1471 struct ctl_path devinet_ctl_path[] = {
1472 { .procname = "net", .ctl_name = CTL_NET, },
1473 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1474 { .procname = "conf", .ctl_name = NET_IPV4_CONF, },
1475 { /* to be set */ },
1476 { },
1477 };
1478
1479 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
1480 if (!t)
1481 goto out;
1482
1483 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1484 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1485 t->devinet_vars[i].extra1 = p;
1486 t->devinet_vars[i].extra2 = net;
1487 }
1488
1489 /*
1490 * Make a copy of dev_name, because '.procname' is regarded as const
1491 * by sysctl and we wouldn't want anyone to change it under our feet
1492 * (see SIOCSIFNAME).
1493 */
1494 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1495 if (!t->dev_name)
1496 goto free;
1497
1498 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1499 devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
1500
1501 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
1502 t->devinet_vars);
1503 if (!t->sysctl_header)
1504 goto free_procname;
1505
1506 p->sysctl = t;
1507 return 0;
1508
1509 free_procname:
1510 kfree(t->dev_name);
1511 free:
1512 kfree(t);
1513 out:
1514 return -ENOBUFS;
1515 }
1516
1517 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1518 {
1519 struct devinet_sysctl_table *t = cnf->sysctl;
1520
1521 if (t == NULL)
1522 return;
1523
1524 cnf->sysctl = NULL;
1525 unregister_sysctl_table(t->sysctl_header);
1526 kfree(t->dev_name);
1527 kfree(t);
1528 }
1529
1530 static void devinet_sysctl_register(struct in_device *idev)
1531 {
1532 neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1533 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1534 __devinet_sysctl_register(idev->dev->nd_net, idev->dev->name,
1535 idev->dev->ifindex, &idev->cnf);
1536 }
1537
1538 static void devinet_sysctl_unregister(struct in_device *idev)
1539 {
1540 __devinet_sysctl_unregister(&idev->cnf);
1541 neigh_sysctl_unregister(idev->arp_parms);
1542 }
1543
1544 static struct ctl_table ctl_forward_entry[] = {
1545 {
1546 .ctl_name = NET_IPV4_FORWARD,
1547 .procname = "ip_forward",
1548 .data = &ipv4_devconf.data[
1549 NET_IPV4_CONF_FORWARDING - 1],
1550 .maxlen = sizeof(int),
1551 .mode = 0644,
1552 .proc_handler = devinet_sysctl_forward,
1553 .strategy = devinet_conf_sysctl,
1554 .extra1 = &ipv4_devconf,
1555 .extra2 = &init_net,
1556 },
1557 { },
1558 };
1559
1560 static __net_initdata struct ctl_path net_ipv4_path[] = {
1561 { .procname = "net", .ctl_name = CTL_NET, },
1562 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1563 { },
1564 };
1565 #endif
1566
1567 static __net_init int devinet_init_net(struct net *net)
1568 {
1569 int err;
1570 struct ipv4_devconf *all, *dflt;
1571 #ifdef CONFIG_SYSCTL
1572 struct ctl_table *tbl = ctl_forward_entry;
1573 struct ctl_table_header *forw_hdr;
1574 #endif
1575
1576 err = -ENOMEM;
1577 all = &ipv4_devconf;
1578 dflt = &ipv4_devconf_dflt;
1579
1580 if (net != &init_net) {
1581 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1582 if (all == NULL)
1583 goto err_alloc_all;
1584
1585 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1586 if (dflt == NULL)
1587 goto err_alloc_dflt;
1588
1589 #ifdef CONFIG_SYSCTL
1590 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1591 if (tbl == NULL)
1592 goto err_alloc_ctl;
1593
1594 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1595 tbl[0].extra1 = all;
1596 tbl[0].extra2 = net;
1597 #endif
1598 }
1599
1600 #ifdef CONFIG_SYSCTL
1601 err = __devinet_sysctl_register(net, "all",
1602 NET_PROTO_CONF_ALL, all);
1603 if (err < 0)
1604 goto err_reg_all;
1605
1606 err = __devinet_sysctl_register(net, "default",
1607 NET_PROTO_CONF_DEFAULT, dflt);
1608 if (err < 0)
1609 goto err_reg_dflt;
1610
1611 err = -ENOMEM;
1612 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1613 if (forw_hdr == NULL)
1614 goto err_reg_ctl;
1615 net->ipv4.forw_hdr = forw_hdr;
1616 #endif
1617
1618 net->ipv4.devconf_all = all;
1619 net->ipv4.devconf_dflt = dflt;
1620 return 0;
1621
1622 #ifdef CONFIG_SYSCTL
1623 err_reg_ctl:
1624 __devinet_sysctl_unregister(dflt);
1625 err_reg_dflt:
1626 __devinet_sysctl_unregister(all);
1627 err_reg_all:
1628 if (tbl != ctl_forward_entry)
1629 kfree(tbl);
1630 err_alloc_ctl:
1631 #endif
1632 if (dflt != &ipv4_devconf_dflt)
1633 kfree(dflt);
1634 err_alloc_dflt:
1635 if (all != &ipv4_devconf)
1636 kfree(all);
1637 err_alloc_all:
1638 return err;
1639 }
1640
1641 static __net_exit void devinet_exit_net(struct net *net)
1642 {
1643 #ifdef CONFIG_SYSCTL
1644 struct ctl_table *tbl;
1645
1646 tbl = net->ipv4.forw_hdr->ctl_table_arg;
1647 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1648 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1649 __devinet_sysctl_unregister(net->ipv4.devconf_all);
1650 kfree(tbl);
1651 #endif
1652 kfree(net->ipv4.devconf_dflt);
1653 kfree(net->ipv4.devconf_all);
1654 }
1655
1656 static __net_initdata struct pernet_operations devinet_ops = {
1657 .init = devinet_init_net,
1658 .exit = devinet_exit_net,
1659 };
1660
1661 void __init devinet_init(void)
1662 {
1663 register_pernet_subsys(&devinet_ops);
1664
1665 register_gifconf(PF_INET, inet_gifconf);
1666 register_netdevice_notifier(&ip_netdev_notifier);
1667
1668 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1669 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1670 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
1671 }
1672
1673 EXPORT_SYMBOL(in_dev_finish_destroy);
1674 EXPORT_SYMBOL(inet_select_addr);
1675 EXPORT_SYMBOL(inetdev_by_index);
1676 EXPORT_SYMBOL(register_inetaddr_notifier);
1677 EXPORT_SYMBOL(unregister_inetaddr_notifier);
WRT350N Kernel Patches