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