~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv4/devinet.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp