?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rxrpc: Show some more information through /proc files
[linux/fpc-iii.git] / net / ipv4 / devinet.c
blobea4bd8a52422e75c98e30cb3ab537e97b2170520
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_BC_FORWARDING)
1831 size += nla_total_size(4);
1832 if (all || type == NETCONFA_PROXY_NEIGH)
1833 size += nla_total_size(4);
1834 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
1835 size += nla_total_size(4);
1836
1837 return size;
1838 }
1839
1840 static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1841 struct ipv4_devconf *devconf, u32 portid,
1842 u32 seq, int event, unsigned int flags,
1843 int type)
1844 {
1845 struct nlmsghdr *nlh;
1846 struct netconfmsg *ncm;
1847 bool all = false;
1848
1849 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1850 flags);
1851 if (!nlh)
1852 return -EMSGSIZE;
1853
1854 if (type == NETCONFA_ALL)
1855 all = true;
1856
1857 ncm = nlmsg_data(nlh);
1858 ncm->ncm_family = AF_INET;
1859
1860 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1861 goto nla_put_failure;
1862
1863 if (!devconf)
1864 goto out;
1865
1866 if ((all || type == NETCONFA_FORWARDING) &&
1867 nla_put_s32(skb, NETCONFA_FORWARDING,
1868 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1869 goto nla_put_failure;
1870 if ((all || type == NETCONFA_RP_FILTER) &&
1871 nla_put_s32(skb, NETCONFA_RP_FILTER,
1872 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1873 goto nla_put_failure;
1874 if ((all || type == NETCONFA_MC_FORWARDING) &&
1875 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1876 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1877 goto nla_put_failure;
1878 if ((all || type == NETCONFA_BC_FORWARDING) &&
1879 nla_put_s32(skb, NETCONFA_BC_FORWARDING,
1880 IPV4_DEVCONF(*devconf, BC_FORWARDING)) < 0)
1881 goto nla_put_failure;
1882 if ((all || type == NETCONFA_PROXY_NEIGH) &&
1883 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
1884 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1885 goto nla_put_failure;
1886 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
1887 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
1888 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
1889 goto nla_put_failure;
1890
1891 out:
1892 nlmsg_end(skb, nlh);
1893 return 0;
1894
1895 nla_put_failure:
1896 nlmsg_cancel(skb, nlh);
1897 return -EMSGSIZE;
1898 }
1899
1900 void inet_netconf_notify_devconf(struct net *net, int event, int type,
1901 int ifindex, struct ipv4_devconf *devconf)
1902 {
1903 struct sk_buff *skb;
1904 int err = -ENOBUFS;
1905
1906 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
1907 if (!skb)
1908 goto errout;
1909
1910 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1911 event, 0, type);
1912 if (err < 0) {
1913 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1914 WARN_ON(err == -EMSGSIZE);
1915 kfree_skb(skb);
1916 goto errout;
1917 }
1918 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
1919 return;
1920 errout:
1921 if (err < 0)
1922 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1923 }
1924
1925 static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1926 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1927 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
1928 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
1929 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
1930 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
1931 };
1932
1933 static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1934 struct nlmsghdr *nlh,
1935 struct netlink_ext_ack *extack)
1936 {
1937 struct net *net = sock_net(in_skb->sk);
1938 struct nlattr *tb[NETCONFA_MAX+1];
1939 struct netconfmsg *ncm;
1940 struct sk_buff *skb;
1941 struct ipv4_devconf *devconf;
1942 struct in_device *in_dev;
1943 struct net_device *dev;
1944 int ifindex;
1945 int err;
1946
1947 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1948 devconf_ipv4_policy, extack);
1949 if (err < 0)
1950 goto errout;
1951
1952 err = -EINVAL;
1953 if (!tb[NETCONFA_IFINDEX])
1954 goto errout;
1955
1956 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1957 switch (ifindex) {
1958 case NETCONFA_IFINDEX_ALL:
1959 devconf = net->ipv4.devconf_all;
1960 break;
1961 case NETCONFA_IFINDEX_DEFAULT:
1962 devconf = net->ipv4.devconf_dflt;
1963 break;
1964 default:
1965 dev = __dev_get_by_index(net, ifindex);
1966 if (!dev)
1967 goto errout;
1968 in_dev = __in_dev_get_rtnl(dev);
1969 if (!in_dev)
1970 goto errout;
1971 devconf = &in_dev->cnf;
1972 break;
1973 }
1974
1975 err = -ENOBUFS;
1976 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
1977 if (!skb)
1978 goto errout;
1979
1980 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1981 NETLINK_CB(in_skb).portid,
1982 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1983 NETCONFA_ALL);
1984 if (err < 0) {
1985 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1986 WARN_ON(err == -EMSGSIZE);
1987 kfree_skb(skb);
1988 goto errout;
1989 }
1990 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1991 errout:
1992 return err;
1993 }
1994
1995 static int inet_netconf_dump_devconf(struct sk_buff *skb,
1996 struct netlink_callback *cb)
1997 {
1998 struct net *net = sock_net(skb->sk);
1999 int h, s_h;
2000 int idx, s_idx;
2001 struct net_device *dev;
2002 struct in_device *in_dev;
2003 struct hlist_head *head;
2004
2005 s_h = cb->args[0];
2006 s_idx = idx = cb->args[1];
2007
2008 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2009 idx = 0;
2010 head = &net->dev_index_head[h];
2011 rcu_read_lock();
2012 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
2013 net->dev_base_seq;
2014 hlist_for_each_entry_rcu(dev, head, index_hlist) {
2015 if (idx < s_idx)
2016 goto cont;
2017 in_dev = __in_dev_get_rcu(dev);
2018 if (!in_dev)
2019 goto cont;
2020
2021 if (inet_netconf_fill_devconf(skb, dev->ifindex,
2022 &in_dev->cnf,
2023 NETLINK_CB(cb->skb).portid,
2024 cb->nlh->nlmsg_seq,
2025 RTM_NEWNETCONF,
2026 NLM_F_MULTI,
2027 NETCONFA_ALL) < 0) {
2028 rcu_read_unlock();
2029 goto done;
2030 }
2031 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2032 cont:
2033 idx++;
2034 }
2035 rcu_read_unlock();
2036 }
2037 if (h == NETDEV_HASHENTRIES) {
2038 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
2039 net->ipv4.devconf_all,
2040 NETLINK_CB(cb->skb).portid,
2041 cb->nlh->nlmsg_seq,
2042 RTM_NEWNETCONF, NLM_F_MULTI,
2043 NETCONFA_ALL) < 0)
2044 goto done;
2045 else
2046 h++;
2047 }
2048 if (h == NETDEV_HASHENTRIES + 1) {
2049 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
2050 net->ipv4.devconf_dflt,
2051 NETLINK_CB(cb->skb).portid,
2052 cb->nlh->nlmsg_seq,
2053 RTM_NEWNETCONF, NLM_F_MULTI,
2054 NETCONFA_ALL) < 0)
2055 goto done;
2056 else
2057 h++;
2058 }
2059 done:
2060 cb->args[0] = h;
2061 cb->args[1] = idx;
2062
2063 return skb->len;
2064 }
2065
2066 #ifdef CONFIG_SYSCTL
2067
2068 static void devinet_copy_dflt_conf(struct net *net, int i)
2069 {
2070 struct net_device *dev;
2071
2072 rcu_read_lock();
2073 for_each_netdev_rcu(net, dev) {
2074 struct in_device *in_dev;
2075
2076 in_dev = __in_dev_get_rcu(dev);
2077 if (in_dev && !test_bit(i, in_dev->cnf.state))
2078 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2079 }
2080 rcu_read_unlock();
2081 }
2082
2083 /* called with RTNL locked */
2084 static void inet_forward_change(struct net *net)
2085 {
2086 struct net_device *dev;
2087 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2088
2089 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2090 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2091 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2092 NETCONFA_FORWARDING,
2093 NETCONFA_IFINDEX_ALL,
2094 net->ipv4.devconf_all);
2095 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2096 NETCONFA_FORWARDING,
2097 NETCONFA_IFINDEX_DEFAULT,
2098 net->ipv4.devconf_dflt);
2099
2100 for_each_netdev(net, dev) {
2101 struct in_device *in_dev;
2102
2103 if (on)
2104 dev_disable_lro(dev);
2105
2106 in_dev = __in_dev_get_rtnl(dev);
2107 if (in_dev) {
2108 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2109 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2110 NETCONFA_FORWARDING,
2111 dev->ifindex, &in_dev->cnf);
2112 }
2113 }
2114 }
2115
2116 static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2117 {
2118 if (cnf == net->ipv4.devconf_dflt)
2119 return NETCONFA_IFINDEX_DEFAULT;
2120 else if (cnf == net->ipv4.devconf_all)
2121 return NETCONFA_IFINDEX_ALL;
2122 else {
2123 struct in_device *idev
2124 = container_of(cnf, struct in_device, cnf);
2125 return idev->dev->ifindex;
2126 }
2127 }
2128
2129 static int devinet_conf_proc(struct ctl_table *ctl, int write,
2130 void __user *buffer,
2131 size_t *lenp, loff_t *ppos)
2132 {
2133 int old_value = *(int *)ctl->data;
2134 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2135 int new_value = *(int *)ctl->data;
2136
2137 if (write) {
2138 struct ipv4_devconf *cnf = ctl->extra1;
2139 struct net *net = ctl->extra2;
2140 int i = (int *)ctl->data - cnf->data;
2141 int ifindex;
2142
2143 set_bit(i, cnf->state);
2144
2145 if (cnf == net->ipv4.devconf_dflt)
2146 devinet_copy_dflt_conf(net, i);
2147 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2148 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2149 if ((new_value == 0) && (old_value != 0))
2150 rt_cache_flush(net);
2151
2152 if (i == IPV4_DEVCONF_BC_FORWARDING - 1 &&
2153 new_value != old_value)
2154 rt_cache_flush(net);
2155
2156 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2157 new_value != old_value) {
2158 ifindex = devinet_conf_ifindex(net, cnf);
2159 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2160 NETCONFA_RP_FILTER,
2161 ifindex, cnf);
2162 }
2163 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2164 new_value != old_value) {
2165 ifindex = devinet_conf_ifindex(net, cnf);
2166 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2167 NETCONFA_PROXY_NEIGH,
2168 ifindex, cnf);
2169 }
2170 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2171 new_value != old_value) {
2172 ifindex = devinet_conf_ifindex(net, cnf);
2173 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2174 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2175 ifindex, cnf);
2176 }
2177 }
2178
2179 return ret;
2180 }
2181
2182 static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2183 void __user *buffer,
2184 size_t *lenp, loff_t *ppos)
2185 {
2186 int *valp = ctl->data;
2187 int val = *valp;
2188 loff_t pos = *ppos;
2189 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2190
2191 if (write && *valp != val) {
2192 struct net *net = ctl->extra2;
2193
2194 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
2195 if (!rtnl_trylock()) {
2196 /* Restore the original values before restarting */
2197 *valp = val;
2198 *ppos = pos;
2199 return restart_syscall();
2200 }
2201 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2202 inet_forward_change(net);
2203 } else {
2204 struct ipv4_devconf *cnf = ctl->extra1;
2205 struct in_device *idev =
2206 container_of(cnf, struct in_device, cnf);
2207 if (*valp)
2208 dev_disable_lro(idev->dev);
2209 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2210 NETCONFA_FORWARDING,
2211 idev->dev->ifindex,
2212 cnf);
2213 }
2214 rtnl_unlock();
2215 rt_cache_flush(net);
2216 } else
2217 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2218 NETCONFA_FORWARDING,
2219 NETCONFA_IFINDEX_DEFAULT,
2220 net->ipv4.devconf_dflt);
2221 }
2222
2223 return ret;
2224 }
2225
2226 static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2227 void __user *buffer,
2228 size_t *lenp, loff_t *ppos)
2229 {
2230 int *valp = ctl->data;
2231 int val = *valp;
2232 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2233 struct net *net = ctl->extra2;
2234
2235 if (write && *valp != val)
2236 rt_cache_flush(net);
2237
2238 return ret;
2239 }
2240
2241 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2242 { \
2243 .procname = name, \
2244 .data = ipv4_devconf.data + \
2245 IPV4_DEVCONF_ ## attr - 1, \
2246 .maxlen = sizeof(int), \
2247 .mode = mval, \
2248 .proc_handler = proc, \
2249 .extra1 = &ipv4_devconf, \
2250 }
2251
2252 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2253 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2254
2255 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2256 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2257
2258 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2259 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2260
2261 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2262 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2263
2264 static struct devinet_sysctl_table {
2265 struct ctl_table_header *sysctl_header;
2266 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
2267 } devinet_sysctl = {
2268 .devinet_vars = {
2269 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2270 devinet_sysctl_forward),
2271 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2272 DEVINET_SYSCTL_RW_ENTRY(BC_FORWARDING, "bc_forwarding"),
2273
2274 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2275 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2276 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2277 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2278 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2279 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2280 "accept_source_route"),
2281 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2282 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2283 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2284 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2285 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2286 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2287 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2288 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2289 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2290 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2291 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2292 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2293 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2294 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2295 "force_igmp_version"),
2296 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2297 "igmpv2_unsolicited_report_interval"),
2298 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2299 "igmpv3_unsolicited_report_interval"),
2300 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2301 "ignore_routes_with_linkdown"),
2302 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2303 "drop_gratuitous_arp"),
2304
2305 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2306 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
2307 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2308 "promote_secondaries"),
2309 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2310 "route_localnet"),
2311 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2312 "drop_unicast_in_l2_multicast"),
2313 },
2314 };
2315
2316 static int __devinet_sysctl_register(struct net *net, char *dev_name,
2317 int ifindex, struct ipv4_devconf *p)
2318 {
2319 int i;
2320 struct devinet_sysctl_table *t;
2321 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2322
2323 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
2324 if (!t)
2325 goto out;
2326
2327 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2328 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2329 t->devinet_vars[i].extra1 = p;
2330 t->devinet_vars[i].extra2 = net;
2331 }
2332
2333 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
2334
2335 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
2336 if (!t->sysctl_header)
2337 goto free;
2338
2339 p->sysctl = t;
2340
2341 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
2342 ifindex, p);
2343 return 0;
2344
2345 free:
2346 kfree(t);
2347 out:
2348 return -ENOBUFS;
2349 }
2350
2351 static void __devinet_sysctl_unregister(struct net *net,
2352 struct ipv4_devconf *cnf, int ifindex)
2353 {
2354 struct devinet_sysctl_table *t = cnf->sysctl;
2355
2356 if (t) {
2357 cnf->sysctl = NULL;
2358 unregister_net_sysctl_table(t->sysctl_header);
2359 kfree(t);
2360 }
2361
2362 inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2363 }
2364
2365 static int devinet_sysctl_register(struct in_device *idev)
2366 {
2367 int err;
2368
2369 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2370 return -EINVAL;
2371
2372 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2373 if (err)
2374 return err;
2375 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2376 idev->dev->ifindex, &idev->cnf);
2377 if (err)
2378 neigh_sysctl_unregister(idev->arp_parms);
2379 return err;
2380 }
2381
2382 static void devinet_sysctl_unregister(struct in_device *idev)
2383 {
2384 struct net *net = dev_net(idev->dev);
2385
2386 __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2387 neigh_sysctl_unregister(idev->arp_parms);
2388 }
2389
2390 static struct ctl_table ctl_forward_entry[] = {
2391 {
2392 .procname = "ip_forward",
2393 .data = &ipv4_devconf.data[
2394 IPV4_DEVCONF_FORWARDING - 1],
2395 .maxlen = sizeof(int),
2396 .mode = 0644,
2397 .proc_handler = devinet_sysctl_forward,
2398 .extra1 = &ipv4_devconf,
2399 .extra2 = &init_net,
2400 },
2401 { },
2402 };
2403 #endif
2404
2405 static __net_init int devinet_init_net(struct net *net)
2406 {
2407 int err;
2408 struct ipv4_devconf *all, *dflt;
2409 #ifdef CONFIG_SYSCTL
2410 struct ctl_table *tbl = ctl_forward_entry;
2411 struct ctl_table_header *forw_hdr;
2412 #endif
2413
2414 err = -ENOMEM;
2415 all = &ipv4_devconf;
2416 dflt = &ipv4_devconf_dflt;
2417
2418 if (!net_eq(net, &init_net)) {
2419 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2420 if (!all)
2421 goto err_alloc_all;
2422
2423 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2424 if (!dflt)
2425 goto err_alloc_dflt;
2426
2427 #ifdef CONFIG_SYSCTL
2428 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2429 if (!tbl)
2430 goto err_alloc_ctl;
2431
2432 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2433 tbl[0].extra1 = all;
2434 tbl[0].extra2 = net;
2435 #endif
2436 }
2437
2438 #ifdef CONFIG_SYSCTL
2439 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2440 if (err < 0)
2441 goto err_reg_all;
2442
2443 err = __devinet_sysctl_register(net, "default",
2444 NETCONFA_IFINDEX_DEFAULT, dflt);
2445 if (err < 0)
2446 goto err_reg_dflt;
2447
2448 err = -ENOMEM;
2449 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2450 if (!forw_hdr)
2451 goto err_reg_ctl;
2452 net->ipv4.forw_hdr = forw_hdr;
2453 #endif
2454
2455 net->ipv4.devconf_all = all;
2456 net->ipv4.devconf_dflt = dflt;
2457 return 0;
2458
2459 #ifdef CONFIG_SYSCTL
2460 err_reg_ctl:
2461 __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2462 err_reg_dflt:
2463 __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2464 err_reg_all:
2465 if (tbl != ctl_forward_entry)
2466 kfree(tbl);
2467 err_alloc_ctl:
2468 #endif
2469 if (dflt != &ipv4_devconf_dflt)
2470 kfree(dflt);
2471 err_alloc_dflt:
2472 if (all != &ipv4_devconf)
2473 kfree(all);
2474 err_alloc_all:
2475 return err;
2476 }
2477
2478 static __net_exit void devinet_exit_net(struct net *net)
2479 {
2480 #ifdef CONFIG_SYSCTL
2481 struct ctl_table *tbl;
2482
2483 tbl = net->ipv4.forw_hdr->ctl_table_arg;
2484 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2485 __devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
2486 NETCONFA_IFINDEX_DEFAULT);
2487 __devinet_sysctl_unregister(net, net->ipv4.devconf_all,
2488 NETCONFA_IFINDEX_ALL);
2489 kfree(tbl);
2490 #endif
2491 kfree(net->ipv4.devconf_dflt);
2492 kfree(net->ipv4.devconf_all);
2493 }
2494
2495 static __net_initdata struct pernet_operations devinet_ops = {
2496 .init = devinet_init_net,
2497 .exit = devinet_exit_net,
2498 };
2499
2500 static struct rtnl_af_ops inet_af_ops __read_mostly = {
2501 .family = AF_INET,
2502 .fill_link_af = inet_fill_link_af,
2503 .get_link_af_size = inet_get_link_af_size,
2504 .validate_link_af = inet_validate_link_af,
2505 .set_link_af = inet_set_link_af,
2506 };
2507
2508 void __init devinet_init(void)
2509 {
2510 int i;
2511
2512 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2513 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2514
2515 register_pernet_subsys(&devinet_ops);
2516
2517 register_gifconf(PF_INET, inet_gifconf);
2518 register_netdevice_notifier(&ip_netdev_notifier);
2519
2520 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
2521
2522 rtnl_af_register(&inet_af_ops);
2523
2524 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0);
2525 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0);
2526 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0);
2527 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2528 inet_netconf_dump_devconf, 0);
2529 }
Linux with added FPC-III support