]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/ipv4/devinet.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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