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