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