]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/ipv4/devinet.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
inet: protect against too small mtu values.
[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 void inetdev_send_gratuitous_arp(struct net_device *dev,
1438 struct in_device *in_dev)
1439
1440 {
1441 struct in_ifaddr *ifa;
1442
1443 for (ifa = in_dev->ifa_list; ifa;
1444 ifa = ifa->ifa_next) {
1445 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1446 ifa->ifa_local, dev,
1447 ifa->ifa_local, NULL,
1448 dev->dev_addr, NULL);
1449 }
1450 }
1451
1452 /* Called only under RTNL semaphore */
1453
1454 static int inetdev_event(struct notifier_block *this, unsigned long event,
1455 void *ptr)
1456 {
1457 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1458 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1459
1460 ASSERT_RTNL();
1461
1462 if (!in_dev) {
1463 if (event == NETDEV_REGISTER) {
1464 in_dev = inetdev_init(dev);
1465 if (IS_ERR(in_dev))
1466 return notifier_from_errno(PTR_ERR(in_dev));
1467 if (dev->flags & IFF_LOOPBACK) {
1468 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1469 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1470 }
1471 } else if (event == NETDEV_CHANGEMTU) {
1472 /* Re-enabling IP */
1473 if (inetdev_valid_mtu(dev->mtu))
1474 in_dev = inetdev_init(dev);
1475 }
1476 goto out;
1477 }
1478
1479 switch (event) {
1480 case NETDEV_REGISTER:
1481 pr_debug("%s: bug\n", __func__);
1482 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1483 break;
1484 case NETDEV_UP:
1485 if (!inetdev_valid_mtu(dev->mtu))
1486 break;
1487 if (dev->flags & IFF_LOOPBACK) {
1488 struct in_ifaddr *ifa = inet_alloc_ifa();
1489
1490 if (ifa) {
1491 INIT_HLIST_NODE(&ifa->hash);
1492 ifa->ifa_local =
1493 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1494 ifa->ifa_prefixlen = 8;
1495 ifa->ifa_mask = inet_make_mask(8);
1496 in_dev_hold(in_dev);
1497 ifa->ifa_dev = in_dev;
1498 ifa->ifa_scope = RT_SCOPE_HOST;
1499 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1500 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1501 INFINITY_LIFE_TIME);
1502 ipv4_devconf_setall(in_dev);
1503 neigh_parms_data_state_setall(in_dev->arp_parms);
1504 inet_insert_ifa(ifa);
1505 }
1506 }
1507 ip_mc_up(in_dev);
1508 /* fall through */
1509 case NETDEV_CHANGEADDR:
1510 if (!IN_DEV_ARP_NOTIFY(in_dev))
1511 break;
1512 /* fall through */
1513 case NETDEV_NOTIFY_PEERS:
1514 /* Send gratuitous ARP to notify of link change */
1515 inetdev_send_gratuitous_arp(dev, in_dev);
1516 break;
1517 case NETDEV_DOWN:
1518 ip_mc_down(in_dev);
1519 break;
1520 case NETDEV_PRE_TYPE_CHANGE:
1521 ip_mc_unmap(in_dev);
1522 break;
1523 case NETDEV_POST_TYPE_CHANGE:
1524 ip_mc_remap(in_dev);
1525 break;
1526 case NETDEV_CHANGEMTU:
1527 if (inetdev_valid_mtu(dev->mtu))
1528 break;
1529 /* disable IP when MTU is not enough */
1530 /* fall through */
1531 case NETDEV_UNREGISTER:
1532 inetdev_destroy(in_dev);
1533 break;
1534 case NETDEV_CHANGENAME:
1535 /* Do not notify about label change, this event is
1536 * not interesting to applications using netlink.
1537 */
1538 inetdev_changename(dev, in_dev);
1539
1540 devinet_sysctl_unregister(in_dev);
1541 devinet_sysctl_register(in_dev);
1542 break;
1543 }
1544 out:
1545 return NOTIFY_DONE;
1546 }
1547
1548 static struct notifier_block ip_netdev_notifier = {
1549 .notifier_call = inetdev_event,
1550 };
1551
1552 static size_t inet_nlmsg_size(void)
1553 {
1554 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1555 + nla_total_size(4) /* IFA_ADDRESS */
1556 + nla_total_size(4) /* IFA_LOCAL */
1557 + nla_total_size(4) /* IFA_BROADCAST */
1558 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1559 + nla_total_size(4) /* IFA_FLAGS */
1560 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1561 }
1562
1563 static inline u32 cstamp_delta(unsigned long cstamp)
1564 {
1565 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1566 }
1567
1568 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1569 unsigned long tstamp, u32 preferred, u32 valid)
1570 {
1571 struct ifa_cacheinfo ci;
1572
1573 ci.cstamp = cstamp_delta(cstamp);
1574 ci.tstamp = cstamp_delta(tstamp);
1575 ci.ifa_prefered = preferred;
1576 ci.ifa_valid = valid;
1577
1578 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1579 }
1580
1581 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1582 u32 portid, u32 seq, int event, unsigned int flags)
1583 {
1584 struct ifaddrmsg *ifm;
1585 struct nlmsghdr *nlh;
1586 u32 preferred, valid;
1587
1588 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1589 if (!nlh)
1590 return -EMSGSIZE;
1591
1592 ifm = nlmsg_data(nlh);
1593 ifm->ifa_family = AF_INET;
1594 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1595 ifm->ifa_flags = ifa->ifa_flags;
1596 ifm->ifa_scope = ifa->ifa_scope;
1597 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1598
1599 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1600 preferred = ifa->ifa_preferred_lft;
1601 valid = ifa->ifa_valid_lft;
1602 if (preferred != INFINITY_LIFE_TIME) {
1603 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1604
1605 if (preferred > tval)
1606 preferred -= tval;
1607 else
1608 preferred = 0;
1609 if (valid != INFINITY_LIFE_TIME) {
1610 if (valid > tval)
1611 valid -= tval;
1612 else
1613 valid = 0;
1614 }
1615 }
1616 } else {
1617 preferred = INFINITY_LIFE_TIME;
1618 valid = INFINITY_LIFE_TIME;
1619 }
1620 if ((ifa->ifa_address &&
1621 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1622 (ifa->ifa_local &&
1623 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
1624 (ifa->ifa_broadcast &&
1625 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1626 (ifa->ifa_label[0] &&
1627 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1628 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
1629 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1630 preferred, valid))
1631 goto nla_put_failure;
1632
1633 nlmsg_end(skb, nlh);
1634 return 0;
1635
1636 nla_put_failure:
1637 nlmsg_cancel(skb, nlh);
1638 return -EMSGSIZE;
1639 }
1640
1641 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1642 {
1643 struct net *net = sock_net(skb->sk);
1644 int h, s_h;
1645 int idx, s_idx;
1646 int ip_idx, s_ip_idx;
1647 struct net_device *dev;
1648 struct in_device *in_dev;
1649 struct in_ifaddr *ifa;
1650 struct hlist_head *head;
1651
1652 s_h = cb->args[0];
1653 s_idx = idx = cb->args[1];
1654 s_ip_idx = ip_idx = cb->args[2];
1655
1656 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1657 idx = 0;
1658 head = &net->dev_index_head[h];
1659 rcu_read_lock();
1660 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1661 net->dev_base_seq;
1662 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1663 if (idx < s_idx)
1664 goto cont;
1665 if (h > s_h || idx > s_idx)
1666 s_ip_idx = 0;
1667 in_dev = __in_dev_get_rcu(dev);
1668 if (!in_dev)
1669 goto cont;
1670
1671 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1672 ifa = ifa->ifa_next, ip_idx++) {
1673 if (ip_idx < s_ip_idx)
1674 continue;
1675 if (inet_fill_ifaddr(skb, ifa,
1676 NETLINK_CB(cb->skb).portid,
1677 cb->nlh->nlmsg_seq,
1678 RTM_NEWADDR, NLM_F_MULTI) < 0) {
1679 rcu_read_unlock();
1680 goto done;
1681 }
1682 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1683 }
1684 cont:
1685 idx++;
1686 }
1687 rcu_read_unlock();
1688 }
1689
1690 done:
1691 cb->args[0] = h;
1692 cb->args[1] = idx;
1693 cb->args[2] = ip_idx;
1694
1695 return skb->len;
1696 }
1697
1698 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1699 u32 portid)
1700 {
1701 struct sk_buff *skb;
1702 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1703 int err = -ENOBUFS;
1704 struct net *net;
1705
1706 net = dev_net(ifa->ifa_dev->dev);
1707 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1708 if (!skb)
1709 goto errout;
1710
1711 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1712 if (err < 0) {
1713 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1714 WARN_ON(err == -EMSGSIZE);
1715 kfree_skb(skb);
1716 goto errout;
1717 }
1718 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1719 return;
1720 errout:
1721 if (err < 0)
1722 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1723 }
1724
1725 static size_t inet_get_link_af_size(const struct net_device *dev,
1726 u32 ext_filter_mask)
1727 {
1728 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1729
1730 if (!in_dev)
1731 return 0;
1732
1733 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1734 }
1735
1736 static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1737 u32 ext_filter_mask)
1738 {
1739 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1740 struct nlattr *nla;
1741 int i;
1742
1743 if (!in_dev)
1744 return -ENODATA;
1745
1746 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1747 if (!nla)
1748 return -EMSGSIZE;
1749
1750 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1751 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1752
1753 return 0;
1754 }
1755
1756 static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1757 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1758 };
1759
1760 static int inet_validate_link_af(const struct net_device *dev,
1761 const struct nlattr *nla)
1762 {
1763 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1764 int err, rem;
1765
1766 if (dev && !__in_dev_get_rcu(dev))
1767 return -EAFNOSUPPORT;
1768
1769 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL);
1770 if (err < 0)
1771 return err;
1772
1773 if (tb[IFLA_INET_CONF]) {
1774 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1775 int cfgid = nla_type(a);
1776
1777 if (nla_len(a) < 4)
1778 return -EINVAL;
1779
1780 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1781 return -EINVAL;
1782 }
1783 }
1784
1785 return 0;
1786 }
1787
1788 static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1789 {
1790 struct in_device *in_dev = __in_dev_get_rcu(dev);
1791 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1792 int rem;
1793
1794 if (!in_dev)
1795 return -EAFNOSUPPORT;
1796
1797 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL, NULL) < 0)
1798 BUG();
1799
1800 if (tb[IFLA_INET_CONF]) {
1801 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1802 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1803 }
1804
1805 return 0;
1806 }
1807
1808 static int inet_netconf_msgsize_devconf(int type)
1809 {
1810 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1811 + nla_total_size(4); /* NETCONFA_IFINDEX */
1812 bool all = false;
1813
1814 if (type == NETCONFA_ALL)
1815 all = true;
1816
1817 if (all || type == NETCONFA_FORWARDING)
1818 size += nla_total_size(4);
1819 if (all || type == NETCONFA_RP_FILTER)
1820 size += nla_total_size(4);
1821 if (all || type == NETCONFA_MC_FORWARDING)
1822 size += nla_total_size(4);
1823 if (all || type == NETCONFA_PROXY_NEIGH)
1824 size += nla_total_size(4);
1825 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
1826 size += nla_total_size(4);
1827
1828 return size;
1829 }
1830
1831 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1832 struct ipv4_devconf *devconf, u32 portid,
1833 u32 seq, int event, unsigned int flags,
1834 int type)
1835 {
1836 struct nlmsghdr *nlh;
1837 struct netconfmsg *ncm;
1838 bool all = false;
1839
1840 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1841 flags);
1842 if (!nlh)
1843 return -EMSGSIZE;
1844
1845 if (type == NETCONFA_ALL)
1846 all = true;
1847
1848 ncm = nlmsg_data(nlh);
1849 ncm->ncm_family = AF_INET;
1850
1851 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1852 goto nla_put_failure;
1853
1854 if (!devconf)
1855 goto out;
1856
1857 if ((all || type == NETCONFA_FORWARDING) &&
1858 nla_put_s32(skb, NETCONFA_FORWARDING,
1859 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1860 goto nla_put_failure;
1861 if ((all || type == NETCONFA_RP_FILTER) &&
1862 nla_put_s32(skb, NETCONFA_RP_FILTER,
1863 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1864 goto nla_put_failure;
1865 if ((all || type == NETCONFA_MC_FORWARDING) &&
1866 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1867 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1868 goto nla_put_failure;
1869 if ((all || type == NETCONFA_PROXY_NEIGH) &&
1870 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
1871 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1872 goto nla_put_failure;
1873 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
1874 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
1875 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
1876 goto nla_put_failure;
1877
1878 out:
1879 nlmsg_end(skb, nlh);
1880 return 0;
1881
1882 nla_put_failure:
1883 nlmsg_cancel(skb, nlh);
1884 return -EMSGSIZE;
1885 }
1886
1887 void inet_netconf_notify_devconf(struct net *net, int event, int type,
1888 int ifindex, struct ipv4_devconf *devconf)
1889 {
1890 struct sk_buff *skb;
1891 int err = -ENOBUFS;
1892
1893 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
1894 if (!skb)
1895 goto errout;
1896
1897 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1898 event, 0, type);
1899 if (err < 0) {
1900 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1901 WARN_ON(err == -EMSGSIZE);
1902 kfree_skb(skb);
1903 goto errout;
1904 }
1905 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
1906 return;
1907 errout:
1908 if (err < 0)
1909 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1910 }
1911
1912 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1913 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1914 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
1915 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
1916 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
1917 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
1918 };
1919
1920 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1921 struct nlmsghdr *nlh,
1922 struct netlink_ext_ack *extack)
1923 {
1924 struct net *net = sock_net(in_skb->sk);
1925 struct nlattr *tb[NETCONFA_MAX+1];
1926 struct netconfmsg *ncm;
1927 struct sk_buff *skb;
1928 struct ipv4_devconf *devconf;
1929 struct in_device *in_dev;
1930 struct net_device *dev;
1931 int ifindex;
1932 int err;
1933
1934 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1935 devconf_ipv4_policy, extack);
1936 if (err < 0)
1937 goto errout;
1938
1939 err = -EINVAL;
1940 if (!tb[NETCONFA_IFINDEX])
1941 goto errout;
1942
1943 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1944 switch (ifindex) {
1945 case NETCONFA_IFINDEX_ALL:
1946 devconf = net->ipv4.devconf_all;
1947 break;
1948 case NETCONFA_IFINDEX_DEFAULT:
1949 devconf = net->ipv4.devconf_dflt;
1950 break;
1951 default:
1952 dev = __dev_get_by_index(net, ifindex);
1953 if (!dev)
1954 goto errout;
1955 in_dev = __in_dev_get_rtnl(dev);
1956 if (!in_dev)
1957 goto errout;
1958 devconf = &in_dev->cnf;
1959 break;
1960 }
1961
1962 err = -ENOBUFS;
1963 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
1964 if (!skb)
1965 goto errout;
1966
1967 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1968 NETLINK_CB(in_skb).portid,
1969 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1970 NETCONFA_ALL);
1971 if (err < 0) {
1972 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1973 WARN_ON(err == -EMSGSIZE);
1974 kfree_skb(skb);
1975 goto errout;
1976 }
1977 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1978 errout:
1979 return err;
1980 }
1981
1982 static int inet_netconf_dump_devconf(struct sk_buff *skb,
1983 struct netlink_callback *cb)
1984 {
1985 struct net *net = sock_net(skb->sk);
1986 int h, s_h;
1987 int idx, s_idx;
1988 struct net_device *dev;
1989 struct in_device *in_dev;
1990 struct hlist_head *head;
1991
1992 s_h = cb->args[0];
1993 s_idx = idx = cb->args[1];
1994
1995 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1996 idx = 0;
1997 head = &net->dev_index_head[h];
1998 rcu_read_lock();
1999 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
2000 net->dev_base_seq;
2001 hlist_for_each_entry_rcu(dev, head, index_hlist) {
2002 if (idx < s_idx)
2003 goto cont;
2004 in_dev = __in_dev_get_rcu(dev);
2005 if (!in_dev)
2006 goto cont;
2007
2008 if (inet_netconf_fill_devconf(skb, dev->ifindex,
2009 &in_dev->cnf,
2010 NETLINK_CB(cb->skb).portid,
2011 cb->nlh->nlmsg_seq,
2012 RTM_NEWNETCONF,
2013 NLM_F_MULTI,
2014 NETCONFA_ALL) < 0) {
2015 rcu_read_unlock();
2016 goto done;
2017 }
2018 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2019 cont:
2020 idx++;
2021 }
2022 rcu_read_unlock();
2023 }
2024 if (h == NETDEV_HASHENTRIES) {
2025 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
2026 net->ipv4.devconf_all,
2027 NETLINK_CB(cb->skb).portid,
2028 cb->nlh->nlmsg_seq,
2029 RTM_NEWNETCONF, NLM_F_MULTI,
2030 NETCONFA_ALL) < 0)
2031 goto done;
2032 else
2033 h++;
2034 }
2035 if (h == NETDEV_HASHENTRIES + 1) {
2036 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
2037 net->ipv4.devconf_dflt,
2038 NETLINK_CB(cb->skb).portid,
2039 cb->nlh->nlmsg_seq,
2040 RTM_NEWNETCONF, NLM_F_MULTI,
2041 NETCONFA_ALL) < 0)
2042 goto done;
2043 else
2044 h++;
2045 }
2046 done:
2047 cb->args[0] = h;
2048 cb->args[1] = idx;
2049
2050 return skb->len;
2051 }
2052
2053 #ifdef CONFIG_SYSCTL
2054
2055 static void devinet_copy_dflt_conf(struct net *net, int i)
2056 {
2057 struct net_device *dev;
2058
2059 rcu_read_lock();
2060 for_each_netdev_rcu(net, dev) {
2061 struct in_device *in_dev;
2062
2063 in_dev = __in_dev_get_rcu(dev);
2064 if (in_dev && !test_bit(i, in_dev->cnf.state))
2065 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2066 }
2067 rcu_read_unlock();
2068 }
2069
2070 /* called with RTNL locked */
2071 static void inet_forward_change(struct net *net)
2072 {
2073 struct net_device *dev;
2074 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2075
2076 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2077 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2078 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2079 NETCONFA_FORWARDING,
2080 NETCONFA_IFINDEX_ALL,
2081 net->ipv4.devconf_all);
2082 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2083 NETCONFA_FORWARDING,
2084 NETCONFA_IFINDEX_DEFAULT,
2085 net->ipv4.devconf_dflt);
2086
2087 for_each_netdev(net, dev) {
2088 struct in_device *in_dev;
2089
2090 if (on)
2091 dev_disable_lro(dev);
2092
2093 in_dev = __in_dev_get_rtnl(dev);
2094 if (in_dev) {
2095 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2096 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2097 NETCONFA_FORWARDING,
2098 dev->ifindex, &in_dev->cnf);
2099 }
2100 }
2101 }
2102
2103 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2104 {
2105 if (cnf == net->ipv4.devconf_dflt)
2106 return NETCONFA_IFINDEX_DEFAULT;
2107 else if (cnf == net->ipv4.devconf_all)
2108 return NETCONFA_IFINDEX_ALL;
2109 else {
2110 struct in_device *idev
2111 = container_of(cnf, struct in_device, cnf);
2112 return idev->dev->ifindex;
2113 }
2114 }
2115
2116 static int devinet_conf_proc(struct ctl_table *ctl, int write,
2117 void __user *buffer,
2118 size_t *lenp, loff_t *ppos)
2119 {
2120 int old_value = *(int *)ctl->data;
2121 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2122 int new_value = *(int *)ctl->data;
2123
2124 if (write) {
2125 struct ipv4_devconf *cnf = ctl->extra1;
2126 struct net *net = ctl->extra2;
2127 int i = (int *)ctl->data - cnf->data;
2128 int ifindex;
2129
2130 set_bit(i, cnf->state);
2131
2132 if (cnf == net->ipv4.devconf_dflt)
2133 devinet_copy_dflt_conf(net, i);
2134 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2135 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2136 if ((new_value == 0) && (old_value != 0))
2137 rt_cache_flush(net);
2138
2139 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2140 new_value != old_value) {
2141 ifindex = devinet_conf_ifindex(net, cnf);
2142 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2143 NETCONFA_RP_FILTER,
2144 ifindex, cnf);
2145 }
2146 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2147 new_value != old_value) {
2148 ifindex = devinet_conf_ifindex(net, cnf);
2149 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2150 NETCONFA_PROXY_NEIGH,
2151 ifindex, cnf);
2152 }
2153 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2154 new_value != old_value) {
2155 ifindex = devinet_conf_ifindex(net, cnf);
2156 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2157 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2158 ifindex, cnf);
2159 }
2160 }
2161
2162 return ret;
2163 }
2164
2165 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2166 void __user *buffer,
2167 size_t *lenp, loff_t *ppos)
2168 {
2169 int *valp = ctl->data;
2170 int val = *valp;
2171 loff_t pos = *ppos;
2172 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2173
2174 if (write && *valp != val) {
2175 struct net *net = ctl->extra2;
2176
2177 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2178 if (!rtnl_trylock()) {
2179 /* Restore the original values before restarting */
2180 *valp = val;
2181 *ppos = pos;
2182 return restart_syscall();
2183 }
2184 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2185 inet_forward_change(net);
2186 } else {
2187 struct ipv4_devconf *cnf = ctl->extra1;
2188 struct in_device *idev =
2189 container_of(cnf, struct in_device, cnf);
2190 if (*valp)
2191 dev_disable_lro(idev->dev);
2192 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2193 NETCONFA_FORWARDING,
2194 idev->dev->ifindex,
2195 cnf);
2196 }
2197 rtnl_unlock();
2198 rt_cache_flush(net);
2199 } else
2200 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2201 NETCONFA_FORWARDING,
2202 NETCONFA_IFINDEX_DEFAULT,
2203 net->ipv4.devconf_dflt);
2204 }
2205
2206 return ret;
2207 }
2208
2209 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2210 void __user *buffer,
2211 size_t *lenp, loff_t *ppos)
2212 {
2213 int *valp = ctl->data;
2214 int val = *valp;
2215 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2216 struct net *net = ctl->extra2;
2217
2218 if (write && *valp != val)
2219 rt_cache_flush(net);
2220
2221 return ret;
2222 }
2223
2224 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2225 { \
2226 .procname = name, \
2227 .data = ipv4_devconf.data + \
2228 IPV4_DEVCONF_ ## attr - 1, \
2229 .maxlen = sizeof(int), \
2230 .mode = mval, \
2231 .proc_handler = proc, \
2232 .extra1 = &ipv4_devconf, \
2233 }
2234
2235 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2236 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2237
2238 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2239 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2240
2241 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2242 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2243
2244 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2245 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2246
2247 static struct devinet_sysctl_table {
2248 struct ctl_table_header *sysctl_header;
2249 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
2250 } devinet_sysctl = {
2251 .devinet_vars = {
2252 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2253 devinet_sysctl_forward),
2254 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2255
2256 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2257 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2258 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2259 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2260 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2261 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2262 "accept_source_route"),
2263 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2264 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2265 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2266 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2267 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2268 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2269 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2270 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2271 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2272 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2273 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2274 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2275 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2276 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2277 "force_igmp_version"),
2278 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2279 "igmpv2_unsolicited_report_interval"),
2280 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2281 "igmpv3_unsolicited_report_interval"),
2282 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2283 "ignore_routes_with_linkdown"),
2284 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2285 "drop_gratuitous_arp"),
2286
2287 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2288 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
2289 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2290 "promote_secondaries"),
2291 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2292 "route_localnet"),
2293 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2294 "drop_unicast_in_l2_multicast"),
2295 },
2296 };
2297
2298 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2299 int ifindex, struct ipv4_devconf *p)
2300 {
2301 int i;
2302 struct devinet_sysctl_table *t;
2303 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2304
2305 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
2306 if (!t)
2307 goto out;
2308
2309 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2310 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2311 t->devinet_vars[i].extra1 = p;
2312 t->devinet_vars[i].extra2 = net;
2313 }
2314
2315 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2316
2317 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2318 if (!t->sysctl_header)
2319 goto free;
2320
2321 p->sysctl = t;
2322
2323 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
2324 ifindex, p);
2325 return 0;
2326
2327 free:
2328 kfree(t);
2329 out:
2330 return -ENOBUFS;
2331 }
2332
2333 static void __devinet_sysctl_unregister(struct net *net,
2334 struct ipv4_devconf *cnf, int ifindex)
2335 {
2336 struct devinet_sysctl_table *t = cnf->sysctl;
2337
2338 if (t) {
2339 cnf->sysctl = NULL;
2340 unregister_net_sysctl_table(t->sysctl_header);
2341 kfree(t);
2342 }
2343
2344 inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2345 }
2346
2347 static int devinet_sysctl_register(struct in_device *idev)
2348 {
2349 int err;
2350
2351 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2352 return -EINVAL;
2353
2354 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2355 if (err)
2356 return err;
2357 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2358 idev->dev->ifindex, &idev->cnf);
2359 if (err)
2360 neigh_sysctl_unregister(idev->arp_parms);
2361 return err;
2362 }
2363
2364 static void devinet_sysctl_unregister(struct in_device *idev)
2365 {
2366 struct net *net = dev_net(idev->dev);
2367
2368 __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2369 neigh_sysctl_unregister(idev->arp_parms);
2370 }
2371
2372 static struct ctl_table ctl_forward_entry[] = {
2373 {
2374 .procname = "ip_forward",
2375 .data = &ipv4_devconf.data[
2376 IPV4_DEVCONF_FORWARDING - 1],
2377 .maxlen = sizeof(int),
2378 .mode = 0644,
2379 .proc_handler = devinet_sysctl_forward,
2380 .extra1 = &ipv4_devconf,
2381 .extra2 = &init_net,
2382 },
2383 { },
2384 };
2385 #endif
2386
2387 static __net_init int devinet_init_net(struct net *net)
2388 {
2389 int err;
2390 struct ipv4_devconf *all, *dflt;
2391 #ifdef CONFIG_SYSCTL
2392 struct ctl_table *tbl = ctl_forward_entry;
2393 struct ctl_table_header *forw_hdr;
2394 #endif
2395
2396 err = -ENOMEM;
2397 all = &ipv4_devconf;
2398 dflt = &ipv4_devconf_dflt;
2399
2400 if (!net_eq(net, &init_net)) {
2401 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2402 if (!all)
2403 goto err_alloc_all;
2404
2405 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2406 if (!dflt)
2407 goto err_alloc_dflt;
2408
2409 #ifdef CONFIG_SYSCTL
2410 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2411 if (!tbl)
2412 goto err_alloc_ctl;
2413
2414 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2415 tbl[0].extra1 = all;
2416 tbl[0].extra2 = net;
2417 #endif
2418 }
2419
2420 #ifdef CONFIG_SYSCTL
2421 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2422 if (err < 0)
2423 goto err_reg_all;
2424
2425 err = __devinet_sysctl_register(net, "default",
2426 NETCONFA_IFINDEX_DEFAULT, dflt);
2427 if (err < 0)
2428 goto err_reg_dflt;
2429
2430 err = -ENOMEM;
2431 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2432 if (!forw_hdr)
2433 goto err_reg_ctl;
2434 net->ipv4.forw_hdr = forw_hdr;
2435 #endif
2436
2437 net->ipv4.devconf_all = all;
2438 net->ipv4.devconf_dflt = dflt;
2439 return 0;
2440
2441 #ifdef CONFIG_SYSCTL
2442 err_reg_ctl:
2443 __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2444 err_reg_dflt:
2445 __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2446 err_reg_all:
2447 if (tbl != ctl_forward_entry)
2448 kfree(tbl);
2449 err_alloc_ctl:
2450 #endif
2451 if (dflt != &ipv4_devconf_dflt)
2452 kfree(dflt);
2453 err_alloc_dflt:
2454 if (all != &ipv4_devconf)
2455 kfree(all);
2456 err_alloc_all:
2457 return err;
2458 }
2459
2460 static __net_exit void devinet_exit_net(struct net *net)
2461 {
2462 #ifdef CONFIG_SYSCTL
2463 struct ctl_table *tbl;
2464
2465 tbl = net->ipv4.forw_hdr->ctl_table_arg;
2466 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2467 __devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
2468 NETCONFA_IFINDEX_DEFAULT);
2469 __devinet_sysctl_unregister(net, net->ipv4.devconf_all,
2470 NETCONFA_IFINDEX_ALL);
2471 kfree(tbl);
2472 #endif
2473 kfree(net->ipv4.devconf_dflt);
2474 kfree(net->ipv4.devconf_all);
2475 }
2476
2477 static __net_initdata struct pernet_operations devinet_ops = {
2478 .init = devinet_init_net,
2479 .exit = devinet_exit_net,
2480 };
2481
2482 static struct rtnl_af_ops inet_af_ops __read_mostly = {
2483 .family = AF_INET,
2484 .fill_link_af = inet_fill_link_af,
2485 .get_link_af_size = inet_get_link_af_size,
2486 .validate_link_af = inet_validate_link_af,
2487 .set_link_af = inet_set_link_af,
2488 };
2489
2490 void __init devinet_init(void)
2491 {
2492 int i;
2493
2494 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2495 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2496
2497 register_pernet_subsys(&devinet_ops);
2498
2499 register_gifconf(PF_INET, inet_gifconf);
2500 register_netdevice_notifier(&ip_netdev_notifier);
2501
2502 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
2503
2504 rtnl_af_register(&inet_af_ops);
2505
2506 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0);
2507 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0);
2508 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0);
2509 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2510 inet_netconf_dump_devconf, 0);
2511 }
ubuntu-bionic-kernel mirror