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