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