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