?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.12.28
[linux/fpc-iii.git] / net / ipv4 / devinet.c
blobf4b34d8f92fe6a2708f8b17835ea45bd46c23adb
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 <linux/bitops.h>
31 #include <linux/capability.h>
32 #include <linux/module.h>
33 #include <linux/types.h>
34 #include <linux/kernel.h>
35 #include <linux/string.h>
36 #include <linux/mm.h>
37 #include <linux/socket.h>
38 #include <linux/sockios.h>
39 #include <linux/in.h>
40 #include <linux/errno.h>
41 #include <linux/interrupt.h>
42 #include <linux/if_addr.h>
43 #include <linux/if_ether.h>
44 #include <linux/inet.h>
45 #include <linux/netdevice.h>
46 #include <linux/etherdevice.h>
47 #include <linux/skbuff.h>
48 #include <linux/init.h>
49 #include <linux/notifier.h>
50 #include <linux/inetdevice.h>
51 #include <linux/igmp.h>
52 #include <linux/slab.h>
53 #include <linux/hash.h>
54 #ifdef CONFIG_SYSCTL
55 #include <linux/sysctl.h>
56 #endif
57 #include <linux/kmod.h>
58 #include <linux/netconf.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 #include <net/addrconf.h>
67
68 #include "fib_lookup.h"
69
70 static struct ipv4_devconf ipv4_devconf = {
71 .data = {
72 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
73 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
74 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
75 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
76 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
77 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
78 },
79 };
80
81 static struct ipv4_devconf ipv4_devconf_dflt = {
82 .data = {
83 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
84 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
85 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
86 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
87 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
88 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
89 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
90 },
91 };
92
93 #define IPV4_DEVCONF_DFLT(net, attr) \
94 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
95
96 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
97 [IFA_LOCAL] = { .type = NLA_U32 },
98 [IFA_ADDRESS] = { .type = NLA_U32 },
99 [IFA_BROADCAST] = { .type = NLA_U32 },
100 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
101 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
102 };
103
104 #define IN4_ADDR_HSIZE_SHIFT 8
105 #define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
106
107 static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
108 static DEFINE_SPINLOCK(inet_addr_hash_lock);
109
110 static u32 inet_addr_hash(struct net *net, __be32 addr)
111 {
112 u32 val = (__force u32) addr ^ net_hash_mix(net);
113
114 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
115 }
116
117 static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
118 {
119 u32 hash = inet_addr_hash(net, ifa->ifa_local);
120
121 spin_lock(&inet_addr_hash_lock);
122 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
123 spin_unlock(&inet_addr_hash_lock);
124 }
125
126 static void inet_hash_remove(struct in_ifaddr *ifa)
127 {
128 spin_lock(&inet_addr_hash_lock);
129 hlist_del_init_rcu(&ifa->hash);
130 spin_unlock(&inet_addr_hash_lock);
131 }
132
133 /**
134 * __ip_dev_find - find the first device with a given source address.
135 * @net: the net namespace
136 * @addr: the source address
137 * @devref: if true, take a reference on the found device
138 *
139 * If a caller uses devref=false, it should be protected by RCU, or RTNL
140 */
141 struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
142 {
143 u32 hash = inet_addr_hash(net, addr);
144 struct net_device *result = NULL;
145 struct in_ifaddr *ifa;
146
147 rcu_read_lock();
148 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
149 if (ifa->ifa_local == addr) {
150 struct net_device *dev = ifa->ifa_dev->dev;
151
152 if (!net_eq(dev_net(dev), net))
153 continue;
154 result = dev;
155 break;
156 }
157 }
158 if (!result) {
159 struct flowi4 fl4 = { .daddr = addr };
160 struct fib_result res = { 0 };
161 struct fib_table *local;
162
163 /* Fallback to FIB local table so that communication
164 * over loopback subnets work.
165 */
166 local = fib_get_table(net, RT_TABLE_LOCAL);
167 if (local &&
168 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
169 res.type == RTN_LOCAL)
170 result = FIB_RES_DEV(res);
171 }
172 if (result && devref)
173 dev_hold(result);
174 rcu_read_unlock();
175 return result;
176 }
177 EXPORT_SYMBOL(__ip_dev_find);
178
179 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
180
181 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
182 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
183 int destroy);
184 #ifdef CONFIG_SYSCTL
185 static void devinet_sysctl_register(struct in_device *idev);
186 static void devinet_sysctl_unregister(struct in_device *idev);
187 #else
188 static void devinet_sysctl_register(struct in_device *idev)
189 {
190 }
191 static void devinet_sysctl_unregister(struct in_device *idev)
192 {
193 }
194 #endif
195
196 /* Locks all the inet devices. */
197
198 static struct in_ifaddr *inet_alloc_ifa(void)
199 {
200 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
201 }
202
203 static void inet_rcu_free_ifa(struct rcu_head *head)
204 {
205 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
206 if (ifa->ifa_dev)
207 in_dev_put(ifa->ifa_dev);
208 kfree(ifa);
209 }
210
211 static void inet_free_ifa(struct in_ifaddr *ifa)
212 {
213 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
214 }
215
216 void in_dev_finish_destroy(struct in_device *idev)
217 {
218 struct net_device *dev = idev->dev;
219
220 WARN_ON(idev->ifa_list);
221 WARN_ON(idev->mc_list);
222 kfree(rcu_dereference_protected(idev->mc_hash, 1));
223 #ifdef NET_REFCNT_DEBUG
224 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
225 #endif
226 dev_put(dev);
227 if (!idev->dead)
228 pr_err("Freeing alive in_device %p\n", idev);
229 else
230 kfree(idev);
231 }
232 EXPORT_SYMBOL(in_dev_finish_destroy);
233
234 static struct in_device *inetdev_init(struct net_device *dev)
235 {
236 struct in_device *in_dev;
237
238 ASSERT_RTNL();
239
240 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
241 if (!in_dev)
242 goto out;
243 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
244 sizeof(in_dev->cnf));
245 in_dev->cnf.sysctl = NULL;
246 in_dev->dev = dev;
247 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
248 if (!in_dev->arp_parms)
249 goto out_kfree;
250 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
251 dev_disable_lro(dev);
252 /* Reference in_dev->dev */
253 dev_hold(dev);
254 /* Account for reference dev->ip_ptr (below) */
255 in_dev_hold(in_dev);
256
257 devinet_sysctl_register(in_dev);
258 ip_mc_init_dev(in_dev);
259 if (dev->flags & IFF_UP)
260 ip_mc_up(in_dev);
261
262 /* we can receive as soon as ip_ptr is set -- do this last */
263 rcu_assign_pointer(dev->ip_ptr, in_dev);
264 out:
265 return in_dev;
266 out_kfree:
267 kfree(in_dev);
268 in_dev = NULL;
269 goto out;
270 }
271
272 static void in_dev_rcu_put(struct rcu_head *head)
273 {
274 struct in_device *idev = container_of(head, struct in_device, rcu_head);
275 in_dev_put(idev);
276 }
277
278 static void inetdev_destroy(struct in_device *in_dev)
279 {
280 struct in_ifaddr *ifa;
281 struct net_device *dev;
282
283 ASSERT_RTNL();
284
285 dev = in_dev->dev;
286
287 in_dev->dead = 1;
288
289 ip_mc_destroy_dev(in_dev);
290
291 while ((ifa = in_dev->ifa_list) != NULL) {
292 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
293 inet_free_ifa(ifa);
294 }
295
296 RCU_INIT_POINTER(dev->ip_ptr, NULL);
297
298 devinet_sysctl_unregister(in_dev);
299 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
300 arp_ifdown(dev);
301
302 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
303 }
304
305 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
306 {
307 rcu_read_lock();
308 for_primary_ifa(in_dev) {
309 if (inet_ifa_match(a, ifa)) {
310 if (!b || inet_ifa_match(b, ifa)) {
311 rcu_read_unlock();
312 return 1;
313 }
314 }
315 } endfor_ifa(in_dev);
316 rcu_read_unlock();
317 return 0;
318 }
319
320 static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
321 int destroy, struct nlmsghdr *nlh, u32 portid)
322 {
323 struct in_ifaddr *promote = NULL;
324 struct in_ifaddr *ifa, *ifa1 = *ifap;
325 struct in_ifaddr *last_prim = in_dev->ifa_list;
326 struct in_ifaddr *prev_prom = NULL;
327 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
328
329 ASSERT_RTNL();
330
331 /* 1. Deleting primary ifaddr forces deletion all secondaries
332 * unless alias promotion is set
333 **/
334
335 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
336 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
337
338 while ((ifa = *ifap1) != NULL) {
339 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
340 ifa1->ifa_scope <= ifa->ifa_scope)
341 last_prim = ifa;
342
343 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
344 ifa1->ifa_mask != ifa->ifa_mask ||
345 !inet_ifa_match(ifa1->ifa_address, ifa)) {
346 ifap1 = &ifa->ifa_next;
347 prev_prom = ifa;
348 continue;
349 }
350
351 if (!do_promote) {
352 inet_hash_remove(ifa);
353 *ifap1 = ifa->ifa_next;
354
355 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
356 blocking_notifier_call_chain(&inetaddr_chain,
357 NETDEV_DOWN, ifa);
358 inet_free_ifa(ifa);
359 } else {
360 promote = ifa;
361 break;
362 }
363 }
364 }
365
366 /* On promotion all secondaries from subnet are changing
367 * the primary IP, we must remove all their routes silently
368 * and later to add them back with new prefsrc. Do this
369 * while all addresses are on the device list.
370 */
371 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
372 if (ifa1->ifa_mask == ifa->ifa_mask &&
373 inet_ifa_match(ifa1->ifa_address, ifa))
374 fib_del_ifaddr(ifa, ifa1);
375 }
376
377 /* 2. Unlink it */
378
379 *ifap = ifa1->ifa_next;
380 inet_hash_remove(ifa1);
381
382 /* 3. Announce address deletion */
383
384 /* Send message first, then call notifier.
385 At first sight, FIB update triggered by notifier
386 will refer to already deleted ifaddr, that could confuse
387 netlink listeners. It is not true: look, gated sees
388 that route deleted and if it still thinks that ifaddr
389 is valid, it will try to restore deleted routes... Grr.
390 So that, this order is correct.
391 */
392 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
393 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
394
395 if (promote) {
396 struct in_ifaddr *next_sec = promote->ifa_next;
397
398 if (prev_prom) {
399 prev_prom->ifa_next = promote->ifa_next;
400 promote->ifa_next = last_prim->ifa_next;
401 last_prim->ifa_next = promote;
402 }
403
404 promote->ifa_flags &= ~IFA_F_SECONDARY;
405 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
406 blocking_notifier_call_chain(&inetaddr_chain,
407 NETDEV_UP, promote);
408 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
409 if (ifa1->ifa_mask != ifa->ifa_mask ||
410 !inet_ifa_match(ifa1->ifa_address, ifa))
411 continue;
412 fib_add_ifaddr(ifa);
413 }
414
415 }
416 if (destroy)
417 inet_free_ifa(ifa1);
418 }
419
420 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
421 int destroy)
422 {
423 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
424 }
425
426 static void check_lifetime(struct work_struct *work);
427
428 static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
429
430 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
431 u32 portid)
432 {
433 struct in_device *in_dev = ifa->ifa_dev;
434 struct in_ifaddr *ifa1, **ifap, **last_primary;
435
436 ASSERT_RTNL();
437
438 if (!ifa->ifa_local) {
439 inet_free_ifa(ifa);
440 return 0;
441 }
442
443 ifa->ifa_flags &= ~IFA_F_SECONDARY;
444 last_primary = &in_dev->ifa_list;
445
446 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
447 ifap = &ifa1->ifa_next) {
448 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
449 ifa->ifa_scope <= ifa1->ifa_scope)
450 last_primary = &ifa1->ifa_next;
451 if (ifa1->ifa_mask == ifa->ifa_mask &&
452 inet_ifa_match(ifa1->ifa_address, ifa)) {
453 if (ifa1->ifa_local == ifa->ifa_local) {
454 inet_free_ifa(ifa);
455 return -EEXIST;
456 }
457 if (ifa1->ifa_scope != ifa->ifa_scope) {
458 inet_free_ifa(ifa);
459 return -EINVAL;
460 }
461 ifa->ifa_flags |= IFA_F_SECONDARY;
462 }
463 }
464
465 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
466 net_srandom(ifa->ifa_local);
467 ifap = last_primary;
468 }
469
470 ifa->ifa_next = *ifap;
471 *ifap = ifa;
472
473 inet_hash_insert(dev_net(in_dev->dev), ifa);
474
475 cancel_delayed_work(&check_lifetime_work);
476 schedule_delayed_work(&check_lifetime_work, 0);
477
478 /* Send message first, then call notifier.
479 Notifier will trigger FIB update, so that
480 listeners of netlink will know about new ifaddr */
481 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
482 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
483
484 return 0;
485 }
486
487 static int inet_insert_ifa(struct in_ifaddr *ifa)
488 {
489 return __inet_insert_ifa(ifa, NULL, 0);
490 }
491
492 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
493 {
494 struct in_device *in_dev = __in_dev_get_rtnl(dev);
495
496 ASSERT_RTNL();
497
498 if (!in_dev) {
499 inet_free_ifa(ifa);
500 return -ENOBUFS;
501 }
502 ipv4_devconf_setall(in_dev);
503 if (ifa->ifa_dev != in_dev) {
504 WARN_ON(ifa->ifa_dev);
505 in_dev_hold(in_dev);
506 ifa->ifa_dev = in_dev;
507 }
508 if (ipv4_is_loopback(ifa->ifa_local))
509 ifa->ifa_scope = RT_SCOPE_HOST;
510 return inet_insert_ifa(ifa);
511 }
512
513 /* Caller must hold RCU or RTNL :
514 * We dont take a reference on found in_device
515 */
516 struct in_device *inetdev_by_index(struct net *net, int ifindex)
517 {
518 struct net_device *dev;
519 struct in_device *in_dev = NULL;
520
521 rcu_read_lock();
522 dev = dev_get_by_index_rcu(net, ifindex);
523 if (dev)
524 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
525 rcu_read_unlock();
526 return in_dev;
527 }
528 EXPORT_SYMBOL(inetdev_by_index);
529
530 /* Called only from RTNL semaphored context. No locks. */
531
532 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
533 __be32 mask)
534 {
535 ASSERT_RTNL();
536
537 for_primary_ifa(in_dev) {
538 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
539 return ifa;
540 } endfor_ifa(in_dev);
541 return NULL;
542 }
543
544 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
545 {
546 struct net *net = sock_net(skb->sk);
547 struct nlattr *tb[IFA_MAX+1];
548 struct in_device *in_dev;
549 struct ifaddrmsg *ifm;
550 struct in_ifaddr *ifa, **ifap;
551 int err = -EINVAL;
552
553 ASSERT_RTNL();
554
555 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
556 if (err < 0)
557 goto errout;
558
559 ifm = nlmsg_data(nlh);
560 in_dev = inetdev_by_index(net, ifm->ifa_index);
561 if (in_dev == NULL) {
562 err = -ENODEV;
563 goto errout;
564 }
565
566 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
567 ifap = &ifa->ifa_next) {
568 if (tb[IFA_LOCAL] &&
569 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
570 continue;
571
572 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
573 continue;
574
575 if (tb[IFA_ADDRESS] &&
576 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
577 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
578 continue;
579
580 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
581 return 0;
582 }
583
584 err = -EADDRNOTAVAIL;
585 errout:
586 return err;
587 }
588
589 #define INFINITY_LIFE_TIME 0xFFFFFFFF
590
591 static void check_lifetime(struct work_struct *work)
592 {
593 unsigned long now, next, next_sec, next_sched;
594 struct in_ifaddr *ifa;
595 struct hlist_node *n;
596 int i;
597
598 now = jiffies;
599 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
600
601 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
602 bool change_needed = false;
603
604 rcu_read_lock();
605 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
606 unsigned long age;
607
608 if (ifa->ifa_flags & IFA_F_PERMANENT)
609 continue;
610
611 /* We try to batch several events at once. */
612 age = (now - ifa->ifa_tstamp +
613 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
614
615 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
616 age >= ifa->ifa_valid_lft) {
617 change_needed = true;
618 } else if (ifa->ifa_preferred_lft ==
619 INFINITY_LIFE_TIME) {
620 continue;
621 } else if (age >= ifa->ifa_preferred_lft) {
622 if (time_before(ifa->ifa_tstamp +
623 ifa->ifa_valid_lft * HZ, next))
624 next = ifa->ifa_tstamp +
625 ifa->ifa_valid_lft * HZ;
626
627 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
628 change_needed = true;
629 } else if (time_before(ifa->ifa_tstamp +
630 ifa->ifa_preferred_lft * HZ,
631 next)) {
632 next = ifa->ifa_tstamp +
633 ifa->ifa_preferred_lft * HZ;
634 }
635 }
636 rcu_read_unlock();
637 if (!change_needed)
638 continue;
639 rtnl_lock();
640 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
641 unsigned long age;
642
643 if (ifa->ifa_flags & IFA_F_PERMANENT)
644 continue;
645
646 /* We try to batch several events at once. */
647 age = (now - ifa->ifa_tstamp +
648 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
649
650 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
651 age >= ifa->ifa_valid_lft) {
652 struct in_ifaddr **ifap;
653
654 for (ifap = &ifa->ifa_dev->ifa_list;
655 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
656 if (*ifap == ifa) {
657 inet_del_ifa(ifa->ifa_dev,
658 ifap, 1);
659 break;
660 }
661 }
662 } else if (ifa->ifa_preferred_lft !=
663 INFINITY_LIFE_TIME &&
664 age >= ifa->ifa_preferred_lft &&
665 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
666 ifa->ifa_flags |= IFA_F_DEPRECATED;
667 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
668 }
669 }
670 rtnl_unlock();
671 }
672
673 next_sec = round_jiffies_up(next);
674 next_sched = next;
675
676 /* If rounded timeout is accurate enough, accept it. */
677 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
678 next_sched = next_sec;
679
680 now = jiffies;
681 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
682 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
683 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
684
685 schedule_delayed_work(&check_lifetime_work, next_sched - now);
686 }
687
688 static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
689 __u32 prefered_lft)
690 {
691 unsigned long timeout;
692
693 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
694
695 timeout = addrconf_timeout_fixup(valid_lft, HZ);
696 if (addrconf_finite_timeout(timeout))
697 ifa->ifa_valid_lft = timeout;
698 else
699 ifa->ifa_flags |= IFA_F_PERMANENT;
700
701 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
702 if (addrconf_finite_timeout(timeout)) {
703 if (timeout == 0)
704 ifa->ifa_flags |= IFA_F_DEPRECATED;
705 ifa->ifa_preferred_lft = timeout;
706 }
707 ifa->ifa_tstamp = jiffies;
708 if (!ifa->ifa_cstamp)
709 ifa->ifa_cstamp = ifa->ifa_tstamp;
710 }
711
712 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
713 __u32 *pvalid_lft, __u32 *pprefered_lft)
714 {
715 struct nlattr *tb[IFA_MAX+1];
716 struct in_ifaddr *ifa;
717 struct ifaddrmsg *ifm;
718 struct net_device *dev;
719 struct in_device *in_dev;
720 int err;
721
722 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
723 if (err < 0)
724 goto errout;
725
726 ifm = nlmsg_data(nlh);
727 err = -EINVAL;
728 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
729 goto errout;
730
731 dev = __dev_get_by_index(net, ifm->ifa_index);
732 err = -ENODEV;
733 if (dev == NULL)
734 goto errout;
735
736 in_dev = __in_dev_get_rtnl(dev);
737 err = -ENOBUFS;
738 if (in_dev == NULL)
739 goto errout;
740
741 ifa = inet_alloc_ifa();
742 if (ifa == NULL)
743 /*
744 * A potential indev allocation can be left alive, it stays
745 * assigned to its device and is destroy with it.
746 */
747 goto errout;
748
749 ipv4_devconf_setall(in_dev);
750 in_dev_hold(in_dev);
751
752 if (tb[IFA_ADDRESS] == NULL)
753 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
754
755 INIT_HLIST_NODE(&ifa->hash);
756 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
757 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
758 ifa->ifa_flags = ifm->ifa_flags;
759 ifa->ifa_scope = ifm->ifa_scope;
760 ifa->ifa_dev = in_dev;
761
762 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
763 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
764
765 if (tb[IFA_BROADCAST])
766 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
767
768 if (tb[IFA_LABEL])
769 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
770 else
771 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
772
773 if (tb[IFA_CACHEINFO]) {
774 struct ifa_cacheinfo *ci;
775
776 ci = nla_data(tb[IFA_CACHEINFO]);
777 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
778 err = -EINVAL;
779 goto errout_free;
780 }
781 *pvalid_lft = ci->ifa_valid;
782 *pprefered_lft = ci->ifa_prefered;
783 }
784
785 return ifa;
786
787 errout_free:
788 inet_free_ifa(ifa);
789 errout:
790 return ERR_PTR(err);
791 }
792
793 static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
794 {
795 struct in_device *in_dev = ifa->ifa_dev;
796 struct in_ifaddr *ifa1, **ifap;
797
798 if (!ifa->ifa_local)
799 return NULL;
800
801 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
802 ifap = &ifa1->ifa_next) {
803 if (ifa1->ifa_mask == ifa->ifa_mask &&
804 inet_ifa_match(ifa1->ifa_address, ifa) &&
805 ifa1->ifa_local == ifa->ifa_local)
806 return ifa1;
807 }
808 return NULL;
809 }
810
811 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
812 {
813 struct net *net = sock_net(skb->sk);
814 struct in_ifaddr *ifa;
815 struct in_ifaddr *ifa_existing;
816 __u32 valid_lft = INFINITY_LIFE_TIME;
817 __u32 prefered_lft = INFINITY_LIFE_TIME;
818
819 ASSERT_RTNL();
820
821 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
822 if (IS_ERR(ifa))
823 return PTR_ERR(ifa);
824
825 ifa_existing = find_matching_ifa(ifa);
826 if (!ifa_existing) {
827 /* It would be best to check for !NLM_F_CREATE here but
828 * userspace alreay relies on not having to provide this.
829 */
830 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
831 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
832 } else {
833 inet_free_ifa(ifa);
834
835 if (nlh->nlmsg_flags & NLM_F_EXCL ||
836 !(nlh->nlmsg_flags & NLM_F_REPLACE))
837 return -EEXIST;
838 ifa = ifa_existing;
839 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
840 cancel_delayed_work(&check_lifetime_work);
841 schedule_delayed_work(&check_lifetime_work, 0);
842 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
843 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
844 }
845 return 0;
846 }
847
848 /*
849 * Determine a default network mask, based on the IP address.
850 */
851
852 static int inet_abc_len(__be32 addr)
853 {
854 int rc = -1; /* Something else, probably a multicast. */
855
856 if (ipv4_is_zeronet(addr))
857 rc = 0;
858 else {
859 __u32 haddr = ntohl(addr);
860
861 if (IN_CLASSA(haddr))
862 rc = 8;
863 else if (IN_CLASSB(haddr))
864 rc = 16;
865 else if (IN_CLASSC(haddr))
866 rc = 24;
867 }
868
869 return rc;
870 }
871
872
873 int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
874 {
875 struct ifreq ifr;
876 struct sockaddr_in sin_orig;
877 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
878 struct in_device *in_dev;
879 struct in_ifaddr **ifap = NULL;
880 struct in_ifaddr *ifa = NULL;
881 struct net_device *dev;
882 char *colon;
883 int ret = -EFAULT;
884 int tryaddrmatch = 0;
885
886 /*
887 * Fetch the caller's info block into kernel space
888 */
889
890 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
891 goto out;
892 ifr.ifr_name[IFNAMSIZ - 1] = 0;
893
894 /* save original address for comparison */
895 memcpy(&sin_orig, sin, sizeof(*sin));
896
897 colon = strchr(ifr.ifr_name, ':');
898 if (colon)
899 *colon = 0;
900
901 dev_load(net, ifr.ifr_name);
902
903 switch (cmd) {
904 case SIOCGIFADDR: /* Get interface address */
905 case SIOCGIFBRDADDR: /* Get the broadcast address */
906 case SIOCGIFDSTADDR: /* Get the destination address */
907 case SIOCGIFNETMASK: /* Get the netmask for the interface */
908 /* Note that these ioctls will not sleep,
909 so that we do not impose a lock.
910 One day we will be forced to put shlock here (I mean SMP)
911 */
912 tryaddrmatch = (sin_orig.sin_family == AF_INET);
913 memset(sin, 0, sizeof(*sin));
914 sin->sin_family = AF_INET;
915 break;
916
917 case SIOCSIFFLAGS:
918 ret = -EPERM;
919 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
920 goto out;
921 break;
922 case SIOCSIFADDR: /* Set interface address (and family) */
923 case SIOCSIFBRDADDR: /* Set the broadcast address */
924 case SIOCSIFDSTADDR: /* Set the destination address */
925 case SIOCSIFNETMASK: /* Set the netmask for the interface */
926 ret = -EPERM;
927 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
928 goto out;
929 ret = -EINVAL;
930 if (sin->sin_family != AF_INET)
931 goto out;
932 break;
933 default:
934 ret = -EINVAL;
935 goto out;
936 }
937
938 rtnl_lock();
939
940 ret = -ENODEV;
941 dev = __dev_get_by_name(net, ifr.ifr_name);
942 if (!dev)
943 goto done;
944
945 if (colon)
946 *colon = ':';
947
948 in_dev = __in_dev_get_rtnl(dev);
949 if (in_dev) {
950 if (tryaddrmatch) {
951 /* Matthias Andree */
952 /* compare label and address (4.4BSD style) */
953 /* note: we only do this for a limited set of ioctls
954 and only if the original address family was AF_INET.
955 This is checked above. */
956 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
957 ifap = &ifa->ifa_next) {
958 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
959 sin_orig.sin_addr.s_addr ==
960 ifa->ifa_local) {
961 break; /* found */
962 }
963 }
964 }
965 /* we didn't get a match, maybe the application is
966 4.3BSD-style and passed in junk so we fall back to
967 comparing just the label */
968 if (!ifa) {
969 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
970 ifap = &ifa->ifa_next)
971 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
972 break;
973 }
974 }
975
976 ret = -EADDRNOTAVAIL;
977 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
978 goto done;
979
980 switch (cmd) {
981 case SIOCGIFADDR: /* Get interface address */
982 sin->sin_addr.s_addr = ifa->ifa_local;
983 goto rarok;
984
985 case SIOCGIFBRDADDR: /* Get the broadcast address */
986 sin->sin_addr.s_addr = ifa->ifa_broadcast;
987 goto rarok;
988
989 case SIOCGIFDSTADDR: /* Get the destination address */
990 sin->sin_addr.s_addr = ifa->ifa_address;
991 goto rarok;
992
993 case SIOCGIFNETMASK: /* Get the netmask for the interface */
994 sin->sin_addr.s_addr = ifa->ifa_mask;
995 goto rarok;
996
997 case SIOCSIFFLAGS:
998 if (colon) {
999 ret = -EADDRNOTAVAIL;
1000 if (!ifa)
1001 break;
1002 ret = 0;
1003 if (!(ifr.ifr_flags & IFF_UP))
1004 inet_del_ifa(in_dev, ifap, 1);
1005 break;
1006 }
1007 ret = dev_change_flags(dev, ifr.ifr_flags);
1008 break;
1009
1010 case SIOCSIFADDR: /* Set interface address (and family) */
1011 ret = -EINVAL;
1012 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1013 break;
1014
1015 if (!ifa) {
1016 ret = -ENOBUFS;
1017 ifa = inet_alloc_ifa();
1018 if (!ifa)
1019 break;
1020 INIT_HLIST_NODE(&ifa->hash);
1021 if (colon)
1022 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1023 else
1024 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1025 } else {
1026 ret = 0;
1027 if (ifa->ifa_local == sin->sin_addr.s_addr)
1028 break;
1029 inet_del_ifa(in_dev, ifap, 0);
1030 ifa->ifa_broadcast = 0;
1031 ifa->ifa_scope = 0;
1032 }
1033
1034 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1035
1036 if (!(dev->flags & IFF_POINTOPOINT)) {
1037 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1038 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1039 if ((dev->flags & IFF_BROADCAST) &&
1040 ifa->ifa_prefixlen < 31)
1041 ifa->ifa_broadcast = ifa->ifa_address |
1042 ~ifa->ifa_mask;
1043 } else {
1044 ifa->ifa_prefixlen = 32;
1045 ifa->ifa_mask = inet_make_mask(32);
1046 }
1047 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
1048 ret = inet_set_ifa(dev, ifa);
1049 break;
1050
1051 case SIOCSIFBRDADDR: /* Set the broadcast address */
1052 ret = 0;
1053 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1054 inet_del_ifa(in_dev, ifap, 0);
1055 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1056 inet_insert_ifa(ifa);
1057 }
1058 break;
1059
1060 case SIOCSIFDSTADDR: /* Set the destination address */
1061 ret = 0;
1062 if (ifa->ifa_address == sin->sin_addr.s_addr)
1063 break;
1064 ret = -EINVAL;
1065 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1066 break;
1067 ret = 0;
1068 inet_del_ifa(in_dev, ifap, 0);
1069 ifa->ifa_address = sin->sin_addr.s_addr;
1070 inet_insert_ifa(ifa);
1071 break;
1072
1073 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1074
1075 /*
1076 * The mask we set must be legal.
1077 */
1078 ret = -EINVAL;
1079 if (bad_mask(sin->sin_addr.s_addr, 0))
1080 break;
1081 ret = 0;
1082 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
1083 __be32 old_mask = ifa->ifa_mask;
1084 inet_del_ifa(in_dev, ifap, 0);
1085 ifa->ifa_mask = sin->sin_addr.s_addr;
1086 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1087
1088 /* See if current broadcast address matches
1089 * with current netmask, then recalculate
1090 * the broadcast address. Otherwise it's a
1091 * funny address, so don't touch it since
1092 * the user seems to know what (s)he's doing...
1093 */
1094 if ((dev->flags & IFF_BROADCAST) &&
1095 (ifa->ifa_prefixlen < 31) &&
1096 (ifa->ifa_broadcast ==
1097 (ifa->ifa_local|~old_mask))) {
1098 ifa->ifa_broadcast = (ifa->ifa_local |
1099 ~sin->sin_addr.s_addr);
1100 }
1101 inet_insert_ifa(ifa);
1102 }
1103 break;
1104 }
1105 done:
1106 rtnl_unlock();
1107 out:
1108 return ret;
1109 rarok:
1110 rtnl_unlock();
1111 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1112 goto out;
1113 }
1114
1115 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1116 {
1117 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1118 struct in_ifaddr *ifa;
1119 struct ifreq ifr;
1120 int done = 0;
1121
1122 if (!in_dev)
1123 goto out;
1124
1125 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1126 if (!buf) {
1127 done += sizeof(ifr);
1128 continue;
1129 }
1130 if (len < (int) sizeof(ifr))
1131 break;
1132 memset(&ifr, 0, sizeof(struct ifreq));
1133 strcpy(ifr.ifr_name, ifa->ifa_label);
1134
1135 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1136 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1137 ifa->ifa_local;
1138
1139 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1140 done = -EFAULT;
1141 break;
1142 }
1143 buf += sizeof(struct ifreq);
1144 len -= sizeof(struct ifreq);
1145 done += sizeof(struct ifreq);
1146 }
1147 out:
1148 return done;
1149 }
1150
1151 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
1152 {
1153 __be32 addr = 0;
1154 struct in_device *in_dev;
1155 struct net *net = dev_net(dev);
1156
1157 rcu_read_lock();
1158 in_dev = __in_dev_get_rcu(dev);
1159 if (!in_dev)
1160 goto no_in_dev;
1161
1162 for_primary_ifa(in_dev) {
1163 if (ifa->ifa_scope > scope)
1164 continue;
1165 if (!dst || inet_ifa_match(dst, ifa)) {
1166 addr = ifa->ifa_local;
1167 break;
1168 }
1169 if (!addr)
1170 addr = ifa->ifa_local;
1171 } endfor_ifa(in_dev);
1172
1173 if (addr)
1174 goto out_unlock;
1175 no_in_dev:
1176
1177 /* Not loopback addresses on loopback should be preferred
1178 in this case. It is importnat that lo is the first interface
1179 in dev_base list.
1180 */
1181 for_each_netdev_rcu(net, dev) {
1182 in_dev = __in_dev_get_rcu(dev);
1183 if (!in_dev)
1184 continue;
1185
1186 for_primary_ifa(in_dev) {
1187 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1188 ifa->ifa_scope <= scope) {
1189 addr = ifa->ifa_local;
1190 goto out_unlock;
1191 }
1192 } endfor_ifa(in_dev);
1193 }
1194 out_unlock:
1195 rcu_read_unlock();
1196 return addr;
1197 }
1198 EXPORT_SYMBOL(inet_select_addr);
1199
1200 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1201 __be32 local, int scope)
1202 {
1203 int same = 0;
1204 __be32 addr = 0;
1205
1206 for_ifa(in_dev) {
1207 if (!addr &&
1208 (local == ifa->ifa_local || !local) &&
1209 ifa->ifa_scope <= scope) {
1210 addr = ifa->ifa_local;
1211 if (same)
1212 break;
1213 }
1214 if (!same) {
1215 same = (!local || inet_ifa_match(local, ifa)) &&
1216 (!dst || inet_ifa_match(dst, ifa));
1217 if (same && addr) {
1218 if (local || !dst)
1219 break;
1220 /* Is the selected addr into dst subnet? */
1221 if (inet_ifa_match(addr, ifa))
1222 break;
1223 /* No, then can we use new local src? */
1224 if (ifa->ifa_scope <= scope) {
1225 addr = ifa->ifa_local;
1226 break;
1227 }
1228 /* search for large dst subnet for addr */
1229 same = 0;
1230 }
1231 }
1232 } endfor_ifa(in_dev);
1233
1234 return same ? addr : 0;
1235 }
1236
1237 /*
1238 * Confirm that local IP address exists using wildcards:
1239 * - in_dev: only on this interface, 0=any interface
1240 * - dst: only in the same subnet as dst, 0=any dst
1241 * - local: address, 0=autoselect the local address
1242 * - scope: maximum allowed scope value for the local address
1243 */
1244 __be32 inet_confirm_addr(struct in_device *in_dev,
1245 __be32 dst, __be32 local, int scope)
1246 {
1247 __be32 addr = 0;
1248 struct net_device *dev;
1249 struct net *net;
1250
1251 if (scope != RT_SCOPE_LINK)
1252 return confirm_addr_indev(in_dev, dst, local, scope);
1253
1254 net = dev_net(in_dev->dev);
1255 rcu_read_lock();
1256 for_each_netdev_rcu(net, dev) {
1257 in_dev = __in_dev_get_rcu(dev);
1258 if (in_dev) {
1259 addr = confirm_addr_indev(in_dev, dst, local, scope);
1260 if (addr)
1261 break;
1262 }
1263 }
1264 rcu_read_unlock();
1265
1266 return addr;
1267 }
1268 EXPORT_SYMBOL(inet_confirm_addr);
1269
1270 /*
1271 * Device notifier
1272 */
1273
1274 int register_inetaddr_notifier(struct notifier_block *nb)
1275 {
1276 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1277 }
1278 EXPORT_SYMBOL(register_inetaddr_notifier);
1279
1280 int unregister_inetaddr_notifier(struct notifier_block *nb)
1281 {
1282 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1283 }
1284 EXPORT_SYMBOL(unregister_inetaddr_notifier);
1285
1286 /* Rename ifa_labels for a device name change. Make some effort to preserve
1287 * existing alias numbering and to create unique labels if possible.
1288 */
1289 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1290 {
1291 struct in_ifaddr *ifa;
1292 int named = 0;
1293
1294 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1295 char old[IFNAMSIZ], *dot;
1296
1297 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1298 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1299 if (named++ == 0)
1300 goto skip;
1301 dot = strchr(old, ':');
1302 if (dot == NULL) {
1303 sprintf(old, ":%d", named);
1304 dot = old;
1305 }
1306 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1307 strcat(ifa->ifa_label, dot);
1308 else
1309 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1310 skip:
1311 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1312 }
1313 }
1314
1315 static bool inetdev_valid_mtu(unsigned int mtu)
1316 {
1317 return mtu >= 68;
1318 }
1319
1320 static void inetdev_send_gratuitous_arp(struct net_device *dev,
1321 struct in_device *in_dev)
1322
1323 {
1324 struct in_ifaddr *ifa;
1325
1326 for (ifa = in_dev->ifa_list; ifa;
1327 ifa = ifa->ifa_next) {
1328 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1329 ifa->ifa_local, dev,
1330 ifa->ifa_local, NULL,
1331 dev->dev_addr, NULL);
1332 }
1333 }
1334
1335 /* Called only under RTNL semaphore */
1336
1337 static int inetdev_event(struct notifier_block *this, unsigned long event,
1338 void *ptr)
1339 {
1340 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1341 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1342
1343 ASSERT_RTNL();
1344
1345 if (!in_dev) {
1346 if (event == NETDEV_REGISTER) {
1347 in_dev = inetdev_init(dev);
1348 if (!in_dev)
1349 return notifier_from_errno(-ENOMEM);
1350 if (dev->flags & IFF_LOOPBACK) {
1351 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1352 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1353 }
1354 } else if (event == NETDEV_CHANGEMTU) {
1355 /* Re-enabling IP */
1356 if (inetdev_valid_mtu(dev->mtu))
1357 in_dev = inetdev_init(dev);
1358 }
1359 goto out;
1360 }
1361
1362 switch (event) {
1363 case NETDEV_REGISTER:
1364 pr_debug("%s: bug\n", __func__);
1365 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1366 break;
1367 case NETDEV_UP:
1368 if (!inetdev_valid_mtu(dev->mtu))
1369 break;
1370 if (dev->flags & IFF_LOOPBACK) {
1371 struct in_ifaddr *ifa = inet_alloc_ifa();
1372
1373 if (ifa) {
1374 INIT_HLIST_NODE(&ifa->hash);
1375 ifa->ifa_local =
1376 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1377 ifa->ifa_prefixlen = 8;
1378 ifa->ifa_mask = inet_make_mask(8);
1379 in_dev_hold(in_dev);
1380 ifa->ifa_dev = in_dev;
1381 ifa->ifa_scope = RT_SCOPE_HOST;
1382 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1383 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1384 INFINITY_LIFE_TIME);
1385 inet_insert_ifa(ifa);
1386 }
1387 }
1388 ip_mc_up(in_dev);
1389 /* fall through */
1390 case NETDEV_CHANGEADDR:
1391 if (!IN_DEV_ARP_NOTIFY(in_dev))
1392 break;
1393 /* fall through */
1394 case NETDEV_NOTIFY_PEERS:
1395 /* Send gratuitous ARP to notify of link change */
1396 inetdev_send_gratuitous_arp(dev, in_dev);
1397 break;
1398 case NETDEV_DOWN:
1399 ip_mc_down(in_dev);
1400 break;
1401 case NETDEV_PRE_TYPE_CHANGE:
1402 ip_mc_unmap(in_dev);
1403 break;
1404 case NETDEV_POST_TYPE_CHANGE:
1405 ip_mc_remap(in_dev);
1406 break;
1407 case NETDEV_CHANGEMTU:
1408 if (inetdev_valid_mtu(dev->mtu))
1409 break;
1410 /* disable IP when MTU is not enough */
1411 case NETDEV_UNREGISTER:
1412 inetdev_destroy(in_dev);
1413 break;
1414 case NETDEV_CHANGENAME:
1415 /* Do not notify about label change, this event is
1416 * not interesting to applications using netlink.
1417 */
1418 inetdev_changename(dev, in_dev);
1419
1420 devinet_sysctl_unregister(in_dev);
1421 devinet_sysctl_register(in_dev);
1422 break;
1423 }
1424 out:
1425 return NOTIFY_DONE;
1426 }
1427
1428 static struct notifier_block ip_netdev_notifier = {
1429 .notifier_call = inetdev_event,
1430 };
1431
1432 static size_t inet_nlmsg_size(void)
1433 {
1434 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1435 + nla_total_size(4) /* IFA_ADDRESS */
1436 + nla_total_size(4) /* IFA_LOCAL */
1437 + nla_total_size(4) /* IFA_BROADCAST */
1438 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1439 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1440 }
1441
1442 static inline u32 cstamp_delta(unsigned long cstamp)
1443 {
1444 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1445 }
1446
1447 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1448 unsigned long tstamp, u32 preferred, u32 valid)
1449 {
1450 struct ifa_cacheinfo ci;
1451
1452 ci.cstamp = cstamp_delta(cstamp);
1453 ci.tstamp = cstamp_delta(tstamp);
1454 ci.ifa_prefered = preferred;
1455 ci.ifa_valid = valid;
1456
1457 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1458 }
1459
1460 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1461 u32 portid, u32 seq, int event, unsigned int flags)
1462 {
1463 struct ifaddrmsg *ifm;
1464 struct nlmsghdr *nlh;
1465 u32 preferred, valid;
1466
1467 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1468 if (nlh == NULL)
1469 return -EMSGSIZE;
1470
1471 ifm = nlmsg_data(nlh);
1472 ifm->ifa_family = AF_INET;
1473 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1474 ifm->ifa_flags = ifa->ifa_flags;
1475 ifm->ifa_scope = ifa->ifa_scope;
1476 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1477
1478 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1479 preferred = ifa->ifa_preferred_lft;
1480 valid = ifa->ifa_valid_lft;
1481 if (preferred != INFINITY_LIFE_TIME) {
1482 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1483
1484 if (preferred > tval)
1485 preferred -= tval;
1486 else
1487 preferred = 0;
1488 if (valid != INFINITY_LIFE_TIME) {
1489 if (valid > tval)
1490 valid -= tval;
1491 else
1492 valid = 0;
1493 }
1494 }
1495 } else {
1496 preferred = INFINITY_LIFE_TIME;
1497 valid = INFINITY_LIFE_TIME;
1498 }
1499 if ((ifa->ifa_address &&
1500 nla_put_be32(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1501 (ifa->ifa_local &&
1502 nla_put_be32(skb, IFA_LOCAL, ifa->ifa_local)) ||
1503 (ifa->ifa_broadcast &&
1504 nla_put_be32(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1505 (ifa->ifa_label[0] &&
1506 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1507 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1508 preferred, valid))
1509 goto nla_put_failure;
1510
1511 return nlmsg_end(skb, nlh);
1512
1513 nla_put_failure:
1514 nlmsg_cancel(skb, nlh);
1515 return -EMSGSIZE;
1516 }
1517
1518 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1519 {
1520 struct net *net = sock_net(skb->sk);
1521 int h, s_h;
1522 int idx, s_idx;
1523 int ip_idx, s_ip_idx;
1524 struct net_device *dev;
1525 struct in_device *in_dev;
1526 struct in_ifaddr *ifa;
1527 struct hlist_head *head;
1528
1529 s_h = cb->args[0];
1530 s_idx = idx = cb->args[1];
1531 s_ip_idx = ip_idx = cb->args[2];
1532
1533 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1534 idx = 0;
1535 head = &net->dev_index_head[h];
1536 rcu_read_lock();
1537 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1538 net->dev_base_seq;
1539 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1540 if (idx < s_idx)
1541 goto cont;
1542 if (h > s_h || idx > s_idx)
1543 s_ip_idx = 0;
1544 in_dev = __in_dev_get_rcu(dev);
1545 if (!in_dev)
1546 goto cont;
1547
1548 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1549 ifa = ifa->ifa_next, ip_idx++) {
1550 if (ip_idx < s_ip_idx)
1551 continue;
1552 if (inet_fill_ifaddr(skb, ifa,
1553 NETLINK_CB(cb->skb).portid,
1554 cb->nlh->nlmsg_seq,
1555 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1556 rcu_read_unlock();
1557 goto done;
1558 }
1559 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1560 }
1561 cont:
1562 idx++;
1563 }
1564 rcu_read_unlock();
1565 }
1566
1567 done:
1568 cb->args[0] = h;
1569 cb->args[1] = idx;
1570 cb->args[2] = ip_idx;
1571
1572 return skb->len;
1573 }
1574
1575 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1576 u32 portid)
1577 {
1578 struct sk_buff *skb;
1579 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1580 int err = -ENOBUFS;
1581 struct net *net;
1582
1583 net = dev_net(ifa->ifa_dev->dev);
1584 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1585 if (skb == NULL)
1586 goto errout;
1587
1588 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1589 if (err < 0) {
1590 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1591 WARN_ON(err == -EMSGSIZE);
1592 kfree_skb(skb);
1593 goto errout;
1594 }
1595 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1596 return;
1597 errout:
1598 if (err < 0)
1599 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1600 }
1601
1602 static size_t inet_get_link_af_size(const struct net_device *dev)
1603 {
1604 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1605
1606 if (!in_dev)
1607 return 0;
1608
1609 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1610 }
1611
1612 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
1613 {
1614 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1615 struct nlattr *nla;
1616 int i;
1617
1618 if (!in_dev)
1619 return -ENODATA;
1620
1621 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1622 if (nla == NULL)
1623 return -EMSGSIZE;
1624
1625 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1626 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1627
1628 return 0;
1629 }
1630
1631 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1632 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1633 };
1634
1635 static int inet_validate_link_af(const struct net_device *dev,
1636 const struct nlattr *nla)
1637 {
1638 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1639 int err, rem;
1640
1641 if (dev && !__in_dev_get_rtnl(dev))
1642 return -EAFNOSUPPORT;
1643
1644 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1645 if (err < 0)
1646 return err;
1647
1648 if (tb[IFLA_INET_CONF]) {
1649 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1650 int cfgid = nla_type(a);
1651
1652 if (nla_len(a) < 4)
1653 return -EINVAL;
1654
1655 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1656 return -EINVAL;
1657 }
1658 }
1659
1660 return 0;
1661 }
1662
1663 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1664 {
1665 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1666 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1667 int rem;
1668
1669 if (!in_dev)
1670 return -EAFNOSUPPORT;
1671
1672 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1673 BUG();
1674
1675 if (tb[IFLA_INET_CONF]) {
1676 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1677 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1678 }
1679
1680 return 0;
1681 }
1682
1683 static int inet_netconf_msgsize_devconf(int type)
1684 {
1685 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1686 + nla_total_size(4); /* NETCONFA_IFINDEX */
1687
1688 /* type -1 is used for ALL */
1689 if (type == -1 || type == NETCONFA_FORWARDING)
1690 size += nla_total_size(4);
1691 if (type == -1 || type == NETCONFA_RP_FILTER)
1692 size += nla_total_size(4);
1693 if (type == -1 || type == NETCONFA_MC_FORWARDING)
1694 size += nla_total_size(4);
1695
1696 return size;
1697 }
1698
1699 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1700 struct ipv4_devconf *devconf, u32 portid,
1701 u32 seq, int event, unsigned int flags,
1702 int type)
1703 {
1704 struct nlmsghdr *nlh;
1705 struct netconfmsg *ncm;
1706
1707 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1708 flags);
1709 if (nlh == NULL)
1710 return -EMSGSIZE;
1711
1712 ncm = nlmsg_data(nlh);
1713 ncm->ncm_family = AF_INET;
1714
1715 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1716 goto nla_put_failure;
1717
1718 /* type -1 is used for ALL */
1719 if ((type == -1 || type == NETCONFA_FORWARDING) &&
1720 nla_put_s32(skb, NETCONFA_FORWARDING,
1721 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1722 goto nla_put_failure;
1723 if ((type == -1 || type == NETCONFA_RP_FILTER) &&
1724 nla_put_s32(skb, NETCONFA_RP_FILTER,
1725 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1726 goto nla_put_failure;
1727 if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
1728 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1729 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1730 goto nla_put_failure;
1731
1732 return nlmsg_end(skb, nlh);
1733
1734 nla_put_failure:
1735 nlmsg_cancel(skb, nlh);
1736 return -EMSGSIZE;
1737 }
1738
1739 void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
1740 struct ipv4_devconf *devconf)
1741 {
1742 struct sk_buff *skb;
1743 int err = -ENOBUFS;
1744
1745 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_ATOMIC);
1746 if (skb == NULL)
1747 goto errout;
1748
1749 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1750 RTM_NEWNETCONF, 0, type);
1751 if (err < 0) {
1752 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1753 WARN_ON(err == -EMSGSIZE);
1754 kfree_skb(skb);
1755 goto errout;
1756 }
1757 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_ATOMIC);
1758 return;
1759 errout:
1760 if (err < 0)
1761 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1762 }
1763
1764 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1765 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1766 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
1767 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
1768 };
1769
1770 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1771 struct nlmsghdr *nlh)
1772 {
1773 struct net *net = sock_net(in_skb->sk);
1774 struct nlattr *tb[NETCONFA_MAX+1];
1775 struct netconfmsg *ncm;
1776 struct sk_buff *skb;
1777 struct ipv4_devconf *devconf;
1778 struct in_device *in_dev;
1779 struct net_device *dev;
1780 int ifindex;
1781 int err;
1782
1783 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1784 devconf_ipv4_policy);
1785 if (err < 0)
1786 goto errout;
1787
1788 err = EINVAL;
1789 if (!tb[NETCONFA_IFINDEX])
1790 goto errout;
1791
1792 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1793 switch (ifindex) {
1794 case NETCONFA_IFINDEX_ALL:
1795 devconf = net->ipv4.devconf_all;
1796 break;
1797 case NETCONFA_IFINDEX_DEFAULT:
1798 devconf = net->ipv4.devconf_dflt;
1799 break;
1800 default:
1801 dev = __dev_get_by_index(net, ifindex);
1802 if (dev == NULL)
1803 goto errout;
1804 in_dev = __in_dev_get_rtnl(dev);
1805 if (in_dev == NULL)
1806 goto errout;
1807 devconf = &in_dev->cnf;
1808 break;
1809 }
1810
1811 err = -ENOBUFS;
1812 skb = nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC);
1813 if (skb == NULL)
1814 goto errout;
1815
1816 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1817 NETLINK_CB(in_skb).portid,
1818 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1819 -1);
1820 if (err < 0) {
1821 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1822 WARN_ON(err == -EMSGSIZE);
1823 kfree_skb(skb);
1824 goto errout;
1825 }
1826 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1827 errout:
1828 return err;
1829 }
1830
1831 static int inet_netconf_dump_devconf(struct sk_buff *skb,
1832 struct netlink_callback *cb)
1833 {
1834 struct net *net = sock_net(skb->sk);
1835 int h, s_h;
1836 int idx, s_idx;
1837 struct net_device *dev;
1838 struct in_device *in_dev;
1839 struct hlist_head *head;
1840
1841 s_h = cb->args[0];
1842 s_idx = idx = cb->args[1];
1843
1844 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1845 idx = 0;
1846 head = &net->dev_index_head[h];
1847 rcu_read_lock();
1848 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1849 net->dev_base_seq;
1850 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1851 if (idx < s_idx)
1852 goto cont;
1853 in_dev = __in_dev_get_rcu(dev);
1854 if (!in_dev)
1855 goto cont;
1856
1857 if (inet_netconf_fill_devconf(skb, dev->ifindex,
1858 &in_dev->cnf,
1859 NETLINK_CB(cb->skb).portid,
1860 cb->nlh->nlmsg_seq,
1861 RTM_NEWNETCONF,
1862 NLM_F_MULTI,
1863 -1) <= 0) {
1864 rcu_read_unlock();
1865 goto done;
1866 }
1867 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1868 cont:
1869 idx++;
1870 }
1871 rcu_read_unlock();
1872 }
1873 if (h == NETDEV_HASHENTRIES) {
1874 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
1875 net->ipv4.devconf_all,
1876 NETLINK_CB(cb->skb).portid,
1877 cb->nlh->nlmsg_seq,
1878 RTM_NEWNETCONF, NLM_F_MULTI,
1879 -1) <= 0)
1880 goto done;
1881 else
1882 h++;
1883 }
1884 if (h == NETDEV_HASHENTRIES + 1) {
1885 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
1886 net->ipv4.devconf_dflt,
1887 NETLINK_CB(cb->skb).portid,
1888 cb->nlh->nlmsg_seq,
1889 RTM_NEWNETCONF, NLM_F_MULTI,
1890 -1) <= 0)
1891 goto done;
1892 else
1893 h++;
1894 }
1895 done:
1896 cb->args[0] = h;
1897 cb->args[1] = idx;
1898
1899 return skb->len;
1900 }
1901
1902 #ifdef CONFIG_SYSCTL
1903
1904 static void devinet_copy_dflt_conf(struct net *net, int i)
1905 {
1906 struct net_device *dev;
1907
1908 rcu_read_lock();
1909 for_each_netdev_rcu(net, dev) {
1910 struct in_device *in_dev;
1911
1912 in_dev = __in_dev_get_rcu(dev);
1913 if (in_dev && !test_bit(i, in_dev->cnf.state))
1914 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1915 }
1916 rcu_read_unlock();
1917 }
1918
1919 /* called with RTNL locked */
1920 static void inet_forward_change(struct net *net)
1921 {
1922 struct net_device *dev;
1923 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1924
1925 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1926 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1927 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1928 NETCONFA_IFINDEX_ALL,
1929 net->ipv4.devconf_all);
1930 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1931 NETCONFA_IFINDEX_DEFAULT,
1932 net->ipv4.devconf_dflt);
1933
1934 for_each_netdev(net, dev) {
1935 struct in_device *in_dev;
1936 if (on)
1937 dev_disable_lro(dev);
1938 rcu_read_lock();
1939 in_dev = __in_dev_get_rcu(dev);
1940 if (in_dev) {
1941 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1942 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1943 dev->ifindex, &in_dev->cnf);
1944 }
1945 rcu_read_unlock();
1946 }
1947 }
1948
1949 static int devinet_conf_proc(struct ctl_table *ctl, int write,
1950 void __user *buffer,
1951 size_t *lenp, loff_t *ppos)
1952 {
1953 int old_value = *(int *)ctl->data;
1954 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1955 int new_value = *(int *)ctl->data;
1956
1957 if (write) {
1958 struct ipv4_devconf *cnf = ctl->extra1;
1959 struct net *net = ctl->extra2;
1960 int i = (int *)ctl->data - cnf->data;
1961
1962 set_bit(i, cnf->state);
1963
1964 if (cnf == net->ipv4.devconf_dflt)
1965 devinet_copy_dflt_conf(net, i);
1966 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
1967 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
1968 if ((new_value == 0) && (old_value != 0))
1969 rt_cache_flush(net);
1970 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
1971 new_value != old_value) {
1972 int ifindex;
1973
1974 if (cnf == net->ipv4.devconf_dflt)
1975 ifindex = NETCONFA_IFINDEX_DEFAULT;
1976 else if (cnf == net->ipv4.devconf_all)
1977 ifindex = NETCONFA_IFINDEX_ALL;
1978 else {
1979 struct in_device *idev =
1980 container_of(cnf, struct in_device,
1981 cnf);
1982 ifindex = idev->dev->ifindex;
1983 }
1984 inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
1985 ifindex, cnf);
1986 }
1987 }
1988
1989 return ret;
1990 }
1991
1992 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
1993 void __user *buffer,
1994 size_t *lenp, loff_t *ppos)
1995 {
1996 int *valp = ctl->data;
1997 int val = *valp;
1998 loff_t pos = *ppos;
1999 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2000
2001 if (write && *valp != val) {
2002 struct net *net = ctl->extra2;
2003
2004 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2005 if (!rtnl_trylock()) {
2006 /* Restore the original values before restarting */
2007 *valp = val;
2008 *ppos = pos;
2009 return restart_syscall();
2010 }
2011 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2012 inet_forward_change(net);
2013 } else {
2014 struct ipv4_devconf *cnf = ctl->extra1;
2015 struct in_device *idev =
2016 container_of(cnf, struct in_device, cnf);
2017 if (*valp)
2018 dev_disable_lro(idev->dev);
2019 inet_netconf_notify_devconf(net,
2020 NETCONFA_FORWARDING,
2021 idev->dev->ifindex,
2022 cnf);
2023 }
2024 rtnl_unlock();
2025 rt_cache_flush(net);
2026 } else
2027 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2028 NETCONFA_IFINDEX_DEFAULT,
2029 net->ipv4.devconf_dflt);
2030 }
2031
2032 return ret;
2033 }
2034
2035 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2036 void __user *buffer,
2037 size_t *lenp, loff_t *ppos)
2038 {
2039 int *valp = ctl->data;
2040 int val = *valp;
2041 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2042 struct net *net = ctl->extra2;
2043
2044 if (write && *valp != val)
2045 rt_cache_flush(net);
2046
2047 return ret;
2048 }
2049
2050 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2051 { \
2052 .procname = name, \
2053 .data = ipv4_devconf.data + \
2054 IPV4_DEVCONF_ ## attr - 1, \
2055 .maxlen = sizeof(int), \
2056 .mode = mval, \
2057 .proc_handler = proc, \
2058 .extra1 = &ipv4_devconf, \
2059 }
2060
2061 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2062 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2063
2064 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2065 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2066
2067 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2068 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2069
2070 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2071 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2072
2073 static struct devinet_sysctl_table {
2074 struct ctl_table_header *sysctl_header;
2075 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
2076 } devinet_sysctl = {
2077 .devinet_vars = {
2078 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2079 devinet_sysctl_forward),
2080 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2081
2082 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2083 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2084 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2085 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2086 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2087 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2088 "accept_source_route"),
2089 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2090 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2091 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2092 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2093 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2094 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2095 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2096 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2097 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2098 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2099 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2100 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2101 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2102 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2103 "force_igmp_version"),
2104 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2105 "igmpv2_unsolicited_report_interval"),
2106 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2107 "igmpv3_unsolicited_report_interval"),
2108
2109 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2110 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
2111 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2112 "promote_secondaries"),
2113 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2114 "route_localnet"),
2115 },
2116 };
2117
2118 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2119 struct ipv4_devconf *p)
2120 {
2121 int i;
2122 struct devinet_sysctl_table *t;
2123 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2124
2125 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
2126 if (!t)
2127 goto out;
2128
2129 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2130 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2131 t->devinet_vars[i].extra1 = p;
2132 t->devinet_vars[i].extra2 = net;
2133 }
2134
2135 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2136
2137 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2138 if (!t->sysctl_header)
2139 goto free;
2140
2141 p->sysctl = t;
2142 return 0;
2143
2144 free:
2145 kfree(t);
2146 out:
2147 return -ENOBUFS;
2148 }
2149
2150 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
2151 {
2152 struct devinet_sysctl_table *t = cnf->sysctl;
2153
2154 if (t == NULL)
2155 return;
2156
2157 cnf->sysctl = NULL;
2158 unregister_net_sysctl_table(t->sysctl_header);
2159 kfree(t);
2160 }
2161
2162 static void devinet_sysctl_register(struct in_device *idev)
2163 {
2164 neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
2165 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2166 &idev->cnf);
2167 }
2168
2169 static void devinet_sysctl_unregister(struct in_device *idev)
2170 {
2171 __devinet_sysctl_unregister(&idev->cnf);
2172 neigh_sysctl_unregister(idev->arp_parms);
2173 }
2174
2175 static struct ctl_table ctl_forward_entry[] = {
2176 {
2177 .procname = "ip_forward",
2178 .data = &ipv4_devconf.data[
2179 IPV4_DEVCONF_FORWARDING - 1],
2180 .maxlen = sizeof(int),
2181 .mode = 0644,
2182 .proc_handler = devinet_sysctl_forward,
2183 .extra1 = &ipv4_devconf,
2184 .extra2 = &init_net,
2185 },
2186 { },
2187 };
2188 #endif
2189
2190 static __net_init int devinet_init_net(struct net *net)
2191 {
2192 int err;
2193 struct ipv4_devconf *all, *dflt;
2194 #ifdef CONFIG_SYSCTL
2195 struct ctl_table *tbl = ctl_forward_entry;
2196 struct ctl_table_header *forw_hdr;
2197 #endif
2198
2199 err = -ENOMEM;
2200 all = &ipv4_devconf;
2201 dflt = &ipv4_devconf_dflt;
2202
2203 if (!net_eq(net, &init_net)) {
2204 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2205 if (all == NULL)
2206 goto err_alloc_all;
2207
2208 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2209 if (dflt == NULL)
2210 goto err_alloc_dflt;
2211
2212 #ifdef CONFIG_SYSCTL
2213 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2214 if (tbl == NULL)
2215 goto err_alloc_ctl;
2216
2217 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2218 tbl[0].extra1 = all;
2219 tbl[0].extra2 = net;
2220 #endif
2221 }
2222
2223 #ifdef CONFIG_SYSCTL
2224 err = __devinet_sysctl_register(net, "all", all);
2225 if (err < 0)
2226 goto err_reg_all;
2227
2228 err = __devinet_sysctl_register(net, "default", dflt);
2229 if (err < 0)
2230 goto err_reg_dflt;
2231
2232 err = -ENOMEM;
2233 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2234 if (forw_hdr == NULL)
2235 goto err_reg_ctl;
2236 net->ipv4.forw_hdr = forw_hdr;
2237 #endif
2238
2239 net->ipv4.devconf_all = all;
2240 net->ipv4.devconf_dflt = dflt;
2241 return 0;
2242
2243 #ifdef CONFIG_SYSCTL
2244 err_reg_ctl:
2245 __devinet_sysctl_unregister(dflt);
2246 err_reg_dflt:
2247 __devinet_sysctl_unregister(all);
2248 err_reg_all:
2249 if (tbl != ctl_forward_entry)
2250 kfree(tbl);
2251 err_alloc_ctl:
2252 #endif
2253 if (dflt != &ipv4_devconf_dflt)
2254 kfree(dflt);
2255 err_alloc_dflt:
2256 if (all != &ipv4_devconf)
2257 kfree(all);
2258 err_alloc_all:
2259 return err;
2260 }
2261
2262 static __net_exit void devinet_exit_net(struct net *net)
2263 {
2264 #ifdef CONFIG_SYSCTL
2265 struct ctl_table *tbl;
2266
2267 tbl = net->ipv4.forw_hdr->ctl_table_arg;
2268 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2269 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
2270 __devinet_sysctl_unregister(net->ipv4.devconf_all);
2271 kfree(tbl);
2272 #endif
2273 kfree(net->ipv4.devconf_dflt);
2274 kfree(net->ipv4.devconf_all);
2275 }
2276
2277 static __net_initdata struct pernet_operations devinet_ops = {
2278 .init = devinet_init_net,
2279 .exit = devinet_exit_net,
2280 };
2281
2282 static struct rtnl_af_ops inet_af_ops = {
2283 .family = AF_INET,
2284 .fill_link_af = inet_fill_link_af,
2285 .get_link_af_size = inet_get_link_af_size,
2286 .validate_link_af = inet_validate_link_af,
2287 .set_link_af = inet_set_link_af,
2288 };
2289
2290 void __init devinet_init(void)
2291 {
2292 int i;
2293
2294 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2295 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2296
2297 register_pernet_subsys(&devinet_ops);
2298
2299 register_gifconf(PF_INET, inet_gifconf);
2300 register_netdevice_notifier(&ip_netdev_notifier);
2301
2302 schedule_delayed_work(&check_lifetime_work, 0);
2303
2304 rtnl_af_register(&inet_af_ops);
2305
2306 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
2307 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
2308 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
2309 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2310 inet_netconf_dump_devconf, NULL);
2311 }
2312
Linux with added FPC-III support