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