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