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