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