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