1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
59#include <net/arp.h>
60#include <net/ip.h>
61#include <net/route.h>
62#include <net/ip_fib.h>
63#include <net/rtnetlink.h>
64#include <net/net_namespace.h>
65
66#include "fib_lookup.h"
67
68static struct ipv4_devconf ipv4_devconf = {
69 .data = {
70 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
71 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
72 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
73 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
74 },
75};
76
77static struct ipv4_devconf ipv4_devconf_dflt = {
78 .data = {
79 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
80 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
81 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
82 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
83 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
84 },
85};
86
87#define IPV4_DEVCONF_DFLT(net, attr) \
88 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
89
90static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
91 [IFA_LOCAL] = { .type = NLA_U32 },
92 [IFA_ADDRESS] = { .type = NLA_U32 },
93 [IFA_BROADCAST] = { .type = NLA_U32 },
94 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
95};
96
97#define IN4_ADDR_HSIZE_SHIFT 8
98#define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
99
100static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
101static DEFINE_SPINLOCK(inet_addr_hash_lock);
102
103static u32 inet_addr_hash(struct net *net, __be32 addr)
104{
105 u32 val = (__force u32) addr ^ net_hash_mix(net);
106
107 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
108}
109
110static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
111{
112 u32 hash = inet_addr_hash(net, ifa->ifa_local);
113
114 spin_lock(&inet_addr_hash_lock);
115 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
116 spin_unlock(&inet_addr_hash_lock);
117}
118
119static void inet_hash_remove(struct in_ifaddr *ifa)
120{
121 spin_lock(&inet_addr_hash_lock);
122 hlist_del_init_rcu(&ifa->hash);
123 spin_unlock(&inet_addr_hash_lock);
124}
125
126
127
128
129
130
131
132
133
134struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
135{
136 u32 hash = inet_addr_hash(net, addr);
137 struct net_device *result = NULL;
138 struct in_ifaddr *ifa;
139 struct hlist_node *node;
140
141 rcu_read_lock();
142 hlist_for_each_entry_rcu(ifa, node, &inet_addr_lst[hash], hash) {
143 if (ifa->ifa_local == addr) {
144 struct net_device *dev = ifa->ifa_dev->dev;
145
146 if (!net_eq(dev_net(dev), net))
147 continue;
148 result = dev;
149 break;
150 }
151 }
152 if (!result) {
153 struct flowi4 fl4 = { .daddr = addr };
154 struct fib_result res = { 0 };
155 struct fib_table *local;
156
157
158
159
160 local = fib_get_table(net, RT_TABLE_LOCAL);
161 if (local &&
162 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
163 res.type == RTN_LOCAL)
164 result = FIB_RES_DEV(res);
165 }
166 if (result && devref)
167 dev_hold(result);
168 rcu_read_unlock();
169 return result;
170}
171EXPORT_SYMBOL(__ip_dev_find);
172
173static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
174
175static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
176static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
177 int destroy);
178#ifdef CONFIG_SYSCTL
179static void devinet_sysctl_register(struct in_device *idev);
180static void devinet_sysctl_unregister(struct in_device *idev);
181#else
182static void devinet_sysctl_register(struct in_device *idev)
183{
184}
185static void devinet_sysctl_unregister(struct in_device *idev)
186{
187}
188#endif
189
190
191
192static struct in_ifaddr *inet_alloc_ifa(void)
193{
194 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
195}
196
197static void inet_rcu_free_ifa(struct rcu_head *head)
198{
199 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
200 if (ifa->ifa_dev)
201 in_dev_put(ifa->ifa_dev);
202 kfree(ifa);
203}
204
205static void inet_free_ifa(struct in_ifaddr *ifa)
206{
207 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
208}
209
210void in_dev_finish_destroy(struct in_device *idev)
211{
212 struct net_device *dev = idev->dev;
213
214 WARN_ON(idev->ifa_list);
215 WARN_ON(idev->mc_list);
216#ifdef NET_REFCNT_DEBUG
217 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
218#endif
219 dev_put(dev);
220 if (!idev->dead)
221 pr_err("Freeing alive in_device %p\n", idev);
222 else
223 kfree(idev);
224}
225EXPORT_SYMBOL(in_dev_finish_destroy);
226
227static struct in_device *inetdev_init(struct net_device *dev)
228{
229 struct in_device *in_dev;
230
231 ASSERT_RTNL();
232
233 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
234 if (!in_dev)
235 goto out;
236 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
237 sizeof(in_dev->cnf));
238 in_dev->cnf.sysctl = NULL;
239 in_dev->dev = dev;
240 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
241 if (!in_dev->arp_parms)
242 goto out_kfree;
243 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
244 dev_disable_lro(dev);
245
246 dev_hold(dev);
247
248 in_dev_hold(in_dev);
249
250 devinet_sysctl_register(in_dev);
251 ip_mc_init_dev(in_dev);
252 if (dev->flags & IFF_UP)
253 ip_mc_up(in_dev);
254
255
256 rcu_assign_pointer(dev->ip_ptr, in_dev);
257out:
258 return in_dev;
259out_kfree:
260 kfree(in_dev);
261 in_dev = NULL;
262 goto out;
263}
264
265static void in_dev_rcu_put(struct rcu_head *head)
266{
267 struct in_device *idev = container_of(head, struct in_device, rcu_head);
268 in_dev_put(idev);
269}
270
271static void inetdev_destroy(struct in_device *in_dev)
272{
273 struct in_ifaddr *ifa;
274 struct net_device *dev;
275
276 ASSERT_RTNL();
277
278 dev = in_dev->dev;
279
280 in_dev->dead = 1;
281
282 ip_mc_destroy_dev(in_dev);
283
284 while ((ifa = in_dev->ifa_list) != NULL) {
285 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
286 inet_free_ifa(ifa);
287 }
288
289 RCU_INIT_POINTER(dev->ip_ptr, NULL);
290
291 devinet_sysctl_unregister(in_dev);
292 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
293 arp_ifdown(dev);
294
295 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
296}
297
298int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
299{
300 rcu_read_lock();
301 for_primary_ifa(in_dev) {
302 if (inet_ifa_match(a, ifa)) {
303 if (!b || inet_ifa_match(b, ifa)) {
304 rcu_read_unlock();
305 return 1;
306 }
307 }
308 } endfor_ifa(in_dev);
309 rcu_read_unlock();
310 return 0;
311}
312
313static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
314 int destroy, struct nlmsghdr *nlh, u32 portid)
315{
316 struct in_ifaddr *promote = NULL;
317 struct in_ifaddr *ifa, *ifa1 = *ifap;
318 struct in_ifaddr *last_prim = in_dev->ifa_list;
319 struct in_ifaddr *prev_prom = NULL;
320 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
321
322 ASSERT_RTNL();
323
324
325
326
327
328 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
329 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
330
331 while ((ifa = *ifap1) != NULL) {
332 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
333 ifa1->ifa_scope <= ifa->ifa_scope)
334 last_prim = ifa;
335
336 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
337 ifa1->ifa_mask != ifa->ifa_mask ||
338 !inet_ifa_match(ifa1->ifa_address, ifa)) {
339 ifap1 = &ifa->ifa_next;
340 prev_prom = ifa;
341 continue;
342 }
343
344 if (!do_promote) {
345 inet_hash_remove(ifa);
346 *ifap1 = ifa->ifa_next;
347
348 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
349 blocking_notifier_call_chain(&inetaddr_chain,
350 NETDEV_DOWN, ifa);
351 inet_free_ifa(ifa);
352 } else {
353 promote = ifa;
354 break;
355 }
356 }
357 }
358
359
360
361
362
363
364 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
365 if (ifa1->ifa_mask == ifa->ifa_mask &&
366 inet_ifa_match(ifa1->ifa_address, ifa))
367 fib_del_ifaddr(ifa, ifa1);
368 }
369
370
371
372 *ifap = ifa1->ifa_next;
373 inet_hash_remove(ifa1);
374
375
376
377
378
379
380
381
382
383
384
385 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
386 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
387
388 if (promote) {
389 struct in_ifaddr *next_sec = promote->ifa_next;
390
391 if (prev_prom) {
392 prev_prom->ifa_next = promote->ifa_next;
393 promote->ifa_next = last_prim->ifa_next;
394 last_prim->ifa_next = promote;
395 }
396
397 promote->ifa_flags &= ~IFA_F_SECONDARY;
398 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
399 blocking_notifier_call_chain(&inetaddr_chain,
400 NETDEV_UP, promote);
401 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
402 if (ifa1->ifa_mask != ifa->ifa_mask ||
403 !inet_ifa_match(ifa1->ifa_address, ifa))
404 continue;
405 fib_add_ifaddr(ifa);
406 }
407
408 }
409 if (destroy)
410 inet_free_ifa(ifa1);
411}
412
413static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
414 int destroy)
415{
416 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
417}
418
419static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
420 u32 portid)
421{
422 struct in_device *in_dev = ifa->ifa_dev;
423 struct in_ifaddr *ifa1, **ifap, **last_primary;
424
425 ASSERT_RTNL();
426
427 if (!ifa->ifa_local) {
428 inet_free_ifa(ifa);
429 return 0;
430 }
431
432 ifa->ifa_flags &= ~IFA_F_SECONDARY;
433 last_primary = &in_dev->ifa_list;
434
435 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
436 ifap = &ifa1->ifa_next) {
437 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
438 ifa->ifa_scope <= ifa1->ifa_scope)
439 last_primary = &ifa1->ifa_next;
440 if (ifa1->ifa_mask == ifa->ifa_mask &&
441 inet_ifa_match(ifa1->ifa_address, ifa)) {
442 if (ifa1->ifa_local == ifa->ifa_local) {
443 inet_free_ifa(ifa);
444 return -EEXIST;
445 }
446 if (ifa1->ifa_scope != ifa->ifa_scope) {
447 inet_free_ifa(ifa);
448 return -EINVAL;
449 }
450 ifa->ifa_flags |= IFA_F_SECONDARY;
451 }
452 }
453
454 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
455 net_srandom(ifa->ifa_local);
456 ifap = last_primary;
457 }
458
459 ifa->ifa_next = *ifap;
460 *ifap = ifa;
461
462 inet_hash_insert(dev_net(in_dev->dev), ifa);
463
464
465
466
467 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
468 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
469
470 return 0;
471}
472
473static int inet_insert_ifa(struct in_ifaddr *ifa)
474{
475 return __inet_insert_ifa(ifa, NULL, 0);
476}
477
478static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
479{
480 struct in_device *in_dev = __in_dev_get_rtnl(dev);
481
482 ASSERT_RTNL();
483
484 if (!in_dev) {
485 inet_free_ifa(ifa);
486 return -ENOBUFS;
487 }
488 ipv4_devconf_setall(in_dev);
489 if (ifa->ifa_dev != in_dev) {
490 WARN_ON(ifa->ifa_dev);
491 in_dev_hold(in_dev);
492 ifa->ifa_dev = in_dev;
493 }
494 if (ipv4_is_loopback(ifa->ifa_local))
495 ifa->ifa_scope = RT_SCOPE_HOST;
496 return inet_insert_ifa(ifa);
497}
498
499
500
501
502struct in_device *inetdev_by_index(struct net *net, int ifindex)
503{
504 struct net_device *dev;
505 struct in_device *in_dev = NULL;
506
507 rcu_read_lock();
508 dev = dev_get_by_index_rcu(net, ifindex);
509 if (dev)
510 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
511 rcu_read_unlock();
512 return in_dev;
513}
514EXPORT_SYMBOL(inetdev_by_index);
515
516
517
518struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
519 __be32 mask)
520{
521 ASSERT_RTNL();
522
523 for_primary_ifa(in_dev) {
524 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
525 return ifa;
526 } endfor_ifa(in_dev);
527 return NULL;
528}
529
530static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
531{
532 struct net *net = sock_net(skb->sk);
533 struct nlattr *tb[IFA_MAX+1];
534 struct in_device *in_dev;
535 struct ifaddrmsg *ifm;
536 struct in_ifaddr *ifa, **ifap;
537 int err = -EINVAL;
538
539 ASSERT_RTNL();
540
541 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
542 if (err < 0)
543 goto errout;
544
545 ifm = nlmsg_data(nlh);
546 in_dev = inetdev_by_index(net, ifm->ifa_index);
547 if (in_dev == NULL) {
548 err = -ENODEV;
549 goto errout;
550 }
551
552 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
553 ifap = &ifa->ifa_next) {
554 if (tb[IFA_LOCAL] &&
555 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
556 continue;
557
558 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
559 continue;
560
561 if (tb[IFA_ADDRESS] &&
562 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
563 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
564 continue;
565
566 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
567 return 0;
568 }
569
570 err = -EADDRNOTAVAIL;
571errout:
572 return err;
573}
574
575static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
576{
577 struct nlattr *tb[IFA_MAX+1];
578 struct in_ifaddr *ifa;
579 struct ifaddrmsg *ifm;
580 struct net_device *dev;
581 struct in_device *in_dev;
582 int err;
583
584 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
585 if (err < 0)
586 goto errout;
587
588 ifm = nlmsg_data(nlh);
589 err = -EINVAL;
590 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
591 goto errout;
592
593 dev = __dev_get_by_index(net, ifm->ifa_index);
594 err = -ENODEV;
595 if (dev == NULL)
596 goto errout;
597
598 in_dev = __in_dev_get_rtnl(dev);
599 err = -ENOBUFS;
600 if (in_dev == NULL)
601 goto errout;
602
603 ifa = inet_alloc_ifa();
604 if (ifa == NULL)
605
606
607
608
609 goto errout;
610
611 ipv4_devconf_setall(in_dev);
612 in_dev_hold(in_dev);
613
614 if (tb[IFA_ADDRESS] == NULL)
615 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
616
617 INIT_HLIST_NODE(&ifa->hash);
618 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
619 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
620 ifa->ifa_flags = ifm->ifa_flags;
621 ifa->ifa_scope = ifm->ifa_scope;
622 ifa->ifa_dev = in_dev;
623
624 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
625 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
626
627 if (tb[IFA_BROADCAST])
628 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
629
630 if (tb[IFA_LABEL])
631 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
632 else
633 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
634
635 return ifa;
636
637errout:
638 return ERR_PTR(err);
639}
640
641static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
642{
643 struct net *net = sock_net(skb->sk);
644 struct in_ifaddr *ifa;
645
646 ASSERT_RTNL();
647
648 ifa = rtm_to_ifaddr(net, nlh);
649 if (IS_ERR(ifa))
650 return PTR_ERR(ifa);
651
652 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
653}
654
655
656
657
658
659static int inet_abc_len(__be32 addr)
660{
661 int rc = -1;
662
663 if (ipv4_is_zeronet(addr))
664 rc = 0;
665 else {
666 __u32 haddr = ntohl(addr);
667
668 if (IN_CLASSA(haddr))
669 rc = 8;
670 else if (IN_CLASSB(haddr))
671 rc = 16;
672 else if (IN_CLASSC(haddr))
673 rc = 24;
674 }
675
676 return rc;
677}
678
679
680int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
681{
682 struct ifreq ifr;
683 struct sockaddr_in sin_orig;
684 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
685 struct in_device *in_dev;
686 struct in_ifaddr **ifap = NULL;
687 struct in_ifaddr *ifa = NULL;
688 struct net_device *dev;
689 char *colon;
690 int ret = -EFAULT;
691 int tryaddrmatch = 0;
692
693
694
695
696
697 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
698 goto out;
699 ifr.ifr_name[IFNAMSIZ - 1] = 0;
700
701
702 memcpy(&sin_orig, sin, sizeof(*sin));
703
704 colon = strchr(ifr.ifr_name, ':');
705 if (colon)
706 *colon = 0;
707
708 dev_load(net, ifr.ifr_name);
709
710 switch (cmd) {
711 case SIOCGIFADDR:
712 case SIOCGIFBRDADDR:
713 case SIOCGIFDSTADDR:
714 case SIOCGIFNETMASK:
715
716
717
718
719 tryaddrmatch = (sin_orig.sin_family == AF_INET);
720 memset(sin, 0, sizeof(*sin));
721 sin->sin_family = AF_INET;
722 break;
723
724 case SIOCSIFFLAGS:
725 ret = -EPERM;
726 if (!capable(CAP_NET_ADMIN))
727 goto out;
728 break;
729 case SIOCSIFADDR:
730 case SIOCSIFBRDADDR:
731 case SIOCSIFDSTADDR:
732 case SIOCSIFNETMASK:
733 ret = -EPERM;
734 if (!capable(CAP_NET_ADMIN))
735 goto out;
736 ret = -EINVAL;
737 if (sin->sin_family != AF_INET)
738 goto out;
739 break;
740 default:
741 ret = -EINVAL;
742 goto out;
743 }
744
745 rtnl_lock();
746
747 ret = -ENODEV;
748 dev = __dev_get_by_name(net, ifr.ifr_name);
749 if (!dev)
750 goto done;
751
752 if (colon)
753 *colon = ':';
754
755 in_dev = __in_dev_get_rtnl(dev);
756 if (in_dev) {
757 if (tryaddrmatch) {
758
759
760
761
762
763 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
764 ifap = &ifa->ifa_next) {
765 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
766 sin_orig.sin_addr.s_addr ==
767 ifa->ifa_local) {
768 break;
769 }
770 }
771 }
772
773
774
775 if (!ifa) {
776 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
777 ifap = &ifa->ifa_next)
778 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
779 break;
780 }
781 }
782
783 ret = -EADDRNOTAVAIL;
784 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
785 goto done;
786
787 switch (cmd) {
788 case SIOCGIFADDR:
789 sin->sin_addr.s_addr = ifa->ifa_local;
790 goto rarok;
791
792 case SIOCGIFBRDADDR:
793 sin->sin_addr.s_addr = ifa->ifa_broadcast;
794 goto rarok;
795
796 case SIOCGIFDSTADDR:
797 sin->sin_addr.s_addr = ifa->ifa_address;
798 goto rarok;
799
800 case SIOCGIFNETMASK:
801 sin->sin_addr.s_addr = ifa->ifa_mask;
802 goto rarok;
803
804 case SIOCSIFFLAGS:
805 if (colon) {
806 ret = -EADDRNOTAVAIL;
807 if (!ifa)
808 break;
809 ret = 0;
810 if (!(ifr.ifr_flags & IFF_UP))
811 inet_del_ifa(in_dev, ifap, 1);
812 break;
813 }
814 ret = dev_change_flags(dev, ifr.ifr_flags);
815 break;
816
817 case SIOCSIFADDR:
818 ret = -EINVAL;
819 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
820 break;
821
822 if (!ifa) {
823 ret = -ENOBUFS;
824 ifa = inet_alloc_ifa();
825 INIT_HLIST_NODE(&ifa->hash);
826 if (!ifa)
827 break;
828 if (colon)
829 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
830 else
831 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
832 } else {
833 ret = 0;
834 if (ifa->ifa_local == sin->sin_addr.s_addr)
835 break;
836 inet_del_ifa(in_dev, ifap, 0);
837 ifa->ifa_broadcast = 0;
838 ifa->ifa_scope = 0;
839 }
840
841 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
842
843 if (!(dev->flags & IFF_POINTOPOINT)) {
844 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
845 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
846 if ((dev->flags & IFF_BROADCAST) &&
847 ifa->ifa_prefixlen < 31)
848 ifa->ifa_broadcast = ifa->ifa_address |
849 ~ifa->ifa_mask;
850 } else {
851 ifa->ifa_prefixlen = 32;
852 ifa->ifa_mask = inet_make_mask(32);
853 }
854 ret = inet_set_ifa(dev, ifa);
855 break;
856
857 case SIOCSIFBRDADDR:
858 ret = 0;
859 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
860 inet_del_ifa(in_dev, ifap, 0);
861 ifa->ifa_broadcast = sin->sin_addr.s_addr;
862 inet_insert_ifa(ifa);
863 }
864 break;
865
866 case SIOCSIFDSTADDR:
867 ret = 0;
868 if (ifa->ifa_address == sin->sin_addr.s_addr)
869 break;
870 ret = -EINVAL;
871 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
872 break;
873 ret = 0;
874 inet_del_ifa(in_dev, ifap, 0);
875 ifa->ifa_address = sin->sin_addr.s_addr;
876 inet_insert_ifa(ifa);
877 break;
878
879 case SIOCSIFNETMASK:
880
881
882
883
884 ret = -EINVAL;
885 if (bad_mask(sin->sin_addr.s_addr, 0))
886 break;
887 ret = 0;
888 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
889 __be32 old_mask = ifa->ifa_mask;
890 inet_del_ifa(in_dev, ifap, 0);
891 ifa->ifa_mask = sin->sin_addr.s_addr;
892 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
893
894
895
896
897
898
899
900 if ((dev->flags & IFF_BROADCAST) &&
901 (ifa->ifa_prefixlen < 31) &&
902 (ifa->ifa_broadcast ==
903 (ifa->ifa_local|~old_mask))) {
904 ifa->ifa_broadcast = (ifa->ifa_local |
905 ~sin->sin_addr.s_addr);
906 }
907 inet_insert_ifa(ifa);
908 }
909 break;
910 }
911done:
912 rtnl_unlock();
913out:
914 return ret;
915rarok:
916 rtnl_unlock();
917 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
918 goto out;
919}
920
921static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
922{
923 struct in_device *in_dev = __in_dev_get_rtnl(dev);
924 struct in_ifaddr *ifa;
925 struct ifreq ifr;
926 int done = 0;
927
928 if (!in_dev)
929 goto out;
930
931 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
932 if (!buf) {
933 done += sizeof(ifr);
934 continue;
935 }
936 if (len < (int) sizeof(ifr))
937 break;
938 memset(&ifr, 0, sizeof(struct ifreq));
939 if (ifa->ifa_label)
940 strcpy(ifr.ifr_name, ifa->ifa_label);
941 else
942 strcpy(ifr.ifr_name, dev->name);
943
944 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
945 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
946 ifa->ifa_local;
947
948 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
949 done = -EFAULT;
950 break;
951 }
952 buf += sizeof(struct ifreq);
953 len -= sizeof(struct ifreq);
954 done += sizeof(struct ifreq);
955 }
956out:
957 return done;
958}
959
960__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
961{
962 __be32 addr = 0;
963 struct in_device *in_dev;
964 struct net *net = dev_net(dev);
965
966 rcu_read_lock();
967 in_dev = __in_dev_get_rcu(dev);
968 if (!in_dev)
969 goto no_in_dev;
970
971 for_primary_ifa(in_dev) {
972 if (ifa->ifa_scope > scope)
973 continue;
974 if (!dst || inet_ifa_match(dst, ifa)) {
975 addr = ifa->ifa_local;
976 break;
977 }
978 if (!addr)
979 addr = ifa->ifa_local;
980 } endfor_ifa(in_dev);
981
982 if (addr)
983 goto out_unlock;
984no_in_dev:
985
986
987
988
989
990 for_each_netdev_rcu(net, dev) {
991 in_dev = __in_dev_get_rcu(dev);
992 if (!in_dev)
993 continue;
994
995 for_primary_ifa(in_dev) {
996 if (ifa->ifa_scope != RT_SCOPE_LINK &&
997 ifa->ifa_scope <= scope) {
998 addr = ifa->ifa_local;
999 goto out_unlock;
1000 }
1001 } endfor_ifa(in_dev);
1002 }
1003out_unlock:
1004 rcu_read_unlock();
1005 return addr;
1006}
1007EXPORT_SYMBOL(inet_select_addr);
1008
1009static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1010 __be32 local, int scope)
1011{
1012 int same = 0;
1013 __be32 addr = 0;
1014
1015 for_ifa(in_dev) {
1016 if (!addr &&
1017 (local == ifa->ifa_local || !local) &&
1018 ifa->ifa_scope <= scope) {
1019 addr = ifa->ifa_local;
1020 if (same)
1021 break;
1022 }
1023 if (!same) {
1024 same = (!local || inet_ifa_match(local, ifa)) &&
1025 (!dst || inet_ifa_match(dst, ifa));
1026 if (same && addr) {
1027 if (local || !dst)
1028 break;
1029
1030 if (inet_ifa_match(addr, ifa))
1031 break;
1032
1033 if (ifa->ifa_scope <= scope) {
1034 addr = ifa->ifa_local;
1035 break;
1036 }
1037
1038 same = 0;
1039 }
1040 }
1041 } endfor_ifa(in_dev);
1042
1043 return same ? addr : 0;
1044}
1045
1046
1047
1048
1049
1050
1051
1052
1053__be32 inet_confirm_addr(struct in_device *in_dev,
1054 __be32 dst, __be32 local, int scope)
1055{
1056 __be32 addr = 0;
1057 struct net_device *dev;
1058 struct net *net;
1059
1060 if (scope != RT_SCOPE_LINK)
1061 return confirm_addr_indev(in_dev, dst, local, scope);
1062
1063 net = dev_net(in_dev->dev);
1064 rcu_read_lock();
1065 for_each_netdev_rcu(net, dev) {
1066 in_dev = __in_dev_get_rcu(dev);
1067 if (in_dev) {
1068 addr = confirm_addr_indev(in_dev, dst, local, scope);
1069 if (addr)
1070 break;
1071 }
1072 }
1073 rcu_read_unlock();
1074
1075 return addr;
1076}
1077EXPORT_SYMBOL(inet_confirm_addr);
1078
1079
1080
1081
1082
1083int register_inetaddr_notifier(struct notifier_block *nb)
1084{
1085 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1086}
1087EXPORT_SYMBOL(register_inetaddr_notifier);
1088
1089int unregister_inetaddr_notifier(struct notifier_block *nb)
1090{
1091 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1092}
1093EXPORT_SYMBOL(unregister_inetaddr_notifier);
1094
1095
1096
1097
1098static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1099{
1100 struct in_ifaddr *ifa;
1101 int named = 0;
1102
1103 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1104 char old[IFNAMSIZ], *dot;
1105
1106 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1107 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1108 if (named++ == 0)
1109 goto skip;
1110 dot = strchr(old, ':');
1111 if (dot == NULL) {
1112 sprintf(old, ":%d", named);
1113 dot = old;
1114 }
1115 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1116 strcat(ifa->ifa_label, dot);
1117 else
1118 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1119skip:
1120 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1121 }
1122}
1123
1124static bool inetdev_valid_mtu(unsigned int mtu)
1125{
1126 return mtu >= 68;
1127}
1128
1129static void inetdev_send_gratuitous_arp(struct net_device *dev,
1130 struct in_device *in_dev)
1131
1132{
1133 struct in_ifaddr *ifa;
1134
1135 for (ifa = in_dev->ifa_list; ifa;
1136 ifa = ifa->ifa_next) {
1137 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1138 ifa->ifa_local, dev,
1139 ifa->ifa_local, NULL,
1140 dev->dev_addr, NULL);
1141 }
1142}
1143
1144
1145
1146static int inetdev_event(struct notifier_block *this, unsigned long event,
1147 void *ptr)
1148{
1149 struct net_device *dev = ptr;
1150 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1151
1152 ASSERT_RTNL();
1153
1154 if (!in_dev) {
1155 if (event == NETDEV_REGISTER) {
1156 in_dev = inetdev_init(dev);
1157 if (!in_dev)
1158 return notifier_from_errno(-ENOMEM);
1159 if (dev->flags & IFF_LOOPBACK) {
1160 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1161 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1162 }
1163 } else if (event == NETDEV_CHANGEMTU) {
1164
1165 if (inetdev_valid_mtu(dev->mtu))
1166 in_dev = inetdev_init(dev);
1167 }
1168 goto out;
1169 }
1170
1171 switch (event) {
1172 case NETDEV_REGISTER:
1173 pr_debug("%s: bug\n", __func__);
1174 RCU_INIT_POINTER(dev->ip_ptr, NULL);
1175 break;
1176 case NETDEV_UP:
1177 if (!inetdev_valid_mtu(dev->mtu))
1178 break;
1179 if (dev->flags & IFF_LOOPBACK) {
1180 struct in_ifaddr *ifa = inet_alloc_ifa();
1181
1182 if (ifa) {
1183 INIT_HLIST_NODE(&ifa->hash);
1184 ifa->ifa_local =
1185 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1186 ifa->ifa_prefixlen = 8;
1187 ifa->ifa_mask = inet_make_mask(8);
1188 in_dev_hold(in_dev);
1189 ifa->ifa_dev = in_dev;
1190 ifa->ifa_scope = RT_SCOPE_HOST;
1191 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1192 inet_insert_ifa(ifa);
1193 }
1194 }
1195 ip_mc_up(in_dev);
1196
1197 case NETDEV_CHANGEADDR:
1198 if (!IN_DEV_ARP_NOTIFY(in_dev))
1199 break;
1200
1201 case NETDEV_NOTIFY_PEERS:
1202
1203 inetdev_send_gratuitous_arp(dev, in_dev);
1204 break;
1205 case NETDEV_DOWN:
1206 ip_mc_down(in_dev);
1207 break;
1208 case NETDEV_PRE_TYPE_CHANGE:
1209 ip_mc_unmap(in_dev);
1210 break;
1211 case NETDEV_POST_TYPE_CHANGE:
1212 ip_mc_remap(in_dev);
1213 break;
1214 case NETDEV_CHANGEMTU:
1215 if (inetdev_valid_mtu(dev->mtu))
1216 break;
1217
1218 case NETDEV_UNREGISTER:
1219 inetdev_destroy(in_dev);
1220 break;
1221 case NETDEV_CHANGENAME:
1222
1223
1224
1225 inetdev_changename(dev, in_dev);
1226
1227 devinet_sysctl_unregister(in_dev);
1228 devinet_sysctl_register(in_dev);
1229 break;
1230 }
1231out:
1232 return NOTIFY_DONE;
1233}
1234
1235static struct notifier_block ip_netdev_notifier = {
1236 .notifier_call = inetdev_event,
1237};
1238
1239static size_t inet_nlmsg_size(void)
1240{
1241 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1242 + nla_total_size(4)
1243 + nla_total_size(4)
1244 + nla_total_size(4)
1245 + nla_total_size(IFNAMSIZ);
1246}
1247
1248static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1249 u32 portid, u32 seq, int event, unsigned int flags)
1250{
1251 struct ifaddrmsg *ifm;
1252 struct nlmsghdr *nlh;
1253
1254 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1255 if (nlh == NULL)
1256 return -EMSGSIZE;
1257
1258 ifm = nlmsg_data(nlh);
1259 ifm->ifa_family = AF_INET;
1260 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1261 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1262 ifm->ifa_scope = ifa->ifa_scope;
1263 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1264
1265 if ((ifa->ifa_address &&
1266 nla_put_be32(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1267 (ifa->ifa_local &&
1268 nla_put_be32(skb, IFA_LOCAL, ifa->ifa_local)) ||
1269 (ifa->ifa_broadcast &&
1270 nla_put_be32(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1271 (ifa->ifa_label[0] &&
1272 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)))
1273 goto nla_put_failure;
1274
1275 return nlmsg_end(skb, nlh);
1276
1277nla_put_failure:
1278 nlmsg_cancel(skb, nlh);
1279 return -EMSGSIZE;
1280}
1281
1282static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1283{
1284 struct net *net = sock_net(skb->sk);
1285 int h, s_h;
1286 int idx, s_idx;
1287 int ip_idx, s_ip_idx;
1288 struct net_device *dev;
1289 struct in_device *in_dev;
1290 struct in_ifaddr *ifa;
1291 struct hlist_head *head;
1292 struct hlist_node *node;
1293
1294 s_h = cb->args[0];
1295 s_idx = idx = cb->args[1];
1296 s_ip_idx = ip_idx = cb->args[2];
1297
1298 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1299 idx = 0;
1300 head = &net->dev_index_head[h];
1301 rcu_read_lock();
1302 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
1303 if (idx < s_idx)
1304 goto cont;
1305 if (h > s_h || idx > s_idx)
1306 s_ip_idx = 0;
1307 in_dev = __in_dev_get_rcu(dev);
1308 if (!in_dev)
1309 goto cont;
1310
1311 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1312 ifa = ifa->ifa_next, ip_idx++) {
1313 if (ip_idx < s_ip_idx)
1314 continue;
1315 if (inet_fill_ifaddr(skb, ifa,
1316 NETLINK_CB(cb->skb).portid,
1317 cb->nlh->nlmsg_seq,
1318 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1319 rcu_read_unlock();
1320 goto done;
1321 }
1322 }
1323cont:
1324 idx++;
1325 }
1326 rcu_read_unlock();
1327 }
1328
1329done:
1330 cb->args[0] = h;
1331 cb->args[1] = idx;
1332 cb->args[2] = ip_idx;
1333
1334 return skb->len;
1335}
1336
1337static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1338 u32 portid)
1339{
1340 struct sk_buff *skb;
1341 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1342 int err = -ENOBUFS;
1343 struct net *net;
1344
1345 net = dev_net(ifa->ifa_dev->dev);
1346 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1347 if (skb == NULL)
1348 goto errout;
1349
1350 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1351 if (err < 0) {
1352
1353 WARN_ON(err == -EMSGSIZE);
1354 kfree_skb(skb);
1355 goto errout;
1356 }
1357 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1358 return;
1359errout:
1360 if (err < 0)
1361 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1362}
1363
1364static size_t inet_get_link_af_size(const struct net_device *dev)
1365{
1366 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1367
1368 if (!in_dev)
1369 return 0;
1370
1371 return nla_total_size(IPV4_DEVCONF_MAX * 4);
1372}
1373
1374static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
1375{
1376 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
1377 struct nlattr *nla;
1378 int i;
1379
1380 if (!in_dev)
1381 return -ENODATA;
1382
1383 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1384 if (nla == NULL)
1385 return -EMSGSIZE;
1386
1387 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1388 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1389
1390 return 0;
1391}
1392
1393static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1394 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1395};
1396
1397static int inet_validate_link_af(const struct net_device *dev,
1398 const struct nlattr *nla)
1399{
1400 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1401 int err, rem;
1402
1403 if (dev && !__in_dev_get_rtnl(dev))
1404 return -EAFNOSUPPORT;
1405
1406 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1407 if (err < 0)
1408 return err;
1409
1410 if (tb[IFLA_INET_CONF]) {
1411 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1412 int cfgid = nla_type(a);
1413
1414 if (nla_len(a) < 4)
1415 return -EINVAL;
1416
1417 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1418 return -EINVAL;
1419 }
1420 }
1421
1422 return 0;
1423}
1424
1425static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1426{
1427 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1428 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1429 int rem;
1430
1431 if (!in_dev)
1432 return -EAFNOSUPPORT;
1433
1434 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1435 BUG();
1436
1437 if (tb[IFLA_INET_CONF]) {
1438 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1439 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1440 }
1441
1442 return 0;
1443}
1444
1445#ifdef CONFIG_SYSCTL
1446
1447static void devinet_copy_dflt_conf(struct net *net, int i)
1448{
1449 struct net_device *dev;
1450
1451 rcu_read_lock();
1452 for_each_netdev_rcu(net, dev) {
1453 struct in_device *in_dev;
1454
1455 in_dev = __in_dev_get_rcu(dev);
1456 if (in_dev && !test_bit(i, in_dev->cnf.state))
1457 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1458 }
1459 rcu_read_unlock();
1460}
1461
1462
1463static void inet_forward_change(struct net *net)
1464{
1465 struct net_device *dev;
1466 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1467
1468 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1469 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1470
1471 for_each_netdev(net, dev) {
1472 struct in_device *in_dev;
1473 if (on)
1474 dev_disable_lro(dev);
1475 rcu_read_lock();
1476 in_dev = __in_dev_get_rcu(dev);
1477 if (in_dev)
1478 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1479 rcu_read_unlock();
1480 }
1481}
1482
1483static int devinet_conf_proc(ctl_table *ctl, int write,
1484 void __user *buffer,
1485 size_t *lenp, loff_t *ppos)
1486{
1487 int old_value = *(int *)ctl->data;
1488 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1489 int new_value = *(int *)ctl->data;
1490
1491 if (write) {
1492 struct ipv4_devconf *cnf = ctl->extra1;
1493 struct net *net = ctl->extra2;
1494 int i = (int *)ctl->data - cnf->data;
1495
1496 set_bit(i, cnf->state);
1497
1498 if (cnf == net->ipv4.devconf_dflt)
1499 devinet_copy_dflt_conf(net, i);
1500 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
1501 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
1502 if ((new_value == 0) && (old_value != 0))
1503 rt_cache_flush(net);
1504 }
1505
1506 return ret;
1507}
1508
1509static int devinet_sysctl_forward(ctl_table *ctl, int write,
1510 void __user *buffer,
1511 size_t *lenp, loff_t *ppos)
1512{
1513 int *valp = ctl->data;
1514 int val = *valp;
1515 loff_t pos = *ppos;
1516 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1517
1518 if (write && *valp != val) {
1519 struct net *net = ctl->extra2;
1520
1521 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
1522 if (!rtnl_trylock()) {
1523
1524 *valp = val;
1525 *ppos = pos;
1526 return restart_syscall();
1527 }
1528 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1529 inet_forward_change(net);
1530 } else if (*valp) {
1531 struct ipv4_devconf *cnf = ctl->extra1;
1532 struct in_device *idev =
1533 container_of(cnf, struct in_device, cnf);
1534 dev_disable_lro(idev->dev);
1535 }
1536 rtnl_unlock();
1537 rt_cache_flush(net);
1538 }
1539 }
1540
1541 return ret;
1542}
1543
1544static int ipv4_doint_and_flush(ctl_table *ctl, int write,
1545 void __user *buffer,
1546 size_t *lenp, loff_t *ppos)
1547{
1548 int *valp = ctl->data;
1549 int val = *valp;
1550 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1551 struct net *net = ctl->extra2;
1552
1553 if (write && *valp != val)
1554 rt_cache_flush(net);
1555
1556 return ret;
1557}
1558
1559#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
1560 { \
1561 .procname = name, \
1562 .data = ipv4_devconf.data + \
1563 IPV4_DEVCONF_ ## attr - 1, \
1564 .maxlen = sizeof(int), \
1565 .mode = mval, \
1566 .proc_handler = proc, \
1567 .extra1 = &ipv4_devconf, \
1568 }
1569
1570#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1571 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
1572
1573#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1574 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
1575
1576#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1577 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
1578
1579#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1580 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
1581
1582static struct devinet_sysctl_table {
1583 struct ctl_table_header *sysctl_header;
1584 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
1585} devinet_sysctl = {
1586 .devinet_vars = {
1587 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1588 devinet_sysctl_forward),
1589 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1590
1591 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1592 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1593 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1594 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1595 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1596 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1597 "accept_source_route"),
1598 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
1599 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
1600 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1601 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1602 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1603 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1604 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1605 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1606 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1607 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1608 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1609 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
1610 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
1611
1612 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1613 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1614 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1615 "force_igmp_version"),
1616 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1617 "promote_secondaries"),
1618 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
1619 "route_localnet"),
1620 },
1621};
1622
1623static int __devinet_sysctl_register(struct net *net, char *dev_name,
1624 struct ipv4_devconf *p)
1625{
1626 int i;
1627 struct devinet_sysctl_table *t;
1628 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
1629
1630 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
1631 if (!t)
1632 goto out;
1633
1634 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1635 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1636 t->devinet_vars[i].extra1 = p;
1637 t->devinet_vars[i].extra2 = net;
1638 }
1639
1640 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
1641
1642 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
1643 if (!t->sysctl_header)
1644 goto free;
1645
1646 p->sysctl = t;
1647 return 0;
1648
1649free:
1650 kfree(t);
1651out:
1652 return -ENOBUFS;
1653}
1654
1655static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1656{
1657 struct devinet_sysctl_table *t = cnf->sysctl;
1658
1659 if (t == NULL)
1660 return;
1661
1662 cnf->sysctl = NULL;
1663 unregister_net_sysctl_table(t->sysctl_header);
1664 kfree(t);
1665}
1666
1667static void devinet_sysctl_register(struct in_device *idev)
1668{
1669 neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
1670 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
1671 &idev->cnf);
1672}
1673
1674static void devinet_sysctl_unregister(struct in_device *idev)
1675{
1676 __devinet_sysctl_unregister(&idev->cnf);
1677 neigh_sysctl_unregister(idev->arp_parms);
1678}
1679
1680static struct ctl_table ctl_forward_entry[] = {
1681 {
1682 .procname = "ip_forward",
1683 .data = &ipv4_devconf.data[
1684 IPV4_DEVCONF_FORWARDING - 1],
1685 .maxlen = sizeof(int),
1686 .mode = 0644,
1687 .proc_handler = devinet_sysctl_forward,
1688 .extra1 = &ipv4_devconf,
1689 .extra2 = &init_net,
1690 },
1691 { },
1692};
1693#endif
1694
1695static __net_init int devinet_init_net(struct net *net)
1696{
1697 int err;
1698 struct ipv4_devconf *all, *dflt;
1699#ifdef CONFIG_SYSCTL
1700 struct ctl_table *tbl = ctl_forward_entry;
1701 struct ctl_table_header *forw_hdr;
1702#endif
1703
1704 err = -ENOMEM;
1705 all = &ipv4_devconf;
1706 dflt = &ipv4_devconf_dflt;
1707
1708 if (!net_eq(net, &init_net)) {
1709 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1710 if (all == NULL)
1711 goto err_alloc_all;
1712
1713 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1714 if (dflt == NULL)
1715 goto err_alloc_dflt;
1716
1717#ifdef CONFIG_SYSCTL
1718 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1719 if (tbl == NULL)
1720 goto err_alloc_ctl;
1721
1722 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
1723 tbl[0].extra1 = all;
1724 tbl[0].extra2 = net;
1725#endif
1726 }
1727
1728#ifdef CONFIG_SYSCTL
1729 err = __devinet_sysctl_register(net, "all", all);
1730 if (err < 0)
1731 goto err_reg_all;
1732
1733 err = __devinet_sysctl_register(net, "default", dflt);
1734 if (err < 0)
1735 goto err_reg_dflt;
1736
1737 err = -ENOMEM;
1738 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
1739 if (forw_hdr == NULL)
1740 goto err_reg_ctl;
1741 net->ipv4.forw_hdr = forw_hdr;
1742#endif
1743
1744 net->ipv4.devconf_all = all;
1745 net->ipv4.devconf_dflt = dflt;
1746 return 0;
1747
1748#ifdef CONFIG_SYSCTL
1749err_reg_ctl:
1750 __devinet_sysctl_unregister(dflt);
1751err_reg_dflt:
1752 __devinet_sysctl_unregister(all);
1753err_reg_all:
1754 if (tbl != ctl_forward_entry)
1755 kfree(tbl);
1756err_alloc_ctl:
1757#endif
1758 if (dflt != &ipv4_devconf_dflt)
1759 kfree(dflt);
1760err_alloc_dflt:
1761 if (all != &ipv4_devconf)
1762 kfree(all);
1763err_alloc_all:
1764 return err;
1765}
1766
1767static __net_exit void devinet_exit_net(struct net *net)
1768{
1769#ifdef CONFIG_SYSCTL
1770 struct ctl_table *tbl;
1771
1772 tbl = net->ipv4.forw_hdr->ctl_table_arg;
1773 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1774 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1775 __devinet_sysctl_unregister(net->ipv4.devconf_all);
1776 kfree(tbl);
1777#endif
1778 kfree(net->ipv4.devconf_dflt);
1779 kfree(net->ipv4.devconf_all);
1780}
1781
1782static __net_initdata struct pernet_operations devinet_ops = {
1783 .init = devinet_init_net,
1784 .exit = devinet_exit_net,
1785};
1786
1787static struct rtnl_af_ops inet_af_ops = {
1788 .family = AF_INET,
1789 .fill_link_af = inet_fill_link_af,
1790 .get_link_af_size = inet_get_link_af_size,
1791 .validate_link_af = inet_validate_link_af,
1792 .set_link_af = inet_set_link_af,
1793};
1794
1795void __init devinet_init(void)
1796{
1797 int i;
1798
1799 for (i = 0; i < IN4_ADDR_HSIZE; i++)
1800 INIT_HLIST_HEAD(&inet_addr_lst[i]);
1801
1802 register_pernet_subsys(&devinet_ops);
1803
1804 register_gifconf(PF_INET, inet_gifconf);
1805 register_netdevice_notifier(&ip_netdev_notifier);
1806
1807 rtnl_af_register(&inet_af_ops);
1808
1809 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
1810 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
1811 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
1812}
1813
1814
