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

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

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

~ [ 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