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