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