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