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