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