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