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