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