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