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