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

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

Version: ~ [ linux-6.0-rc6 ] ~ [ linux-5.19.10 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.69 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.144 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.214 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.259 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.294 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.329 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

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