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