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