11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET3 IP device support routines. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: $Id: devinet.c,v 1.44 2001/10/31 21:55:54 davem Exp $ 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 71da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 81da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 91da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds * Derived from the IP parts of dev.c 1.0.19 1202c30a84SJesper Juhl * Authors: Ross Biro 131da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 141da177e4SLinus Torvalds * Mark Evans, <evansmp@uhura.aston.ac.uk> 151da177e4SLinus Torvalds * 161da177e4SLinus Torvalds * Additional Authors: 171da177e4SLinus Torvalds * Alan Cox, <gw4pts@gw4pts.ampr.org> 181da177e4SLinus Torvalds * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 191da177e4SLinus Torvalds * 201da177e4SLinus Torvalds * Changes: 211da177e4SLinus Torvalds * Alexey Kuznetsov: pa_* fields are replaced with ifaddr 221da177e4SLinus Torvalds * lists. 231da177e4SLinus Torvalds * Cyrus Durgin: updated for kmod 241da177e4SLinus Torvalds * Matthias Andree: in devinet_ioctl, compare label and 251da177e4SLinus Torvalds * address (4.4BSD alias style support), 261da177e4SLinus Torvalds * fall back to comparing just the label 271da177e4SLinus Torvalds * if no match found. 281da177e4SLinus Torvalds */ 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <asm/uaccess.h> 321da177e4SLinus Torvalds #include <asm/system.h> 331da177e4SLinus Torvalds #include <linux/bitops.h> 344fc268d2SRandy Dunlap #include <linux/capability.h> 351da177e4SLinus Torvalds #include <linux/module.h> 361da177e4SLinus Torvalds #include <linux/types.h> 371da177e4SLinus Torvalds #include <linux/kernel.h> 381da177e4SLinus Torvalds #include <linux/string.h> 391da177e4SLinus Torvalds #include <linux/mm.h> 401da177e4SLinus Torvalds #include <linux/socket.h> 411da177e4SLinus Torvalds #include <linux/sockios.h> 421da177e4SLinus Torvalds #include <linux/in.h> 431da177e4SLinus Torvalds #include <linux/errno.h> 441da177e4SLinus Torvalds #include <linux/interrupt.h> 451823730fSThomas Graf #include <linux/if_addr.h> 461da177e4SLinus Torvalds #include <linux/if_ether.h> 471da177e4SLinus Torvalds #include <linux/inet.h> 481da177e4SLinus Torvalds #include <linux/netdevice.h> 491da177e4SLinus Torvalds #include <linux/etherdevice.h> 501da177e4SLinus Torvalds #include <linux/skbuff.h> 511da177e4SLinus Torvalds #include <linux/init.h> 521da177e4SLinus Torvalds #include <linux/notifier.h> 531da177e4SLinus Torvalds #include <linux/inetdevice.h> 541da177e4SLinus Torvalds #include <linux/igmp.h> 551da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 561da177e4SLinus Torvalds #include <linux/sysctl.h> 571da177e4SLinus Torvalds #endif 581da177e4SLinus Torvalds #include <linux/kmod.h> 591da177e4SLinus Torvalds 6014c85021SArnaldo Carvalho de Melo #include <net/arp.h> 611da177e4SLinus Torvalds #include <net/ip.h> 621da177e4SLinus Torvalds #include <net/route.h> 631da177e4SLinus Torvalds #include <net/ip_fib.h> 6463f3444fSThomas Graf #include <net/rtnetlink.h> 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds struct ipv4_devconf ipv4_devconf = { 6742f811b8SHerbert Xu .data = { 6842f811b8SHerbert Xu [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1, 6942f811b8SHerbert Xu [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1, 7042f811b8SHerbert Xu [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1, 7142f811b8SHerbert Xu [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1, 7242f811b8SHerbert Xu }, 731da177e4SLinus Torvalds }; 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds static struct ipv4_devconf ipv4_devconf_dflt = { 7642f811b8SHerbert Xu .data = { 7742f811b8SHerbert Xu [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1, 7842f811b8SHerbert Xu [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1, 7942f811b8SHerbert Xu [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1, 8042f811b8SHerbert Xu [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1, 8142f811b8SHerbert Xu [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1, 8242f811b8SHerbert Xu }, 831da177e4SLinus Torvalds }; 841da177e4SLinus Torvalds 8542f811b8SHerbert Xu #define IPV4_DEVCONF_DFLT(attr) IPV4_DEVCONF(ipv4_devconf_dflt, attr) 8642f811b8SHerbert Xu 87ef7c79edSPatrick McHardy static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = { 885c753978SThomas Graf [IFA_LOCAL] = { .type = NLA_U32 }, 895c753978SThomas Graf [IFA_ADDRESS] = { .type = NLA_U32 }, 905c753978SThomas Graf [IFA_BROADCAST] = { .type = NLA_U32 }, 915c753978SThomas Graf [IFA_ANYCAST] = { .type = NLA_U32 }, 925176f91eSThomas Graf [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, 935c753978SThomas Graf }; 945c753978SThomas Graf 95d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32); 961da177e4SLinus Torvalds 97e041c683SAlan Stern static BLOCKING_NOTIFIER_HEAD(inetaddr_chain); 981da177e4SLinus Torvalds static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 991da177e4SLinus Torvalds int destroy); 1001da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 10166f27a52SPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev); 1021da177e4SLinus Torvalds static void devinet_sysctl_unregister(struct ipv4_devconf *p); 1031da177e4SLinus Torvalds #endif 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds /* Locks all the inet devices. */ 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static struct in_ifaddr *inet_alloc_ifa(void) 1081da177e4SLinus Torvalds { 1090da974f4SPanagiotis Issaris struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL); 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds if (ifa) { 1121da177e4SLinus Torvalds INIT_RCU_HEAD(&ifa->rcu_head); 1131da177e4SLinus Torvalds } 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds return ifa; 1161da177e4SLinus Torvalds } 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds static void inet_rcu_free_ifa(struct rcu_head *head) 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 1211da177e4SLinus Torvalds if (ifa->ifa_dev) 1221da177e4SLinus Torvalds in_dev_put(ifa->ifa_dev); 1231da177e4SLinus Torvalds kfree(ifa); 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds static inline void inet_free_ifa(struct in_ifaddr *ifa) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 1291da177e4SLinus Torvalds } 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds void in_dev_finish_destroy(struct in_device *idev) 1321da177e4SLinus Torvalds { 1331da177e4SLinus Torvalds struct net_device *dev = idev->dev; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds BUG_TRAP(!idev->ifa_list); 1361da177e4SLinus Torvalds BUG_TRAP(!idev->mc_list); 1371da177e4SLinus Torvalds #ifdef NET_REFCNT_DEBUG 1381da177e4SLinus Torvalds printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", 1391da177e4SLinus Torvalds idev, dev ? dev->name : "NIL"); 1401da177e4SLinus Torvalds #endif 1411da177e4SLinus Torvalds dev_put(dev); 1421da177e4SLinus Torvalds if (!idev->dead) 1431da177e4SLinus Torvalds printk("Freeing alive in_device %p\n", idev); 1441da177e4SLinus Torvalds else { 1451da177e4SLinus Torvalds kfree(idev); 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds } 1481da177e4SLinus Torvalds 14971e27da9SHerbert Xu static struct in_device *inetdev_init(struct net_device *dev) 1501da177e4SLinus Torvalds { 1511da177e4SLinus Torvalds struct in_device *in_dev; 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds ASSERT_RTNL(); 1541da177e4SLinus Torvalds 1550da974f4SPanagiotis Issaris in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL); 1561da177e4SLinus Torvalds if (!in_dev) 1571da177e4SLinus Torvalds goto out; 1581da177e4SLinus Torvalds INIT_RCU_HEAD(&in_dev->rcu_head); 1591da177e4SLinus Torvalds memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf)); 1601da177e4SLinus Torvalds in_dev->cnf.sysctl = NULL; 1611da177e4SLinus Torvalds in_dev->dev = dev; 1621da177e4SLinus Torvalds if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL) 1631da177e4SLinus Torvalds goto out_kfree; 1641da177e4SLinus Torvalds /* Reference in_dev->dev */ 1651da177e4SLinus Torvalds dev_hold(dev); 1661da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 1671da177e4SLinus Torvalds neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 1681da177e4SLinus Torvalds NET_IPV4_NEIGH, "ipv4", NULL, NULL); 1691da177e4SLinus Torvalds #endif 1701da177e4SLinus Torvalds 17130c4cf57SDavid L Stevens /* Account for reference dev->ip_ptr (below) */ 1721da177e4SLinus Torvalds in_dev_hold(in_dev); 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 17566f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 1761da177e4SLinus Torvalds #endif 1771da177e4SLinus Torvalds ip_mc_init_dev(in_dev); 1781da177e4SLinus Torvalds if (dev->flags & IFF_UP) 1791da177e4SLinus Torvalds ip_mc_up(in_dev); 180483479ecSJarek Poplawski 18130c4cf57SDavid L Stevens /* we can receive as soon as ip_ptr is set -- do this last */ 18230c4cf57SDavid L Stevens rcu_assign_pointer(dev->ip_ptr, in_dev); 183483479ecSJarek Poplawski out: 1841da177e4SLinus Torvalds return in_dev; 1851da177e4SLinus Torvalds out_kfree: 1861da177e4SLinus Torvalds kfree(in_dev); 1871da177e4SLinus Torvalds in_dev = NULL; 1881da177e4SLinus Torvalds goto out; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds static void in_dev_rcu_put(struct rcu_head *head) 1921da177e4SLinus Torvalds { 1931da177e4SLinus Torvalds struct in_device *idev = container_of(head, struct in_device, rcu_head); 1941da177e4SLinus Torvalds in_dev_put(idev); 1951da177e4SLinus Torvalds } 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds static void inetdev_destroy(struct in_device *in_dev) 1981da177e4SLinus Torvalds { 1991da177e4SLinus Torvalds struct in_ifaddr *ifa; 2001da177e4SLinus Torvalds struct net_device *dev; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds ASSERT_RTNL(); 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds dev = in_dev->dev; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds in_dev->dead = 1; 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds ip_mc_destroy_dev(in_dev); 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds while ((ifa = in_dev->ifa_list) != NULL) { 2111da177e4SLinus Torvalds inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 2121da177e4SLinus Torvalds inet_free_ifa(ifa); 2131da177e4SLinus Torvalds } 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 2161da177e4SLinus Torvalds devinet_sysctl_unregister(&in_dev->cnf); 2171da177e4SLinus Torvalds #endif 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds dev->ip_ptr = NULL; 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 2221da177e4SLinus Torvalds neigh_sysctl_unregister(in_dev->arp_parms); 2231da177e4SLinus Torvalds #endif 2241da177e4SLinus Torvalds neigh_parms_release(&arp_tbl, in_dev->arp_parms); 2251da177e4SLinus Torvalds arp_ifdown(dev); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 230ff428d72SAl Viro int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b) 2311da177e4SLinus Torvalds { 2321da177e4SLinus Torvalds rcu_read_lock(); 2331da177e4SLinus Torvalds for_primary_ifa(in_dev) { 2341da177e4SLinus Torvalds if (inet_ifa_match(a, ifa)) { 2351da177e4SLinus Torvalds if (!b || inet_ifa_match(b, ifa)) { 2361da177e4SLinus Torvalds rcu_read_unlock(); 2371da177e4SLinus Torvalds return 1; 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds } endfor_ifa(in_dev); 2411da177e4SLinus Torvalds rcu_read_unlock(); 2421da177e4SLinus Torvalds return 0; 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds 245d6062cbbSThomas Graf static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 246d6062cbbSThomas Graf int destroy, struct nlmsghdr *nlh, u32 pid) 2471da177e4SLinus Torvalds { 2488f937c60SHarald Welte struct in_ifaddr *promote = NULL; 2490ff60a45SJamal Hadi Salim struct in_ifaddr *ifa, *ifa1 = *ifap; 2500ff60a45SJamal Hadi Salim struct in_ifaddr *last_prim = in_dev->ifa_list; 2510ff60a45SJamal Hadi Salim struct in_ifaddr *prev_prom = NULL; 2520ff60a45SJamal Hadi Salim int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds ASSERT_RTNL(); 2551da177e4SLinus Torvalds 2568f937c60SHarald Welte /* 1. Deleting primary ifaddr forces deletion all secondaries 2578f937c60SHarald Welte * unless alias promotion is set 2588f937c60SHarald Welte **/ 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 2611da177e4SLinus Torvalds struct in_ifaddr **ifap1 = &ifa1->ifa_next; 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds while ((ifa = *ifap1) != NULL) { 2640ff60a45SJamal Hadi Salim if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 2650ff60a45SJamal Hadi Salim ifa1->ifa_scope <= ifa->ifa_scope) 2660ff60a45SJamal Hadi Salim last_prim = ifa; 2670ff60a45SJamal Hadi Salim 2681da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 2691da177e4SLinus Torvalds ifa1->ifa_mask != ifa->ifa_mask || 2701da177e4SLinus Torvalds !inet_ifa_match(ifa1->ifa_address, ifa)) { 2711da177e4SLinus Torvalds ifap1 = &ifa->ifa_next; 2720ff60a45SJamal Hadi Salim prev_prom = ifa; 2731da177e4SLinus Torvalds continue; 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds 2760ff60a45SJamal Hadi Salim if (!do_promote) { 2771da177e4SLinus Torvalds *ifap1 = ifa->ifa_next; 2781da177e4SLinus Torvalds 279d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid); 280e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 281e041c683SAlan Stern NETDEV_DOWN, ifa); 2821da177e4SLinus Torvalds inet_free_ifa(ifa); 2838f937c60SHarald Welte } else { 2848f937c60SHarald Welte promote = ifa; 2858f937c60SHarald Welte break; 2868f937c60SHarald Welte } 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds /* 2. Unlink it */ 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds *ifap = ifa1->ifa_next; 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds /* 3. Announce address deletion */ 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds /* Send message first, then call notifier. 2971da177e4SLinus Torvalds At first sight, FIB update triggered by notifier 2981da177e4SLinus Torvalds will refer to already deleted ifaddr, that could confuse 2991da177e4SLinus Torvalds netlink listeners. It is not true: look, gated sees 3001da177e4SLinus Torvalds that route deleted and if it still thinks that ifaddr 3011da177e4SLinus Torvalds is valid, it will try to restore deleted routes... Grr. 3021da177e4SLinus Torvalds So that, this order is correct. 3031da177e4SLinus Torvalds */ 304d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid); 305e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 3060ff60a45SJamal Hadi Salim 3070ff60a45SJamal Hadi Salim if (promote) { 3080ff60a45SJamal Hadi Salim 3090ff60a45SJamal Hadi Salim if (prev_prom) { 3100ff60a45SJamal Hadi Salim prev_prom->ifa_next = promote->ifa_next; 3110ff60a45SJamal Hadi Salim promote->ifa_next = last_prim->ifa_next; 3120ff60a45SJamal Hadi Salim last_prim->ifa_next = promote; 3130ff60a45SJamal Hadi Salim } 3140ff60a45SJamal Hadi Salim 3150ff60a45SJamal Hadi Salim promote->ifa_flags &= ~IFA_F_SECONDARY; 316d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid); 317e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 318e041c683SAlan Stern NETDEV_UP, promote); 3190ff60a45SJamal Hadi Salim for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) { 3200ff60a45SJamal Hadi Salim if (ifa1->ifa_mask != ifa->ifa_mask || 3210ff60a45SJamal Hadi Salim !inet_ifa_match(ifa1->ifa_address, ifa)) 3220ff60a45SJamal Hadi Salim continue; 3230ff60a45SJamal Hadi Salim fib_add_ifaddr(ifa); 3240ff60a45SJamal Hadi Salim } 3250ff60a45SJamal Hadi Salim 3260ff60a45SJamal Hadi Salim } 3276363097cSHerbert Xu if (destroy) 3281da177e4SLinus Torvalds inet_free_ifa(ifa1); 3291da177e4SLinus Torvalds } 3301da177e4SLinus Torvalds 331d6062cbbSThomas Graf static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 332d6062cbbSThomas Graf int destroy) 333d6062cbbSThomas Graf { 334d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, destroy, NULL, 0); 335d6062cbbSThomas Graf } 336d6062cbbSThomas Graf 337d6062cbbSThomas Graf static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh, 338d6062cbbSThomas Graf u32 pid) 3391da177e4SLinus Torvalds { 3401da177e4SLinus Torvalds struct in_device *in_dev = ifa->ifa_dev; 3411da177e4SLinus Torvalds struct in_ifaddr *ifa1, **ifap, **last_primary; 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds ASSERT_RTNL(); 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds if (!ifa->ifa_local) { 3461da177e4SLinus Torvalds inet_free_ifa(ifa); 3471da177e4SLinus Torvalds return 0; 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds ifa->ifa_flags &= ~IFA_F_SECONDARY; 3511da177e4SLinus Torvalds last_primary = &in_dev->ifa_list; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 3541da177e4SLinus Torvalds ifap = &ifa1->ifa_next) { 3551da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 3561da177e4SLinus Torvalds ifa->ifa_scope <= ifa1->ifa_scope) 3571da177e4SLinus Torvalds last_primary = &ifa1->ifa_next; 3581da177e4SLinus Torvalds if (ifa1->ifa_mask == ifa->ifa_mask && 3591da177e4SLinus Torvalds inet_ifa_match(ifa1->ifa_address, ifa)) { 3601da177e4SLinus Torvalds if (ifa1->ifa_local == ifa->ifa_local) { 3611da177e4SLinus Torvalds inet_free_ifa(ifa); 3621da177e4SLinus Torvalds return -EEXIST; 3631da177e4SLinus Torvalds } 3641da177e4SLinus Torvalds if (ifa1->ifa_scope != ifa->ifa_scope) { 3651da177e4SLinus Torvalds inet_free_ifa(ifa); 3661da177e4SLinus Torvalds return -EINVAL; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds ifa->ifa_flags |= IFA_F_SECONDARY; 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 3731da177e4SLinus Torvalds net_srandom(ifa->ifa_local); 3741da177e4SLinus Torvalds ifap = last_primary; 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds ifa->ifa_next = *ifap; 3781da177e4SLinus Torvalds *ifap = ifa; 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds /* Send message first, then call notifier. 3811da177e4SLinus Torvalds Notifier will trigger FIB update, so that 3821da177e4SLinus Torvalds listeners of netlink will know about new ifaddr */ 383d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid); 384e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds return 0; 3871da177e4SLinus Torvalds } 3881da177e4SLinus Torvalds 389d6062cbbSThomas Graf static int inet_insert_ifa(struct in_ifaddr *ifa) 390d6062cbbSThomas Graf { 391d6062cbbSThomas Graf return __inet_insert_ifa(ifa, NULL, 0); 392d6062cbbSThomas Graf } 393d6062cbbSThomas Graf 3941da177e4SLinus Torvalds static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 3951da177e4SLinus Torvalds { 396e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds ASSERT_RTNL(); 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds if (!in_dev) { 4011da177e4SLinus Torvalds inet_free_ifa(ifa); 4021da177e4SLinus Torvalds return -ENOBUFS; 4031da177e4SLinus Torvalds } 40471e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 4051da177e4SLinus Torvalds if (ifa->ifa_dev != in_dev) { 4061da177e4SLinus Torvalds BUG_TRAP(!ifa->ifa_dev); 4071da177e4SLinus Torvalds in_dev_hold(in_dev); 4081da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds if (LOOPBACK(ifa->ifa_local)) 4111da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 4121da177e4SLinus Torvalds return inet_insert_ifa(ifa); 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds struct in_device *inetdev_by_index(int ifindex) 4161da177e4SLinus Torvalds { 4171da177e4SLinus Torvalds struct net_device *dev; 4181da177e4SLinus Torvalds struct in_device *in_dev = NULL; 4191da177e4SLinus Torvalds read_lock(&dev_base_lock); 420881d966bSEric W. Biederman dev = __dev_get_by_index(&init_net, ifindex); 4211da177e4SLinus Torvalds if (dev) 4221da177e4SLinus Torvalds in_dev = in_dev_get(dev); 4231da177e4SLinus Torvalds read_unlock(&dev_base_lock); 4241da177e4SLinus Torvalds return in_dev; 4251da177e4SLinus Torvalds } 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds /* Called only from RTNL semaphored context. No locks. */ 4281da177e4SLinus Torvalds 42960cad5daSAl Viro struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix, 43060cad5daSAl Viro __be32 mask) 4311da177e4SLinus Torvalds { 4321da177e4SLinus Torvalds ASSERT_RTNL(); 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds for_primary_ifa(in_dev) { 4351da177e4SLinus Torvalds if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa)) 4361da177e4SLinus Torvalds return ifa; 4371da177e4SLinus Torvalds } endfor_ifa(in_dev); 4381da177e4SLinus Torvalds return NULL; 4391da177e4SLinus Torvalds } 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 4421da177e4SLinus Torvalds { 443b854272bSDenis V. Lunev struct net *net = skb->sk->sk_net; 444dfdd5fd4SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4451da177e4SLinus Torvalds struct in_device *in_dev; 446dfdd5fd4SThomas Graf struct ifaddrmsg *ifm; 4471da177e4SLinus Torvalds struct in_ifaddr *ifa, **ifap; 448dfdd5fd4SThomas Graf int err = -EINVAL; 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds ASSERT_RTNL(); 4511da177e4SLinus Torvalds 452b854272bSDenis V. Lunev if (net != &init_net) 453b854272bSDenis V. Lunev return -EINVAL; 454b854272bSDenis V. Lunev 455dfdd5fd4SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 456dfdd5fd4SThomas Graf if (err < 0) 457dfdd5fd4SThomas Graf goto errout; 458dfdd5fd4SThomas Graf 459dfdd5fd4SThomas Graf ifm = nlmsg_data(nlh); 460dfdd5fd4SThomas Graf in_dev = inetdev_by_index(ifm->ifa_index); 461dfdd5fd4SThomas Graf if (in_dev == NULL) { 462dfdd5fd4SThomas Graf err = -ENODEV; 463dfdd5fd4SThomas Graf goto errout; 464dfdd5fd4SThomas Graf } 465dfdd5fd4SThomas Graf 4661da177e4SLinus Torvalds __in_dev_put(in_dev); 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 4691da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 470dfdd5fd4SThomas Graf if (tb[IFA_LOCAL] && 471a7a628c4SAl Viro ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL])) 4721da177e4SLinus Torvalds continue; 473dfdd5fd4SThomas Graf 474dfdd5fd4SThomas Graf if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) 475dfdd5fd4SThomas Graf continue; 476dfdd5fd4SThomas Graf 477dfdd5fd4SThomas Graf if (tb[IFA_ADDRESS] && 478dfdd5fd4SThomas Graf (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 479a7a628c4SAl Viro !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa))) 480dfdd5fd4SThomas Graf continue; 481dfdd5fd4SThomas Graf 482d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid); 4831da177e4SLinus Torvalds return 0; 4841da177e4SLinus Torvalds } 485dfdd5fd4SThomas Graf 486dfdd5fd4SThomas Graf err = -EADDRNOTAVAIL; 487dfdd5fd4SThomas Graf errout: 488dfdd5fd4SThomas Graf return err; 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds 4915c753978SThomas Graf static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh) 4921da177e4SLinus Torvalds { 4935c753978SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4945c753978SThomas Graf struct in_ifaddr *ifa; 4955c753978SThomas Graf struct ifaddrmsg *ifm; 4961da177e4SLinus Torvalds struct net_device *dev; 4971da177e4SLinus Torvalds struct in_device *in_dev; 4985c753978SThomas Graf int err = -EINVAL; 4991da177e4SLinus Torvalds 5005c753978SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 5015c753978SThomas Graf if (err < 0) 5025c753978SThomas Graf goto errout; 5031da177e4SLinus Torvalds 5045c753978SThomas Graf ifm = nlmsg_data(nlh); 505c4e38f41SEvgeniy Polyakov if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) { 506c4e38f41SEvgeniy Polyakov err = -EINVAL; 5075c753978SThomas Graf goto errout; 508c4e38f41SEvgeniy Polyakov } 5091da177e4SLinus Torvalds 510881d966bSEric W. Biederman dev = __dev_get_by_index(&init_net, ifm->ifa_index); 5115c753978SThomas Graf if (dev == NULL) { 5125c753978SThomas Graf err = -ENODEV; 5135c753978SThomas Graf goto errout; 5141da177e4SLinus Torvalds } 5151da177e4SLinus Torvalds 5165c753978SThomas Graf in_dev = __in_dev_get_rtnl(dev); 5175c753978SThomas Graf if (in_dev == NULL) { 5185c753978SThomas Graf err = -ENOBUFS; 5195c753978SThomas Graf goto errout; 5205c753978SThomas Graf } 52171e27da9SHerbert Xu 5225c753978SThomas Graf ifa = inet_alloc_ifa(); 5235c753978SThomas Graf if (ifa == NULL) { 5245c753978SThomas Graf /* 5255c753978SThomas Graf * A potential indev allocation can be left alive, it stays 5265c753978SThomas Graf * assigned to its device and is destroy with it. 5275c753978SThomas Graf */ 5285c753978SThomas Graf err = -ENOBUFS; 5295c753978SThomas Graf goto errout; 5305c753978SThomas Graf } 5315c753978SThomas Graf 532a4e65d36SPavel Emelyanov ipv4_devconf_setall(in_dev); 5335c753978SThomas Graf in_dev_hold(in_dev); 5345c753978SThomas Graf 5355c753978SThomas Graf if (tb[IFA_ADDRESS] == NULL) 5365c753978SThomas Graf tb[IFA_ADDRESS] = tb[IFA_LOCAL]; 5375c753978SThomas Graf 5381da177e4SLinus Torvalds ifa->ifa_prefixlen = ifm->ifa_prefixlen; 5391da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 5401da177e4SLinus Torvalds ifa->ifa_flags = ifm->ifa_flags; 5411da177e4SLinus Torvalds ifa->ifa_scope = ifm->ifa_scope; 5421da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 5435c753978SThomas Graf 544a7a628c4SAl Viro ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]); 545a7a628c4SAl Viro ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]); 5465c753978SThomas Graf 5475c753978SThomas Graf if (tb[IFA_BROADCAST]) 548a7a628c4SAl Viro ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]); 5495c753978SThomas Graf 5505c753978SThomas Graf if (tb[IFA_ANYCAST]) 551a7a628c4SAl Viro ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]); 5525c753978SThomas Graf 5535c753978SThomas Graf if (tb[IFA_LABEL]) 5545c753978SThomas Graf nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ); 5551da177e4SLinus Torvalds else 5561da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 5571da177e4SLinus Torvalds 5585c753978SThomas Graf return ifa; 5595c753978SThomas Graf 5605c753978SThomas Graf errout: 5615c753978SThomas Graf return ERR_PTR(err); 5625c753978SThomas Graf } 5635c753978SThomas Graf 5645c753978SThomas Graf static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 5655c753978SThomas Graf { 566b854272bSDenis V. Lunev struct net *net = skb->sk->sk_net; 5675c753978SThomas Graf struct in_ifaddr *ifa; 5685c753978SThomas Graf 5695c753978SThomas Graf ASSERT_RTNL(); 5705c753978SThomas Graf 571b854272bSDenis V. Lunev if (net != &init_net) 572b854272bSDenis V. Lunev return -EINVAL; 573b854272bSDenis V. Lunev 5745c753978SThomas Graf ifa = rtm_to_ifaddr(nlh); 5755c753978SThomas Graf if (IS_ERR(ifa)) 5765c753978SThomas Graf return PTR_ERR(ifa); 5775c753978SThomas Graf 578d6062cbbSThomas Graf return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid); 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds /* 5821da177e4SLinus Torvalds * Determine a default network mask, based on the IP address. 5831da177e4SLinus Torvalds */ 5841da177e4SLinus Torvalds 585714e85beSAl Viro static __inline__ int inet_abc_len(__be32 addr) 5861da177e4SLinus Torvalds { 5871da177e4SLinus Torvalds int rc = -1; /* Something else, probably a multicast. */ 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds if (ZERONET(addr)) 5901da177e4SLinus Torvalds rc = 0; 5911da177e4SLinus Torvalds else { 592714e85beSAl Viro __u32 haddr = ntohl(addr); 5931da177e4SLinus Torvalds 594714e85beSAl Viro if (IN_CLASSA(haddr)) 5951da177e4SLinus Torvalds rc = 8; 596714e85beSAl Viro else if (IN_CLASSB(haddr)) 5971da177e4SLinus Torvalds rc = 16; 598714e85beSAl Viro else if (IN_CLASSC(haddr)) 5991da177e4SLinus Torvalds rc = 24; 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds return rc; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds int devinet_ioctl(unsigned int cmd, void __user *arg) 6071da177e4SLinus Torvalds { 6081da177e4SLinus Torvalds struct ifreq ifr; 6091da177e4SLinus Torvalds struct sockaddr_in sin_orig; 6101da177e4SLinus Torvalds struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 6111da177e4SLinus Torvalds struct in_device *in_dev; 6121da177e4SLinus Torvalds struct in_ifaddr **ifap = NULL; 6131da177e4SLinus Torvalds struct in_ifaddr *ifa = NULL; 6141da177e4SLinus Torvalds struct net_device *dev; 6151da177e4SLinus Torvalds char *colon; 6161da177e4SLinus Torvalds int ret = -EFAULT; 6171da177e4SLinus Torvalds int tryaddrmatch = 0; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* 6201da177e4SLinus Torvalds * Fetch the caller's info block into kernel space 6211da177e4SLinus Torvalds */ 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 6241da177e4SLinus Torvalds goto out; 6251da177e4SLinus Torvalds ifr.ifr_name[IFNAMSIZ - 1] = 0; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* save original address for comparison */ 6281da177e4SLinus Torvalds memcpy(&sin_orig, sin, sizeof(*sin)); 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds colon = strchr(ifr.ifr_name, ':'); 6311da177e4SLinus Torvalds if (colon) 6321da177e4SLinus Torvalds *colon = 0; 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds #ifdef CONFIG_KMOD 635881d966bSEric W. Biederman dev_load(&init_net, ifr.ifr_name); 6361da177e4SLinus Torvalds #endif 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds switch (cmd) { 6391da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6401da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6411da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 6421da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 6431da177e4SLinus Torvalds /* Note that these ioctls will not sleep, 6441da177e4SLinus Torvalds so that we do not impose a lock. 6451da177e4SLinus Torvalds One day we will be forced to put shlock here (I mean SMP) 6461da177e4SLinus Torvalds */ 6471da177e4SLinus Torvalds tryaddrmatch = (sin_orig.sin_family == AF_INET); 6481da177e4SLinus Torvalds memset(sin, 0, sizeof(*sin)); 6491da177e4SLinus Torvalds sin->sin_family = AF_INET; 6501da177e4SLinus Torvalds break; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds case SIOCSIFFLAGS: 6531da177e4SLinus Torvalds ret = -EACCES; 6541da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6551da177e4SLinus Torvalds goto out; 6561da177e4SLinus Torvalds break; 6571da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 6581da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 6591da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 6601da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 6611da177e4SLinus Torvalds ret = -EACCES; 6621da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6631da177e4SLinus Torvalds goto out; 6641da177e4SLinus Torvalds ret = -EINVAL; 6651da177e4SLinus Torvalds if (sin->sin_family != AF_INET) 6661da177e4SLinus Torvalds goto out; 6671da177e4SLinus Torvalds break; 6681da177e4SLinus Torvalds default: 6691da177e4SLinus Torvalds ret = -EINVAL; 6701da177e4SLinus Torvalds goto out; 6711da177e4SLinus Torvalds } 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds rtnl_lock(); 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds ret = -ENODEV; 676881d966bSEric W. Biederman if ((dev = __dev_get_by_name(&init_net, ifr.ifr_name)) == NULL) 6771da177e4SLinus Torvalds goto done; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds if (colon) 6801da177e4SLinus Torvalds *colon = ':'; 6811da177e4SLinus Torvalds 682e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 6831da177e4SLinus Torvalds if (tryaddrmatch) { 6841da177e4SLinus Torvalds /* Matthias Andree */ 6851da177e4SLinus Torvalds /* compare label and address (4.4BSD style) */ 6861da177e4SLinus Torvalds /* note: we only do this for a limited set of ioctls 6871da177e4SLinus Torvalds and only if the original address family was AF_INET. 6881da177e4SLinus Torvalds This is checked above. */ 6891da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6901da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 6911da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 6921da177e4SLinus Torvalds sin_orig.sin_addr.s_addr == 6931da177e4SLinus Torvalds ifa->ifa_address) { 6941da177e4SLinus Torvalds break; /* found */ 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds } 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds /* we didn't get a match, maybe the application is 6991da177e4SLinus Torvalds 4.3BSD-style and passed in junk so we fall back to 7001da177e4SLinus Torvalds comparing just the label */ 7011da177e4SLinus Torvalds if (!ifa) { 7021da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 7031da177e4SLinus Torvalds ifap = &ifa->ifa_next) 7041da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 7051da177e4SLinus Torvalds break; 7061da177e4SLinus Torvalds } 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 7101da177e4SLinus Torvalds if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 7111da177e4SLinus Torvalds goto done; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds switch (cmd) { 7141da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 7151da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_local; 7161da177e4SLinus Torvalds goto rarok; 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 7191da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_broadcast; 7201da177e4SLinus Torvalds goto rarok; 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 7231da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_address; 7241da177e4SLinus Torvalds goto rarok; 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 7271da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_mask; 7281da177e4SLinus Torvalds goto rarok; 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds case SIOCSIFFLAGS: 7311da177e4SLinus Torvalds if (colon) { 7321da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 7331da177e4SLinus Torvalds if (!ifa) 7341da177e4SLinus Torvalds break; 7351da177e4SLinus Torvalds ret = 0; 7361da177e4SLinus Torvalds if (!(ifr.ifr_flags & IFF_UP)) 7371da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 1); 7381da177e4SLinus Torvalds break; 7391da177e4SLinus Torvalds } 7401da177e4SLinus Torvalds ret = dev_change_flags(dev, ifr.ifr_flags); 7411da177e4SLinus Torvalds break; 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 7441da177e4SLinus Torvalds ret = -EINVAL; 7451da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7461da177e4SLinus Torvalds break; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds if (!ifa) { 7491da177e4SLinus Torvalds ret = -ENOBUFS; 7501da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) == NULL) 7511da177e4SLinus Torvalds break; 7521da177e4SLinus Torvalds if (colon) 7531da177e4SLinus Torvalds memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 7541da177e4SLinus Torvalds else 7551da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 7561da177e4SLinus Torvalds } else { 7571da177e4SLinus Torvalds ret = 0; 7581da177e4SLinus Torvalds if (ifa->ifa_local == sin->sin_addr.s_addr) 7591da177e4SLinus Torvalds break; 7601da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7611da177e4SLinus Torvalds ifa->ifa_broadcast = 0; 7621da177e4SLinus Torvalds ifa->ifa_anycast = 0; 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds if (!(dev->flags & IFF_POINTOPOINT)) { 7681da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 7691da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 7701da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 7711da177e4SLinus Torvalds ifa->ifa_prefixlen < 31) 7721da177e4SLinus Torvalds ifa->ifa_broadcast = ifa->ifa_address | 7731da177e4SLinus Torvalds ~ifa->ifa_mask; 7741da177e4SLinus Torvalds } else { 7751da177e4SLinus Torvalds ifa->ifa_prefixlen = 32; 7761da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(32); 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds ret = inet_set_ifa(dev, ifa); 7791da177e4SLinus Torvalds break; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 7821da177e4SLinus Torvalds ret = 0; 7831da177e4SLinus Torvalds if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 7841da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7851da177e4SLinus Torvalds ifa->ifa_broadcast = sin->sin_addr.s_addr; 7861da177e4SLinus Torvalds inet_insert_ifa(ifa); 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds break; 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 7911da177e4SLinus Torvalds ret = 0; 7921da177e4SLinus Torvalds if (ifa->ifa_address == sin->sin_addr.s_addr) 7931da177e4SLinus Torvalds break; 7941da177e4SLinus Torvalds ret = -EINVAL; 7951da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7961da177e4SLinus Torvalds break; 7971da177e4SLinus Torvalds ret = 0; 7981da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7991da177e4SLinus Torvalds ifa->ifa_address = sin->sin_addr.s_addr; 8001da177e4SLinus Torvalds inet_insert_ifa(ifa); 8011da177e4SLinus Torvalds break; 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds /* 8061da177e4SLinus Torvalds * The mask we set must be legal. 8071da177e4SLinus Torvalds */ 8081da177e4SLinus Torvalds ret = -EINVAL; 8091da177e4SLinus Torvalds if (bad_mask(sin->sin_addr.s_addr, 0)) 8101da177e4SLinus Torvalds break; 8111da177e4SLinus Torvalds ret = 0; 8121da177e4SLinus Torvalds if (ifa->ifa_mask != sin->sin_addr.s_addr) { 813a144ea4bSAl Viro __be32 old_mask = ifa->ifa_mask; 8141da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 8151da177e4SLinus Torvalds ifa->ifa_mask = sin->sin_addr.s_addr; 8161da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds /* See if current broadcast address matches 8191da177e4SLinus Torvalds * with current netmask, then recalculate 8201da177e4SLinus Torvalds * the broadcast address. Otherwise it's a 8211da177e4SLinus Torvalds * funny address, so don't touch it since 8221da177e4SLinus Torvalds * the user seems to know what (s)he's doing... 8231da177e4SLinus Torvalds */ 8241da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 8251da177e4SLinus Torvalds (ifa->ifa_prefixlen < 31) && 8261da177e4SLinus Torvalds (ifa->ifa_broadcast == 827dcab5e1eSDavid Engel (ifa->ifa_local|~old_mask))) { 8281da177e4SLinus Torvalds ifa->ifa_broadcast = (ifa->ifa_local | 8291da177e4SLinus Torvalds ~sin->sin_addr.s_addr); 8301da177e4SLinus Torvalds } 8311da177e4SLinus Torvalds inet_insert_ifa(ifa); 8321da177e4SLinus Torvalds } 8331da177e4SLinus Torvalds break; 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds done: 8361da177e4SLinus Torvalds rtnl_unlock(); 8371da177e4SLinus Torvalds out: 8381da177e4SLinus Torvalds return ret; 8391da177e4SLinus Torvalds rarok: 8401da177e4SLinus Torvalds rtnl_unlock(); 8411da177e4SLinus Torvalds ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 8421da177e4SLinus Torvalds goto out; 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 8461da177e4SLinus Torvalds { 847e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 8481da177e4SLinus Torvalds struct in_ifaddr *ifa; 8491da177e4SLinus Torvalds struct ifreq ifr; 8501da177e4SLinus Torvalds int done = 0; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds if (!in_dev || (ifa = in_dev->ifa_list) == NULL) 8531da177e4SLinus Torvalds goto out; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds for (; ifa; ifa = ifa->ifa_next) { 8561da177e4SLinus Torvalds if (!buf) { 8571da177e4SLinus Torvalds done += sizeof(ifr); 8581da177e4SLinus Torvalds continue; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds if (len < (int) sizeof(ifr)) 8611da177e4SLinus Torvalds break; 8621da177e4SLinus Torvalds memset(&ifr, 0, sizeof(struct ifreq)); 8631da177e4SLinus Torvalds if (ifa->ifa_label) 8641da177e4SLinus Torvalds strcpy(ifr.ifr_name, ifa->ifa_label); 8651da177e4SLinus Torvalds else 8661da177e4SLinus Torvalds strcpy(ifr.ifr_name, dev->name); 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 8691da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 8701da177e4SLinus Torvalds ifa->ifa_local; 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 8731da177e4SLinus Torvalds done = -EFAULT; 8741da177e4SLinus Torvalds break; 8751da177e4SLinus Torvalds } 8761da177e4SLinus Torvalds buf += sizeof(struct ifreq); 8771da177e4SLinus Torvalds len -= sizeof(struct ifreq); 8781da177e4SLinus Torvalds done += sizeof(struct ifreq); 8791da177e4SLinus Torvalds } 8801da177e4SLinus Torvalds out: 8811da177e4SLinus Torvalds return done; 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds 884a61ced5dSAl Viro __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope) 8851da177e4SLinus Torvalds { 886a61ced5dSAl Viro __be32 addr = 0; 8871da177e4SLinus Torvalds struct in_device *in_dev; 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds rcu_read_lock(); 890e5ed6399SHerbert Xu in_dev = __in_dev_get_rcu(dev); 8911da177e4SLinus Torvalds if (!in_dev) 8921da177e4SLinus Torvalds goto no_in_dev; 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8951da177e4SLinus Torvalds if (ifa->ifa_scope > scope) 8961da177e4SLinus Torvalds continue; 8971da177e4SLinus Torvalds if (!dst || inet_ifa_match(dst, ifa)) { 8981da177e4SLinus Torvalds addr = ifa->ifa_local; 8991da177e4SLinus Torvalds break; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds if (!addr) 9021da177e4SLinus Torvalds addr = ifa->ifa_local; 9031da177e4SLinus Torvalds } endfor_ifa(in_dev); 9041da177e4SLinus Torvalds no_in_dev: 9051da177e4SLinus Torvalds rcu_read_unlock(); 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds if (addr) 9081da177e4SLinus Torvalds goto out; 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds /* Not loopback addresses on loopback should be preferred 9111da177e4SLinus Torvalds in this case. It is importnat that lo is the first interface 9121da177e4SLinus Torvalds in dev_base list. 9131da177e4SLinus Torvalds */ 9141da177e4SLinus Torvalds read_lock(&dev_base_lock); 9151da177e4SLinus Torvalds rcu_read_lock(); 916881d966bSEric W. Biederman for_each_netdev(&init_net, dev) { 917e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev)) == NULL) 9181da177e4SLinus Torvalds continue; 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds for_primary_ifa(in_dev) { 9211da177e4SLinus Torvalds if (ifa->ifa_scope != RT_SCOPE_LINK && 9221da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9231da177e4SLinus Torvalds addr = ifa->ifa_local; 9241da177e4SLinus Torvalds goto out_unlock_both; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds } endfor_ifa(in_dev); 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds out_unlock_both: 9291da177e4SLinus Torvalds read_unlock(&dev_base_lock); 9301da177e4SLinus Torvalds rcu_read_unlock(); 9311da177e4SLinus Torvalds out: 9321da177e4SLinus Torvalds return addr; 9331da177e4SLinus Torvalds } 9341da177e4SLinus Torvalds 93560cad5daSAl Viro static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst, 93660cad5daSAl Viro __be32 local, int scope) 9371da177e4SLinus Torvalds { 9381da177e4SLinus Torvalds int same = 0; 939a144ea4bSAl Viro __be32 addr = 0; 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds for_ifa(in_dev) { 9421da177e4SLinus Torvalds if (!addr && 9431da177e4SLinus Torvalds (local == ifa->ifa_local || !local) && 9441da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9451da177e4SLinus Torvalds addr = ifa->ifa_local; 9461da177e4SLinus Torvalds if (same) 9471da177e4SLinus Torvalds break; 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds if (!same) { 9501da177e4SLinus Torvalds same = (!local || inet_ifa_match(local, ifa)) && 9511da177e4SLinus Torvalds (!dst || inet_ifa_match(dst, ifa)); 9521da177e4SLinus Torvalds if (same && addr) { 9531da177e4SLinus Torvalds if (local || !dst) 9541da177e4SLinus Torvalds break; 9551da177e4SLinus Torvalds /* Is the selected addr into dst subnet? */ 9561da177e4SLinus Torvalds if (inet_ifa_match(addr, ifa)) 9571da177e4SLinus Torvalds break; 9581da177e4SLinus Torvalds /* No, then can we use new local src? */ 9591da177e4SLinus Torvalds if (ifa->ifa_scope <= scope) { 9601da177e4SLinus Torvalds addr = ifa->ifa_local; 9611da177e4SLinus Torvalds break; 9621da177e4SLinus Torvalds } 9631da177e4SLinus Torvalds /* search for large dst subnet for addr */ 9641da177e4SLinus Torvalds same = 0; 9651da177e4SLinus Torvalds } 9661da177e4SLinus Torvalds } 9671da177e4SLinus Torvalds } endfor_ifa(in_dev); 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds return same? addr : 0; 9701da177e4SLinus Torvalds } 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds /* 9731da177e4SLinus Torvalds * Confirm that local IP address exists using wildcards: 9741da177e4SLinus Torvalds * - dev: only on this interface, 0=any interface 9751da177e4SLinus Torvalds * - dst: only in the same subnet as dst, 0=any dst 9761da177e4SLinus Torvalds * - local: address, 0=autoselect the local address 9771da177e4SLinus Torvalds * - scope: maximum allowed scope value for the local address 9781da177e4SLinus Torvalds */ 97960cad5daSAl Viro __be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope) 9801da177e4SLinus Torvalds { 98160cad5daSAl Viro __be32 addr = 0; 9821da177e4SLinus Torvalds struct in_device *in_dev; 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds if (dev) { 9851da177e4SLinus Torvalds rcu_read_lock(); 986e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev))) 9871da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9881da177e4SLinus Torvalds rcu_read_unlock(); 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds return addr; 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds read_lock(&dev_base_lock); 9941da177e4SLinus Torvalds rcu_read_lock(); 995881d966bSEric W. Biederman for_each_netdev(&init_net, dev) { 996e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev))) { 9971da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9981da177e4SLinus Torvalds if (addr) 9991da177e4SLinus Torvalds break; 10001da177e4SLinus Torvalds } 10011da177e4SLinus Torvalds } 10021da177e4SLinus Torvalds rcu_read_unlock(); 10031da177e4SLinus Torvalds read_unlock(&dev_base_lock); 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds return addr; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds /* 10091da177e4SLinus Torvalds * Device notifier 10101da177e4SLinus Torvalds */ 10111da177e4SLinus Torvalds 10121da177e4SLinus Torvalds int register_inetaddr_notifier(struct notifier_block *nb) 10131da177e4SLinus Torvalds { 1014e041c683SAlan Stern return blocking_notifier_chain_register(&inetaddr_chain, nb); 10151da177e4SLinus Torvalds } 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds int unregister_inetaddr_notifier(struct notifier_block *nb) 10181da177e4SLinus Torvalds { 1019e041c683SAlan Stern return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds 10221da177e4SLinus Torvalds /* Rename ifa_labels for a device name change. Make some effort to preserve existing 10231da177e4SLinus Torvalds * alias numbering and to create unique labels if possible. 10241da177e4SLinus Torvalds */ 10251da177e4SLinus Torvalds static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 10261da177e4SLinus Torvalds { 10271da177e4SLinus Torvalds struct in_ifaddr *ifa; 10281da177e4SLinus Torvalds int named = 0; 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 10311da177e4SLinus Torvalds char old[IFNAMSIZ], *dot; 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds memcpy(old, ifa->ifa_label, IFNAMSIZ); 10341da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10351da177e4SLinus Torvalds if (named++ == 0) 10361da177e4SLinus Torvalds continue; 103744344b2aSMark McLoughlin dot = strchr(old, ':'); 10381da177e4SLinus Torvalds if (dot == NULL) { 10391da177e4SLinus Torvalds sprintf(old, ":%d", named); 10401da177e4SLinus Torvalds dot = old; 10411da177e4SLinus Torvalds } 10421da177e4SLinus Torvalds if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) { 10431da177e4SLinus Torvalds strcat(ifa->ifa_label, dot); 10441da177e4SLinus Torvalds } else { 10451da177e4SLinus Torvalds strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds } 10481da177e4SLinus Torvalds } 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds /* Called only under RTNL semaphore */ 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds static int inetdev_event(struct notifier_block *this, unsigned long event, 10531da177e4SLinus Torvalds void *ptr) 10541da177e4SLinus Torvalds { 10551da177e4SLinus Torvalds struct net_device *dev = ptr; 1056e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 10571da177e4SLinus Torvalds 1058e9dc8653SEric W. Biederman if (dev->nd_net != &init_net) 1059e9dc8653SEric W. Biederman return NOTIFY_DONE; 1060e9dc8653SEric W. Biederman 10611da177e4SLinus Torvalds ASSERT_RTNL(); 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds if (!in_dev) { 10648030f544SHerbert Xu if (event == NETDEV_REGISTER) { 10651da177e4SLinus Torvalds in_dev = inetdev_init(dev); 10668d76527eSHerbert Xu if (!in_dev) 1067b217d616SHerbert Xu return notifier_from_errno(-ENOMEM); 10680cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 106942f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOXFRM, 1); 107042f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOPOLICY, 1); 10711da177e4SLinus Torvalds } 10728030f544SHerbert Xu } 10731da177e4SLinus Torvalds goto out; 10741da177e4SLinus Torvalds } 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds switch (event) { 10771da177e4SLinus Torvalds case NETDEV_REGISTER: 10781da177e4SLinus Torvalds printk(KERN_DEBUG "inetdev_event: bug\n"); 10791da177e4SLinus Torvalds dev->ip_ptr = NULL; 10801da177e4SLinus Torvalds break; 10811da177e4SLinus Torvalds case NETDEV_UP: 10821da177e4SLinus Torvalds if (dev->mtu < 68) 10831da177e4SLinus Torvalds break; 10840cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 10851da177e4SLinus Torvalds struct in_ifaddr *ifa; 10861da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) != NULL) { 10871da177e4SLinus Torvalds ifa->ifa_local = 10881da177e4SLinus Torvalds ifa->ifa_address = htonl(INADDR_LOOPBACK); 10891da177e4SLinus Torvalds ifa->ifa_prefixlen = 8; 10901da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(8); 10911da177e4SLinus Torvalds in_dev_hold(in_dev); 10921da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 10931da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 10941da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10951da177e4SLinus Torvalds inet_insert_ifa(ifa); 10961da177e4SLinus Torvalds } 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds ip_mc_up(in_dev); 10991da177e4SLinus Torvalds break; 11001da177e4SLinus Torvalds case NETDEV_DOWN: 11011da177e4SLinus Torvalds ip_mc_down(in_dev); 11021da177e4SLinus Torvalds break; 11031da177e4SLinus Torvalds case NETDEV_CHANGEMTU: 11041da177e4SLinus Torvalds if (dev->mtu >= 68) 11051da177e4SLinus Torvalds break; 11061da177e4SLinus Torvalds /* MTU falled under 68, disable IP */ 11071da177e4SLinus Torvalds case NETDEV_UNREGISTER: 11081da177e4SLinus Torvalds inetdev_destroy(in_dev); 11091da177e4SLinus Torvalds break; 11101da177e4SLinus Torvalds case NETDEV_CHANGENAME: 11111da177e4SLinus Torvalds /* Do not notify about label change, this event is 11121da177e4SLinus Torvalds * not interesting to applications using netlink. 11131da177e4SLinus Torvalds */ 11141da177e4SLinus Torvalds inetdev_changename(dev, in_dev); 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 11171da177e4SLinus Torvalds devinet_sysctl_unregister(&in_dev->cnf); 11181da177e4SLinus Torvalds neigh_sysctl_unregister(in_dev->arp_parms); 11191da177e4SLinus Torvalds neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 11201da177e4SLinus Torvalds NET_IPV4_NEIGH, "ipv4", NULL, NULL); 112166f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 11221da177e4SLinus Torvalds #endif 11231da177e4SLinus Torvalds break; 11241da177e4SLinus Torvalds } 11251da177e4SLinus Torvalds out: 11261da177e4SLinus Torvalds return NOTIFY_DONE; 11271da177e4SLinus Torvalds } 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds static struct notifier_block ip_netdev_notifier = { 11301da177e4SLinus Torvalds .notifier_call =inetdev_event, 11311da177e4SLinus Torvalds }; 11321da177e4SLinus Torvalds 1133339bf98fSThomas Graf static inline size_t inet_nlmsg_size(void) 1134339bf98fSThomas Graf { 1135339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 1136339bf98fSThomas Graf + nla_total_size(4) /* IFA_ADDRESS */ 1137339bf98fSThomas Graf + nla_total_size(4) /* IFA_LOCAL */ 1138339bf98fSThomas Graf + nla_total_size(4) /* IFA_BROADCAST */ 1139339bf98fSThomas Graf + nla_total_size(4) /* IFA_ANYCAST */ 1140339bf98fSThomas Graf + nla_total_size(IFNAMSIZ); /* IFA_LABEL */ 1141339bf98fSThomas Graf } 1142339bf98fSThomas Graf 11431da177e4SLinus Torvalds static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1144b6544c0bSJamal Hadi Salim u32 pid, u32 seq, int event, unsigned int flags) 11451da177e4SLinus Torvalds { 11461da177e4SLinus Torvalds struct ifaddrmsg *ifm; 11471da177e4SLinus Torvalds struct nlmsghdr *nlh; 11481da177e4SLinus Torvalds 114947f68512SThomas Graf nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags); 115047f68512SThomas Graf if (nlh == NULL) 115126932566SPatrick McHardy return -EMSGSIZE; 115247f68512SThomas Graf 115347f68512SThomas Graf ifm = nlmsg_data(nlh); 11541da177e4SLinus Torvalds ifm->ifa_family = AF_INET; 11551da177e4SLinus Torvalds ifm->ifa_prefixlen = ifa->ifa_prefixlen; 11561da177e4SLinus Torvalds ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT; 11571da177e4SLinus Torvalds ifm->ifa_scope = ifa->ifa_scope; 11581da177e4SLinus Torvalds ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 11591da177e4SLinus Torvalds 116047f68512SThomas Graf if (ifa->ifa_address) 1161a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address); 116247f68512SThomas Graf 116347f68512SThomas Graf if (ifa->ifa_local) 1164a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local); 116547f68512SThomas Graf 116647f68512SThomas Graf if (ifa->ifa_broadcast) 1167a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast); 116847f68512SThomas Graf 116947f68512SThomas Graf if (ifa->ifa_anycast) 1170a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast); 117147f68512SThomas Graf 117247f68512SThomas Graf if (ifa->ifa_label[0]) 117347f68512SThomas Graf NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label); 117447f68512SThomas Graf 117547f68512SThomas Graf return nlmsg_end(skb, nlh); 117647f68512SThomas Graf 117747f68512SThomas Graf nla_put_failure: 117826932566SPatrick McHardy nlmsg_cancel(skb, nlh); 117926932566SPatrick McHardy return -EMSGSIZE; 11801da177e4SLinus Torvalds } 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 11831da177e4SLinus Torvalds { 1184b854272bSDenis V. Lunev struct net *net = skb->sk->sk_net; 11851da177e4SLinus Torvalds int idx, ip_idx; 11861da177e4SLinus Torvalds struct net_device *dev; 11871da177e4SLinus Torvalds struct in_device *in_dev; 11881da177e4SLinus Torvalds struct in_ifaddr *ifa; 11891da177e4SLinus Torvalds int s_ip_idx, s_idx = cb->args[0]; 11901da177e4SLinus Torvalds 1191b854272bSDenis V. Lunev if (net != &init_net) 1192b854272bSDenis V. Lunev return 0; 1193b854272bSDenis V. Lunev 11941da177e4SLinus Torvalds s_ip_idx = ip_idx = cb->args[1]; 11957562f876SPavel Emelianov idx = 0; 1196881d966bSEric W. Biederman for_each_netdev(&init_net, dev) { 11971da177e4SLinus Torvalds if (idx < s_idx) 11987562f876SPavel Emelianov goto cont; 11991da177e4SLinus Torvalds if (idx > s_idx) 12001da177e4SLinus Torvalds s_ip_idx = 0; 12016313c1e0SPatrick McHardy if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) 12027562f876SPavel Emelianov goto cont; 12031da177e4SLinus Torvalds 12041da177e4SLinus Torvalds for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 12051da177e4SLinus Torvalds ifa = ifa->ifa_next, ip_idx++) { 12061da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 1207596e4150SStephen Hemminger continue; 12081da177e4SLinus Torvalds if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid, 12091da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 12106313c1e0SPatrick McHardy RTM_NEWADDR, NLM_F_MULTI) <= 0) 12111da177e4SLinus Torvalds goto done; 12121da177e4SLinus Torvalds } 12137562f876SPavel Emelianov cont: 12147562f876SPavel Emelianov idx++; 12151da177e4SLinus Torvalds } 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds done: 12181da177e4SLinus Torvalds cb->args[0] = idx; 12191da177e4SLinus Torvalds cb->args[1] = ip_idx; 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds return skb->len; 12221da177e4SLinus Torvalds } 12231da177e4SLinus Torvalds 1224d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh, 1225d6062cbbSThomas Graf u32 pid) 12261da177e4SLinus Torvalds { 122747f68512SThomas Graf struct sk_buff *skb; 1228d6062cbbSThomas Graf u32 seq = nlh ? nlh->nlmsg_seq : 0; 1229d6062cbbSThomas Graf int err = -ENOBUFS; 12301da177e4SLinus Torvalds 1231339bf98fSThomas Graf skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL); 123247f68512SThomas Graf if (skb == NULL) 1233d6062cbbSThomas Graf goto errout; 1234d6062cbbSThomas Graf 1235d6062cbbSThomas Graf err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0); 123626932566SPatrick McHardy if (err < 0) { 123726932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet_nlmsg_size() */ 123826932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 123926932566SPatrick McHardy kfree_skb(skb); 124026932566SPatrick McHardy goto errout; 124126932566SPatrick McHardy } 124297c53cacSDenis V. Lunev err = rtnl_notify(skb, &init_net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL); 1243d6062cbbSThomas Graf errout: 1244d6062cbbSThomas Graf if (err < 0) 124597c53cacSDenis V. Lunev rtnl_set_sk_err(&init_net, RTNLGRP_IPV4_IFADDR, err); 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 12491da177e4SLinus Torvalds 125031be3085SHerbert Xu static void devinet_copy_dflt_conf(int i) 125131be3085SHerbert Xu { 125231be3085SHerbert Xu struct net_device *dev; 125331be3085SHerbert Xu 125431be3085SHerbert Xu read_lock(&dev_base_lock); 1255881d966bSEric W. Biederman for_each_netdev(&init_net, dev) { 125631be3085SHerbert Xu struct in_device *in_dev; 125731be3085SHerbert Xu rcu_read_lock(); 125831be3085SHerbert Xu in_dev = __in_dev_get_rcu(dev); 125931be3085SHerbert Xu if (in_dev && !test_bit(i, in_dev->cnf.state)) 126031be3085SHerbert Xu in_dev->cnf.data[i] = ipv4_devconf_dflt.data[i]; 126131be3085SHerbert Xu rcu_read_unlock(); 126231be3085SHerbert Xu } 126331be3085SHerbert Xu read_unlock(&dev_base_lock); 126431be3085SHerbert Xu } 126531be3085SHerbert Xu 126668dd299bSPavel Emelyanov static void inet_forward_change(void) 126768dd299bSPavel Emelyanov { 126868dd299bSPavel Emelyanov struct net_device *dev; 126968dd299bSPavel Emelyanov int on = IPV4_DEVCONF_ALL(FORWARDING); 127068dd299bSPavel Emelyanov 127168dd299bSPavel Emelyanov IPV4_DEVCONF_ALL(ACCEPT_REDIRECTS) = !on; 127268dd299bSPavel Emelyanov IPV4_DEVCONF_DFLT(FORWARDING) = on; 127368dd299bSPavel Emelyanov 127468dd299bSPavel Emelyanov read_lock(&dev_base_lock); 127568dd299bSPavel Emelyanov for_each_netdev(&init_net, dev) { 127668dd299bSPavel Emelyanov struct in_device *in_dev; 127768dd299bSPavel Emelyanov rcu_read_lock(); 127868dd299bSPavel Emelyanov in_dev = __in_dev_get_rcu(dev); 127968dd299bSPavel Emelyanov if (in_dev) 128068dd299bSPavel Emelyanov IN_DEV_CONF_SET(in_dev, FORWARDING, on); 128168dd299bSPavel Emelyanov rcu_read_unlock(); 128268dd299bSPavel Emelyanov } 128368dd299bSPavel Emelyanov read_unlock(&dev_base_lock); 128468dd299bSPavel Emelyanov 128568dd299bSPavel Emelyanov rt_cache_flush(0); 128668dd299bSPavel Emelyanov } 128768dd299bSPavel Emelyanov 128831be3085SHerbert Xu static int devinet_conf_proc(ctl_table *ctl, int write, 128931be3085SHerbert Xu struct file* filp, void __user *buffer, 129031be3085SHerbert Xu size_t *lenp, loff_t *ppos) 129131be3085SHerbert Xu { 129231be3085SHerbert Xu int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 129331be3085SHerbert Xu 129431be3085SHerbert Xu if (write) { 129531be3085SHerbert Xu struct ipv4_devconf *cnf = ctl->extra1; 129631be3085SHerbert Xu int i = (int *)ctl->data - cnf->data; 129731be3085SHerbert Xu 129831be3085SHerbert Xu set_bit(i, cnf->state); 129931be3085SHerbert Xu 130031be3085SHerbert Xu if (cnf == &ipv4_devconf_dflt) 130131be3085SHerbert Xu devinet_copy_dflt_conf(i); 130231be3085SHerbert Xu } 130331be3085SHerbert Xu 130431be3085SHerbert Xu return ret; 130531be3085SHerbert Xu } 130631be3085SHerbert Xu 130731be3085SHerbert Xu static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen, 130831be3085SHerbert Xu void __user *oldval, size_t __user *oldlenp, 130931be3085SHerbert Xu void __user *newval, size_t newlen) 131031be3085SHerbert Xu { 131131be3085SHerbert Xu struct ipv4_devconf *cnf; 131231be3085SHerbert Xu int *valp = table->data; 131331be3085SHerbert Xu int new; 131431be3085SHerbert Xu int i; 131531be3085SHerbert Xu 131631be3085SHerbert Xu if (!newval || !newlen) 131731be3085SHerbert Xu return 0; 131831be3085SHerbert Xu 131931be3085SHerbert Xu if (newlen != sizeof(int)) 132031be3085SHerbert Xu return -EINVAL; 132131be3085SHerbert Xu 132231be3085SHerbert Xu if (get_user(new, (int __user *)newval)) 132331be3085SHerbert Xu return -EFAULT; 132431be3085SHerbert Xu 132531be3085SHerbert Xu if (new == *valp) 132631be3085SHerbert Xu return 0; 132731be3085SHerbert Xu 132831be3085SHerbert Xu if (oldval && oldlenp) { 132931be3085SHerbert Xu size_t len; 133031be3085SHerbert Xu 133131be3085SHerbert Xu if (get_user(len, oldlenp)) 133231be3085SHerbert Xu return -EFAULT; 133331be3085SHerbert Xu 133431be3085SHerbert Xu if (len) { 133531be3085SHerbert Xu if (len > table->maxlen) 133631be3085SHerbert Xu len = table->maxlen; 133731be3085SHerbert Xu if (copy_to_user(oldval, valp, len)) 133831be3085SHerbert Xu return -EFAULT; 133931be3085SHerbert Xu if (put_user(len, oldlenp)) 134031be3085SHerbert Xu return -EFAULT; 134131be3085SHerbert Xu } 134231be3085SHerbert Xu } 134331be3085SHerbert Xu 134431be3085SHerbert Xu *valp = new; 134531be3085SHerbert Xu 134631be3085SHerbert Xu cnf = table->extra1; 134731be3085SHerbert Xu i = (int *)table->data - cnf->data; 134831be3085SHerbert Xu 134931be3085SHerbert Xu set_bit(i, cnf->state); 135031be3085SHerbert Xu 135131be3085SHerbert Xu if (cnf == &ipv4_devconf_dflt) 135231be3085SHerbert Xu devinet_copy_dflt_conf(i); 135331be3085SHerbert Xu 135431be3085SHerbert Xu return 1; 135531be3085SHerbert Xu } 135631be3085SHerbert Xu 13571da177e4SLinus Torvalds static int devinet_sysctl_forward(ctl_table *ctl, int write, 13581da177e4SLinus Torvalds struct file* filp, void __user *buffer, 13591da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13601da177e4SLinus Torvalds { 13611da177e4SLinus Torvalds int *valp = ctl->data; 13621da177e4SLinus Torvalds int val = *valp; 13631da177e4SLinus Torvalds int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds if (write && *valp != val) { 136642f811b8SHerbert Xu if (valp == &IPV4_DEVCONF_ALL(FORWARDING)) 13671da177e4SLinus Torvalds inet_forward_change(); 136842f811b8SHerbert Xu else if (valp != &IPV4_DEVCONF_DFLT(FORWARDING)) 13691da177e4SLinus Torvalds rt_cache_flush(0); 13701da177e4SLinus Torvalds } 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds return ret; 13731da177e4SLinus Torvalds } 13741da177e4SLinus Torvalds 13751da177e4SLinus Torvalds int ipv4_doint_and_flush(ctl_table *ctl, int write, 13761da177e4SLinus Torvalds struct file* filp, void __user *buffer, 13771da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13781da177e4SLinus Torvalds { 13791da177e4SLinus Torvalds int *valp = ctl->data; 13801da177e4SLinus Torvalds int val = *valp; 13811da177e4SLinus Torvalds int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 13821da177e4SLinus Torvalds 13831da177e4SLinus Torvalds if (write && *valp != val) 13841da177e4SLinus Torvalds rt_cache_flush(0); 13851da177e4SLinus Torvalds 13861da177e4SLinus Torvalds return ret; 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen, 13901da177e4SLinus Torvalds void __user *oldval, size_t __user *oldlenp, 13911f29bcd7SAlexey Dobriyan void __user *newval, size_t newlen) 13921da177e4SLinus Torvalds { 139331be3085SHerbert Xu int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp, 139431be3085SHerbert Xu newval, newlen); 13951da177e4SLinus Torvalds 139631be3085SHerbert Xu if (ret == 1) 13971da177e4SLinus Torvalds rt_cache_flush(0); 139831be3085SHerbert Xu 139931be3085SHerbert Xu return ret; 14001da177e4SLinus Torvalds } 14011da177e4SLinus Torvalds 14021da177e4SLinus Torvalds 140342f811b8SHerbert Xu #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \ 140442f811b8SHerbert Xu { \ 140542f811b8SHerbert Xu .ctl_name = NET_IPV4_CONF_ ## attr, \ 140642f811b8SHerbert Xu .procname = name, \ 140742f811b8SHerbert Xu .data = ipv4_devconf.data + \ 140842f811b8SHerbert Xu NET_IPV4_CONF_ ## attr - 1, \ 140942f811b8SHerbert Xu .maxlen = sizeof(int), \ 141042f811b8SHerbert Xu .mode = mval, \ 141142f811b8SHerbert Xu .proc_handler = proc, \ 141242f811b8SHerbert Xu .strategy = sysctl, \ 141331be3085SHerbert Xu .extra1 = &ipv4_devconf, \ 141442f811b8SHerbert Xu } 141542f811b8SHerbert Xu 141642f811b8SHerbert Xu #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \ 141731be3085SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \ 141831be3085SHerbert Xu devinet_conf_sysctl) 141942f811b8SHerbert Xu 142042f811b8SHerbert Xu #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \ 142131be3085SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \ 142231be3085SHerbert Xu devinet_conf_sysctl) 142342f811b8SHerbert Xu 142442f811b8SHerbert Xu #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \ 142542f811b8SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl) 142642f811b8SHerbert Xu 142742f811b8SHerbert Xu #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \ 142842f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \ 142942f811b8SHerbert Xu ipv4_doint_and_flush_strategy) 143042f811b8SHerbert Xu 14311da177e4SLinus Torvalds static struct devinet_sysctl_table { 14321da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 1433bfada697SPavel Emelyanov struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX]; 1434bfada697SPavel Emelyanov char *dev_name; 14351da177e4SLinus Torvalds } devinet_sysctl = { 14361da177e4SLinus Torvalds .devinet_vars = { 143742f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding", 143831be3085SHerbert Xu devinet_sysctl_forward, 143931be3085SHerbert Xu devinet_conf_sysctl), 144042f811b8SHerbert Xu DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"), 144142f811b8SHerbert Xu 144242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"), 144342f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"), 144442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"), 144542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"), 144642f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"), 144742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE, 144842f811b8SHerbert Xu "accept_source_route"), 144942f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"), 145042f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"), 145142f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"), 145242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"), 145342f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"), 145442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"), 145542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"), 145642f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"), 145742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"), 145842f811b8SHerbert Xu 145942f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"), 146042f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"), 146142f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION, 146242f811b8SHerbert Xu "force_igmp_version"), 146342f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES, 146442f811b8SHerbert Xu "promote_secondaries"), 14651da177e4SLinus Torvalds }, 14661da177e4SLinus Torvalds }; 14671da177e4SLinus Torvalds 146866f27a52SPavel Emelyanov static void __devinet_sysctl_register(char *dev_name, int ctl_name, 14691da177e4SLinus Torvalds struct ipv4_devconf *p) 14701da177e4SLinus Torvalds { 14711da177e4SLinus Torvalds int i; 14729fa89642SPavel Emelyanov struct devinet_sysctl_table *t; 14731da177e4SLinus Torvalds 1474bfada697SPavel Emelyanov #define DEVINET_CTL_PATH_DEV 3 1475bfada697SPavel Emelyanov 1476bfada697SPavel Emelyanov struct ctl_path devinet_ctl_path[] = { 1477bfada697SPavel Emelyanov { .procname = "net", .ctl_name = CTL_NET, }, 1478bfada697SPavel Emelyanov { .procname = "ipv4", .ctl_name = NET_IPV4, }, 1479bfada697SPavel Emelyanov { .procname = "conf", .ctl_name = NET_IPV4_CONF, }, 1480bfada697SPavel Emelyanov { /* to be set */ }, 1481bfada697SPavel Emelyanov { }, 1482bfada697SPavel Emelyanov }; 1483bfada697SPavel Emelyanov 14849fa89642SPavel Emelyanov t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL); 14851da177e4SLinus Torvalds if (!t) 14869fa89642SPavel Emelyanov goto out; 14879fa89642SPavel Emelyanov 14881da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 14891da177e4SLinus Torvalds t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 149031be3085SHerbert Xu t->devinet_vars[i].extra1 = p; 14911da177e4SLinus Torvalds } 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds /* 14941da177e4SLinus Torvalds * Make a copy of dev_name, because '.procname' is regarded as const 14951da177e4SLinus Torvalds * by sysctl and we wouldn't want anyone to change it under our feet 14961da177e4SLinus Torvalds * (see SIOCSIFNAME). 14971da177e4SLinus Torvalds */ 1498bfada697SPavel Emelyanov t->dev_name = kstrdup(dev_name, GFP_KERNEL); 1499bfada697SPavel Emelyanov if (!t->dev_name) 15001da177e4SLinus Torvalds goto free; 15011da177e4SLinus Torvalds 1502bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name; 1503bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name; 15041da177e4SLinus Torvalds 1505bfada697SPavel Emelyanov t->sysctl_header = register_sysctl_paths(devinet_ctl_path, 1506bfada697SPavel Emelyanov t->devinet_vars); 15071da177e4SLinus Torvalds if (!t->sysctl_header) 15081da177e4SLinus Torvalds goto free_procname; 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds p->sysctl = t; 15111da177e4SLinus Torvalds return; 15121da177e4SLinus Torvalds 15131da177e4SLinus Torvalds free_procname: 1514bfada697SPavel Emelyanov kfree(t->dev_name); 15151da177e4SLinus Torvalds free: 15161da177e4SLinus Torvalds kfree(t); 15179fa89642SPavel Emelyanov out: 15181da177e4SLinus Torvalds return; 15191da177e4SLinus Torvalds } 15201da177e4SLinus Torvalds 152166f27a52SPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev) 152266f27a52SPavel Emelyanov { 152366f27a52SPavel Emelyanov return __devinet_sysctl_register(idev->dev->name, idev->dev->ifindex, 152466f27a52SPavel Emelyanov &idev->cnf); 152566f27a52SPavel Emelyanov } 152666f27a52SPavel Emelyanov 15271da177e4SLinus Torvalds static void devinet_sysctl_unregister(struct ipv4_devconf *p) 15281da177e4SLinus Torvalds { 15291da177e4SLinus Torvalds if (p->sysctl) { 15301da177e4SLinus Torvalds struct devinet_sysctl_table *t = p->sysctl; 15311da177e4SLinus Torvalds p->sysctl = NULL; 15321da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 1533bfada697SPavel Emelyanov kfree(t->dev_name); 15341da177e4SLinus Torvalds kfree(t); 15351da177e4SLinus Torvalds } 15361da177e4SLinus Torvalds } 15371da177e4SLinus Torvalds #endif 15381da177e4SLinus Torvalds 153968dd299bSPavel Emelyanov static struct ctl_table ctl_forward_entry[] = { 154068dd299bSPavel Emelyanov { 154168dd299bSPavel Emelyanov .ctl_name = NET_IPV4_FORWARD, 154268dd299bSPavel Emelyanov .procname = "ip_forward", 154368dd299bSPavel Emelyanov .data = &ipv4_devconf.data[ 154468dd299bSPavel Emelyanov NET_IPV4_CONF_FORWARDING - 1], 154568dd299bSPavel Emelyanov .maxlen = sizeof(int), 154668dd299bSPavel Emelyanov .mode = 0644, 154768dd299bSPavel Emelyanov .proc_handler = devinet_sysctl_forward, 154868dd299bSPavel Emelyanov .strategy = devinet_conf_sysctl, 154968dd299bSPavel Emelyanov .extra1 = &ipv4_devconf, 155068dd299bSPavel Emelyanov }, 155168dd299bSPavel Emelyanov { }, 155268dd299bSPavel Emelyanov }; 155368dd299bSPavel Emelyanov 155468dd299bSPavel Emelyanov static __initdata struct ctl_path net_ipv4_path[] = { 155568dd299bSPavel Emelyanov { .procname = "net", .ctl_name = CTL_NET, }, 155668dd299bSPavel Emelyanov { .procname = "ipv4", .ctl_name = NET_IPV4, }, 155768dd299bSPavel Emelyanov { }, 155868dd299bSPavel Emelyanov }; 155968dd299bSPavel Emelyanov 15601da177e4SLinus Torvalds void __init devinet_init(void) 15611da177e4SLinus Torvalds { 15621da177e4SLinus Torvalds register_gifconf(PF_INET, inet_gifconf); 15631da177e4SLinus Torvalds register_netdevice_notifier(&ip_netdev_notifier); 156463f3444fSThomas Graf 156563f3444fSThomas Graf rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL); 156663f3444fSThomas Graf rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL); 156763f3444fSThomas Graf rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr); 15681da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 156966f27a52SPavel Emelyanov __devinet_sysctl_register("all", NET_PROTO_CONF_ALL, 157066f27a52SPavel Emelyanov &ipv4_devconf); 157166f27a52SPavel Emelyanov __devinet_sysctl_register("default", NET_PROTO_CONF_DEFAULT, 157266f27a52SPavel Emelyanov &ipv4_devconf_dflt); 157368dd299bSPavel Emelyanov register_sysctl_paths(net_ipv4_path, ctl_forward_entry); 15741da177e4SLinus Torvalds #endif 15751da177e4SLinus Torvalds } 15761da177e4SLinus Torvalds 15771da177e4SLinus Torvalds EXPORT_SYMBOL(in_dev_finish_destroy); 15781da177e4SLinus Torvalds EXPORT_SYMBOL(inet_select_addr); 15791da177e4SLinus Torvalds EXPORT_SYMBOL(inetdev_by_index); 15801da177e4SLinus Torvalds EXPORT_SYMBOL(register_inetaddr_notifier); 15811da177e4SLinus Torvalds EXPORT_SYMBOL(unregister_inetaddr_notifier); 1582