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