net: fix netlink address dumping in IPv4/IPv6
[linux-2.6.git] / net / ipv4 / devinet.c
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 <asm/system.h>
31 #include <linux/bitops.h>
32 #include <linux/capability.h>
33 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/kernel.h>
36 #include <linux/string.h>
37 #include <linux/mm.h>
38 #include <linux/socket.h>
39 #include <linux/sockios.h>
40 #include <linux/in.h>
41 #include <linux/errno.h>
42 #include <linux/interrupt.h>
43 #include <linux/if_addr.h>
44 #include <linux/if_ether.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/skbuff.h>
49 #include <linux/init.h>
50 #include <linux/notifier.h>
51 #include <linux/inetdevice.h>
52 #include <linux/igmp.h>
53 #ifdef CONFIG_SYSCTL
54 #include <linux/sysctl.h>
55 #endif
56 #include <linux/kmod.h>
57
58 #include <net/arp.h>
59 #include <net/ip.h>
60 #include <net/route.h>
61 #include <net/ip_fib.h>
62 #include <net/rtnetlink.h>
63 #include <net/net_namespace.h>
64
65 static struct ipv4_devconf ipv4_devconf = {
66         .data = {
67                 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
68                 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
69                 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
70                 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
71         },
72 };
73
74 static struct ipv4_devconf ipv4_devconf_dflt = {
75         .data = {
76                 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
77                 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
78                 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
79                 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
80                 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
81         },
82 };
83
84 #define IPV4_DEVCONF_DFLT(net, attr) \
85         IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
86
87 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
88         [IFA_LOCAL]             = { .type = NLA_U32 },
89         [IFA_ADDRESS]           = { .type = NLA_U32 },
90         [IFA_BROADCAST]         = { .type = NLA_U32 },
91         [IFA_LABEL]             = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
92 };
93
94 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
95
96 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
97 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
98                          int destroy);
99 #ifdef CONFIG_SYSCTL
100 static void devinet_sysctl_register(struct in_device *idev);
101 static void devinet_sysctl_unregister(struct in_device *idev);
102 #else
103 static inline void devinet_sysctl_register(struct in_device *idev)
104 {
105 }
106 static inline void devinet_sysctl_unregister(struct in_device *idev)
107 {
108 }
109 #endif
110
111 /* Locks all the inet devices. */
112
113 static struct in_ifaddr *inet_alloc_ifa(void)
114 {
115         return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
116 }
117
118 static void inet_rcu_free_ifa(struct rcu_head *head)
119 {
120         struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
121         if (ifa->ifa_dev)
122                 in_dev_put(ifa->ifa_dev);
123         kfree(ifa);
124 }
125
126 static inline void inet_free_ifa(struct in_ifaddr *ifa)
127 {
128         call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
129 }
130
131 void in_dev_finish_destroy(struct in_device *idev)
132 {
133         struct net_device *dev = idev->dev;
134
135         WARN_ON(idev->ifa_list);
136         WARN_ON(idev->mc_list);
137 #ifdef NET_REFCNT_DEBUG
138         printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
139                idev, dev ? dev->name : "NIL");
140 #endif
141         dev_put(dev);
142         if (!idev->dead)
143                 pr_err("Freeing alive in_device %p\n", idev);
144         else
145                 kfree(idev);
146 }
147 EXPORT_SYMBOL(in_dev_finish_destroy);
148
149 static struct in_device *inetdev_init(struct net_device *dev)
150 {
151         struct in_device *in_dev;
152
153         ASSERT_RTNL();
154
155         in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
156         if (!in_dev)
157                 goto out;
158         memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
159                         sizeof(in_dev->cnf));
160         in_dev->cnf.sysctl = NULL;
161         in_dev->dev = dev;
162         in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
163         if (!in_dev->arp_parms)
164                 goto out_kfree;
165         if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
166                 dev_disable_lro(dev);
167         /* Reference in_dev->dev */
168         dev_hold(dev);
169         /* Account for reference dev->ip_ptr (below) */
170         in_dev_hold(in_dev);
171
172         devinet_sysctl_register(in_dev);
173         ip_mc_init_dev(in_dev);
174         if (dev->flags & IFF_UP)
175                 ip_mc_up(in_dev);
176
177         /* we can receive as soon as ip_ptr is set -- do this last */
178         rcu_assign_pointer(dev->ip_ptr, in_dev);
179 out:
180         return in_dev;
181 out_kfree:
182         kfree(in_dev);
183         in_dev = NULL;
184         goto out;
185 }
186
187 static void in_dev_rcu_put(struct rcu_head *head)
188 {
189         struct in_device *idev = container_of(head, struct in_device, rcu_head);
190         in_dev_put(idev);
191 }
192
193 static void inetdev_destroy(struct in_device *in_dev)
194 {
195         struct in_ifaddr *ifa;
196         struct net_device *dev;
197
198         ASSERT_RTNL();
199
200         dev = in_dev->dev;
201
202         in_dev->dead = 1;
203
204         ip_mc_destroy_dev(in_dev);
205
206         while ((ifa = in_dev->ifa_list) != NULL) {
207                 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
208                 inet_free_ifa(ifa);
209         }
210
211         dev->ip_ptr = NULL;
212
213         devinet_sysctl_unregister(in_dev);
214         neigh_parms_release(&arp_tbl, in_dev->arp_parms);
215         arp_ifdown(dev);
216
217         call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
218 }
219
220 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
221 {
222         rcu_read_lock();
223         for_primary_ifa(in_dev) {
224                 if (inet_ifa_match(a, ifa)) {
225                         if (!b || inet_ifa_match(b, ifa)) {
226                                 rcu_read_unlock();
227                                 return 1;
228                         }
229                 }
230         } endfor_ifa(in_dev);
231         rcu_read_unlock();
232         return 0;
233 }
234
235 static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
236                          int destroy, struct nlmsghdr *nlh, u32 pid)
237 {
238         struct in_ifaddr *promote = NULL;
239         struct in_ifaddr *ifa, *ifa1 = *ifap;
240         struct in_ifaddr *last_prim = in_dev->ifa_list;
241         struct in_ifaddr *prev_prom = NULL;
242         int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
243
244         ASSERT_RTNL();
245
246         /* 1. Deleting primary ifaddr forces deletion all secondaries
247          * unless alias promotion is set
248          **/
249
250         if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
251                 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
252
253                 while ((ifa = *ifap1) != NULL) {
254                         if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
255                             ifa1->ifa_scope <= ifa->ifa_scope)
256                                 last_prim = ifa;
257
258                         if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
259                             ifa1->ifa_mask != ifa->ifa_mask ||
260                             !inet_ifa_match(ifa1->ifa_address, ifa)) {
261                                 ifap1 = &ifa->ifa_next;
262                                 prev_prom = ifa;
263                                 continue;
264                         }
265
266                         if (!do_promote) {
267                                 *ifap1 = ifa->ifa_next;
268
269                                 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
270                                 blocking_notifier_call_chain(&inetaddr_chain,
271                                                 NETDEV_DOWN, ifa);
272                                 inet_free_ifa(ifa);
273                         } else {
274                                 promote = ifa;
275                                 break;
276                         }
277                 }
278         }
279
280         /* 2. Unlink it */
281
282         *ifap = ifa1->ifa_next;
283
284         /* 3. Announce address deletion */
285
286         /* Send message first, then call notifier.
287            At first sight, FIB update triggered by notifier
288            will refer to already deleted ifaddr, that could confuse
289            netlink listeners. It is not true: look, gated sees
290            that route deleted and if it still thinks that ifaddr
291            is valid, it will try to restore deleted routes... Grr.
292            So that, this order is correct.
293          */
294         rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
295         blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
296
297         if (promote) {
298
299                 if (prev_prom) {
300                         prev_prom->ifa_next = promote->ifa_next;
301                         promote->ifa_next = last_prim->ifa_next;
302                         last_prim->ifa_next = promote;
303                 }
304
305                 promote->ifa_flags &= ~IFA_F_SECONDARY;
306                 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
307                 blocking_notifier_call_chain(&inetaddr_chain,
308                                 NETDEV_UP, promote);
309                 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
310                         if (ifa1->ifa_mask != ifa->ifa_mask ||
311                             !inet_ifa_match(ifa1->ifa_address, ifa))
312                                         continue;
313                         fib_add_ifaddr(ifa);
314                 }
315
316         }
317         if (destroy)
318                 inet_free_ifa(ifa1);
319 }
320
321 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
322                          int destroy)
323 {
324         __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
325 }
326
327 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
328                              u32 pid)
329 {
330         struct in_device *in_dev = ifa->ifa_dev;
331         struct in_ifaddr *ifa1, **ifap, **last_primary;
332
333         ASSERT_RTNL();
334
335         if (!ifa->ifa_local) {
336                 inet_free_ifa(ifa);
337                 return 0;
338         }
339
340         ifa->ifa_flags &= ~IFA_F_SECONDARY;
341         last_primary = &in_dev->ifa_list;
342
343         for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
344              ifap = &ifa1->ifa_next) {
345                 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
346                     ifa->ifa_scope <= ifa1->ifa_scope)
347                         last_primary = &ifa1->ifa_next;
348                 if (ifa1->ifa_mask == ifa->ifa_mask &&
349                     inet_ifa_match(ifa1->ifa_address, ifa)) {
350                         if (ifa1->ifa_local == ifa->ifa_local) {
351                                 inet_free_ifa(ifa);
352                                 return -EEXIST;
353                         }
354                         if (ifa1->ifa_scope != ifa->ifa_scope) {
355                                 inet_free_ifa(ifa);
356                                 return -EINVAL;
357                         }
358                         ifa->ifa_flags |= IFA_F_SECONDARY;
359                 }
360         }
361
362         if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
363                 net_srandom(ifa->ifa_local);
364                 ifap = last_primary;
365         }
366
367         ifa->ifa_next = *ifap;
368         *ifap = ifa;
369
370         /* Send message first, then call notifier.
371            Notifier will trigger FIB update, so that
372            listeners of netlink will know about new ifaddr */
373         rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
374         blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
375
376         return 0;
377 }
378
379 static int inet_insert_ifa(struct in_ifaddr *ifa)
380 {
381         return __inet_insert_ifa(ifa, NULL, 0);
382 }
383
384 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
385 {
386         struct in_device *in_dev = __in_dev_get_rtnl(dev);
387
388         ASSERT_RTNL();
389
390         if (!in_dev) {
391                 inet_free_ifa(ifa);
392                 return -ENOBUFS;
393         }
394         ipv4_devconf_setall(in_dev);
395         if (ifa->ifa_dev != in_dev) {
396                 WARN_ON(ifa->ifa_dev);
397                 in_dev_hold(in_dev);
398                 ifa->ifa_dev = in_dev;
399         }
400         if (ipv4_is_loopback(ifa->ifa_local))
401                 ifa->ifa_scope = RT_SCOPE_HOST;
402         return inet_insert_ifa(ifa);
403 }
404
405 struct in_device *inetdev_by_index(struct net *net, int ifindex)
406 {
407         struct net_device *dev;
408         struct in_device *in_dev = NULL;
409
410         rcu_read_lock();
411         dev = dev_get_by_index_rcu(net, ifindex);
412         if (dev)
413                 in_dev = in_dev_get(dev);
414         rcu_read_unlock();
415         return in_dev;
416 }
417 EXPORT_SYMBOL(inetdev_by_index);
418
419 /* Called only from RTNL semaphored context. No locks. */
420
421 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
422                                     __be32 mask)
423 {
424         ASSERT_RTNL();
425
426         for_primary_ifa(in_dev) {
427                 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
428                         return ifa;
429         } endfor_ifa(in_dev);
430         return NULL;
431 }
432
433 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
434 {
435         struct net *net = sock_net(skb->sk);
436         struct nlattr *tb[IFA_MAX+1];
437         struct in_device *in_dev;
438         struct ifaddrmsg *ifm;
439         struct in_ifaddr *ifa, **ifap;
440         int err = -EINVAL;
441
442         ASSERT_RTNL();
443
444         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
445         if (err < 0)
446                 goto errout;
447
448         ifm = nlmsg_data(nlh);
449         in_dev = inetdev_by_index(net, ifm->ifa_index);
450         if (in_dev == NULL) {
451                 err = -ENODEV;
452                 goto errout;
453         }
454
455         __in_dev_put(in_dev);
456
457         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
458              ifap = &ifa->ifa_next) {
459                 if (tb[IFA_LOCAL] &&
460                     ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
461                         continue;
462
463                 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
464                         continue;
465
466                 if (tb[IFA_ADDRESS] &&
467                     (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
468                     !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
469                         continue;
470
471                 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
472                 return 0;
473         }
474
475         err = -EADDRNOTAVAIL;
476 errout:
477         return err;
478 }
479
480 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
481 {
482         struct nlattr *tb[IFA_MAX+1];
483         struct in_ifaddr *ifa;
484         struct ifaddrmsg *ifm;
485         struct net_device *dev;
486         struct in_device *in_dev;
487         int err;
488
489         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
490         if (err < 0)
491                 goto errout;
492
493         ifm = nlmsg_data(nlh);
494         err = -EINVAL;
495         if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
496                 goto errout;
497
498         dev = __dev_get_by_index(net, ifm->ifa_index);
499         err = -ENODEV;
500         if (dev == NULL)
501                 goto errout;
502
503         in_dev = __in_dev_get_rtnl(dev);
504         err = -ENOBUFS;
505         if (in_dev == NULL)
506                 goto errout;
507
508         ifa = inet_alloc_ifa();
509         if (ifa == NULL)
510                 /*
511                  * A potential indev allocation can be left alive, it stays
512                  * assigned to its device and is destroy with it.
513                  */
514                 goto errout;
515
516         ipv4_devconf_setall(in_dev);
517         in_dev_hold(in_dev);
518
519         if (tb[IFA_ADDRESS] == NULL)
520                 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
521
522         ifa->ifa_prefixlen = ifm->ifa_prefixlen;
523         ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
524         ifa->ifa_flags = ifm->ifa_flags;
525         ifa->ifa_scope = ifm->ifa_scope;
526         ifa->ifa_dev = in_dev;
527
528         ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
529         ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
530
531         if (tb[IFA_BROADCAST])
532                 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
533
534         if (tb[IFA_LABEL])
535                 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
536         else
537                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
538
539         return ifa;
540
541 errout:
542         return ERR_PTR(err);
543 }
544
545 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
546 {
547         struct net *net = sock_net(skb->sk);
548         struct in_ifaddr *ifa;
549
550         ASSERT_RTNL();
551
552         ifa = rtm_to_ifaddr(net, nlh);
553         if (IS_ERR(ifa))
554                 return PTR_ERR(ifa);
555
556         return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
557 }
558
559 /*
560  *      Determine a default network mask, based on the IP address.
561  */
562
563 static inline int inet_abc_len(__be32 addr)
564 {
565         int rc = -1;    /* Something else, probably a multicast. */
566
567         if (ipv4_is_zeronet(addr))
568                 rc = 0;
569         else {
570                 __u32 haddr = ntohl(addr);
571
572                 if (IN_CLASSA(haddr))
573                         rc = 8;
574                 else if (IN_CLASSB(haddr))
575                         rc = 16;
576                 else if (IN_CLASSC(haddr))
577                         rc = 24;
578         }
579
580         return rc;
581 }
582
583
584 int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
585 {
586         struct ifreq ifr;
587         struct sockaddr_in sin_orig;
588         struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
589         struct in_device *in_dev;
590         struct in_ifaddr **ifap = NULL;
591         struct in_ifaddr *ifa = NULL;
592         struct net_device *dev;
593         char *colon;
594         int ret = -EFAULT;
595         int tryaddrmatch = 0;
596
597         /*
598          *      Fetch the caller's info block into kernel space
599          */
600
601         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
602                 goto out;
603         ifr.ifr_name[IFNAMSIZ - 1] = 0;
604
605         /* save original address for comparison */
606         memcpy(&sin_orig, sin, sizeof(*sin));
607
608         colon = strchr(ifr.ifr_name, ':');
609         if (colon)
610                 *colon = 0;
611
612         dev_load(net, ifr.ifr_name);
613
614         switch (cmd) {
615         case SIOCGIFADDR:       /* Get interface address */
616         case SIOCGIFBRDADDR:    /* Get the broadcast address */
617         case SIOCGIFDSTADDR:    /* Get the destination address */
618         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
619                 /* Note that these ioctls will not sleep,
620                    so that we do not impose a lock.
621                    One day we will be forced to put shlock here (I mean SMP)
622                  */
623                 tryaddrmatch = (sin_orig.sin_family == AF_INET);
624                 memset(sin, 0, sizeof(*sin));
625                 sin->sin_family = AF_INET;
626                 break;
627
628         case SIOCSIFFLAGS:
629                 ret = -EACCES;
630                 if (!capable(CAP_NET_ADMIN))
631                         goto out;
632                 break;
633         case SIOCSIFADDR:       /* Set interface address (and family) */
634         case SIOCSIFBRDADDR:    /* Set the broadcast address */
635         case SIOCSIFDSTADDR:    /* Set the destination address */
636         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
637                 ret = -EACCES;
638                 if (!capable(CAP_NET_ADMIN))
639                         goto out;
640                 ret = -EINVAL;
641                 if (sin->sin_family != AF_INET)
642                         goto out;
643                 break;
644         default:
645                 ret = -EINVAL;
646                 goto out;
647         }
648
649         rtnl_lock();
650
651         ret = -ENODEV;
652         dev = __dev_get_by_name(net, ifr.ifr_name);
653         if (!dev)
654                 goto done;
655
656         if (colon)
657                 *colon = ':';
658
659         in_dev = __in_dev_get_rtnl(dev);
660         if (in_dev) {
661                 if (tryaddrmatch) {
662                         /* Matthias Andree */
663                         /* compare label and address (4.4BSD style) */
664                         /* note: we only do this for a limited set of ioctls
665                            and only if the original address family was AF_INET.
666                            This is checked above. */
667                         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
668                              ifap = &ifa->ifa_next) {
669                                 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
670                                     sin_orig.sin_addr.s_addr ==
671                                                         ifa->ifa_address) {
672                                         break; /* found */
673                                 }
674                         }
675                 }
676                 /* we didn't get a match, maybe the application is
677                    4.3BSD-style and passed in junk so we fall back to
678                    comparing just the label */
679                 if (!ifa) {
680                         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
681                              ifap = &ifa->ifa_next)
682                                 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
683                                         break;
684                 }
685         }
686
687         ret = -EADDRNOTAVAIL;
688         if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
689                 goto done;
690
691         switch (cmd) {
692         case SIOCGIFADDR:       /* Get interface address */
693                 sin->sin_addr.s_addr = ifa->ifa_local;
694                 goto rarok;
695
696         case SIOCGIFBRDADDR:    /* Get the broadcast address */
697                 sin->sin_addr.s_addr = ifa->ifa_broadcast;
698                 goto rarok;
699
700         case SIOCGIFDSTADDR:    /* Get the destination address */
701                 sin->sin_addr.s_addr = ifa->ifa_address;
702                 goto rarok;
703
704         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
705                 sin->sin_addr.s_addr = ifa->ifa_mask;
706                 goto rarok;
707
708         case SIOCSIFFLAGS:
709                 if (colon) {
710                         ret = -EADDRNOTAVAIL;
711                         if (!ifa)
712                                 break;
713                         ret = 0;
714                         if (!(ifr.ifr_flags & IFF_UP))
715                                 inet_del_ifa(in_dev, ifap, 1);
716                         break;
717                 }
718                 ret = dev_change_flags(dev, ifr.ifr_flags);
719                 break;
720
721         case SIOCSIFADDR:       /* Set interface address (and family) */
722                 ret = -EINVAL;
723                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
724                         break;
725
726                 if (!ifa) {
727                         ret = -ENOBUFS;
728                         ifa = inet_alloc_ifa();
729                         if (!ifa)
730                                 break;
731                         if (colon)
732                                 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
733                         else
734                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
735                 } else {
736                         ret = 0;
737                         if (ifa->ifa_local == sin->sin_addr.s_addr)
738                                 break;
739                         inet_del_ifa(in_dev, ifap, 0);
740                         ifa->ifa_broadcast = 0;
741                         ifa->ifa_scope = 0;
742                 }
743
744                 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
745
746                 if (!(dev->flags & IFF_POINTOPOINT)) {
747                         ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
748                         ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
749                         if ((dev->flags & IFF_BROADCAST) &&
750                             ifa->ifa_prefixlen < 31)
751                                 ifa->ifa_broadcast = ifa->ifa_address |
752                                                      ~ifa->ifa_mask;
753                 } else {
754                         ifa->ifa_prefixlen = 32;
755                         ifa->ifa_mask = inet_make_mask(32);
756                 }
757                 ret = inet_set_ifa(dev, ifa);
758                 break;
759
760         case SIOCSIFBRDADDR:    /* Set the broadcast address */
761                 ret = 0;
762                 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
763                         inet_del_ifa(in_dev, ifap, 0);
764                         ifa->ifa_broadcast = sin->sin_addr.s_addr;
765                         inet_insert_ifa(ifa);
766                 }
767                 break;
768
769         case SIOCSIFDSTADDR:    /* Set the destination address */
770                 ret = 0;
771                 if (ifa->ifa_address == sin->sin_addr.s_addr)
772                         break;
773                 ret = -EINVAL;
774                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
775                         break;
776                 ret = 0;
777                 inet_del_ifa(in_dev, ifap, 0);
778                 ifa->ifa_address = sin->sin_addr.s_addr;
779                 inet_insert_ifa(ifa);
780                 break;
781
782         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
783
784                 /*
785                  *      The mask we set must be legal.
786                  */
787                 ret = -EINVAL;
788                 if (bad_mask(sin->sin_addr.s_addr, 0))
789                         break;
790                 ret = 0;
791                 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
792                         __be32 old_mask = ifa->ifa_mask;
793                         inet_del_ifa(in_dev, ifap, 0);
794                         ifa->ifa_mask = sin->sin_addr.s_addr;
795                         ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
796
797                         /* See if current broadcast address matches
798                          * with current netmask, then recalculate
799                          * the broadcast address. Otherwise it's a
800                          * funny address, so don't touch it since
801                          * the user seems to know what (s)he's doing...
802                          */
803                         if ((dev->flags & IFF_BROADCAST) &&
804                             (ifa->ifa_prefixlen < 31) &&
805                             (ifa->ifa_broadcast ==
806                              (ifa->ifa_local|~old_mask))) {
807                                 ifa->ifa_broadcast = (ifa->ifa_local |
808                                                       ~sin->sin_addr.s_addr);
809                         }
810                         inet_insert_ifa(ifa);
811                 }
812                 break;
813         }
814 done:
815         rtnl_unlock();
816 out:
817         return ret;
818 rarok:
819         rtnl_unlock();
820         ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
821         goto out;
822 }
823
824 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
825 {
826         struct in_device *in_dev = __in_dev_get_rtnl(dev);
827         struct in_ifaddr *ifa;
828         struct ifreq ifr;
829         int done = 0;
830
831         if (!in_dev)
832                 goto out;
833
834         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
835                 if (!buf) {
836                         done += sizeof(ifr);
837                         continue;
838                 }
839                 if (len < (int) sizeof(ifr))
840                         break;
841                 memset(&ifr, 0, sizeof(struct ifreq));
842                 if (ifa->ifa_label)
843                         strcpy(ifr.ifr_name, ifa->ifa_label);
844                 else
845                         strcpy(ifr.ifr_name, dev->name);
846
847                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
848                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
849                                                                 ifa->ifa_local;
850
851                 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
852                         done = -EFAULT;
853                         break;
854                 }
855                 buf  += sizeof(struct ifreq);
856                 len  -= sizeof(struct ifreq);
857                 done += sizeof(struct ifreq);
858         }
859 out:
860         return done;
861 }
862
863 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
864 {
865         __be32 addr = 0;
866         struct in_device *in_dev;
867         struct net *net = dev_net(dev);
868
869         rcu_read_lock();
870         in_dev = __in_dev_get_rcu(dev);
871         if (!in_dev)
872                 goto no_in_dev;
873
874         for_primary_ifa(in_dev) {
875                 if (ifa->ifa_scope > scope)
876                         continue;
877                 if (!dst || inet_ifa_match(dst, ifa)) {
878                         addr = ifa->ifa_local;
879                         break;
880                 }
881                 if (!addr)
882                         addr = ifa->ifa_local;
883         } endfor_ifa(in_dev);
884
885         if (addr)
886                 goto out_unlock;
887 no_in_dev:
888
889         /* Not loopback addresses on loopback should be preferred
890            in this case. It is importnat that lo is the first interface
891            in dev_base list.
892          */
893         for_each_netdev_rcu(net, dev) {
894                 in_dev = __in_dev_get_rcu(dev);
895                 if (!in_dev)
896                         continue;
897
898                 for_primary_ifa(in_dev) {
899                         if (ifa->ifa_scope != RT_SCOPE_LINK &&
900                             ifa->ifa_scope <= scope) {
901                                 addr = ifa->ifa_local;
902                                 goto out_unlock;
903                         }
904                 } endfor_ifa(in_dev);
905         }
906 out_unlock:
907         rcu_read_unlock();
908         return addr;
909 }
910 EXPORT_SYMBOL(inet_select_addr);
911
912 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
913                               __be32 local, int scope)
914 {
915         int same = 0;
916         __be32 addr = 0;
917
918         for_ifa(in_dev) {
919                 if (!addr &&
920                     (local == ifa->ifa_local || !local) &&
921                     ifa->ifa_scope <= scope) {
922                         addr = ifa->ifa_local;
923                         if (same)
924                                 break;
925                 }
926                 if (!same) {
927                         same = (!local || inet_ifa_match(local, ifa)) &&
928                                 (!dst || inet_ifa_match(dst, ifa));
929                         if (same && addr) {
930                                 if (local || !dst)
931                                         break;
932                                 /* Is the selected addr into dst subnet? */
933                                 if (inet_ifa_match(addr, ifa))
934                                         break;
935                                 /* No, then can we use new local src? */
936                                 if (ifa->ifa_scope <= scope) {
937                                         addr = ifa->ifa_local;
938                                         break;
939                                 }
940                                 /* search for large dst subnet for addr */
941                                 same = 0;
942                         }
943                 }
944         } endfor_ifa(in_dev);
945
946         return same ? addr : 0;
947 }
948
949 /*
950  * Confirm that local IP address exists using wildcards:
951  * - in_dev: only on this interface, 0=any interface
952  * - dst: only in the same subnet as dst, 0=any dst
953  * - local: address, 0=autoselect the local address
954  * - scope: maximum allowed scope value for the local address
955  */
956 __be32 inet_confirm_addr(struct in_device *in_dev,
957                          __be32 dst, __be32 local, int scope)
958 {
959         __be32 addr = 0;
960         struct net_device *dev;
961         struct net *net;
962
963         if (scope != RT_SCOPE_LINK)
964                 return confirm_addr_indev(in_dev, dst, local, scope);
965
966         net = dev_net(in_dev->dev);
967         rcu_read_lock();
968         for_each_netdev_rcu(net, dev) {
969                 in_dev = __in_dev_get_rcu(dev);
970                 if (in_dev) {
971                         addr = confirm_addr_indev(in_dev, dst, local, scope);
972                         if (addr)
973                                 break;
974                 }
975         }
976         rcu_read_unlock();
977
978         return addr;
979 }
980
981 /*
982  *      Device notifier
983  */
984
985 int register_inetaddr_notifier(struct notifier_block *nb)
986 {
987         return blocking_notifier_chain_register(&inetaddr_chain, nb);
988 }
989 EXPORT_SYMBOL(register_inetaddr_notifier);
990
991 int unregister_inetaddr_notifier(struct notifier_block *nb)
992 {
993         return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
994 }
995 EXPORT_SYMBOL(unregister_inetaddr_notifier);
996
997 /* Rename ifa_labels for a device name change. Make some effort to preserve
998  * existing alias numbering and to create unique labels if possible.
999 */
1000 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1001 {
1002         struct in_ifaddr *ifa;
1003         int named = 0;
1004
1005         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1006                 char old[IFNAMSIZ], *dot;
1007
1008                 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1009                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1010                 if (named++ == 0)
1011                         goto skip;
1012                 dot = strchr(old, ':');
1013                 if (dot == NULL) {
1014                         sprintf(old, ":%d", named);
1015                         dot = old;
1016                 }
1017                 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1018                         strcat(ifa->ifa_label, dot);
1019                 else
1020                         strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1021 skip:
1022                 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1023         }
1024 }
1025
1026 static inline bool inetdev_valid_mtu(unsigned mtu)
1027 {
1028         return mtu >= 68;
1029 }
1030
1031 /* Called only under RTNL semaphore */
1032
1033 static int inetdev_event(struct notifier_block *this, unsigned long event,
1034                          void *ptr)
1035 {
1036         struct net_device *dev = ptr;
1037         struct in_device *in_dev = __in_dev_get_rtnl(dev);
1038
1039         ASSERT_RTNL();
1040
1041         if (!in_dev) {
1042                 if (event == NETDEV_REGISTER) {
1043                         in_dev = inetdev_init(dev);
1044                         if (!in_dev)
1045                                 return notifier_from_errno(-ENOMEM);
1046                         if (dev->flags & IFF_LOOPBACK) {
1047                                 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1048                                 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1049                         }
1050                 } else if (event == NETDEV_CHANGEMTU) {
1051                         /* Re-enabling IP */
1052                         if (inetdev_valid_mtu(dev->mtu))
1053                                 in_dev = inetdev_init(dev);
1054                 }
1055                 goto out;
1056         }
1057
1058         switch (event) {
1059         case NETDEV_REGISTER:
1060                 printk(KERN_DEBUG "inetdev_event: bug\n");
1061                 dev->ip_ptr = NULL;
1062                 break;
1063         case NETDEV_UP:
1064                 if (!inetdev_valid_mtu(dev->mtu))
1065                         break;
1066                 if (dev->flags & IFF_LOOPBACK) {
1067                         struct in_ifaddr *ifa = inet_alloc_ifa();
1068
1069                         if (ifa) {
1070                                 ifa->ifa_local =
1071                                   ifa->ifa_address = htonl(INADDR_LOOPBACK);
1072                                 ifa->ifa_prefixlen = 8;
1073                                 ifa->ifa_mask = inet_make_mask(8);
1074                                 in_dev_hold(in_dev);
1075                                 ifa->ifa_dev = in_dev;
1076                                 ifa->ifa_scope = RT_SCOPE_HOST;
1077                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1078                                 inet_insert_ifa(ifa);
1079                         }
1080                 }
1081                 ip_mc_up(in_dev);
1082                 /* fall through */
1083         case NETDEV_CHANGEADDR:
1084                 /* Send gratuitous ARP to notify of link change */
1085                 if (IN_DEV_ARP_NOTIFY(in_dev)) {
1086                         struct in_ifaddr *ifa = in_dev->ifa_list;
1087
1088                         if (ifa)
1089                                 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1090                                          ifa->ifa_address, dev,
1091                                          ifa->ifa_address, NULL,
1092                                          dev->dev_addr, NULL);
1093                 }
1094                 break;
1095         case NETDEV_DOWN:
1096                 ip_mc_down(in_dev);
1097                 break;
1098         case NETDEV_BONDING_OLDTYPE:
1099                 ip_mc_unmap(in_dev);
1100                 break;
1101         case NETDEV_BONDING_NEWTYPE:
1102                 ip_mc_remap(in_dev);
1103                 break;
1104         case NETDEV_CHANGEMTU:
1105                 if (inetdev_valid_mtu(dev->mtu))
1106                         break;
1107                 /* disable IP when MTU is not enough */
1108         case NETDEV_UNREGISTER:
1109                 inetdev_destroy(in_dev);
1110                 break;
1111         case NETDEV_CHANGENAME:
1112                 /* Do not notify about label change, this event is
1113                  * not interesting to applications using netlink.
1114                  */
1115                 inetdev_changename(dev, in_dev);
1116
1117                 devinet_sysctl_unregister(in_dev);
1118                 devinet_sysctl_register(in_dev);
1119                 break;
1120         }
1121 out:
1122         return NOTIFY_DONE;
1123 }
1124
1125 static struct notifier_block ip_netdev_notifier = {
1126         .notifier_call = inetdev_event,
1127 };
1128
1129 static inline size_t inet_nlmsg_size(void)
1130 {
1131         return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1132                + nla_total_size(4) /* IFA_ADDRESS */
1133                + nla_total_size(4) /* IFA_LOCAL */
1134                + nla_total_size(4) /* IFA_BROADCAST */
1135                + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1136 }
1137
1138 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1139                             u32 pid, u32 seq, int event, unsigned int flags)
1140 {
1141         struct ifaddrmsg *ifm;
1142         struct nlmsghdr  *nlh;
1143
1144         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1145         if (nlh == NULL)
1146                 return -EMSGSIZE;
1147
1148         ifm = nlmsg_data(nlh);
1149         ifm->ifa_family = AF_INET;
1150         ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1151         ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1152         ifm->ifa_scope = ifa->ifa_scope;
1153         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1154
1155         if (ifa->ifa_address)
1156                 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1157
1158         if (ifa->ifa_local)
1159                 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1160
1161         if (ifa->ifa_broadcast)
1162                 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1163
1164         if (ifa->ifa_label[0])
1165                 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1166
1167         return nlmsg_end(skb, nlh);
1168
1169 nla_put_failure:
1170         nlmsg_cancel(skb, nlh);
1171         return -EMSGSIZE;
1172 }
1173
1174 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1175 {
1176         struct net *net = sock_net(skb->sk);
1177         int h, s_h;
1178         int idx, s_idx;
1179         int ip_idx, s_ip_idx;
1180         struct net_device *dev;
1181         struct in_device *in_dev;
1182         struct in_ifaddr *ifa;
1183         struct hlist_head *head;
1184         struct hlist_node *node;
1185
1186         s_h = cb->args[0];
1187         s_idx = idx = cb->args[1];
1188         s_ip_idx = ip_idx = cb->args[2];
1189
1190         for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1191                 idx = 0;
1192                 head = &net->dev_index_head[h];
1193                 rcu_read_lock();
1194                 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
1195                         if (idx < s_idx)
1196                                 goto cont;
1197                         if (h > s_h || idx > s_idx)
1198                                 s_ip_idx = 0;
1199                         in_dev = __in_dev_get_rcu(dev);
1200                         if (!in_dev)
1201                                 goto cont;
1202
1203                         for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1204                              ifa = ifa->ifa_next, ip_idx++) {
1205                                 if (ip_idx < s_ip_idx)
1206                                         continue;
1207                                 if (inet_fill_ifaddr(skb, ifa,
1208                                              NETLINK_CB(cb->skb).pid,
1209                                              cb->nlh->nlmsg_seq,
1210                                              RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1211                                         rcu_read_unlock();
1212                                         goto done;
1213                                 }
1214                         }
1215 cont:
1216                         idx++;
1217                 }
1218                 rcu_read_unlock();
1219         }
1220
1221 done:
1222         cb->args[0] = h;
1223         cb->args[1] = idx;
1224         cb->args[2] = ip_idx;
1225
1226         return skb->len;
1227 }
1228
1229 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1230                       u32 pid)
1231 {
1232         struct sk_buff *skb;
1233         u32 seq = nlh ? nlh->nlmsg_seq : 0;
1234         int err = -ENOBUFS;
1235         struct net *net;
1236
1237         net = dev_net(ifa->ifa_dev->dev);
1238         skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1239         if (skb == NULL)
1240                 goto errout;
1241
1242         err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1243         if (err < 0) {
1244                 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1245                 WARN_ON(err == -EMSGSIZE);
1246                 kfree_skb(skb);
1247                 goto errout;
1248         }
1249         rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1250         return;
1251 errout:
1252         if (err < 0)
1253                 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1254 }
1255
1256 #ifdef CONFIG_SYSCTL
1257
1258 static void devinet_copy_dflt_conf(struct net *net, int i)
1259 {
1260         struct net_device *dev;
1261
1262         rcu_read_lock();
1263         for_each_netdev_rcu(net, dev) {
1264                 struct in_device *in_dev;
1265
1266                 in_dev = __in_dev_get_rcu(dev);
1267                 if (in_dev && !test_bit(i, in_dev->cnf.state))
1268                         in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1269         }
1270         rcu_read_unlock();
1271 }
1272
1273 /* called with RTNL locked */
1274 static void inet_forward_change(struct net *net)
1275 {
1276         struct net_device *dev;
1277         int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1278
1279         IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1280         IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1281
1282         for_each_netdev(net, dev) {
1283                 struct in_device *in_dev;
1284                 if (on)
1285                         dev_disable_lro(dev);
1286                 rcu_read_lock();
1287                 in_dev = __in_dev_get_rcu(dev);
1288                 if (in_dev)
1289                         IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1290                 rcu_read_unlock();
1291         }
1292 }
1293
1294 static int devinet_conf_proc(ctl_table *ctl, int write,
1295                              void __user *buffer,
1296                              size_t *lenp, loff_t *ppos)
1297 {
1298         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1299
1300         if (write) {
1301                 struct ipv4_devconf *cnf = ctl->extra1;
1302                 struct net *net = ctl->extra2;
1303                 int i = (int *)ctl->data - cnf->data;
1304
1305                 set_bit(i, cnf->state);
1306
1307                 if (cnf == net->ipv4.devconf_dflt)
1308                         devinet_copy_dflt_conf(net, i);
1309         }
1310
1311         return ret;
1312 }
1313
1314 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1315                                   void __user *buffer,
1316                                   size_t *lenp, loff_t *ppos)
1317 {
1318         int *valp = ctl->data;
1319         int val = *valp;
1320         loff_t pos = *ppos;
1321         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1322
1323         if (write && *valp != val) {
1324                 struct net *net = ctl->extra2;
1325
1326                 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
1327                         if (!rtnl_trylock()) {
1328                                 /* Restore the original values before restarting */
1329                                 *valp = val;
1330                                 *ppos = pos;
1331                                 return restart_syscall();
1332                         }
1333                         if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1334                                 inet_forward_change(net);
1335                         } else if (*valp) {
1336                                 struct ipv4_devconf *cnf = ctl->extra1;
1337                                 struct in_device *idev =
1338                                         container_of(cnf, struct in_device, cnf);
1339                                 dev_disable_lro(idev->dev);
1340                         }
1341                         rtnl_unlock();
1342                         rt_cache_flush(net, 0);
1343                 }
1344         }
1345
1346         return ret;
1347 }
1348
1349 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1350                          void __user *buffer,
1351                          size_t *lenp, loff_t *ppos)
1352 {
1353         int *valp = ctl->data;
1354         int val = *valp;
1355         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1356         struct net *net = ctl->extra2;
1357
1358         if (write && *valp != val)
1359                 rt_cache_flush(net, 0);
1360
1361         return ret;
1362 }
1363
1364 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
1365         { \
1366                 .procname       = name, \
1367                 .data           = ipv4_devconf.data + \
1368                                   IPV4_DEVCONF_ ## attr - 1, \
1369                 .maxlen         = sizeof(int), \
1370                 .mode           = mval, \
1371                 .proc_handler   = proc, \
1372                 .extra1         = &ipv4_devconf, \
1373         }
1374
1375 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1376         DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
1377
1378 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1379         DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
1380
1381 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1382         DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
1383
1384 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1385         DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
1386
1387 static struct devinet_sysctl_table {
1388         struct ctl_table_header *sysctl_header;
1389         struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
1390         char *dev_name;
1391 } devinet_sysctl = {
1392         .devinet_vars = {
1393                 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1394                                              devinet_sysctl_forward),
1395                 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1396
1397                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1398                 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1399                 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1400                 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1401                 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1402                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1403                                         "accept_source_route"),
1404                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
1405                 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
1406                 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1407                 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1408                 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1409                 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1410                 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1411                 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1412                 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1413                 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1414                 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1415                 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
1416                 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
1417
1418                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1419                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1420                 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1421                                               "force_igmp_version"),
1422                 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1423                                               "promote_secondaries"),
1424         },
1425 };
1426
1427 static int __devinet_sysctl_register(struct net *net, char *dev_name,
1428                                         struct ipv4_devconf *p)
1429 {
1430         int i;
1431         struct devinet_sysctl_table *t;
1432
1433 #define DEVINET_CTL_PATH_DEV    3
1434
1435         struct ctl_path devinet_ctl_path[] = {
1436                 { .procname = "net",  },
1437                 { .procname = "ipv4", },
1438                 { .procname = "conf", },
1439                 { /* to be set */ },
1440                 { },
1441         };
1442
1443         t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
1444         if (!t)
1445                 goto out;
1446
1447         for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1448                 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1449                 t->devinet_vars[i].extra1 = p;
1450                 t->devinet_vars[i].extra2 = net;
1451         }
1452
1453         /*
1454          * Make a copy of dev_name, because '.procname' is regarded as const
1455          * by sysctl and we wouldn't want anyone to change it under our feet
1456          * (see SIOCSIFNAME).
1457          */
1458         t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1459         if (!t->dev_name)
1460                 goto free;
1461
1462         devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1463
1464         t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
1465                         t->devinet_vars);
1466         if (!t->sysctl_header)
1467                 goto free_procname;
1468
1469         p->sysctl = t;
1470         return 0;
1471
1472 free_procname:
1473         kfree(t->dev_name);
1474 free:
1475         kfree(t);
1476 out:
1477         return -ENOBUFS;
1478 }
1479
1480 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1481 {
1482         struct devinet_sysctl_table *t = cnf->sysctl;
1483
1484         if (t == NULL)
1485                 return;
1486
1487         cnf->sysctl = NULL;
1488         unregister_sysctl_table(t->sysctl_header);
1489         kfree(t->dev_name);
1490         kfree(t);
1491 }
1492
1493 static void devinet_sysctl_register(struct in_device *idev)
1494 {
1495         neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
1496         __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
1497                                         &idev->cnf);
1498 }
1499
1500 static void devinet_sysctl_unregister(struct in_device *idev)
1501 {
1502         __devinet_sysctl_unregister(&idev->cnf);
1503         neigh_sysctl_unregister(idev->arp_parms);
1504 }
1505
1506 static struct ctl_table ctl_forward_entry[] = {
1507         {
1508                 .procname       = "ip_forward",
1509                 .data           = &ipv4_devconf.data[
1510                                         IPV4_DEVCONF_FORWARDING - 1],
1511                 .maxlen         = sizeof(int),
1512                 .mode           = 0644,
1513                 .proc_handler   = devinet_sysctl_forward,
1514                 .extra1         = &ipv4_devconf,
1515                 .extra2         = &init_net,
1516         },
1517         { },
1518 };
1519
1520 static __net_initdata struct ctl_path net_ipv4_path[] = {
1521         { .procname = "net", },
1522         { .procname = "ipv4", },
1523         { },
1524 };
1525 #endif
1526
1527 static __net_init int devinet_init_net(struct net *net)
1528 {
1529         int err;
1530         struct ipv4_devconf *all, *dflt;
1531 #ifdef CONFIG_SYSCTL
1532         struct ctl_table *tbl = ctl_forward_entry;
1533         struct ctl_table_header *forw_hdr;
1534 #endif
1535
1536         err = -ENOMEM;
1537         all = &ipv4_devconf;
1538         dflt = &ipv4_devconf_dflt;
1539
1540         if (!net_eq(net, &init_net)) {
1541                 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1542                 if (all == NULL)
1543                         goto err_alloc_all;
1544
1545                 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1546                 if (dflt == NULL)
1547                         goto err_alloc_dflt;
1548
1549 #ifdef CONFIG_SYSCTL
1550                 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1551                 if (tbl == NULL)
1552                         goto err_alloc_ctl;
1553
1554                 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
1555                 tbl[0].extra1 = all;
1556                 tbl[0].extra2 = net;
1557 #endif
1558         }
1559
1560 #ifdef CONFIG_SYSCTL
1561         err = __devinet_sysctl_register(net, "all", all);
1562         if (err < 0)
1563                 goto err_reg_all;
1564
1565         err = __devinet_sysctl_register(net, "default", dflt);
1566         if (err < 0)
1567                 goto err_reg_dflt;
1568
1569         err = -ENOMEM;
1570         forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1571         if (forw_hdr == NULL)
1572                 goto err_reg_ctl;
1573         net->ipv4.forw_hdr = forw_hdr;
1574 #endif
1575
1576         net->ipv4.devconf_all = all;
1577         net->ipv4.devconf_dflt = dflt;
1578         return 0;
1579
1580 #ifdef CONFIG_SYSCTL
1581 err_reg_ctl:
1582         __devinet_sysctl_unregister(dflt);
1583 err_reg_dflt:
1584         __devinet_sysctl_unregister(all);
1585 err_reg_all:
1586         if (tbl != ctl_forward_entry)
1587                 kfree(tbl);
1588 err_alloc_ctl:
1589 #endif
1590         if (dflt != &ipv4_devconf_dflt)
1591                 kfree(dflt);
1592 err_alloc_dflt:
1593         if (all != &ipv4_devconf)
1594                 kfree(all);
1595 err_alloc_all:
1596         return err;
1597 }
1598
1599 static __net_exit void devinet_exit_net(struct net *net)
1600 {
1601 #ifdef CONFIG_SYSCTL
1602         struct ctl_table *tbl;
1603
1604         tbl = net->ipv4.forw_hdr->ctl_table_arg;
1605         unregister_net_sysctl_table(net->ipv4.forw_hdr);
1606         __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1607         __devinet_sysctl_unregister(net->ipv4.devconf_all);
1608         kfree(tbl);
1609 #endif
1610         kfree(net->ipv4.devconf_dflt);
1611         kfree(net->ipv4.devconf_all);
1612 }
1613
1614 static __net_initdata struct pernet_operations devinet_ops = {
1615         .init = devinet_init_net,
1616         .exit = devinet_exit_net,
1617 };
1618
1619 void __init devinet_init(void)
1620 {
1621         register_pernet_subsys(&devinet_ops);
1622
1623         register_gifconf(PF_INET, inet_gifconf);
1624         register_netdevice_notifier(&ip_netdev_notifier);
1625
1626         rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1627         rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1628         rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
1629 }
1630