]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - net/ipv4/devinet.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'efi-urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/efi/efi into...
[mirror_ubuntu-artful-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 if (err < 0)
587 goto errout;
588
589 ifm = nlmsg_data(nlh);
590 in_dev = inetdev_by_index(net, ifm->ifa_index);
591 if (!in_dev) {
592 err = -ENODEV;
593 goto errout;
594 }
595
596 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
597 ifap = &ifa->ifa_next) {
598 if (tb[IFA_LOCAL] &&
599 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
600 continue;
601
602 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
603 continue;
604
605 if (tb[IFA_ADDRESS] &&
606 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
607 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
608 continue;
609
610 if (ipv4_is_multicast(ifa->ifa_address))
611 ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
612 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
613 return 0;
614 }
615
616 err = -EADDRNOTAVAIL;
617 errout:
618 return err;
619 }
620
621 #define INFINITY_LIFE_TIME 0xFFFFFFFF
622
623 static void check_lifetime(struct work_struct *work)
624 {
625 unsigned long now, next, next_sec, next_sched;
626 struct in_ifaddr *ifa;
627 struct hlist_node *n;
628 int i;
629
630 now = jiffies;
631 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
632
633 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
634 bool change_needed = false;
635
636 rcu_read_lock();
637 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
638 unsigned long age;
639
640 if (ifa->ifa_flags & IFA_F_PERMANENT)
641 continue;
642
643 /* We try to batch several events at once. */
644 age = (now - ifa->ifa_tstamp +
645 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
646
647 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
648 age >= ifa->ifa_valid_lft) {
649 change_needed = true;
650 } else if (ifa->ifa_preferred_lft ==
651 INFINITY_LIFE_TIME) {
652 continue;
653 } else if (age >= ifa->ifa_preferred_lft) {
654 if (time_before(ifa->ifa_tstamp +
655 ifa->ifa_valid_lft * HZ, next))
656 next = ifa->ifa_tstamp +
657 ifa->ifa_valid_lft * HZ;
658
659 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
660 change_needed = true;
661 } else if (time_before(ifa->ifa_tstamp +
662 ifa->ifa_preferred_lft * HZ,
663 next)) {
664 next = ifa->ifa_tstamp +
665 ifa->ifa_preferred_lft * HZ;
666 }
667 }
668 rcu_read_unlock();
669 if (!change_needed)
670 continue;
671 rtnl_lock();
672 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
673 unsigned long age;
674
675 if (ifa->ifa_flags & IFA_F_PERMANENT)
676 continue;
677
678 /* We try to batch several events at once. */
679 age = (now - ifa->ifa_tstamp +
680 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
681
682 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
683 age >= ifa->ifa_valid_lft) {
684 struct in_ifaddr **ifap;
685
686 for (ifap = &ifa->ifa_dev->ifa_list;
687 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
688 if (*ifap == ifa) {
689 inet_del_ifa(ifa->ifa_dev,
690 ifap, 1);
691 break;
692 }
693 }
694 } else if (ifa->ifa_preferred_lft !=
695 INFINITY_LIFE_TIME &&
696 age >= ifa->ifa_preferred_lft &&
697 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
698 ifa->ifa_flags |= IFA_F_DEPRECATED;
699 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
700 }
701 }
702 rtnl_unlock();
703 }
704
705 next_sec = round_jiffies_up(next);
706 next_sched = next;
707
708 /* If rounded timeout is accurate enough, accept it. */
709 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
710 next_sched = next_sec;
711
712 now = jiffies;
713 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
714 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
715 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
716
717 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
718 next_sched - now);
719 }
720
721 static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
722 __u32 prefered_lft)
723 {
724 unsigned long timeout;
725
726 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
727
728 timeout = addrconf_timeout_fixup(valid_lft, HZ);
729 if (addrconf_finite_timeout(timeout))
730 ifa->ifa_valid_lft = timeout;
731 else
732 ifa->ifa_flags |= IFA_F_PERMANENT;
733
734 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
735 if (addrconf_finite_timeout(timeout)) {
736 if (timeout == 0)
737 ifa->ifa_flags |= IFA_F_DEPRECATED;
738 ifa->ifa_preferred_lft = timeout;
739 }
740 ifa->ifa_tstamp = jiffies;
741 if (!ifa->ifa_cstamp)
742 ifa->ifa_cstamp = ifa->ifa_tstamp;
743 }
744
745 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
746 __u32 *pvalid_lft, __u32 *pprefered_lft)
747 {
748 struct nlattr *tb[IFA_MAX+1];
749 struct in_ifaddr *ifa;
750 struct ifaddrmsg *ifm;
751 struct net_device *dev;
752 struct in_device *in_dev;
753 int err;
754
755 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
756 if (err < 0)
757 goto errout;
758
759 ifm = nlmsg_data(nlh);
760 err = -EINVAL;
761 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
762 goto errout;
763
764 dev = __dev_get_by_index(net, ifm->ifa_index);
765 err = -ENODEV;
766 if (!dev)
767 goto errout;
768
769 in_dev = __in_dev_get_rtnl(dev);
770 err = -ENOBUFS;
771 if (!in_dev)
772 goto errout;
773
774 ifa = inet_alloc_ifa();
775 if (!ifa)
776 /*
777 * A potential indev allocation can be left alive, it stays
778 * assigned to its device and is destroy with it.
779 */
780 goto errout;
781
782 ipv4_devconf_setall(in_dev);
783 neigh_parms_data_state_setall(in_dev->arp_parms);
784 in_dev_hold(in_dev);
785
786 if (!tb[IFA_ADDRESS])
787 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
788
789 INIT_HLIST_NODE(&ifa->hash);
790 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
791 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
792 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
793 ifm->ifa_flags;
794 ifa->ifa_scope = ifm->ifa_scope;
795 ifa->ifa_dev = in_dev;
796
797 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
798 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
799
800 if (tb[IFA_BROADCAST])
801 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
802
803 if (tb[IFA_LABEL])
804 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
805 else
806 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
807
808 if (tb[IFA_CACHEINFO]) {
809 struct ifa_cacheinfo *ci;
810
811 ci = nla_data(tb[IFA_CACHEINFO]);
812 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
813 err = -EINVAL;
814 goto errout_free;
815 }
816 *pvalid_lft = ci->ifa_valid;
817 *pprefered_lft = ci->ifa_prefered;
818 }
819
820 return ifa;
821
822 errout_free:
823 inet_free_ifa(ifa);
824 errout:
825 return ERR_PTR(err);
826 }
827
828 static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
829 {
830 struct in_device *in_dev = ifa->ifa_dev;
831 struct in_ifaddr *ifa1, **ifap;
832
833 if (!ifa->ifa_local)
834 return NULL;
835
836 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
837 ifap = &ifa1->ifa_next) {
838 if (ifa1->ifa_mask == ifa->ifa_mask &&
839 inet_ifa_match(ifa1->ifa_address, ifa) &&
840 ifa1->ifa_local == ifa->ifa_local)
841 return ifa1;
842 }
843 return NULL;
844 }
845
846 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
847 {
848 struct net *net = sock_net(skb->sk);
849 struct in_ifaddr *ifa;
850 struct in_ifaddr *ifa_existing;
851 __u32 valid_lft = INFINITY_LIFE_TIME;
852 __u32 prefered_lft = INFINITY_LIFE_TIME;
853
854 ASSERT_RTNL();
855
856 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
857 if (IS_ERR(ifa))
858 return PTR_ERR(ifa);
859
860 ifa_existing = find_matching_ifa(ifa);
861 if (!ifa_existing) {
862 /* It would be best to check for !NLM_F_CREATE here but
863 * userspace already relies on not having to provide this.
864 */
865 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
866 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
867 int ret = ip_mc_config(net->ipv4.mc_autojoin_sk,
868 true, ifa);
869
870 if (ret < 0) {
871 inet_free_ifa(ifa);
872 return ret;
873 }
874 }
875 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
876 } else {
877 inet_free_ifa(ifa);
878
879 if (nlh->nlmsg_flags & NLM_F_EXCL ||
880 !(nlh->nlmsg_flags & NLM_F_REPLACE))
881 return -EEXIST;
882 ifa = ifa_existing;
883 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
884 cancel_delayed_work(&check_lifetime_work);
885 queue_delayed_work(system_power_efficient_wq,
886 &check_lifetime_work, 0);
887 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
888 }
889 return 0;
890 }
891
892 /*
893 * Determine a default network mask, based on the IP address.
894 */
895
896 static int inet_abc_len(__be32 addr)
897 {
898 int rc = -1; /* Something else, probably a multicast. */
899
900 if (ipv4_is_zeronet(addr))
901 rc = 0;
902 else {
903 __u32 haddr = ntohl(addr);
904
905 if (IN_CLASSA(haddr))
906 rc = 8;
907 else if (IN_CLASSB(haddr))
908 rc = 16;
909 else if (IN_CLASSC(haddr))
910 rc = 24;
911 }
912
913 return rc;
914 }
915
916
917 int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
918 {
919 struct ifreq ifr;
920 struct sockaddr_in sin_orig;
921 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
922 struct in_device *in_dev;
923 struct in_ifaddr **ifap = NULL;
924 struct in_ifaddr *ifa = NULL;
925 struct net_device *dev;
926 char *colon;
927 int ret = -EFAULT;
928 int tryaddrmatch = 0;
929
930 /*
931 * Fetch the caller's info block into kernel space
932 */
933
934 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
935 goto out;
936 ifr.ifr_name[IFNAMSIZ - 1] = 0;
937
938 /* save original address for comparison */
939 memcpy(&sin_orig, sin, sizeof(*sin));
940
941 colon = strchr(ifr.ifr_name, ':');
942 if (colon)
943 *colon = 0;
944
945 dev_load(net, ifr.ifr_name);
946
947 switch (cmd) {
948 case SIOCGIFADDR: /* Get interface address */
949 case SIOCGIFBRDADDR: /* Get the broadcast address */
950 case SIOCGIFDSTADDR: /* Get the destination address */
951 case SIOCGIFNETMASK: /* Get the netmask for the interface */
952 /* Note that these ioctls will not sleep,
953 so that we do not impose a lock.
954 One day we will be forced to put shlock here (I mean SMP)
955 */
956 tryaddrmatch = (sin_orig.sin_family == AF_INET);
957 memset(sin, 0, sizeof(*sin));
958 sin->sin_family = AF_INET;
959 break;
960
961 case SIOCSIFFLAGS:
962 ret = -EPERM;
963 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
964 goto out;
965 break;
966 case SIOCSIFADDR: /* Set interface address (and family) */
967 case SIOCSIFBRDADDR: /* Set the broadcast address */
968 case SIOCSIFDSTADDR: /* Set the destination address */
969 case SIOCSIFNETMASK: /* Set the netmask for the interface */
970 ret = -EPERM;
971 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
972 goto out;
973 ret = -EINVAL;
974 if (sin->sin_family != AF_INET)
975 goto out;
976 break;
977 default:
978 ret = -EINVAL;
979 goto out;
980 }
981
982 rtnl_lock();
983
984 ret = -ENODEV;
985 dev = __dev_get_by_name(net, ifr.ifr_name);
986 if (!dev)
987 goto done;
988
989 if (colon)
990 *colon = ':';
991
992 in_dev = __in_dev_get_rtnl(dev);
993 if (in_dev) {
994 if (tryaddrmatch) {
995 /* Matthias Andree */
996 /* compare label and address (4.4BSD style) */
997 /* note: we only do this for a limited set of ioctls
998 and only if the original address family was AF_INET.
999 This is checked above. */
1000 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1001 ifap = &ifa->ifa_next) {
1002 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
1003 sin_orig.sin_addr.s_addr ==
1004 ifa->ifa_local) {
1005 break; /* found */
1006 }
1007 }
1008 }
1009 /* we didn't get a match, maybe the application is
1010 4.3BSD-style and passed in junk so we fall back to
1011 comparing just the label */
1012 if (!ifa) {
1013 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1014 ifap = &ifa->ifa_next)
1015 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
1016 break;
1017 }
1018 }
1019
1020 ret = -EADDRNOTAVAIL;
1021 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
1022 goto done;
1023
1024 switch (cmd) {
1025 case SIOCGIFADDR: /* Get interface address */
1026 sin->sin_addr.s_addr = ifa->ifa_local;
1027 goto rarok;
1028
1029 case SIOCGIFBRDADDR: /* Get the broadcast address */
1030 sin->sin_addr.s_addr = ifa->ifa_broadcast;
1031 goto rarok;
1032
1033 case SIOCGIFDSTADDR: /* Get the destination address */
1034 sin->sin_addr.s_addr = ifa->ifa_address;
1035 goto rarok;
1036
1037 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1038 sin->sin_addr.s_addr = ifa->ifa_mask;
1039 goto rarok;
1040
1041 case SIOCSIFFLAGS:
1042 if (colon) {
1043 ret = -EADDRNOTAVAIL;
1044 if (!ifa)
1045 break;
1046 ret = 0;
1047 if (!(ifr.ifr_flags & IFF_UP))
1048 inet_del_ifa(in_dev, ifap, 1);
1049 break;
1050 }
1051 ret = dev_change_flags(dev, ifr.ifr_flags);
1052 break;
1053
1054 case SIOCSIFADDR: /* Set interface address (and family) */
1055 ret = -EINVAL;
1056 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1057 break;
1058
1059 if (!ifa) {
1060 ret = -ENOBUFS;
1061 ifa = inet_alloc_ifa();
1062 if (!ifa)
1063 break;
1064 INIT_HLIST_NODE(&ifa->hash);
1065 if (colon)
1066 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1067 else
1068 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1069 } else {
1070 ret = 0;
1071 if (ifa->ifa_local == sin->sin_addr.s_addr)
1072 break;
1073 inet_del_ifa(in_dev, ifap, 0);
1074 ifa->ifa_broadcast = 0;
1075 ifa->ifa_scope = 0;
1076 }
1077
1078 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1079
1080 if (!(dev->flags & IFF_POINTOPOINT)) {
1081 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1082 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1083 if ((dev->flags & IFF_BROADCAST) &&
1084 ifa->ifa_prefixlen < 31)
1085 ifa->ifa_broadcast = ifa->ifa_address |
1086 ~ifa->ifa_mask;
1087 } else {
1088 ifa->ifa_prefixlen = 32;
1089 ifa->ifa_mask = inet_make_mask(32);
1090 }
1091 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
1092 ret = inet_set_ifa(dev, ifa);
1093 break;
1094
1095 case SIOCSIFBRDADDR: /* Set the broadcast address */
1096 ret = 0;
1097 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1098 inet_del_ifa(in_dev, ifap, 0);
1099 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1100 inet_insert_ifa(ifa);
1101 }
1102 break;
1103
1104 case SIOCSIFDSTADDR: /* Set the destination address */
1105 ret = 0;
1106 if (ifa->ifa_address == sin->sin_addr.s_addr)
1107 break;
1108 ret = -EINVAL;
1109 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1110 break;
1111 ret = 0;
1112 inet_del_ifa(in_dev, ifap, 0);
1113 ifa->ifa_address = sin->sin_addr.s_addr;
1114 inet_insert_ifa(ifa);
1115 break;
1116
1117 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1118
1119 /*
1120 * The mask we set must be legal.
1121 */
1122 ret = -EINVAL;
1123 if (bad_mask(sin->sin_addr.s_addr, 0))
1124 break;
1125 ret = 0;
1126 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
1127 __be32 old_mask = ifa->ifa_mask;
1128 inet_del_ifa(in_dev, ifap, 0);
1129 ifa->ifa_mask = sin->sin_addr.s_addr;
1130 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1131
1132 /* See if current broadcast address matches
1133 * with current netmask, then recalculate
1134 * the broadcast address. Otherwise it's a
1135 * funny address, so don't touch it since
1136 * the user seems to know what (s)he's doing...
1137 */
1138 if ((dev->flags & IFF_BROADCAST) &&
1139 (ifa->ifa_prefixlen < 31) &&
1140 (ifa->ifa_broadcast ==
1141 (ifa->ifa_local|~old_mask))) {
1142 ifa->ifa_broadcast = (ifa->ifa_local |
1143 ~sin->sin_addr.s_addr);
1144 }
1145 inet_insert_ifa(ifa);
1146 }
1147 break;
1148 }
1149 done:
1150 rtnl_unlock();
1151 out:
1152 return ret;
1153 rarok:
1154 rtnl_unlock();
1155 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1156 goto out;
1157 }
1158
1159 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1160 {
1161 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1162 struct in_ifaddr *ifa;
1163 struct ifreq ifr;
1164 int done = 0;
1165
1166 if (!in_dev)
1167 goto out;
1168
1169 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1170 if (!buf) {
1171 done += sizeof(ifr);
1172 continue;
1173 }
1174 if (len < (int) sizeof(ifr))
1175 break;
1176 memset(&ifr, 0, sizeof(struct ifreq));
1177 strcpy(ifr.ifr_name, ifa->ifa_label);
1178
1179 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1180 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1181 ifa->ifa_local;
1182
1183 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1184 done = -EFAULT;
1185 break;
1186 }
1187 buf += sizeof(struct ifreq);
1188 len -= sizeof(struct ifreq);
1189 done += sizeof(struct ifreq);
1190 }
1191 out:
1192 return done;
1193 }
1194
1195 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
1196 {
1197 __be32 addr = 0;
1198 struct in_device *in_dev;
1199 struct net *net = dev_net(dev);
1200 int master_idx;
1201
1202 rcu_read_lock();
1203 in_dev = __in_dev_get_rcu(dev);
1204 if (!in_dev)
1205 goto no_in_dev;
1206
1207 for_primary_ifa(in_dev) {
1208 if (ifa->ifa_scope > scope)
1209 continue;
1210 if (!dst || inet_ifa_match(dst, ifa)) {
1211 addr = ifa->ifa_local;
1212 break;
1213 }
1214 if (!addr)
1215 addr = ifa->ifa_local;
1216 } endfor_ifa(in_dev);
1217
1218 if (addr)
1219 goto out_unlock;
1220 no_in_dev:
1221 master_idx = l3mdev_master_ifindex_rcu(dev);
1222
1223 /* For VRFs, the VRF device takes the place of the loopback device,
1224 * with addresses on it being preferred. Note in such cases the
1225 * loopback device will be among the devices that fail the master_idx
1226 * equality check in the loop below.
1227 */
1228 if (master_idx &&
1229 (dev = dev_get_by_index_rcu(net, master_idx)) &&
1230 (in_dev = __in_dev_get_rcu(dev))) {
1231 for_primary_ifa(in_dev) {
1232 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1233 ifa->ifa_scope <= scope) {
1234 addr = ifa->ifa_local;
1235 goto out_unlock;
1236 }
1237 } endfor_ifa(in_dev);
1238 }
1239
1240 /* Not loopback addresses on loopback should be preferred
1241 in this case. It is important that lo is the first interface
1242 in dev_base list.
1243 */
1244 for_each_netdev_rcu(net, dev) {
1245 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1246 continue;
1247
1248 in_dev = __in_dev_get_rcu(dev);
1249 if (!in_dev)
1250 continue;
1251
1252 for_primary_ifa(in_dev) {
1253 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1254 ifa->ifa_scope <= scope) {
1255 addr = ifa->ifa_local;
1256 goto out_unlock;
1257 }
1258 } endfor_ifa(in_dev);
1259 }
1260 out_unlock:
1261 rcu_read_unlock();
1262 return addr;
1263 }
1264 EXPORT_SYMBOL(inet_select_addr);
1265
1266 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1267 __be32 local, int scope)
1268 {
1269 int same = 0;
1270 __be32 addr = 0;
1271
1272 for_ifa(in_dev) {
1273 if (!addr &&
1274 (local == ifa->ifa_local || !local) &&
1275 ifa->ifa_scope <= scope) {
1276 addr = ifa->ifa_local;
1277 if (same)
1278 break;
1279 }
1280 if (!same) {
1281 same = (!local || inet_ifa_match(local, ifa)) &&
1282 (!dst || inet_ifa_match(dst, ifa));
1283 if (same && addr) {
1284 if (local || !dst)
1285 break;
1286 /* Is the selected addr into dst subnet? */
1287 if (inet_ifa_match(addr, ifa))
1288 break;
1289 /* No, then can we use new local src? */
1290 if (ifa->ifa_scope <= scope) {
1291 addr = ifa->ifa_local;
1292 break;
1293 }
1294 /* search for large dst subnet for addr */
1295 same = 0;
1296 }
1297 }
1298 } endfor_ifa(in_dev);
1299
1300 return same ? addr : 0;
1301 }
1302
1303 /*
1304 * Confirm that local IP address exists using wildcards:
1305 * - net: netns to check, cannot be NULL
1306 * - in_dev: only on this interface, NULL=any interface
1307 * - dst: only in the same subnet as dst, 0=any dst
1308 * - local: address, 0=autoselect the local address
1309 * - scope: maximum allowed scope value for the local address
1310 */
1311 __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1312 __be32 dst, __be32 local, int scope)
1313 {
1314 __be32 addr = 0;
1315 struct net_device *dev;
1316
1317 if (in_dev)
1318 return confirm_addr_indev(in_dev, dst, local, scope);
1319
1320 rcu_read_lock();
1321 for_each_netdev_rcu(net, dev) {
1322 in_dev = __in_dev_get_rcu(dev);
1323 if (in_dev) {
1324 addr = confirm_addr_indev(in_dev, dst, local, scope);
1325 if (addr)
1326 break;
1327 }
1328 }
1329 rcu_read_unlock();
1330
1331 return addr;
1332 }
1333 EXPORT_SYMBOL(inet_confirm_addr);
1334
1335 /*
1336 * Device notifier
1337 */
1338
1339 int register_inetaddr_notifier(struct notifier_block *nb)
1340 {
1341 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1342 }
1343 EXPORT_SYMBOL(register_inetaddr_notifier);
1344
1345 int unregister_inetaddr_notifier(struct notifier_block *nb)
1346 {
1347 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1348 }
1349 EXPORT_SYMBOL(unregister_inetaddr_notifier);
1350
1351 /* Rename ifa_labels for a device name change. Make some effort to preserve
1352 * existing alias numbering and to create unique labels if possible.
1353 */
1354 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1355 {
1356 struct in_ifaddr *ifa;
1357 int named = 0;
1358
1359 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1360 char old[IFNAMSIZ], *dot;
1361
1362 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1363 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1364 if (named++ == 0)
1365 goto skip;
1366 dot = strchr(old, ':');
1367 if (!dot) {
1368 sprintf(old, ":%d", named);
1369 dot = old;
1370 }
1371 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1372 strcat(ifa->ifa_label, dot);
1373 else
1374 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1375 skip:
1376 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1377 }
1378 }
1379
1380 static bool inetdev_valid_mtu(unsigned int mtu)
1381 {
1382 return mtu >= 68;
1383 }
1384
1385 static void inetdev_send_gratuitous_arp(struct net_device *dev,
1386 struct in_device *in_dev)
1387
1388 {
1389 struct in_ifaddr *ifa;
1390
1391 for (ifa = in_dev->ifa_list; ifa;
1392 ifa = ifa->ifa_next) {
1393 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1394 ifa->ifa_local, dev,
1395 ifa->ifa_local, NULL,
1396 dev->dev_addr, NULL);
1397 }
1398 }
1399
1400 /* Called only under RTNL semaphore */
1401
1402 static int inetdev_event(struct notifier_block *this, unsigned long event,
1403 void *ptr)
1404 {
1405 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1406 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1407
1408 ASSERT_RTNL();
1409
1410 if (!in_dev) {
1411 if (event == NETDEV_REGISTER) {
1412 in_dev = inetdev_init(dev);
1413 if (IS_ERR(in_dev))
1414 return notifier_from_errno(PTR_ERR(in_dev));
1415 if (dev->flags & IFF_LOOPBACK) {
1416 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1417 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1418 }
1419 } else if (event == NETDEV_CHANGEMTU) {
1420 /* Re-enabling IP */
1421 if (inetdev_valid_mtu(dev->mtu))
1422 in_dev = inetdev_init(dev);
1423 }
1424 goto out;
1425 }
1426
1427 switch (event) {
1428 case NETDEV_REGISTER:
1429 pr_debug("%s: bug\n", __func__);
1430 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1431 break;
1432 case NETDEV_UP:
1433 if (!inetdev_valid_mtu(dev->mtu))
1434 break;
1435 if (dev->flags & IFF_LOOPBACK) {
1436 struct in_ifaddr *ifa = inet_alloc_ifa();
1437
1438 if (ifa) {
1439 INIT_HLIST_NODE(&ifa->hash);
1440 ifa->ifa_local =
1441 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1442 ifa->ifa_prefixlen = 8;
1443 ifa->ifa_mask = inet_make_mask(8);
1444 in_dev_hold(in_dev);
1445 ifa->ifa_dev = in_dev;
1446 ifa->ifa_scope = RT_SCOPE_HOST;
1447 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1448 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1449 INFINITY_LIFE_TIME);
1450 ipv4_devconf_setall(in_dev);
1451 neigh_parms_data_state_setall(in_dev->arp_parms);
1452 inet_insert_ifa(ifa);
1453 }
1454 }
1455 ip_mc_up(in_dev);
1456 /* fall through */
1457 case NETDEV_CHANGEADDR:
1458 if (!IN_DEV_ARP_NOTIFY(in_dev))
1459 break;
1460 /* fall through */
1461 case NETDEV_NOTIFY_PEERS:
1462 /* Send gratuitous ARP to notify of link change */
1463 inetdev_send_gratuitous_arp(dev, in_dev);
1464 break;
1465 case NETDEV_DOWN:
1466 ip_mc_down(in_dev);
1467 break;
1468 case NETDEV_PRE_TYPE_CHANGE:
1469 ip_mc_unmap(in_dev);
1470 break;
1471 case NETDEV_POST_TYPE_CHANGE:
1472 ip_mc_remap(in_dev);
1473 break;
1474 case NETDEV_CHANGEMTU:
1475 if (inetdev_valid_mtu(dev->mtu))
1476 break;
1477 /* disable IP when MTU is not enough */
1478 case NETDEV_UNREGISTER:
1479 inetdev_destroy(in_dev);
1480 break;
1481 case NETDEV_CHANGENAME:
1482 /* Do not notify about label change, this event is
1483 * not interesting to applications using netlink.
1484 */
1485 inetdev_changename(dev, in_dev);
1486
1487 devinet_sysctl_unregister(in_dev);
1488 devinet_sysctl_register(in_dev);
1489 break;
1490 }
1491 out:
1492 return NOTIFY_DONE;
1493 }
1494
1495 static struct notifier_block ip_netdev_notifier = {
1496 .notifier_call = inetdev_event,
1497 };
1498
1499 static size_t inet_nlmsg_size(void)
1500 {
1501 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1502 + nla_total_size(4) /* IFA_ADDRESS */
1503 + nla_total_size(4) /* IFA_LOCAL */
1504 + nla_total_size(4) /* IFA_BROADCAST */
1505 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1506 + nla_total_size(4) /* IFA_FLAGS */
1507 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1508 }
1509
1510 static inline u32 cstamp_delta(unsigned long cstamp)
1511 {
1512 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1513 }
1514
1515 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1516 unsigned long tstamp, u32 preferred, u32 valid)
1517 {
1518 struct ifa_cacheinfo ci;
1519
1520 ci.cstamp = cstamp_delta(cstamp);
1521 ci.tstamp = cstamp_delta(tstamp);
1522 ci.ifa_prefered = preferred;
1523 ci.ifa_valid = valid;
1524
1525 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1526 }
1527
1528 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1529 u32 portid, u32 seq, int event, unsigned int flags)
1530 {
1531 struct ifaddrmsg *ifm;
1532 struct nlmsghdr *nlh;
1533 u32 preferred, valid;
1534
1535 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1536 if (!nlh)
1537 return -EMSGSIZE;
1538
1539 ifm = nlmsg_data(nlh);
1540 ifm->ifa_family = AF_INET;
1541 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1542 ifm->ifa_flags = ifa->ifa_flags;
1543 ifm->ifa_scope = ifa->ifa_scope;
1544 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1545
1546 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1547 preferred = ifa->ifa_preferred_lft;
1548 valid = ifa->ifa_valid_lft;
1549 if (preferred != INFINITY_LIFE_TIME) {
1550 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1551
1552 if (preferred > tval)
1553 preferred -= tval;
1554 else
1555 preferred = 0;
1556 if (valid != INFINITY_LIFE_TIME) {
1557 if (valid > tval)
1558 valid -= tval;
1559 else
1560 valid = 0;
1561 }
1562 }
1563 } else {
1564 preferred = INFINITY_LIFE_TIME;
1565 valid = INFINITY_LIFE_TIME;
1566 }
1567 if ((ifa->ifa_address &&
1568 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1569 (ifa->ifa_local &&
1570 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
1571 (ifa->ifa_broadcast &&
1572 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1573 (ifa->ifa_label[0] &&
1574 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1575 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
1576 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1577 preferred, valid))
1578 goto nla_put_failure;
1579
1580 nlmsg_end(skb, nlh);
1581 return 0;
1582
1583 nla_put_failure:
1584 nlmsg_cancel(skb, nlh);
1585 return -EMSGSIZE;
1586 }
1587
1588 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1589 {
1590 struct net *net = sock_net(skb->sk);
1591 int h, s_h;
1592 int idx, s_idx;
1593 int ip_idx, s_ip_idx;
1594 struct net_device *dev;
1595 struct in_device *in_dev;
1596 struct in_ifaddr *ifa;
1597 struct hlist_head *head;
1598
1599 s_h = cb->args[0];
1600 s_idx = idx = cb->args[1];
1601 s_ip_idx = ip_idx = cb->args[2];
1602
1603 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1604 idx = 0;
1605 head = &net->dev_index_head[h];
1606 rcu_read_lock();
1607 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1608 net->dev_base_seq;
1609 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1610 if (idx < s_idx)
1611 goto cont;
1612 if (h > s_h || idx > s_idx)
1613 s_ip_idx = 0;
1614 in_dev = __in_dev_get_rcu(dev);
1615 if (!in_dev)
1616 goto cont;
1617
1618 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1619 ifa = ifa->ifa_next, ip_idx++) {
1620 if (ip_idx < s_ip_idx)
1621 continue;
1622 if (inet_fill_ifaddr(skb, ifa,
1623 NETLINK_CB(cb->skb).portid,
1624 cb->nlh->nlmsg_seq,
1625 RTM_NEWADDR, NLM_F_MULTI) < 0) {
1626 rcu_read_unlock();
1627 goto done;
1628 }
1629 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1630 }
1631 cont:
1632 idx++;
1633 }
1634 rcu_read_unlock();
1635 }
1636
1637 done:
1638 cb->args[0] = h;
1639 cb->args[1] = idx;
1640 cb->args[2] = ip_idx;
1641
1642 return skb->len;
1643 }
1644
1645 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1646 u32 portid)
1647 {
1648 struct sk_buff *skb;
1649 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1650 int err = -ENOBUFS;
1651 struct net *net;
1652
1653 net = dev_net(ifa->ifa_dev->dev);
1654 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1655 if (!skb)
1656 goto errout;
1657
1658 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1659 if (err < 0) {
1660 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1661 WARN_ON(err == -EMSGSIZE);
1662 kfree_skb(skb);
1663 goto errout;
1664 }
1665 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1666 return;
1667 errout:
1668 if (err < 0)
1669 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1670 }
1671
1672 static size_t inet_get_link_af_size(const struct net_device *dev,
1673 u32 ext_filter_mask)
1674 {
1675 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1676
1677 if (!in_dev)
1678 return 0;
1679
1680 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1681 }
1682
1683 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1684 u32 ext_filter_mask)
1685 {
1686 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1687 struct nlattr *nla;
1688 int i;
1689
1690 if (!in_dev)
1691 return -ENODATA;
1692
1693 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1694 if (!nla)
1695 return -EMSGSIZE;
1696
1697 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1698 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1699
1700 return 0;
1701 }
1702
1703 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1704 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1705 };
1706
1707 static int inet_validate_link_af(const struct net_device *dev,
1708 const struct nlattr *nla)
1709 {
1710 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1711 int err, rem;
1712
1713 if (dev && !__in_dev_get_rtnl(dev))
1714 return -EAFNOSUPPORT;
1715
1716 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1717 if (err < 0)
1718 return err;
1719
1720 if (tb[IFLA_INET_CONF]) {
1721 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1722 int cfgid = nla_type(a);
1723
1724 if (nla_len(a) < 4)
1725 return -EINVAL;
1726
1727 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1728 return -EINVAL;
1729 }
1730 }
1731
1732 return 0;
1733 }
1734
1735 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1736 {
1737 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1738 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1739 int rem;
1740
1741 if (!in_dev)
1742 return -EAFNOSUPPORT;
1743
1744 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1745 BUG();
1746
1747 if (tb[IFLA_INET_CONF]) {
1748 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1749 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1750 }
1751
1752 return 0;
1753 }
1754
1755 static int inet_netconf_msgsize_devconf(int type)
1756 {
1757 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1758 + nla_total_size(4); /* NETCONFA_IFINDEX */
1759 bool all = false;
1760
1761 if (type == NETCONFA_ALL)
1762 all = true;
1763
1764 if (all || type == NETCONFA_FORWARDING)
1765 size += nla_total_size(4);
1766 if (all || type == NETCONFA_RP_FILTER)
1767 size += nla_total_size(4);
1768 if (all || type == NETCONFA_MC_FORWARDING)
1769 size += nla_total_size(4);
1770 if (all || type == NETCONFA_PROXY_NEIGH)
1771 size += nla_total_size(4);
1772 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
1773 size += nla_total_size(4);
1774
1775 return size;
1776 }
1777
1778 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1779 struct ipv4_devconf *devconf, u32 portid,
1780 u32 seq, int event, unsigned int flags,
1781 int type)
1782 {
1783 struct nlmsghdr *nlh;
1784 struct netconfmsg *ncm;
1785 bool all = false;
1786
1787 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1788 flags);
1789 if (!nlh)
1790 return -EMSGSIZE;
1791
1792 if (type == NETCONFA_ALL)
1793 all = true;
1794
1795 ncm = nlmsg_data(nlh);
1796 ncm->ncm_family = AF_INET;
1797
1798 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1799 goto nla_put_failure;
1800
1801 if ((all || type == NETCONFA_FORWARDING) &&
1802 nla_put_s32(skb, NETCONFA_FORWARDING,
1803 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1804 goto nla_put_failure;
1805 if ((all || type == NETCONFA_RP_FILTER) &&
1806 nla_put_s32(skb, NETCONFA_RP_FILTER,
1807 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1808 goto nla_put_failure;
1809 if ((all || type == NETCONFA_MC_FORWARDING) &&
1810 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1811 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1812 goto nla_put_failure;
1813 if ((all || type == NETCONFA_PROXY_NEIGH) &&
1814 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
1815 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1816 goto nla_put_failure;
1817 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
1818 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
1819 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
1820 goto nla_put_failure;
1821
1822 nlmsg_end(skb, nlh);
1823 return 0;
1824
1825 nla_put_failure:
1826 nlmsg_cancel(skb, nlh);
1827 return -EMSGSIZE;
1828 }
1829
1830 void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
1831 struct ipv4_devconf *devconf)
1832 {
1833 struct sk_buff *skb;
1834 int err = -ENOBUFS;
1835
1836 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
1837 if (!skb)
1838 goto errout;
1839
1840 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1841 RTM_NEWNETCONF, 0, type);
1842 if (err < 0) {
1843 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1844 WARN_ON(err == -EMSGSIZE);
1845 kfree_skb(skb);
1846 goto errout;
1847 }
1848 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
1849 return;
1850 errout:
1851 if (err < 0)
1852 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1853 }
1854
1855 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1856 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1857 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
1858 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
1859 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
1860 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
1861 };
1862
1863 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1864 struct nlmsghdr *nlh)
1865 {
1866 struct net *net = sock_net(in_skb->sk);
1867 struct nlattr *tb[NETCONFA_MAX+1];
1868 struct netconfmsg *ncm;
1869 struct sk_buff *skb;
1870 struct ipv4_devconf *devconf;
1871 struct in_device *in_dev;
1872 struct net_device *dev;
1873 int ifindex;
1874 int err;
1875
1876 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1877 devconf_ipv4_policy);
1878 if (err < 0)
1879 goto errout;
1880
1881 err = -EINVAL;
1882 if (!tb[NETCONFA_IFINDEX])
1883 goto errout;
1884
1885 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1886 switch (ifindex) {
1887 case NETCONFA_IFINDEX_ALL:
1888 devconf = net->ipv4.devconf_all;
1889 break;
1890 case NETCONFA_IFINDEX_DEFAULT:
1891 devconf = net->ipv4.devconf_dflt;
1892 break;
1893 default:
1894 dev = __dev_get_by_index(net, ifindex);
1895 if (!dev)
1896 goto errout;
1897 in_dev = __in_dev_get_rtnl(dev);
1898 if (!in_dev)
1899 goto errout;
1900 devconf = &in_dev->cnf;
1901 break;
1902 }
1903
1904 err = -ENOBUFS;
1905 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
1906 if (!skb)
1907 goto errout;
1908
1909 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1910 NETLINK_CB(in_skb).portid,
1911 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1912 NETCONFA_ALL);
1913 if (err < 0) {
1914 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1915 WARN_ON(err == -EMSGSIZE);
1916 kfree_skb(skb);
1917 goto errout;
1918 }
1919 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1920 errout:
1921 return err;
1922 }
1923
1924 static int inet_netconf_dump_devconf(struct sk_buff *skb,
1925 struct netlink_callback *cb)
1926 {
1927 struct net *net = sock_net(skb->sk);
1928 int h, s_h;
1929 int idx, s_idx;
1930 struct net_device *dev;
1931 struct in_device *in_dev;
1932 struct hlist_head *head;
1933
1934 s_h = cb->args[0];
1935 s_idx = idx = cb->args[1];
1936
1937 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1938 idx = 0;
1939 head = &net->dev_index_head[h];
1940 rcu_read_lock();
1941 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1942 net->dev_base_seq;
1943 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1944 if (idx < s_idx)
1945 goto cont;
1946 in_dev = __in_dev_get_rcu(dev);
1947 if (!in_dev)
1948 goto cont;
1949
1950 if (inet_netconf_fill_devconf(skb, dev->ifindex,
1951 &in_dev->cnf,
1952 NETLINK_CB(cb->skb).portid,
1953 cb->nlh->nlmsg_seq,
1954 RTM_NEWNETCONF,
1955 NLM_F_MULTI,
1956 NETCONFA_ALL) < 0) {
1957 rcu_read_unlock();
1958 goto done;
1959 }
1960 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1961 cont:
1962 idx++;
1963 }
1964 rcu_read_unlock();
1965 }
1966 if (h == NETDEV_HASHENTRIES) {
1967 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
1968 net->ipv4.devconf_all,
1969 NETLINK_CB(cb->skb).portid,
1970 cb->nlh->nlmsg_seq,
1971 RTM_NEWNETCONF, NLM_F_MULTI,
1972 NETCONFA_ALL) < 0)
1973 goto done;
1974 else
1975 h++;
1976 }
1977 if (h == NETDEV_HASHENTRIES + 1) {
1978 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
1979 net->ipv4.devconf_dflt,
1980 NETLINK_CB(cb->skb).portid,
1981 cb->nlh->nlmsg_seq,
1982 RTM_NEWNETCONF, NLM_F_MULTI,
1983 NETCONFA_ALL) < 0)
1984 goto done;
1985 else
1986 h++;
1987 }
1988 done:
1989 cb->args[0] = h;
1990 cb->args[1] = idx;
1991
1992 return skb->len;
1993 }
1994
1995 #ifdef CONFIG_SYSCTL
1996
1997 static void devinet_copy_dflt_conf(struct net *net, int i)
1998 {
1999 struct net_device *dev;
2000
2001 rcu_read_lock();
2002 for_each_netdev_rcu(net, dev) {
2003 struct in_device *in_dev;
2004
2005 in_dev = __in_dev_get_rcu(dev);
2006 if (in_dev && !test_bit(i, in_dev->cnf.state))
2007 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2008 }
2009 rcu_read_unlock();
2010 }
2011
2012 /* called with RTNL locked */
2013 static void inet_forward_change(struct net *net)
2014 {
2015 struct net_device *dev;
2016 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2017
2018 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2019 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2020 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2021 NETCONFA_IFINDEX_ALL,
2022 net->ipv4.devconf_all);
2023 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2024 NETCONFA_IFINDEX_DEFAULT,
2025 net->ipv4.devconf_dflt);
2026
2027 for_each_netdev(net, dev) {
2028 struct in_device *in_dev;
2029
2030 if (on)
2031 dev_disable_lro(dev);
2032
2033 in_dev = __in_dev_get_rtnl(dev);
2034 if (in_dev) {
2035 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2036 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2037 dev->ifindex, &in_dev->cnf);
2038 }
2039 }
2040 }
2041
2042 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2043 {
2044 if (cnf == net->ipv4.devconf_dflt)
2045 return NETCONFA_IFINDEX_DEFAULT;
2046 else if (cnf == net->ipv4.devconf_all)
2047 return NETCONFA_IFINDEX_ALL;
2048 else {
2049 struct in_device *idev
2050 = container_of(cnf, struct in_device, cnf);
2051 return idev->dev->ifindex;
2052 }
2053 }
2054
2055 static int devinet_conf_proc(struct ctl_table *ctl, int write,
2056 void __user *buffer,
2057 size_t *lenp, loff_t *ppos)
2058 {
2059 int old_value = *(int *)ctl->data;
2060 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2061 int new_value = *(int *)ctl->data;
2062
2063 if (write) {
2064 struct ipv4_devconf *cnf = ctl->extra1;
2065 struct net *net = ctl->extra2;
2066 int i = (int *)ctl->data - cnf->data;
2067 int ifindex;
2068
2069 set_bit(i, cnf->state);
2070
2071 if (cnf == net->ipv4.devconf_dflt)
2072 devinet_copy_dflt_conf(net, i);
2073 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2074 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2075 if ((new_value == 0) && (old_value != 0))
2076 rt_cache_flush(net);
2077
2078 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2079 new_value != old_value) {
2080 ifindex = devinet_conf_ifindex(net, cnf);
2081 inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
2082 ifindex, cnf);
2083 }
2084 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2085 new_value != old_value) {
2086 ifindex = devinet_conf_ifindex(net, cnf);
2087 inet_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
2088 ifindex, cnf);
2089 }
2090 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2091 new_value != old_value) {
2092 ifindex = devinet_conf_ifindex(net, cnf);
2093 inet_netconf_notify_devconf(net, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2094 ifindex, cnf);
2095 }
2096 }
2097
2098 return ret;
2099 }
2100
2101 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2102 void __user *buffer,
2103 size_t *lenp, loff_t *ppos)
2104 {
2105 int *valp = ctl->data;
2106 int val = *valp;
2107 loff_t pos = *ppos;
2108 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2109
2110 if (write && *valp != val) {
2111 struct net *net = ctl->extra2;
2112
2113 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2114 if (!rtnl_trylock()) {
2115 /* Restore the original values before restarting */
2116 *valp = val;
2117 *ppos = pos;
2118 return restart_syscall();
2119 }
2120 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2121 inet_forward_change(net);
2122 } else {
2123 struct ipv4_devconf *cnf = ctl->extra1;
2124 struct in_device *idev =
2125 container_of(cnf, struct in_device, cnf);
2126 if (*valp)
2127 dev_disable_lro(idev->dev);
2128 inet_netconf_notify_devconf(net,
2129 NETCONFA_FORWARDING,
2130 idev->dev->ifindex,
2131 cnf);
2132 }
2133 rtnl_unlock();
2134 rt_cache_flush(net);
2135 } else
2136 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2137 NETCONFA_IFINDEX_DEFAULT,
2138 net->ipv4.devconf_dflt);
2139 }
2140
2141 return ret;
2142 }
2143
2144 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2145 void __user *buffer,
2146 size_t *lenp, loff_t *ppos)
2147 {
2148 int *valp = ctl->data;
2149 int val = *valp;
2150 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2151 struct net *net = ctl->extra2;
2152
2153 if (write && *valp != val)
2154 rt_cache_flush(net);
2155
2156 return ret;
2157 }
2158
2159 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2160 { \
2161 .procname = name, \
2162 .data = ipv4_devconf.data + \
2163 IPV4_DEVCONF_ ## attr - 1, \
2164 .maxlen = sizeof(int), \
2165 .mode = mval, \
2166 .proc_handler = proc, \
2167 .extra1 = &ipv4_devconf, \
2168 }
2169
2170 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2171 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2172
2173 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2174 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2175
2176 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2177 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2178
2179 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2180 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2181
2182 static struct devinet_sysctl_table {
2183 struct ctl_table_header *sysctl_header;
2184 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
2185 } devinet_sysctl = {
2186 .devinet_vars = {
2187 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2188 devinet_sysctl_forward),
2189 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2190
2191 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2192 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2193 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2194 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2195 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2196 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2197 "accept_source_route"),
2198 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2199 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2200 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2201 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2202 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2203 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2204 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2205 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2206 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2207 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2208 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2209 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2210 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2211 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2212 "force_igmp_version"),
2213 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2214 "igmpv2_unsolicited_report_interval"),
2215 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2216 "igmpv3_unsolicited_report_interval"),
2217 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2218 "ignore_routes_with_linkdown"),
2219 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2220 "drop_gratuitous_arp"),
2221
2222 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2223 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
2224 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2225 "promote_secondaries"),
2226 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2227 "route_localnet"),
2228 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2229 "drop_unicast_in_l2_multicast"),
2230 },
2231 };
2232
2233 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2234 int ifindex, struct ipv4_devconf *p)
2235 {
2236 int i;
2237 struct devinet_sysctl_table *t;
2238 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2239
2240 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
2241 if (!t)
2242 goto out;
2243
2244 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2245 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2246 t->devinet_vars[i].extra1 = p;
2247 t->devinet_vars[i].extra2 = net;
2248 }
2249
2250 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2251
2252 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2253 if (!t->sysctl_header)
2254 goto free;
2255
2256 p->sysctl = t;
2257
2258 inet_netconf_notify_devconf(net, NETCONFA_ALL, ifindex, p);
2259 return 0;
2260
2261 free:
2262 kfree(t);
2263 out:
2264 return -ENOBUFS;
2265 }
2266
2267 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
2268 {
2269 struct devinet_sysctl_table *t = cnf->sysctl;
2270
2271 if (!t)
2272 return;
2273
2274 cnf->sysctl = NULL;
2275 unregister_net_sysctl_table(t->sysctl_header);
2276 kfree(t);
2277 }
2278
2279 static int devinet_sysctl_register(struct in_device *idev)
2280 {
2281 int err;
2282
2283 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2284 return -EINVAL;
2285
2286 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2287 if (err)
2288 return err;
2289 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2290 idev->dev->ifindex, &idev->cnf);
2291 if (err)
2292 neigh_sysctl_unregister(idev->arp_parms);
2293 return err;
2294 }
2295
2296 static void devinet_sysctl_unregister(struct in_device *idev)
2297 {
2298 __devinet_sysctl_unregister(&idev->cnf);
2299 neigh_sysctl_unregister(idev->arp_parms);
2300 }
2301
2302 static struct ctl_table ctl_forward_entry[] = {
2303 {
2304 .procname = "ip_forward",
2305 .data = &ipv4_devconf.data[
2306 IPV4_DEVCONF_FORWARDING - 1],
2307 .maxlen = sizeof(int),
2308 .mode = 0644,
2309 .proc_handler = devinet_sysctl_forward,
2310 .extra1 = &ipv4_devconf,
2311 .extra2 = &init_net,
2312 },
2313 { },
2314 };
2315 #endif
2316
2317 static __net_init int devinet_init_net(struct net *net)
2318 {
2319 int err;
2320 struct ipv4_devconf *all, *dflt;
2321 #ifdef CONFIG_SYSCTL
2322 struct ctl_table *tbl = ctl_forward_entry;
2323 struct ctl_table_header *forw_hdr;
2324 #endif
2325
2326 err = -ENOMEM;
2327 all = &ipv4_devconf;
2328 dflt = &ipv4_devconf_dflt;
2329
2330 if (!net_eq(net, &init_net)) {
2331 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2332 if (!all)
2333 goto err_alloc_all;
2334
2335 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2336 if (!dflt)
2337 goto err_alloc_dflt;
2338
2339 #ifdef CONFIG_SYSCTL
2340 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2341 if (!tbl)
2342 goto err_alloc_ctl;
2343
2344 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2345 tbl[0].extra1 = all;
2346 tbl[0].extra2 = net;
2347 #endif
2348 }
2349
2350 #ifdef CONFIG_SYSCTL
2351 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2352 if (err < 0)
2353 goto err_reg_all;
2354
2355 err = __devinet_sysctl_register(net, "default",
2356 NETCONFA_IFINDEX_DEFAULT, dflt);
2357 if (err < 0)
2358 goto err_reg_dflt;
2359
2360 err = -ENOMEM;
2361 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2362 if (!forw_hdr)
2363 goto err_reg_ctl;
2364 net->ipv4.forw_hdr = forw_hdr;
2365 #endif
2366
2367 net->ipv4.devconf_all = all;
2368 net->ipv4.devconf_dflt = dflt;
2369 return 0;
2370
2371 #ifdef CONFIG_SYSCTL
2372 err_reg_ctl:
2373 __devinet_sysctl_unregister(dflt);
2374 err_reg_dflt:
2375 __devinet_sysctl_unregister(all);
2376 err_reg_all:
2377 if (tbl != ctl_forward_entry)
2378 kfree(tbl);
2379 err_alloc_ctl:
2380 #endif
2381 if (dflt != &ipv4_devconf_dflt)
2382 kfree(dflt);
2383 err_alloc_dflt:
2384 if (all != &ipv4_devconf)
2385 kfree(all);
2386 err_alloc_all:
2387 return err;
2388 }
2389
2390 static __net_exit void devinet_exit_net(struct net *net)
2391 {
2392 #ifdef CONFIG_SYSCTL
2393 struct ctl_table *tbl;
2394
2395 tbl = net->ipv4.forw_hdr->ctl_table_arg;
2396 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2397 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
2398 __devinet_sysctl_unregister(net->ipv4.devconf_all);
2399 kfree(tbl);
2400 #endif
2401 kfree(net->ipv4.devconf_dflt);
2402 kfree(net->ipv4.devconf_all);
2403 }
2404
2405 static __net_initdata struct pernet_operations devinet_ops = {
2406 .init = devinet_init_net,
2407 .exit = devinet_exit_net,
2408 };
2409
2410 static struct rtnl_af_ops inet_af_ops __read_mostly = {
2411 .family = AF_INET,
2412 .fill_link_af = inet_fill_link_af,
2413 .get_link_af_size = inet_get_link_af_size,
2414 .validate_link_af = inet_validate_link_af,
2415 .set_link_af = inet_set_link_af,
2416 };
2417
2418 void __init devinet_init(void)
2419 {
2420 int i;
2421
2422 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2423 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2424
2425 register_pernet_subsys(&devinet_ops);
2426
2427 register_gifconf(PF_INET, inet_gifconf);
2428 register_netdevice_notifier(&ip_netdev_notifier);
2429
2430 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
2431
2432 rtnl_af_register(&inet_af_ops);
2433
2434 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
2435 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
2436 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
2437 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2438 inet_netconf_dump_devconf, NULL);
2439 }
Ubuntu Artful kernel mirror