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