projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[NETNS]: Enable inetdev_event notifier.
[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 #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 ifa->ifa_scope = 0;
756 }
757
758 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
759
760 if (!(dev->flags & IFF_POINTOPOINT)) {
761 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
762 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
763 if ((dev->flags & IFF_BROADCAST) &&
764 ifa->ifa_prefixlen < 31)
765 ifa->ifa_broadcast = ifa->ifa_address |
766 ~ifa->ifa_mask;
767 } else {
768 ifa->ifa_prefixlen = 32;
769 ifa->ifa_mask = inet_make_mask(32);
770 }
771 ret = inet_set_ifa(dev, ifa);
772 break;
773
774 case SIOCSIFBRDADDR: /* Set the broadcast address */
775 ret = 0;
776 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
777 inet_del_ifa(in_dev, ifap, 0);
778 ifa->ifa_broadcast = sin->sin_addr.s_addr;
779 inet_insert_ifa(ifa);
780 }
781 break;
782
783 case SIOCSIFDSTADDR: /* Set the destination address */
784 ret = 0;
785 if (ifa->ifa_address == sin->sin_addr.s_addr)
786 break;
787 ret = -EINVAL;
788 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
789 break;
790 ret = 0;
791 inet_del_ifa(in_dev, ifap, 0);
792 ifa->ifa_address = sin->sin_addr.s_addr;
793 inet_insert_ifa(ifa);
794 break;
795
796 case SIOCSIFNETMASK: /* Set the netmask for the interface */
797
798 /*
799 * The mask we set must be legal.
800 */
801 ret = -EINVAL;
802 if (bad_mask(sin->sin_addr.s_addr, 0))
803 break;
804 ret = 0;
805 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
806 __be32 old_mask = ifa->ifa_mask;
807 inet_del_ifa(in_dev, ifap, 0);
808 ifa->ifa_mask = sin->sin_addr.s_addr;
809 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
810
811 /* See if current broadcast address matches
812 * with current netmask, then recalculate
813 * the broadcast address. Otherwise it's a
814 * funny address, so don't touch it since
815 * the user seems to know what (s)he's doing...
816 */
817 if ((dev->flags & IFF_BROADCAST) &&
818 (ifa->ifa_prefixlen < 31) &&
819 (ifa->ifa_broadcast ==
820 (ifa->ifa_local|~old_mask))) {
821 ifa->ifa_broadcast = (ifa->ifa_local |
822 ~sin->sin_addr.s_addr);
823 }
824 inet_insert_ifa(ifa);
825 }
826 break;
827 }
828 done:
829 rtnl_unlock();
830 out:
831 return ret;
832 rarok:
833 rtnl_unlock();
834 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
835 goto out;
836 }
837
838 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
839 {
840 struct in_device *in_dev = __in_dev_get_rtnl(dev);
841 struct in_ifaddr *ifa;
842 struct ifreq ifr;
843 int done = 0;
844
845 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
846 goto out;
847
848 for (; ifa; ifa = ifa->ifa_next) {
849 if (!buf) {
850 done += sizeof(ifr);
851 continue;
852 }
853 if (len < (int) sizeof(ifr))
854 break;
855 memset(&ifr, 0, sizeof(struct ifreq));
856 if (ifa->ifa_label)
857 strcpy(ifr.ifr_name, ifa->ifa_label);
858 else
859 strcpy(ifr.ifr_name, dev->name);
860
861 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
862 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
863 ifa->ifa_local;
864
865 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
866 done = -EFAULT;
867 break;
868 }
869 buf += sizeof(struct ifreq);
870 len -= sizeof(struct ifreq);
871 done += sizeof(struct ifreq);
872 }
873 out:
874 return done;
875 }
876
877 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
878 {
879 __be32 addr = 0;
880 struct in_device *in_dev;
881
882 rcu_read_lock();
883 in_dev = __in_dev_get_rcu(dev);
884 if (!in_dev)
885 goto no_in_dev;
886
887 for_primary_ifa(in_dev) {
888 if (ifa->ifa_scope > scope)
889 continue;
890 if (!dst || inet_ifa_match(dst, ifa)) {
891 addr = ifa->ifa_local;
892 break;
893 }
894 if (!addr)
895 addr = ifa->ifa_local;
896 } endfor_ifa(in_dev);
897 no_in_dev:
898 rcu_read_unlock();
899
900 if (addr)
901 goto out;
902
903 /* Not loopback addresses on loopback should be preferred
904 in this case. It is importnat that lo is the first interface
905 in dev_base list.
906 */
907 read_lock(&dev_base_lock);
908 rcu_read_lock();
909 for_each_netdev(&init_net, dev) {
910 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
911 continue;
912
913 for_primary_ifa(in_dev) {
914 if (ifa->ifa_scope != RT_SCOPE_LINK &&
915 ifa->ifa_scope <= scope) {
916 addr = ifa->ifa_local;
917 goto out_unlock_both;
918 }
919 } endfor_ifa(in_dev);
920 }
921 out_unlock_both:
922 read_unlock(&dev_base_lock);
923 rcu_read_unlock();
924 out:
925 return addr;
926 }
927
928 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
929 __be32 local, int scope)
930 {
931 int same = 0;
932 __be32 addr = 0;
933
934 for_ifa(in_dev) {
935 if (!addr &&
936 (local == ifa->ifa_local || !local) &&
937 ifa->ifa_scope <= scope) {
938 addr = ifa->ifa_local;
939 if (same)
940 break;
941 }
942 if (!same) {
943 same = (!local || inet_ifa_match(local, ifa)) &&
944 (!dst || inet_ifa_match(dst, ifa));
945 if (same && addr) {
946 if (local || !dst)
947 break;
948 /* Is the selected addr into dst subnet? */
949 if (inet_ifa_match(addr, ifa))
950 break;
951 /* No, then can we use new local src? */
952 if (ifa->ifa_scope <= scope) {
953 addr = ifa->ifa_local;
954 break;
955 }
956 /* search for large dst subnet for addr */
957 same = 0;
958 }
959 }
960 } endfor_ifa(in_dev);
961
962 return same? addr : 0;
963 }
964
965 /*
966 * Confirm that local IP address exists using wildcards:
967 * - in_dev: only on this interface, 0=any interface
968 * - dst: only in the same subnet as dst, 0=any dst
969 * - local: address, 0=autoselect the local address
970 * - scope: maximum allowed scope value for the local address
971 */
972 __be32 inet_confirm_addr(struct in_device *in_dev,
973 __be32 dst, __be32 local, int scope)
974 {
975 __be32 addr = 0;
976 struct net_device *dev;
977 struct net *net;
978
979 if (scope != RT_SCOPE_LINK)
980 return confirm_addr_indev(in_dev, dst, local, scope);
981
982 net = in_dev->dev->nd_net;
983 read_lock(&dev_base_lock);
984 rcu_read_lock();
985 for_each_netdev(net, dev) {
986 if ((in_dev = __in_dev_get_rcu(dev))) {
987 addr = confirm_addr_indev(in_dev, dst, local, scope);
988 if (addr)
989 break;
990 }
991 }
992 rcu_read_unlock();
993 read_unlock(&dev_base_lock);
994
995 return addr;
996 }
997
998 /*
999 * Device notifier
1000 */
1001
1002 int register_inetaddr_notifier(struct notifier_block *nb)
1003 {
1004 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1005 }
1006
1007 int unregister_inetaddr_notifier(struct notifier_block *nb)
1008 {
1009 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1010 }
1011
1012 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
1013 * alias numbering and to create unique labels if possible.
1014 */
1015 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1016 {
1017 struct in_ifaddr *ifa;
1018 int named = 0;
1019
1020 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1021 char old[IFNAMSIZ], *dot;
1022
1023 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1024 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1025 if (named++ == 0)
1026 continue;
1027 dot = strchr(old, ':');
1028 if (dot == NULL) {
1029 sprintf(old, ":%d", named);
1030 dot = old;
1031 }
1032 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1033 strcat(ifa->ifa_label, dot);
1034 } else {
1035 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1036 }
1037 }
1038 }
1039
1040 /* Called only under RTNL semaphore */
1041
1042 static int inetdev_event(struct notifier_block *this, unsigned long event,
1043 void *ptr)
1044 {
1045 struct net_device *dev = ptr;
1046 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1047
1048 ASSERT_RTNL();
1049
1050 if (!in_dev) {
1051 if (event == NETDEV_REGISTER) {
1052 in_dev = inetdev_init(dev);
1053 if (!in_dev)
1054 return notifier_from_errno(-ENOMEM);
1055 if (dev->flags & IFF_LOOPBACK) {
1056 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1057 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1058 }
1059 }
1060 goto out;
1061 }
1062
1063 switch (event) {
1064 case NETDEV_REGISTER:
1065 printk(KERN_DEBUG "inetdev_event: bug\n");
1066 dev->ip_ptr = NULL;
1067 break;
1068 case NETDEV_UP:
1069 if (dev->mtu < 68)
1070 break;
1071 if (dev->flags & IFF_LOOPBACK) {
1072 struct in_ifaddr *ifa;
1073 if ((ifa = inet_alloc_ifa()) != NULL) {
1074 ifa->ifa_local =
1075 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1076 ifa->ifa_prefixlen = 8;
1077 ifa->ifa_mask = inet_make_mask(8);
1078 in_dev_hold(in_dev);
1079 ifa->ifa_dev = in_dev;
1080 ifa->ifa_scope = RT_SCOPE_HOST;
1081 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1082 inet_insert_ifa(ifa);
1083 }
1084 }
1085 ip_mc_up(in_dev);
1086 break;
1087 case NETDEV_DOWN:
1088 ip_mc_down(in_dev);
1089 break;
1090 case NETDEV_CHANGEMTU:
1091 if (dev->mtu >= 68)
1092 break;
1093 /* MTU falled under 68, disable IP */
1094 case NETDEV_UNREGISTER:
1095 inetdev_destroy(in_dev);
1096 break;
1097 case NETDEV_CHANGENAME:
1098 /* Do not notify about label change, this event is
1099 * not interesting to applications using netlink.
1100 */
1101 inetdev_changename(dev, in_dev);
1102
1103 devinet_sysctl_unregister(in_dev);
1104 devinet_sysctl_register(in_dev);
1105 break;
1106 }
1107 out:
1108 return NOTIFY_DONE;
1109 }
1110
1111 static struct notifier_block ip_netdev_notifier = {
1112 .notifier_call =inetdev_event,
1113 };
1114
1115 static inline size_t inet_nlmsg_size(void)
1116 {
1117 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1118 + nla_total_size(4) /* IFA_ADDRESS */
1119 + nla_total_size(4) /* IFA_LOCAL */
1120 + nla_total_size(4) /* IFA_BROADCAST */
1121 + nla_total_size(4) /* IFA_ANYCAST */
1122 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1123 }
1124
1125 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1126 u32 pid, u32 seq, int event, unsigned int flags)
1127 {
1128 struct ifaddrmsg *ifm;
1129 struct nlmsghdr *nlh;
1130
1131 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1132 if (nlh == NULL)
1133 return -EMSGSIZE;
1134
1135 ifm = nlmsg_data(nlh);
1136 ifm->ifa_family = AF_INET;
1137 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1138 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1139 ifm->ifa_scope = ifa->ifa_scope;
1140 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1141
1142 if (ifa->ifa_address)
1143 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1144
1145 if (ifa->ifa_local)
1146 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1147
1148 if (ifa->ifa_broadcast)
1149 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1150
1151 if (ifa->ifa_anycast)
1152 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
1153
1154 if (ifa->ifa_label[0])
1155 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1156
1157 return nlmsg_end(skb, nlh);
1158
1159 nla_put_failure:
1160 nlmsg_cancel(skb, nlh);
1161 return -EMSGSIZE;
1162 }
1163
1164 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1165 {
1166 struct net *net = skb->sk->sk_net;
1167 int idx, ip_idx;
1168 struct net_device *dev;
1169 struct in_device *in_dev;
1170 struct in_ifaddr *ifa;
1171 int s_ip_idx, s_idx = cb->args[0];
1172
1173 if (net != &init_net)
1174 return 0;
1175
1176 s_ip_idx = ip_idx = cb->args[1];
1177 idx = 0;
1178 for_each_netdev(net, dev) {
1179 if (idx < s_idx)
1180 goto cont;
1181 if (idx > s_idx)
1182 s_ip_idx = 0;
1183 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
1184 goto cont;
1185
1186 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1187 ifa = ifa->ifa_next, ip_idx++) {
1188 if (ip_idx < s_ip_idx)
1189 continue;
1190 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1191 cb->nlh->nlmsg_seq,
1192 RTM_NEWADDR, NLM_F_MULTI) <= 0)
1193 goto done;
1194 }
1195 cont:
1196 idx++;
1197 }
1198
1199 done:
1200 cb->args[0] = idx;
1201 cb->args[1] = ip_idx;
1202
1203 return skb->len;
1204 }
1205
1206 static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1207 u32 pid)
1208 {
1209 struct sk_buff *skb;
1210 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1211 int err = -ENOBUFS;
1212 struct net *net;
1213
1214 net = ifa->ifa_dev->dev->nd_net;
1215 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1216 if (skb == NULL)
1217 goto errout;
1218
1219 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1220 if (err < 0) {
1221 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1222 WARN_ON(err == -EMSGSIZE);
1223 kfree_skb(skb);
1224 goto errout;
1225 }
1226 err = rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1227 errout:
1228 if (err < 0)
1229 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1230 }
1231
1232 #ifdef CONFIG_SYSCTL
1233
1234 static void devinet_copy_dflt_conf(struct net *net, int i)
1235 {
1236 struct net_device *dev;
1237
1238 read_lock(&dev_base_lock);
1239 for_each_netdev(net, dev) {
1240 struct in_device *in_dev;
1241 rcu_read_lock();
1242 in_dev = __in_dev_get_rcu(dev);
1243 if (in_dev && !test_bit(i, in_dev->cnf.state))
1244 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1245 rcu_read_unlock();
1246 }
1247 read_unlock(&dev_base_lock);
1248 }
1249
1250 static void inet_forward_change(struct net *net)
1251 {
1252 struct net_device *dev;
1253 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1254
1255 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1256 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1257
1258 read_lock(&dev_base_lock);
1259 for_each_netdev(net, dev) {
1260 struct in_device *in_dev;
1261 rcu_read_lock();
1262 in_dev = __in_dev_get_rcu(dev);
1263 if (in_dev)
1264 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1265 rcu_read_unlock();
1266 }
1267 read_unlock(&dev_base_lock);
1268
1269 rt_cache_flush(0);
1270 }
1271
1272 static int devinet_conf_proc(ctl_table *ctl, int write,
1273 struct file* filp, void __user *buffer,
1274 size_t *lenp, loff_t *ppos)
1275 {
1276 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1277
1278 if (write) {
1279 struct ipv4_devconf *cnf = ctl->extra1;
1280 struct net *net = ctl->extra2;
1281 int i = (int *)ctl->data - cnf->data;
1282
1283 set_bit(i, cnf->state);
1284
1285 if (cnf == net->ipv4.devconf_dflt)
1286 devinet_copy_dflt_conf(net, i);
1287 }
1288
1289 return ret;
1290 }
1291
1292 static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1293 void __user *oldval, size_t __user *oldlenp,
1294 void __user *newval, size_t newlen)
1295 {
1296 struct ipv4_devconf *cnf;
1297 struct net *net;
1298 int *valp = table->data;
1299 int new;
1300 int i;
1301
1302 if (!newval || !newlen)
1303 return 0;
1304
1305 if (newlen != sizeof(int))
1306 return -EINVAL;
1307
1308 if (get_user(new, (int __user *)newval))
1309 return -EFAULT;
1310
1311 if (new == *valp)
1312 return 0;
1313
1314 if (oldval && oldlenp) {
1315 size_t len;
1316
1317 if (get_user(len, oldlenp))
1318 return -EFAULT;
1319
1320 if (len) {
1321 if (len > table->maxlen)
1322 len = table->maxlen;
1323 if (copy_to_user(oldval, valp, len))
1324 return -EFAULT;
1325 if (put_user(len, oldlenp))
1326 return -EFAULT;
1327 }
1328 }
1329
1330 *valp = new;
1331
1332 cnf = table->extra1;
1333 net = table->extra2;
1334 i = (int *)table->data - cnf->data;
1335
1336 set_bit(i, cnf->state);
1337
1338 if (cnf == net->ipv4.devconf_dflt)
1339 devinet_copy_dflt_conf(net, i);
1340
1341 return 1;
1342 }
1343
1344 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1345 struct file* filp, void __user *buffer,
1346 size_t *lenp, loff_t *ppos)
1347 {
1348 int *valp = ctl->data;
1349 int val = *valp;
1350 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1351
1352 if (write && *valp != val) {
1353 struct net *net = ctl->extra2;
1354
1355 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING))
1356 inet_forward_change(net);
1357 else if (valp != &IPV4_DEVCONF_DFLT(net, 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 t->devinet_vars[i].extra2 = net;
1481 }
1482
1483 /*
1484 * Make a copy of dev_name, because '.procname' is regarded as const
1485 * by sysctl and we wouldn't want anyone to change it under our feet
1486 * (see SIOCSIFNAME).
1487 */
1488 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1489 if (!t->dev_name)
1490 goto free;
1491
1492 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1493 devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
1494
1495 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
1496 t->devinet_vars);
1497 if (!t->sysctl_header)
1498 goto free_procname;
1499
1500 p->sysctl = t;
1501 return 0;
1502
1503 free_procname:
1504 kfree(t->dev_name);
1505 free:
1506 kfree(t);
1507 out:
1508 return -ENOBUFS;
1509 }
1510
1511 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1512 {
1513 struct devinet_sysctl_table *t = cnf->sysctl;
1514
1515 if (t == NULL)
1516 return;
1517
1518 cnf->sysctl = NULL;
1519 unregister_sysctl_table(t->sysctl_header);
1520 kfree(t->dev_name);
1521 kfree(t);
1522 }
1523
1524 static void devinet_sysctl_register(struct in_device *idev)
1525 {
1526 neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1527 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1528 __devinet_sysctl_register(idev->dev->nd_net, idev->dev->name,
1529 idev->dev->ifindex, &idev->cnf);
1530 }
1531
1532 static void devinet_sysctl_unregister(struct in_device *idev)
1533 {
1534 __devinet_sysctl_unregister(&idev->cnf);
1535 neigh_sysctl_unregister(idev->arp_parms);
1536 }
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 .extra2 = &init_net,
1550 },
1551 { },
1552 };
1553
1554 static __net_initdata struct ctl_path net_ipv4_path[] = {
1555 { .procname = "net", .ctl_name = CTL_NET, },
1556 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1557 { },
1558 };
1559 #endif
1560
1561 static __net_init int devinet_init_net(struct net *net)
1562 {
1563 int err;
1564 struct ipv4_devconf *all, *dflt;
1565 #ifdef CONFIG_SYSCTL
1566 struct ctl_table *tbl = ctl_forward_entry;
1567 struct ctl_table_header *forw_hdr;
1568 #endif
1569
1570 err = -ENOMEM;
1571 all = &ipv4_devconf;
1572 dflt = &ipv4_devconf_dflt;
1573
1574 if (net != &init_net) {
1575 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1576 if (all == NULL)
1577 goto err_alloc_all;
1578
1579 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1580 if (dflt == NULL)
1581 goto err_alloc_dflt;
1582
1583 #ifdef CONFIG_SYSCTL
1584 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1585 if (tbl == NULL)
1586 goto err_alloc_ctl;
1587
1588 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1589 tbl[0].extra1 = all;
1590 tbl[0].extra2 = net;
1591 #endif
1592 }
1593
1594 #ifdef CONFIG_SYSCTL
1595 err = __devinet_sysctl_register(net, "all",
1596 NET_PROTO_CONF_ALL, all);
1597 if (err < 0)
1598 goto err_reg_all;
1599
1600 err = __devinet_sysctl_register(net, "default",
1601 NET_PROTO_CONF_DEFAULT, dflt);
1602 if (err < 0)
1603 goto err_reg_dflt;
1604
1605 err = -ENOMEM;
1606 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1607 if (forw_hdr == NULL)
1608 goto err_reg_ctl;
1609 net->ipv4.forw_hdr = forw_hdr;
1610 #endif
1611
1612 net->ipv4.devconf_all = all;
1613 net->ipv4.devconf_dflt = dflt;
1614 return 0;
1615
1616 #ifdef CONFIG_SYSCTL
1617 err_reg_ctl:
1618 __devinet_sysctl_unregister(dflt);
1619 err_reg_dflt:
1620 __devinet_sysctl_unregister(all);
1621 err_reg_all:
1622 if (tbl != ctl_forward_entry)
1623 kfree(tbl);
1624 err_alloc_ctl:
1625 #endif
1626 if (dflt != &ipv4_devconf_dflt)
1627 kfree(dflt);
1628 err_alloc_dflt:
1629 if (all != &ipv4_devconf)
1630 kfree(all);
1631 err_alloc_all:
1632 return err;
1633 }
1634
1635 static __net_exit void devinet_exit_net(struct net *net)
1636 {
1637 #ifdef CONFIG_SYSCTL
1638 struct ctl_table *tbl;
1639
1640 tbl = net->ipv4.forw_hdr->ctl_table_arg;
1641 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1642 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1643 __devinet_sysctl_unregister(net->ipv4.devconf_all);
1644 kfree(tbl);
1645 #endif
1646 kfree(net->ipv4.devconf_dflt);
1647 kfree(net->ipv4.devconf_all);
1648 }
1649
1650 static __net_initdata struct pernet_operations devinet_ops = {
1651 .init = devinet_init_net,
1652 .exit = devinet_exit_net,
1653 };
1654
1655 void __init devinet_init(void)
1656 {
1657 register_pernet_subsys(&devinet_ops);
1658
1659 register_gifconf(PF_INET, inet_gifconf);
1660 register_netdevice_notifier(&ip_netdev_notifier);
1661
1662 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1663 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1664 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
1665 }
1666
1667 EXPORT_SYMBOL(in_dev_finish_destroy);
1668 EXPORT_SYMBOL(inet_select_addr);
1669 EXPORT_SYMBOL(inetdev_by_index);
1670 EXPORT_SYMBOL(register_inetaddr_notifier);
1671 EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linux kernel - Deliverables
This page took 0.089544 seconds and 6 git commands to generate.