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