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