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