11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET3 IP device support routines. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 51da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 61da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 71da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * Derived from the IP parts of dev.c 1.0.19 1002c30a84SJesper Juhl * Authors: Ross Biro 111da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 121da177e4SLinus Torvalds * Mark Evans, <evansmp@uhura.aston.ac.uk> 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * Additional Authors: 151da177e4SLinus Torvalds * Alan Cox, <gw4pts@gw4pts.ampr.org> 161da177e4SLinus Torvalds * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 171da177e4SLinus Torvalds * 181da177e4SLinus Torvalds * Changes: 191da177e4SLinus Torvalds * Alexey Kuznetsov: pa_* fields are replaced with ifaddr 201da177e4SLinus Torvalds * lists. 211da177e4SLinus Torvalds * Cyrus Durgin: updated for kmod 221da177e4SLinus Torvalds * Matthias Andree: in devinet_ioctl, compare label and 231da177e4SLinus Torvalds * address (4.4BSD alias style support), 241da177e4SLinus Torvalds * fall back to comparing just the label 251da177e4SLinus Torvalds * if no match found. 261da177e4SLinus Torvalds */ 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds #include <asm/uaccess.h> 301da177e4SLinus Torvalds #include <asm/system.h> 311da177e4SLinus Torvalds #include <linux/bitops.h> 324fc268d2SRandy Dunlap #include <linux/capability.h> 331da177e4SLinus Torvalds #include <linux/module.h> 341da177e4SLinus Torvalds #include <linux/types.h> 351da177e4SLinus Torvalds #include <linux/kernel.h> 361da177e4SLinus Torvalds #include <linux/string.h> 371da177e4SLinus Torvalds #include <linux/mm.h> 381da177e4SLinus Torvalds #include <linux/socket.h> 391da177e4SLinus Torvalds #include <linux/sockios.h> 401da177e4SLinus Torvalds #include <linux/in.h> 411da177e4SLinus Torvalds #include <linux/errno.h> 421da177e4SLinus Torvalds #include <linux/interrupt.h> 431823730fSThomas Graf #include <linux/if_addr.h> 441da177e4SLinus Torvalds #include <linux/if_ether.h> 451da177e4SLinus Torvalds #include <linux/inet.h> 461da177e4SLinus Torvalds #include <linux/netdevice.h> 471da177e4SLinus Torvalds #include <linux/etherdevice.h> 481da177e4SLinus Torvalds #include <linux/skbuff.h> 491da177e4SLinus Torvalds #include <linux/init.h> 501da177e4SLinus Torvalds #include <linux/notifier.h> 511da177e4SLinus Torvalds #include <linux/inetdevice.h> 521da177e4SLinus Torvalds #include <linux/igmp.h> 531da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 541da177e4SLinus Torvalds #include <linux/sysctl.h> 551da177e4SLinus Torvalds #endif 561da177e4SLinus Torvalds #include <linux/kmod.h> 571da177e4SLinus Torvalds 5814c85021SArnaldo Carvalho de Melo #include <net/arp.h> 591da177e4SLinus Torvalds #include <net/ip.h> 601da177e4SLinus Torvalds #include <net/route.h> 611da177e4SLinus Torvalds #include <net/ip_fib.h> 6263f3444fSThomas Graf #include <net/rtnetlink.h> 63752d14dcSPavel Emelyanov #include <net/net_namespace.h> 641da177e4SLinus Torvalds 650027ba84SAdrian Bunk static struct ipv4_devconf ipv4_devconf = { 6642f811b8SHerbert Xu .data = { 6742f811b8SHerbert Xu [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1, 6842f811b8SHerbert Xu [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1, 6942f811b8SHerbert Xu [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1, 7042f811b8SHerbert Xu [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1, 7142f811b8SHerbert Xu }, 721da177e4SLinus Torvalds }; 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds static struct ipv4_devconf ipv4_devconf_dflt = { 7542f811b8SHerbert Xu .data = { 7642f811b8SHerbert Xu [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1, 7742f811b8SHerbert Xu [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1, 7842f811b8SHerbert Xu [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1, 7942f811b8SHerbert Xu [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1, 8042f811b8SHerbert Xu [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1, 8142f811b8SHerbert Xu }, 821da177e4SLinus Torvalds }; 831da177e4SLinus Torvalds 849355bbd6SPavel Emelyanov #define IPV4_DEVCONF_DFLT(net, attr) \ 859355bbd6SPavel Emelyanov IPV4_DEVCONF((*net->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 }, 915176f91eSThomas Graf [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, 925c753978SThomas Graf }; 935c753978SThomas Graf 94d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32); 951da177e4SLinus Torvalds 96e041c683SAlan Stern static BLOCKING_NOTIFIER_HEAD(inetaddr_chain); 971da177e4SLinus Torvalds static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 981da177e4SLinus Torvalds int destroy); 991da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 10066f27a52SPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev); 10151602b2aSPavel Emelyanov static void devinet_sysctl_unregister(struct in_device *idev); 10251602b2aSPavel Emelyanov #else 10351602b2aSPavel Emelyanov static inline void devinet_sysctl_register(struct in_device *idev) 10451602b2aSPavel Emelyanov { 10551602b2aSPavel Emelyanov } 10651602b2aSPavel Emelyanov static inline void devinet_sysctl_unregister(struct in_device *idev) 10751602b2aSPavel Emelyanov { 10851602b2aSPavel Emelyanov } 1091da177e4SLinus Torvalds #endif 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds /* Locks all the inet devices. */ 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static struct in_ifaddr *inet_alloc_ifa(void) 1141da177e4SLinus Torvalds { 11593adcc80SAlexey Dobriyan return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL); 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 135547b792cSIlpo Järvinen WARN_ON(idev->ifa_list); 136547b792cSIlpo Järvinen WARN_ON(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) 1439f9354b9SEric Dumazet pr_err("Freeing alive in_device %p\n", idev); 1449f9354b9SEric Dumazet else 1451da177e4SLinus Torvalds kfree(idev); 1461da177e4SLinus Torvalds } 1479f9354b9SEric Dumazet EXPORT_SYMBOL(in_dev_finish_destroy); 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; 158c346dca1SYOSHIFUJI Hideaki memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt, 1599355bbd6SPavel Emelyanov sizeof(in_dev->cnf)); 1601da177e4SLinus Torvalds in_dev->cnf.sysctl = NULL; 1611da177e4SLinus Torvalds in_dev->dev = dev; 1629f9354b9SEric Dumazet in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl); 1639f9354b9SEric Dumazet if (!in_dev->arp_parms) 1641da177e4SLinus Torvalds goto out_kfree; 1650187bdfbSBen Hutchings if (IPV4_DEVCONF(in_dev->cnf, FORWARDING)) 1660187bdfbSBen Hutchings dev_disable_lro(dev); 1671da177e4SLinus Torvalds /* Reference in_dev->dev */ 1681da177e4SLinus Torvalds dev_hold(dev); 16930c4cf57SDavid L Stevens /* Account for reference dev->ip_ptr (below) */ 1701da177e4SLinus Torvalds in_dev_hold(in_dev); 1711da177e4SLinus Torvalds 17266f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 1731da177e4SLinus Torvalds ip_mc_init_dev(in_dev); 1741da177e4SLinus Torvalds if (dev->flags & IFF_UP) 1751da177e4SLinus Torvalds ip_mc_up(in_dev); 176483479ecSJarek Poplawski 17730c4cf57SDavid L Stevens /* we can receive as soon as ip_ptr is set -- do this last */ 17830c4cf57SDavid L Stevens rcu_assign_pointer(dev->ip_ptr, in_dev); 179483479ecSJarek Poplawski out: 1801da177e4SLinus Torvalds return in_dev; 1811da177e4SLinus Torvalds out_kfree: 1821da177e4SLinus Torvalds kfree(in_dev); 1831da177e4SLinus Torvalds in_dev = NULL; 1841da177e4SLinus Torvalds goto out; 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds static void in_dev_rcu_put(struct rcu_head *head) 1881da177e4SLinus Torvalds { 1891da177e4SLinus Torvalds struct in_device *idev = container_of(head, struct in_device, rcu_head); 1901da177e4SLinus Torvalds in_dev_put(idev); 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds static void inetdev_destroy(struct in_device *in_dev) 1941da177e4SLinus Torvalds { 1951da177e4SLinus Torvalds struct in_ifaddr *ifa; 1961da177e4SLinus Torvalds struct net_device *dev; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds ASSERT_RTNL(); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds dev = in_dev->dev; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds in_dev->dead = 1; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds ip_mc_destroy_dev(in_dev); 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds while ((ifa = in_dev->ifa_list) != NULL) { 2071da177e4SLinus Torvalds inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 2081da177e4SLinus Torvalds inet_free_ifa(ifa); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds dev->ip_ptr = NULL; 2121da177e4SLinus Torvalds 21351602b2aSPavel Emelyanov devinet_sysctl_unregister(in_dev); 2141da177e4SLinus Torvalds neigh_parms_release(&arp_tbl, in_dev->arp_parms); 2151da177e4SLinus Torvalds arp_ifdown(dev); 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 2181da177e4SLinus Torvalds } 2191da177e4SLinus Torvalds 220ff428d72SAl Viro int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b) 2211da177e4SLinus Torvalds { 2221da177e4SLinus Torvalds rcu_read_lock(); 2231da177e4SLinus Torvalds for_primary_ifa(in_dev) { 2241da177e4SLinus Torvalds if (inet_ifa_match(a, ifa)) { 2251da177e4SLinus Torvalds if (!b || inet_ifa_match(b, ifa)) { 2261da177e4SLinus Torvalds rcu_read_unlock(); 2271da177e4SLinus Torvalds return 1; 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds } endfor_ifa(in_dev); 2311da177e4SLinus Torvalds rcu_read_unlock(); 2321da177e4SLinus Torvalds return 0; 2331da177e4SLinus Torvalds } 2341da177e4SLinus Torvalds 235d6062cbbSThomas Graf static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 236d6062cbbSThomas Graf int destroy, struct nlmsghdr *nlh, u32 pid) 2371da177e4SLinus Torvalds { 2388f937c60SHarald Welte struct in_ifaddr *promote = NULL; 2390ff60a45SJamal Hadi Salim struct in_ifaddr *ifa, *ifa1 = *ifap; 2400ff60a45SJamal Hadi Salim struct in_ifaddr *last_prim = in_dev->ifa_list; 2410ff60a45SJamal Hadi Salim struct in_ifaddr *prev_prom = NULL; 2420ff60a45SJamal Hadi Salim int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds ASSERT_RTNL(); 2451da177e4SLinus Torvalds 2468f937c60SHarald Welte /* 1. Deleting primary ifaddr forces deletion all secondaries 2478f937c60SHarald Welte * unless alias promotion is set 2488f937c60SHarald Welte **/ 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 2511da177e4SLinus Torvalds struct in_ifaddr **ifap1 = &ifa1->ifa_next; 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds while ((ifa = *ifap1) != NULL) { 2540ff60a45SJamal Hadi Salim if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 2550ff60a45SJamal Hadi Salim ifa1->ifa_scope <= ifa->ifa_scope) 2560ff60a45SJamal Hadi Salim last_prim = ifa; 2570ff60a45SJamal Hadi Salim 2581da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 2591da177e4SLinus Torvalds ifa1->ifa_mask != ifa->ifa_mask || 2601da177e4SLinus Torvalds !inet_ifa_match(ifa1->ifa_address, ifa)) { 2611da177e4SLinus Torvalds ifap1 = &ifa->ifa_next; 2620ff60a45SJamal Hadi Salim prev_prom = ifa; 2631da177e4SLinus Torvalds continue; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds 2660ff60a45SJamal Hadi Salim if (!do_promote) { 2671da177e4SLinus Torvalds *ifap1 = ifa->ifa_next; 2681da177e4SLinus Torvalds 269d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid); 270e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 271e041c683SAlan Stern NETDEV_DOWN, ifa); 2721da177e4SLinus Torvalds inet_free_ifa(ifa); 2738f937c60SHarald Welte } else { 2748f937c60SHarald Welte promote = ifa; 2758f937c60SHarald Welte break; 2768f937c60SHarald Welte } 2771da177e4SLinus Torvalds } 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds /* 2. Unlink it */ 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds *ifap = ifa1->ifa_next; 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds /* 3. Announce address deletion */ 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds /* Send message first, then call notifier. 2871da177e4SLinus Torvalds At first sight, FIB update triggered by notifier 2881da177e4SLinus Torvalds will refer to already deleted ifaddr, that could confuse 2891da177e4SLinus Torvalds netlink listeners. It is not true: look, gated sees 2901da177e4SLinus Torvalds that route deleted and if it still thinks that ifaddr 2911da177e4SLinus Torvalds is valid, it will try to restore deleted routes... Grr. 2921da177e4SLinus Torvalds So that, this order is correct. 2931da177e4SLinus Torvalds */ 294d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid); 295e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 2960ff60a45SJamal Hadi Salim 2970ff60a45SJamal Hadi Salim if (promote) { 2980ff60a45SJamal Hadi Salim 2990ff60a45SJamal Hadi Salim if (prev_prom) { 3000ff60a45SJamal Hadi Salim prev_prom->ifa_next = promote->ifa_next; 3010ff60a45SJamal Hadi Salim promote->ifa_next = last_prim->ifa_next; 3020ff60a45SJamal Hadi Salim last_prim->ifa_next = promote; 3030ff60a45SJamal Hadi Salim } 3040ff60a45SJamal Hadi Salim 3050ff60a45SJamal Hadi Salim promote->ifa_flags &= ~IFA_F_SECONDARY; 306d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid); 307e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 308e041c683SAlan Stern NETDEV_UP, promote); 3090ff60a45SJamal Hadi Salim for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) { 3100ff60a45SJamal Hadi Salim if (ifa1->ifa_mask != ifa->ifa_mask || 3110ff60a45SJamal Hadi Salim !inet_ifa_match(ifa1->ifa_address, ifa)) 3120ff60a45SJamal Hadi Salim continue; 3130ff60a45SJamal Hadi Salim fib_add_ifaddr(ifa); 3140ff60a45SJamal Hadi Salim } 3150ff60a45SJamal Hadi Salim 3160ff60a45SJamal Hadi Salim } 3176363097cSHerbert Xu if (destroy) 3181da177e4SLinus Torvalds inet_free_ifa(ifa1); 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds 321d6062cbbSThomas Graf static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 322d6062cbbSThomas Graf int destroy) 323d6062cbbSThomas Graf { 324d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, destroy, NULL, 0); 325d6062cbbSThomas Graf } 326d6062cbbSThomas Graf 327d6062cbbSThomas Graf static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh, 328d6062cbbSThomas Graf u32 pid) 3291da177e4SLinus Torvalds { 3301da177e4SLinus Torvalds struct in_device *in_dev = ifa->ifa_dev; 3311da177e4SLinus Torvalds struct in_ifaddr *ifa1, **ifap, **last_primary; 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds ASSERT_RTNL(); 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds if (!ifa->ifa_local) { 3361da177e4SLinus Torvalds inet_free_ifa(ifa); 3371da177e4SLinus Torvalds return 0; 3381da177e4SLinus Torvalds } 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds ifa->ifa_flags &= ~IFA_F_SECONDARY; 3411da177e4SLinus Torvalds last_primary = &in_dev->ifa_list; 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 3441da177e4SLinus Torvalds ifap = &ifa1->ifa_next) { 3451da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 3461da177e4SLinus Torvalds ifa->ifa_scope <= ifa1->ifa_scope) 3471da177e4SLinus Torvalds last_primary = &ifa1->ifa_next; 3481da177e4SLinus Torvalds if (ifa1->ifa_mask == ifa->ifa_mask && 3491da177e4SLinus Torvalds inet_ifa_match(ifa1->ifa_address, ifa)) { 3501da177e4SLinus Torvalds if (ifa1->ifa_local == ifa->ifa_local) { 3511da177e4SLinus Torvalds inet_free_ifa(ifa); 3521da177e4SLinus Torvalds return -EEXIST; 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds if (ifa1->ifa_scope != ifa->ifa_scope) { 3551da177e4SLinus Torvalds inet_free_ifa(ifa); 3561da177e4SLinus Torvalds return -EINVAL; 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds ifa->ifa_flags |= IFA_F_SECONDARY; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 3631da177e4SLinus Torvalds net_srandom(ifa->ifa_local); 3641da177e4SLinus Torvalds ifap = last_primary; 3651da177e4SLinus Torvalds } 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds ifa->ifa_next = *ifap; 3681da177e4SLinus Torvalds *ifap = ifa; 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds /* Send message first, then call notifier. 3711da177e4SLinus Torvalds Notifier will trigger FIB update, so that 3721da177e4SLinus Torvalds listeners of netlink will know about new ifaddr */ 373d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid); 374e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds return 0; 3771da177e4SLinus Torvalds } 3781da177e4SLinus Torvalds 379d6062cbbSThomas Graf static int inet_insert_ifa(struct in_ifaddr *ifa) 380d6062cbbSThomas Graf { 381d6062cbbSThomas Graf return __inet_insert_ifa(ifa, NULL, 0); 382d6062cbbSThomas Graf } 383d6062cbbSThomas Graf 3841da177e4SLinus Torvalds static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 3851da177e4SLinus Torvalds { 386e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds ASSERT_RTNL(); 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds if (!in_dev) { 3911da177e4SLinus Torvalds inet_free_ifa(ifa); 3921da177e4SLinus Torvalds return -ENOBUFS; 3931da177e4SLinus Torvalds } 39471e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 3951da177e4SLinus Torvalds if (ifa->ifa_dev != in_dev) { 396547b792cSIlpo Järvinen WARN_ON(ifa->ifa_dev); 3971da177e4SLinus Torvalds in_dev_hold(in_dev); 3981da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 3991da177e4SLinus Torvalds } 400f97c1e0cSJoe Perches if (ipv4_is_loopback(ifa->ifa_local)) 4011da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 4021da177e4SLinus Torvalds return inet_insert_ifa(ifa); 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4057fee0ca2SDenis V. Lunev struct in_device *inetdev_by_index(struct net *net, int ifindex) 4061da177e4SLinus Torvalds { 4071da177e4SLinus Torvalds struct net_device *dev; 4081da177e4SLinus Torvalds struct in_device *in_dev = NULL; 409c148fc2eSEric Dumazet 410c148fc2eSEric Dumazet rcu_read_lock(); 411c148fc2eSEric Dumazet dev = dev_get_by_index_rcu(net, ifindex); 4121da177e4SLinus Torvalds if (dev) 4131da177e4SLinus Torvalds in_dev = in_dev_get(dev); 414c148fc2eSEric Dumazet rcu_read_unlock(); 4151da177e4SLinus Torvalds return in_dev; 4161da177e4SLinus Torvalds } 4179f9354b9SEric Dumazet EXPORT_SYMBOL(inetdev_by_index); 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds /* Called only from RTNL semaphored context. No locks. */ 4201da177e4SLinus Torvalds 42160cad5daSAl Viro struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix, 42260cad5daSAl Viro __be32 mask) 4231da177e4SLinus Torvalds { 4241da177e4SLinus Torvalds ASSERT_RTNL(); 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds for_primary_ifa(in_dev) { 4271da177e4SLinus Torvalds if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa)) 4281da177e4SLinus Torvalds return ifa; 4291da177e4SLinus Torvalds } endfor_ifa(in_dev); 4301da177e4SLinus Torvalds return NULL; 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 4341da177e4SLinus Torvalds { 4353b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 436dfdd5fd4SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4371da177e4SLinus Torvalds struct in_device *in_dev; 438dfdd5fd4SThomas Graf struct ifaddrmsg *ifm; 4391da177e4SLinus Torvalds struct in_ifaddr *ifa, **ifap; 440dfdd5fd4SThomas Graf int err = -EINVAL; 4411da177e4SLinus Torvalds 4421da177e4SLinus Torvalds ASSERT_RTNL(); 4431da177e4SLinus Torvalds 444dfdd5fd4SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 445dfdd5fd4SThomas Graf if (err < 0) 446dfdd5fd4SThomas Graf goto errout; 447dfdd5fd4SThomas Graf 448dfdd5fd4SThomas Graf ifm = nlmsg_data(nlh); 4497fee0ca2SDenis V. Lunev in_dev = inetdev_by_index(net, ifm->ifa_index); 450dfdd5fd4SThomas Graf if (in_dev == NULL) { 451dfdd5fd4SThomas Graf err = -ENODEV; 452dfdd5fd4SThomas Graf goto errout; 453dfdd5fd4SThomas Graf } 454dfdd5fd4SThomas Graf 4551da177e4SLinus Torvalds __in_dev_put(in_dev); 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 4581da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 459dfdd5fd4SThomas Graf if (tb[IFA_LOCAL] && 460a7a628c4SAl Viro ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL])) 4611da177e4SLinus Torvalds continue; 462dfdd5fd4SThomas Graf 463dfdd5fd4SThomas Graf if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) 464dfdd5fd4SThomas Graf continue; 465dfdd5fd4SThomas Graf 466dfdd5fd4SThomas Graf if (tb[IFA_ADDRESS] && 467dfdd5fd4SThomas Graf (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 468a7a628c4SAl Viro !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa))) 469dfdd5fd4SThomas Graf continue; 470dfdd5fd4SThomas Graf 471d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid); 4721da177e4SLinus Torvalds return 0; 4731da177e4SLinus Torvalds } 474dfdd5fd4SThomas Graf 475dfdd5fd4SThomas Graf err = -EADDRNOTAVAIL; 476dfdd5fd4SThomas Graf errout: 477dfdd5fd4SThomas Graf return err; 4781da177e4SLinus Torvalds } 4791da177e4SLinus Torvalds 4804b8aa9abSDenis V. Lunev static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh) 4811da177e4SLinus Torvalds { 4825c753978SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4835c753978SThomas Graf struct in_ifaddr *ifa; 4845c753978SThomas Graf struct ifaddrmsg *ifm; 4851da177e4SLinus Torvalds struct net_device *dev; 4861da177e4SLinus Torvalds struct in_device *in_dev; 4877b218574SDenis V. Lunev int err; 4881da177e4SLinus Torvalds 4895c753978SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 4905c753978SThomas Graf if (err < 0) 4915c753978SThomas Graf goto errout; 4921da177e4SLinus Torvalds 4935c753978SThomas Graf ifm = nlmsg_data(nlh); 494c4e38f41SEvgeniy Polyakov err = -EINVAL; 4957b218574SDenis V. Lunev if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) 4965c753978SThomas Graf goto errout; 4971da177e4SLinus Torvalds 4984b8aa9abSDenis V. Lunev dev = __dev_get_by_index(net, ifm->ifa_index); 4995c753978SThomas Graf err = -ENODEV; 5007b218574SDenis V. Lunev if (dev == NULL) 5015c753978SThomas Graf goto errout; 5021da177e4SLinus Torvalds 5035c753978SThomas Graf in_dev = __in_dev_get_rtnl(dev); 5045c753978SThomas Graf err = -ENOBUFS; 5057b218574SDenis V. Lunev if (in_dev == NULL) 5065c753978SThomas Graf goto errout; 50771e27da9SHerbert Xu 5085c753978SThomas Graf ifa = inet_alloc_ifa(); 5097b218574SDenis V. Lunev if (ifa == NULL) 5105c753978SThomas Graf /* 5115c753978SThomas Graf * A potential indev allocation can be left alive, it stays 5125c753978SThomas Graf * assigned to its device and is destroy with it. 5135c753978SThomas Graf */ 5145c753978SThomas Graf goto errout; 5155c753978SThomas Graf 516a4e65d36SPavel Emelyanov ipv4_devconf_setall(in_dev); 5175c753978SThomas Graf in_dev_hold(in_dev); 5185c753978SThomas Graf 5195c753978SThomas Graf if (tb[IFA_ADDRESS] == NULL) 5205c753978SThomas Graf tb[IFA_ADDRESS] = tb[IFA_LOCAL]; 5215c753978SThomas Graf 5221da177e4SLinus Torvalds ifa->ifa_prefixlen = ifm->ifa_prefixlen; 5231da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 5241da177e4SLinus Torvalds ifa->ifa_flags = ifm->ifa_flags; 5251da177e4SLinus Torvalds ifa->ifa_scope = ifm->ifa_scope; 5261da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 5275c753978SThomas Graf 528a7a628c4SAl Viro ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]); 529a7a628c4SAl Viro ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]); 5305c753978SThomas Graf 5315c753978SThomas Graf if (tb[IFA_BROADCAST]) 532a7a628c4SAl Viro ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]); 5335c753978SThomas Graf 5345c753978SThomas Graf if (tb[IFA_LABEL]) 5355c753978SThomas Graf nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ); 5361da177e4SLinus Torvalds else 5371da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 5381da177e4SLinus Torvalds 5395c753978SThomas Graf return ifa; 5405c753978SThomas Graf 5415c753978SThomas Graf errout: 5425c753978SThomas Graf return ERR_PTR(err); 5435c753978SThomas Graf } 5445c753978SThomas Graf 5455c753978SThomas Graf static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 5465c753978SThomas Graf { 5473b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 5485c753978SThomas Graf struct in_ifaddr *ifa; 5495c753978SThomas Graf 5505c753978SThomas Graf ASSERT_RTNL(); 5515c753978SThomas Graf 5524b8aa9abSDenis V. Lunev ifa = rtm_to_ifaddr(net, nlh); 5535c753978SThomas Graf if (IS_ERR(ifa)) 5545c753978SThomas Graf return PTR_ERR(ifa); 5555c753978SThomas Graf 556d6062cbbSThomas Graf return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid); 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds /* 5601da177e4SLinus Torvalds * Determine a default network mask, based on the IP address. 5611da177e4SLinus Torvalds */ 5621da177e4SLinus Torvalds 5639f9354b9SEric Dumazet static inline int inet_abc_len(__be32 addr) 5641da177e4SLinus Torvalds { 5651da177e4SLinus Torvalds int rc = -1; /* Something else, probably a multicast. */ 5661da177e4SLinus Torvalds 567f97c1e0cSJoe Perches if (ipv4_is_zeronet(addr)) 5681da177e4SLinus Torvalds rc = 0; 5691da177e4SLinus Torvalds else { 570714e85beSAl Viro __u32 haddr = ntohl(addr); 5711da177e4SLinus Torvalds 572714e85beSAl Viro if (IN_CLASSA(haddr)) 5731da177e4SLinus Torvalds rc = 8; 574714e85beSAl Viro else if (IN_CLASSB(haddr)) 5751da177e4SLinus Torvalds rc = 16; 576714e85beSAl Viro else if (IN_CLASSC(haddr)) 5771da177e4SLinus Torvalds rc = 24; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds return rc; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds 584e5b13cb1SDenis V. Lunev int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg) 5851da177e4SLinus Torvalds { 5861da177e4SLinus Torvalds struct ifreq ifr; 5871da177e4SLinus Torvalds struct sockaddr_in sin_orig; 5881da177e4SLinus Torvalds struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 5891da177e4SLinus Torvalds struct in_device *in_dev; 5901da177e4SLinus Torvalds struct in_ifaddr **ifap = NULL; 5911da177e4SLinus Torvalds struct in_ifaddr *ifa = NULL; 5921da177e4SLinus Torvalds struct net_device *dev; 5931da177e4SLinus Torvalds char *colon; 5941da177e4SLinus Torvalds int ret = -EFAULT; 5951da177e4SLinus Torvalds int tryaddrmatch = 0; 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds /* 5981da177e4SLinus Torvalds * Fetch the caller's info block into kernel space 5991da177e4SLinus Torvalds */ 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 6021da177e4SLinus Torvalds goto out; 6031da177e4SLinus Torvalds ifr.ifr_name[IFNAMSIZ - 1] = 0; 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds /* save original address for comparison */ 6061da177e4SLinus Torvalds memcpy(&sin_orig, sin, sizeof(*sin)); 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds colon = strchr(ifr.ifr_name, ':'); 6091da177e4SLinus Torvalds if (colon) 6101da177e4SLinus Torvalds *colon = 0; 6111da177e4SLinus Torvalds 612e5b13cb1SDenis V. Lunev dev_load(net, ifr.ifr_name); 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds switch (cmd) { 6151da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6161da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6171da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 6181da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 6191da177e4SLinus Torvalds /* Note that these ioctls will not sleep, 6201da177e4SLinus Torvalds so that we do not impose a lock. 6211da177e4SLinus Torvalds One day we will be forced to put shlock here (I mean SMP) 6221da177e4SLinus Torvalds */ 6231da177e4SLinus Torvalds tryaddrmatch = (sin_orig.sin_family == AF_INET); 6241da177e4SLinus Torvalds memset(sin, 0, sizeof(*sin)); 6251da177e4SLinus Torvalds sin->sin_family = AF_INET; 6261da177e4SLinus Torvalds break; 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds case SIOCSIFFLAGS: 6291da177e4SLinus Torvalds ret = -EACCES; 6301da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6311da177e4SLinus Torvalds goto out; 6321da177e4SLinus Torvalds break; 6331da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 6341da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 6351da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 6361da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 6371da177e4SLinus Torvalds ret = -EACCES; 6381da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6391da177e4SLinus Torvalds goto out; 6401da177e4SLinus Torvalds ret = -EINVAL; 6411da177e4SLinus Torvalds if (sin->sin_family != AF_INET) 6421da177e4SLinus Torvalds goto out; 6431da177e4SLinus Torvalds break; 6441da177e4SLinus Torvalds default: 6451da177e4SLinus Torvalds ret = -EINVAL; 6461da177e4SLinus Torvalds goto out; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds rtnl_lock(); 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds ret = -ENODEV; 6529f9354b9SEric Dumazet dev = __dev_get_by_name(net, ifr.ifr_name); 6539f9354b9SEric Dumazet if (!dev) 6541da177e4SLinus Torvalds goto done; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds if (colon) 6571da177e4SLinus Torvalds *colon = ':'; 6581da177e4SLinus Torvalds 6599f9354b9SEric Dumazet in_dev = __in_dev_get_rtnl(dev); 6609f9354b9SEric Dumazet if (in_dev) { 6611da177e4SLinus Torvalds if (tryaddrmatch) { 6621da177e4SLinus Torvalds /* Matthias Andree */ 6631da177e4SLinus Torvalds /* compare label and address (4.4BSD style) */ 6641da177e4SLinus Torvalds /* note: we only do this for a limited set of ioctls 6651da177e4SLinus Torvalds and only if the original address family was AF_INET. 6661da177e4SLinus Torvalds This is checked above. */ 6671da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6681da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 6691da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 6701da177e4SLinus Torvalds sin_orig.sin_addr.s_addr == 6711da177e4SLinus Torvalds ifa->ifa_address) { 6721da177e4SLinus Torvalds break; /* found */ 6731da177e4SLinus Torvalds } 6741da177e4SLinus Torvalds } 6751da177e4SLinus Torvalds } 6761da177e4SLinus Torvalds /* we didn't get a match, maybe the application is 6771da177e4SLinus Torvalds 4.3BSD-style and passed in junk so we fall back to 6781da177e4SLinus Torvalds comparing just the label */ 6791da177e4SLinus Torvalds if (!ifa) { 6801da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6811da177e4SLinus Torvalds ifap = &ifa->ifa_next) 6821da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 6831da177e4SLinus Torvalds break; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 6881da177e4SLinus Torvalds if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 6891da177e4SLinus Torvalds goto done; 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds switch (cmd) { 6921da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6931da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_local; 6941da177e4SLinus Torvalds goto rarok; 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6971da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_broadcast; 6981da177e4SLinus Torvalds goto rarok; 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 7011da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_address; 7021da177e4SLinus Torvalds goto rarok; 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 7051da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_mask; 7061da177e4SLinus Torvalds goto rarok; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds case SIOCSIFFLAGS: 7091da177e4SLinus Torvalds if (colon) { 7101da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 7111da177e4SLinus Torvalds if (!ifa) 7121da177e4SLinus Torvalds break; 7131da177e4SLinus Torvalds ret = 0; 7141da177e4SLinus Torvalds if (!(ifr.ifr_flags & IFF_UP)) 7151da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 1); 7161da177e4SLinus Torvalds break; 7171da177e4SLinus Torvalds } 7181da177e4SLinus Torvalds ret = dev_change_flags(dev, ifr.ifr_flags); 7191da177e4SLinus Torvalds break; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 7221da177e4SLinus Torvalds ret = -EINVAL; 7231da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7241da177e4SLinus Torvalds break; 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds if (!ifa) { 7271da177e4SLinus Torvalds ret = -ENOBUFS; 7289f9354b9SEric Dumazet ifa = inet_alloc_ifa(); 7299f9354b9SEric Dumazet if (!ifa) 7301da177e4SLinus Torvalds break; 7311da177e4SLinus Torvalds if (colon) 7321da177e4SLinus Torvalds memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 7331da177e4SLinus Torvalds else 7341da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 7351da177e4SLinus Torvalds } else { 7361da177e4SLinus Torvalds ret = 0; 7371da177e4SLinus Torvalds if (ifa->ifa_local == sin->sin_addr.s_addr) 7381da177e4SLinus Torvalds break; 7391da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7401da177e4SLinus Torvalds ifa->ifa_broadcast = 0; 741148f9729SBjorn Mork ifa->ifa_scope = 0; 7421da177e4SLinus Torvalds } 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds if (!(dev->flags & IFF_POINTOPOINT)) { 7471da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 7481da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 7491da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 7501da177e4SLinus Torvalds ifa->ifa_prefixlen < 31) 7511da177e4SLinus Torvalds ifa->ifa_broadcast = ifa->ifa_address | 7521da177e4SLinus Torvalds ~ifa->ifa_mask; 7531da177e4SLinus Torvalds } else { 7541da177e4SLinus Torvalds ifa->ifa_prefixlen = 32; 7551da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(32); 7561da177e4SLinus Torvalds } 7571da177e4SLinus Torvalds ret = inet_set_ifa(dev, ifa); 7581da177e4SLinus Torvalds break; 7591da177e4SLinus Torvalds 7601da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 7611da177e4SLinus Torvalds ret = 0; 7621da177e4SLinus Torvalds if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 7631da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7641da177e4SLinus Torvalds ifa->ifa_broadcast = sin->sin_addr.s_addr; 7651da177e4SLinus Torvalds inet_insert_ifa(ifa); 7661da177e4SLinus Torvalds } 7671da177e4SLinus Torvalds break; 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 7701da177e4SLinus Torvalds ret = 0; 7711da177e4SLinus Torvalds if (ifa->ifa_address == sin->sin_addr.s_addr) 7721da177e4SLinus Torvalds break; 7731da177e4SLinus Torvalds ret = -EINVAL; 7741da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7751da177e4SLinus Torvalds break; 7761da177e4SLinus Torvalds ret = 0; 7771da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7781da177e4SLinus Torvalds ifa->ifa_address = sin->sin_addr.s_addr; 7791da177e4SLinus Torvalds inet_insert_ifa(ifa); 7801da177e4SLinus Torvalds break; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds /* 7851da177e4SLinus Torvalds * The mask we set must be legal. 7861da177e4SLinus Torvalds */ 7871da177e4SLinus Torvalds ret = -EINVAL; 7881da177e4SLinus Torvalds if (bad_mask(sin->sin_addr.s_addr, 0)) 7891da177e4SLinus Torvalds break; 7901da177e4SLinus Torvalds ret = 0; 7911da177e4SLinus Torvalds if (ifa->ifa_mask != sin->sin_addr.s_addr) { 792a144ea4bSAl Viro __be32 old_mask = ifa->ifa_mask; 7931da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7941da177e4SLinus Torvalds ifa->ifa_mask = sin->sin_addr.s_addr; 7951da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds /* See if current broadcast address matches 7981da177e4SLinus Torvalds * with current netmask, then recalculate 7991da177e4SLinus Torvalds * the broadcast address. Otherwise it's a 8001da177e4SLinus Torvalds * funny address, so don't touch it since 8011da177e4SLinus Torvalds * the user seems to know what (s)he's doing... 8021da177e4SLinus Torvalds */ 8031da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 8041da177e4SLinus Torvalds (ifa->ifa_prefixlen < 31) && 8051da177e4SLinus Torvalds (ifa->ifa_broadcast == 806dcab5e1eSDavid Engel (ifa->ifa_local|~old_mask))) { 8071da177e4SLinus Torvalds ifa->ifa_broadcast = (ifa->ifa_local | 8081da177e4SLinus Torvalds ~sin->sin_addr.s_addr); 8091da177e4SLinus Torvalds } 8101da177e4SLinus Torvalds inet_insert_ifa(ifa); 8111da177e4SLinus Torvalds } 8121da177e4SLinus Torvalds break; 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds done: 8151da177e4SLinus Torvalds rtnl_unlock(); 8161da177e4SLinus Torvalds out: 8171da177e4SLinus Torvalds return ret; 8181da177e4SLinus Torvalds rarok: 8191da177e4SLinus Torvalds rtnl_unlock(); 8201da177e4SLinus Torvalds ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 8211da177e4SLinus Torvalds goto out; 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 8251da177e4SLinus Torvalds { 826e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 8271da177e4SLinus Torvalds struct in_ifaddr *ifa; 8281da177e4SLinus Torvalds struct ifreq ifr; 8291da177e4SLinus Torvalds int done = 0; 8301da177e4SLinus Torvalds 8319f9354b9SEric Dumazet if (!in_dev) 8321da177e4SLinus Torvalds goto out; 8331da177e4SLinus Torvalds 8349f9354b9SEric Dumazet for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 8351da177e4SLinus Torvalds if (!buf) { 8361da177e4SLinus Torvalds done += sizeof(ifr); 8371da177e4SLinus Torvalds continue; 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds if (len < (int) sizeof(ifr)) 8401da177e4SLinus Torvalds break; 8411da177e4SLinus Torvalds memset(&ifr, 0, sizeof(struct ifreq)); 8421da177e4SLinus Torvalds if (ifa->ifa_label) 8431da177e4SLinus Torvalds strcpy(ifr.ifr_name, ifa->ifa_label); 8441da177e4SLinus Torvalds else 8451da177e4SLinus Torvalds strcpy(ifr.ifr_name, dev->name); 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 8481da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 8491da177e4SLinus Torvalds ifa->ifa_local; 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 8521da177e4SLinus Torvalds done = -EFAULT; 8531da177e4SLinus Torvalds break; 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds buf += sizeof(struct ifreq); 8561da177e4SLinus Torvalds len -= sizeof(struct ifreq); 8571da177e4SLinus Torvalds done += sizeof(struct ifreq); 8581da177e4SLinus Torvalds } 8591da177e4SLinus Torvalds out: 8601da177e4SLinus Torvalds return done; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 863a61ced5dSAl Viro __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope) 8641da177e4SLinus Torvalds { 865a61ced5dSAl Viro __be32 addr = 0; 8661da177e4SLinus Torvalds struct in_device *in_dev; 867c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 8681da177e4SLinus Torvalds 8691da177e4SLinus Torvalds rcu_read_lock(); 870e5ed6399SHerbert Xu in_dev = __in_dev_get_rcu(dev); 8711da177e4SLinus Torvalds if (!in_dev) 8721da177e4SLinus Torvalds goto no_in_dev; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8751da177e4SLinus Torvalds if (ifa->ifa_scope > scope) 8761da177e4SLinus Torvalds continue; 8771da177e4SLinus Torvalds if (!dst || inet_ifa_match(dst, ifa)) { 8781da177e4SLinus Torvalds addr = ifa->ifa_local; 8791da177e4SLinus Torvalds break; 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds if (!addr) 8821da177e4SLinus Torvalds addr = ifa->ifa_local; 8831da177e4SLinus Torvalds } endfor_ifa(in_dev); 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds if (addr) 886c6d14c84SEric Dumazet goto out_unlock; 8879f9354b9SEric Dumazet no_in_dev: 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds /* Not loopback addresses on loopback should be preferred 8901da177e4SLinus Torvalds in this case. It is importnat that lo is the first interface 8911da177e4SLinus Torvalds in dev_base list. 8921da177e4SLinus Torvalds */ 893c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 8949f9354b9SEric Dumazet in_dev = __in_dev_get_rcu(dev); 8959f9354b9SEric Dumazet if (!in_dev) 8961da177e4SLinus Torvalds continue; 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8991da177e4SLinus Torvalds if (ifa->ifa_scope != RT_SCOPE_LINK && 9001da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9011da177e4SLinus Torvalds addr = ifa->ifa_local; 902c6d14c84SEric Dumazet goto out_unlock; 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds } endfor_ifa(in_dev); 9051da177e4SLinus Torvalds } 906c6d14c84SEric Dumazet out_unlock: 9071da177e4SLinus Torvalds rcu_read_unlock(); 9081da177e4SLinus Torvalds return addr; 9091da177e4SLinus Torvalds } 9109f9354b9SEric Dumazet EXPORT_SYMBOL(inet_select_addr); 9111da177e4SLinus Torvalds 91260cad5daSAl Viro static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst, 91360cad5daSAl Viro __be32 local, int scope) 9141da177e4SLinus Torvalds { 9151da177e4SLinus Torvalds int same = 0; 916a144ea4bSAl Viro __be32 addr = 0; 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds for_ifa(in_dev) { 9191da177e4SLinus Torvalds if (!addr && 9201da177e4SLinus Torvalds (local == ifa->ifa_local || !local) && 9211da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9221da177e4SLinus Torvalds addr = ifa->ifa_local; 9231da177e4SLinus Torvalds if (same) 9241da177e4SLinus Torvalds break; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds if (!same) { 9271da177e4SLinus Torvalds same = (!local || inet_ifa_match(local, ifa)) && 9281da177e4SLinus Torvalds (!dst || inet_ifa_match(dst, ifa)); 9291da177e4SLinus Torvalds if (same && addr) { 9301da177e4SLinus Torvalds if (local || !dst) 9311da177e4SLinus Torvalds break; 9321da177e4SLinus Torvalds /* Is the selected addr into dst subnet? */ 9331da177e4SLinus Torvalds if (inet_ifa_match(addr, ifa)) 9341da177e4SLinus Torvalds break; 9351da177e4SLinus Torvalds /* No, then can we use new local src? */ 9361da177e4SLinus Torvalds if (ifa->ifa_scope <= scope) { 9371da177e4SLinus Torvalds addr = ifa->ifa_local; 9381da177e4SLinus Torvalds break; 9391da177e4SLinus Torvalds } 9401da177e4SLinus Torvalds /* search for large dst subnet for addr */ 9411da177e4SLinus Torvalds same = 0; 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds } endfor_ifa(in_dev); 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds return same ? addr : 0; 9471da177e4SLinus Torvalds } 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds /* 9501da177e4SLinus Torvalds * Confirm that local IP address exists using wildcards: 9519bd85e32SDenis V. Lunev * - in_dev: only on this interface, 0=any interface 9521da177e4SLinus Torvalds * - dst: only in the same subnet as dst, 0=any dst 9531da177e4SLinus Torvalds * - local: address, 0=autoselect the local address 9541da177e4SLinus Torvalds * - scope: maximum allowed scope value for the local address 9551da177e4SLinus Torvalds */ 9569bd85e32SDenis V. Lunev __be32 inet_confirm_addr(struct in_device *in_dev, 9579bd85e32SDenis V. Lunev __be32 dst, __be32 local, int scope) 9581da177e4SLinus Torvalds { 95960cad5daSAl Viro __be32 addr = 0; 9609bd85e32SDenis V. Lunev struct net_device *dev; 96139a6d063SDenis V. Lunev struct net *net; 9621da177e4SLinus Torvalds 96339a6d063SDenis V. Lunev if (scope != RT_SCOPE_LINK) 9649bd85e32SDenis V. Lunev return confirm_addr_indev(in_dev, dst, local, scope); 9651da177e4SLinus Torvalds 966c346dca1SYOSHIFUJI Hideaki net = dev_net(in_dev->dev); 9671da177e4SLinus Torvalds rcu_read_lock(); 968c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 9699f9354b9SEric Dumazet in_dev = __in_dev_get_rcu(dev); 9709f9354b9SEric Dumazet if (in_dev) { 9711da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9721da177e4SLinus Torvalds if (addr) 9731da177e4SLinus Torvalds break; 9741da177e4SLinus Torvalds } 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds rcu_read_unlock(); 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds return addr; 9791da177e4SLinus Torvalds } 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds /* 9821da177e4SLinus Torvalds * Device notifier 9831da177e4SLinus Torvalds */ 9841da177e4SLinus Torvalds 9851da177e4SLinus Torvalds int register_inetaddr_notifier(struct notifier_block *nb) 9861da177e4SLinus Torvalds { 987e041c683SAlan Stern return blocking_notifier_chain_register(&inetaddr_chain, nb); 9881da177e4SLinus Torvalds } 9899f9354b9SEric Dumazet EXPORT_SYMBOL(register_inetaddr_notifier); 9901da177e4SLinus Torvalds 9911da177e4SLinus Torvalds int unregister_inetaddr_notifier(struct notifier_block *nb) 9921da177e4SLinus Torvalds { 993e041c683SAlan Stern return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 9941da177e4SLinus Torvalds } 9959f9354b9SEric Dumazet EXPORT_SYMBOL(unregister_inetaddr_notifier); 9961da177e4SLinus Torvalds 9979f9354b9SEric Dumazet /* Rename ifa_labels for a device name change. Make some effort to preserve 9989f9354b9SEric Dumazet * existing alias numbering and to create unique labels if possible. 9991da177e4SLinus Torvalds */ 10001da177e4SLinus Torvalds static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 10011da177e4SLinus Torvalds { 10021da177e4SLinus Torvalds struct in_ifaddr *ifa; 10031da177e4SLinus Torvalds int named = 0; 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 10061da177e4SLinus Torvalds char old[IFNAMSIZ], *dot; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds memcpy(old, ifa->ifa_label, IFNAMSIZ); 10091da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10101da177e4SLinus Torvalds if (named++ == 0) 1011573bf470SThomas Graf goto skip; 101244344b2aSMark McLoughlin dot = strchr(old, ':'); 10131da177e4SLinus Torvalds if (dot == NULL) { 10141da177e4SLinus Torvalds sprintf(old, ":%d", named); 10151da177e4SLinus Torvalds dot = old; 10161da177e4SLinus Torvalds } 10179f9354b9SEric Dumazet if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) 10181da177e4SLinus Torvalds strcat(ifa->ifa_label, dot); 10199f9354b9SEric Dumazet else 10201da177e4SLinus Torvalds strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 1021573bf470SThomas Graf skip: 1022573bf470SThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0); 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds } 10251da177e4SLinus Torvalds 102606770843SBreno Leitao static inline bool inetdev_valid_mtu(unsigned mtu) 102706770843SBreno Leitao { 102806770843SBreno Leitao return mtu >= 68; 102906770843SBreno Leitao } 103006770843SBreno Leitao 10311da177e4SLinus Torvalds /* Called only under RTNL semaphore */ 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds static int inetdev_event(struct notifier_block *this, unsigned long event, 10341da177e4SLinus Torvalds void *ptr) 10351da177e4SLinus Torvalds { 10361da177e4SLinus Torvalds struct net_device *dev = ptr; 1037e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds ASSERT_RTNL(); 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds if (!in_dev) { 10428030f544SHerbert Xu if (event == NETDEV_REGISTER) { 10431da177e4SLinus Torvalds in_dev = inetdev_init(dev); 10448d76527eSHerbert Xu if (!in_dev) 1045b217d616SHerbert Xu return notifier_from_errno(-ENOMEM); 10460cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 104742f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOXFRM, 1); 104842f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOPOLICY, 1); 10491da177e4SLinus Torvalds } 105006770843SBreno Leitao } else if (event == NETDEV_CHANGEMTU) { 105106770843SBreno Leitao /* Re-enabling IP */ 105206770843SBreno Leitao if (inetdev_valid_mtu(dev->mtu)) 105306770843SBreno Leitao in_dev = inetdev_init(dev); 10548030f544SHerbert Xu } 10551da177e4SLinus Torvalds goto out; 10561da177e4SLinus Torvalds } 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds switch (event) { 10591da177e4SLinus Torvalds case NETDEV_REGISTER: 10601da177e4SLinus Torvalds printk(KERN_DEBUG "inetdev_event: bug\n"); 10611da177e4SLinus Torvalds dev->ip_ptr = NULL; 10621da177e4SLinus Torvalds break; 10631da177e4SLinus Torvalds case NETDEV_UP: 106406770843SBreno Leitao if (!inetdev_valid_mtu(dev->mtu)) 10651da177e4SLinus Torvalds break; 10660cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 10679f9354b9SEric Dumazet struct in_ifaddr *ifa = inet_alloc_ifa(); 10689f9354b9SEric Dumazet 10699f9354b9SEric Dumazet if (ifa) { 10701da177e4SLinus Torvalds ifa->ifa_local = 10711da177e4SLinus Torvalds ifa->ifa_address = htonl(INADDR_LOOPBACK); 10721da177e4SLinus Torvalds ifa->ifa_prefixlen = 8; 10731da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(8); 10741da177e4SLinus Torvalds in_dev_hold(in_dev); 10751da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 10761da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 10771da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10781da177e4SLinus Torvalds inet_insert_ifa(ifa); 10791da177e4SLinus Torvalds } 10801da177e4SLinus Torvalds } 10811da177e4SLinus Torvalds ip_mc_up(in_dev); 1082eefef1cfSStephen Hemminger /* fall through */ 1083eefef1cfSStephen Hemminger case NETDEV_CHANGEADDR: 1084a21090cfSStephen Hemminger /* Send gratuitous ARP to notify of link change */ 1085a21090cfSStephen Hemminger if (IN_DEV_ARP_NOTIFY(in_dev)) { 1086a21090cfSStephen Hemminger struct in_ifaddr *ifa = in_dev->ifa_list; 1087a21090cfSStephen Hemminger 1088a21090cfSStephen Hemminger if (ifa) 1089eefef1cfSStephen Hemminger arp_send(ARPOP_REQUEST, ETH_P_ARP, 1090a21090cfSStephen Hemminger ifa->ifa_address, dev, 1091a21090cfSStephen Hemminger ifa->ifa_address, NULL, 1092a21090cfSStephen Hemminger dev->dev_addr, NULL); 1093a21090cfSStephen Hemminger } 10941da177e4SLinus Torvalds break; 10951da177e4SLinus Torvalds case NETDEV_DOWN: 10961da177e4SLinus Torvalds ip_mc_down(in_dev); 10971da177e4SLinus Torvalds break; 109875c78500SMoni Shoua case NETDEV_BONDING_OLDTYPE: 109975c78500SMoni Shoua ip_mc_unmap(in_dev); 110075c78500SMoni Shoua break; 110175c78500SMoni Shoua case NETDEV_BONDING_NEWTYPE: 110275c78500SMoni Shoua ip_mc_remap(in_dev); 110375c78500SMoni Shoua break; 11041da177e4SLinus Torvalds case NETDEV_CHANGEMTU: 110506770843SBreno Leitao if (inetdev_valid_mtu(dev->mtu)) 11061da177e4SLinus Torvalds break; 110706770843SBreno Leitao /* disable IP when MTU is not enough */ 11081da177e4SLinus Torvalds case NETDEV_UNREGISTER: 11091da177e4SLinus Torvalds inetdev_destroy(in_dev); 11101da177e4SLinus Torvalds break; 11111da177e4SLinus Torvalds case NETDEV_CHANGENAME: 11121da177e4SLinus Torvalds /* Do not notify about label change, this event is 11131da177e4SLinus Torvalds * not interesting to applications using netlink. 11141da177e4SLinus Torvalds */ 11151da177e4SLinus Torvalds inetdev_changename(dev, in_dev); 11161da177e4SLinus Torvalds 111751602b2aSPavel Emelyanov devinet_sysctl_unregister(in_dev); 111866f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 11191da177e4SLinus Torvalds break; 11201da177e4SLinus Torvalds } 11211da177e4SLinus Torvalds out: 11221da177e4SLinus Torvalds return NOTIFY_DONE; 11231da177e4SLinus Torvalds } 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds static struct notifier_block ip_netdev_notifier = { 11261da177e4SLinus Torvalds .notifier_call = inetdev_event, 11271da177e4SLinus Torvalds }; 11281da177e4SLinus Torvalds 1129339bf98fSThomas Graf static inline size_t inet_nlmsg_size(void) 1130339bf98fSThomas Graf { 1131339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 1132339bf98fSThomas Graf + nla_total_size(4) /* IFA_ADDRESS */ 1133339bf98fSThomas Graf + nla_total_size(4) /* IFA_LOCAL */ 1134339bf98fSThomas Graf + nla_total_size(4) /* IFA_BROADCAST */ 1135339bf98fSThomas Graf + nla_total_size(IFNAMSIZ); /* IFA_LABEL */ 1136339bf98fSThomas Graf } 1137339bf98fSThomas Graf 11381da177e4SLinus Torvalds static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1139b6544c0bSJamal Hadi Salim u32 pid, u32 seq, int event, unsigned int flags) 11401da177e4SLinus Torvalds { 11411da177e4SLinus Torvalds struct ifaddrmsg *ifm; 11421da177e4SLinus Torvalds struct nlmsghdr *nlh; 11431da177e4SLinus Torvalds 114447f68512SThomas Graf nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags); 114547f68512SThomas Graf if (nlh == NULL) 114626932566SPatrick McHardy return -EMSGSIZE; 114747f68512SThomas Graf 114847f68512SThomas Graf ifm = nlmsg_data(nlh); 11491da177e4SLinus Torvalds ifm->ifa_family = AF_INET; 11501da177e4SLinus Torvalds ifm->ifa_prefixlen = ifa->ifa_prefixlen; 11511da177e4SLinus Torvalds ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT; 11521da177e4SLinus Torvalds ifm->ifa_scope = ifa->ifa_scope; 11531da177e4SLinus Torvalds ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 11541da177e4SLinus Torvalds 115547f68512SThomas Graf if (ifa->ifa_address) 1156a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address); 115747f68512SThomas Graf 115847f68512SThomas Graf if (ifa->ifa_local) 1159a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local); 116047f68512SThomas Graf 116147f68512SThomas Graf if (ifa->ifa_broadcast) 1162a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast); 116347f68512SThomas Graf 116447f68512SThomas Graf if (ifa->ifa_label[0]) 116547f68512SThomas Graf NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label); 116647f68512SThomas Graf 116747f68512SThomas Graf return nlmsg_end(skb, nlh); 116847f68512SThomas Graf 116947f68512SThomas Graf nla_put_failure: 117026932566SPatrick McHardy nlmsg_cancel(skb, nlh); 117126932566SPatrick McHardy return -EMSGSIZE; 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 11751da177e4SLinus Torvalds { 11763b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 1177eec4df98SEric Dumazet int h, s_h; 1178eec4df98SEric Dumazet int idx, s_idx; 1179eec4df98SEric Dumazet int ip_idx, s_ip_idx; 11801da177e4SLinus Torvalds struct net_device *dev; 11811da177e4SLinus Torvalds struct in_device *in_dev; 11821da177e4SLinus Torvalds struct in_ifaddr *ifa; 1183eec4df98SEric Dumazet struct hlist_head *head; 1184eec4df98SEric Dumazet struct hlist_node *node; 11851da177e4SLinus Torvalds 1186eec4df98SEric Dumazet s_h = cb->args[0]; 1187eec4df98SEric Dumazet s_idx = idx = cb->args[1]; 1188eec4df98SEric Dumazet s_ip_idx = ip_idx = cb->args[2]; 1189eec4df98SEric Dumazet 1190eec4df98SEric Dumazet for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 11917562f876SPavel Emelianov idx = 0; 1192eec4df98SEric Dumazet head = &net->dev_index_head[h]; 1193eec4df98SEric Dumazet rcu_read_lock(); 1194eec4df98SEric Dumazet hlist_for_each_entry_rcu(dev, node, head, index_hlist) { 11951da177e4SLinus Torvalds if (idx < s_idx) 11967562f876SPavel Emelianov goto cont; 11971da177e4SLinus Torvalds if (idx > s_idx) 11981da177e4SLinus Torvalds s_ip_idx = 0; 1199eec4df98SEric Dumazet in_dev = __in_dev_get_rcu(dev); 12009f9354b9SEric Dumazet if (!in_dev) 12017562f876SPavel Emelianov goto cont; 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 12041da177e4SLinus Torvalds ifa = ifa->ifa_next, ip_idx++) { 12051da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 1206596e4150SStephen Hemminger continue; 1207eec4df98SEric Dumazet if (inet_fill_ifaddr(skb, ifa, 1208eec4df98SEric Dumazet NETLINK_CB(cb->skb).pid, 12091da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 1210eec4df98SEric Dumazet RTM_NEWADDR, NLM_F_MULTI) <= 0) { 1211eec4df98SEric Dumazet rcu_read_unlock(); 12121da177e4SLinus Torvalds goto done; 12131da177e4SLinus Torvalds } 1214eec4df98SEric Dumazet } 12157562f876SPavel Emelianov cont: 12167562f876SPavel Emelianov idx++; 12171da177e4SLinus Torvalds } 1218eec4df98SEric Dumazet rcu_read_unlock(); 1219eec4df98SEric Dumazet } 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds done: 1222eec4df98SEric Dumazet cb->args[0] = h; 1223eec4df98SEric Dumazet cb->args[1] = idx; 1224eec4df98SEric Dumazet cb->args[2] = ip_idx; 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds return skb->len; 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds 1229d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh, 1230d6062cbbSThomas Graf u32 pid) 12311da177e4SLinus Torvalds { 123247f68512SThomas Graf struct sk_buff *skb; 1233d6062cbbSThomas Graf u32 seq = nlh ? nlh->nlmsg_seq : 0; 1234d6062cbbSThomas Graf int err = -ENOBUFS; 12354b8aa9abSDenis V. Lunev struct net *net; 12361da177e4SLinus Torvalds 1237c346dca1SYOSHIFUJI Hideaki net = dev_net(ifa->ifa_dev->dev); 1238339bf98fSThomas Graf skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL); 123947f68512SThomas Graf if (skb == NULL) 1240d6062cbbSThomas Graf goto errout; 1241d6062cbbSThomas Graf 1242d6062cbbSThomas Graf err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0); 124326932566SPatrick McHardy if (err < 0) { 124426932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet_nlmsg_size() */ 124526932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 124626932566SPatrick McHardy kfree_skb(skb); 124726932566SPatrick McHardy goto errout; 124826932566SPatrick McHardy } 12491ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL); 12501ce85fe4SPablo Neira Ayuso return; 1251d6062cbbSThomas Graf errout: 1252d6062cbbSThomas Graf if (err < 0) 12534b8aa9abSDenis V. Lunev rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err); 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 12571da177e4SLinus Torvalds 1258c0ce9fb3SPavel Emelyanov static void devinet_copy_dflt_conf(struct net *net, int i) 125931be3085SHerbert Xu { 126031be3085SHerbert Xu struct net_device *dev; 126131be3085SHerbert Xu 126231be3085SHerbert Xu rcu_read_lock(); 1263c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 1264c6d14c84SEric Dumazet struct in_device *in_dev; 1265c6d14c84SEric Dumazet 126631be3085SHerbert Xu in_dev = __in_dev_get_rcu(dev); 126731be3085SHerbert Xu if (in_dev && !test_bit(i, in_dev->cnf.state)) 12689355bbd6SPavel Emelyanov in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i]; 1269c6d14c84SEric Dumazet } 127031be3085SHerbert Xu rcu_read_unlock(); 127131be3085SHerbert Xu } 127231be3085SHerbert Xu 1273c6d14c84SEric Dumazet /* called with RTNL locked */ 1274c0ce9fb3SPavel Emelyanov static void inet_forward_change(struct net *net) 127568dd299bSPavel Emelyanov { 127668dd299bSPavel Emelyanov struct net_device *dev; 1277586f1211SPavel Emelyanov int on = IPV4_DEVCONF_ALL(net, FORWARDING); 127868dd299bSPavel Emelyanov 1279586f1211SPavel Emelyanov IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on; 12809355bbd6SPavel Emelyanov IPV4_DEVCONF_DFLT(net, FORWARDING) = on; 128168dd299bSPavel Emelyanov 1282c0ce9fb3SPavel Emelyanov for_each_netdev(net, dev) { 128368dd299bSPavel Emelyanov struct in_device *in_dev; 12840187bdfbSBen Hutchings if (on) 12850187bdfbSBen Hutchings dev_disable_lro(dev); 128668dd299bSPavel Emelyanov rcu_read_lock(); 128768dd299bSPavel Emelyanov in_dev = __in_dev_get_rcu(dev); 128868dd299bSPavel Emelyanov if (in_dev) 128968dd299bSPavel Emelyanov IN_DEV_CONF_SET(in_dev, FORWARDING, on); 129068dd299bSPavel Emelyanov rcu_read_unlock(); 129168dd299bSPavel Emelyanov } 129268dd299bSPavel Emelyanov } 129368dd299bSPavel Emelyanov 129431be3085SHerbert Xu static int devinet_conf_proc(ctl_table *ctl, int write, 12958d65af78SAlexey Dobriyan void __user *buffer, 129631be3085SHerbert Xu size_t *lenp, loff_t *ppos) 129731be3085SHerbert Xu { 12988d65af78SAlexey Dobriyan int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 129931be3085SHerbert Xu 130031be3085SHerbert Xu if (write) { 130131be3085SHerbert Xu struct ipv4_devconf *cnf = ctl->extra1; 1302c0ce9fb3SPavel Emelyanov struct net *net = ctl->extra2; 130331be3085SHerbert Xu int i = (int *)ctl->data - cnf->data; 130431be3085SHerbert Xu 130531be3085SHerbert Xu set_bit(i, cnf->state); 130631be3085SHerbert Xu 13079355bbd6SPavel Emelyanov if (cnf == net->ipv4.devconf_dflt) 1308c0ce9fb3SPavel Emelyanov devinet_copy_dflt_conf(net, i); 130931be3085SHerbert Xu } 131031be3085SHerbert Xu 131131be3085SHerbert Xu return ret; 131231be3085SHerbert Xu } 131331be3085SHerbert Xu 1314f221e726SAlexey Dobriyan static int devinet_conf_sysctl(ctl_table *table, 131531be3085SHerbert Xu void __user *oldval, size_t __user *oldlenp, 131631be3085SHerbert Xu void __user *newval, size_t newlen) 131731be3085SHerbert Xu { 131831be3085SHerbert Xu struct ipv4_devconf *cnf; 1319c0ce9fb3SPavel Emelyanov struct net *net; 132031be3085SHerbert Xu int *valp = table->data; 132131be3085SHerbert Xu int new; 132231be3085SHerbert Xu int i; 132331be3085SHerbert Xu 132431be3085SHerbert Xu if (!newval || !newlen) 132531be3085SHerbert Xu return 0; 132631be3085SHerbert Xu 132731be3085SHerbert Xu if (newlen != sizeof(int)) 132831be3085SHerbert Xu return -EINVAL; 132931be3085SHerbert Xu 133031be3085SHerbert Xu if (get_user(new, (int __user *)newval)) 133131be3085SHerbert Xu return -EFAULT; 133231be3085SHerbert Xu 133331be3085SHerbert Xu if (new == *valp) 133431be3085SHerbert Xu return 0; 133531be3085SHerbert Xu 133631be3085SHerbert Xu if (oldval && oldlenp) { 133731be3085SHerbert Xu size_t len; 133831be3085SHerbert Xu 133931be3085SHerbert Xu if (get_user(len, oldlenp)) 134031be3085SHerbert Xu return -EFAULT; 134131be3085SHerbert Xu 134231be3085SHerbert Xu if (len) { 134331be3085SHerbert Xu if (len > table->maxlen) 134431be3085SHerbert Xu len = table->maxlen; 134531be3085SHerbert Xu if (copy_to_user(oldval, valp, len)) 134631be3085SHerbert Xu return -EFAULT; 134731be3085SHerbert Xu if (put_user(len, oldlenp)) 134831be3085SHerbert Xu return -EFAULT; 134931be3085SHerbert Xu } 135031be3085SHerbert Xu } 135131be3085SHerbert Xu 135231be3085SHerbert Xu *valp = new; 135331be3085SHerbert Xu 135431be3085SHerbert Xu cnf = table->extra1; 1355c0ce9fb3SPavel Emelyanov net = table->extra2; 135631be3085SHerbert Xu i = (int *)table->data - cnf->data; 135731be3085SHerbert Xu 135831be3085SHerbert Xu set_bit(i, cnf->state); 135931be3085SHerbert Xu 13609355bbd6SPavel Emelyanov if (cnf == net->ipv4.devconf_dflt) 1361c0ce9fb3SPavel Emelyanov devinet_copy_dflt_conf(net, i); 136231be3085SHerbert Xu 136331be3085SHerbert Xu return 1; 136431be3085SHerbert Xu } 136531be3085SHerbert Xu 13661da177e4SLinus Torvalds static int devinet_sysctl_forward(ctl_table *ctl, int write, 13678d65af78SAlexey Dobriyan void __user *buffer, 13681da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13691da177e4SLinus Torvalds { 13701da177e4SLinus Torvalds int *valp = ctl->data; 13711da177e4SLinus Torvalds int val = *valp; 13728d65af78SAlexey Dobriyan int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds if (write && *valp != val) { 1375c0ce9fb3SPavel Emelyanov struct net *net = ctl->extra2; 1376c0ce9fb3SPavel Emelyanov 13770187bdfbSBen Hutchings if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) { 13789b8adb5eSEric W. Biederman if (!rtnl_trylock()) 13799b8adb5eSEric W. Biederman return restart_syscall(); 13800187bdfbSBen Hutchings if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) { 1381c0ce9fb3SPavel Emelyanov inet_forward_change(net); 13820187bdfbSBen Hutchings } else if (*valp) { 13830187bdfbSBen Hutchings struct ipv4_devconf *cnf = ctl->extra1; 13840187bdfbSBen Hutchings struct in_device *idev = 13850187bdfbSBen Hutchings container_of(cnf, struct in_device, cnf); 13860187bdfbSBen Hutchings dev_disable_lro(idev->dev); 13870187bdfbSBen Hutchings } 13880187bdfbSBen Hutchings rtnl_unlock(); 138976e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 13901da177e4SLinus Torvalds } 13910187bdfbSBen Hutchings } 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds return ret; 13941da177e4SLinus Torvalds } 13951da177e4SLinus Torvalds 13961da177e4SLinus Torvalds int ipv4_doint_and_flush(ctl_table *ctl, int write, 13978d65af78SAlexey Dobriyan void __user *buffer, 13981da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13991da177e4SLinus Torvalds { 14001da177e4SLinus Torvalds int *valp = ctl->data; 14011da177e4SLinus Torvalds int val = *valp; 14028d65af78SAlexey Dobriyan int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 140376e6ebfbSDenis V. Lunev struct net *net = ctl->extra2; 14041da177e4SLinus Torvalds 14051da177e4SLinus Torvalds if (write && *valp != val) 140676e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds return ret; 14091da177e4SLinus Torvalds } 14101da177e4SLinus Torvalds 1411f221e726SAlexey Dobriyan int ipv4_doint_and_flush_strategy(ctl_table *table, 14121da177e4SLinus Torvalds void __user *oldval, size_t __user *oldlenp, 14131f29bcd7SAlexey Dobriyan void __user *newval, size_t newlen) 14141da177e4SLinus Torvalds { 1415f221e726SAlexey Dobriyan int ret = devinet_conf_sysctl(table, oldval, oldlenp, newval, newlen); 141676e6ebfbSDenis V. Lunev struct net *net = table->extra2; 14171da177e4SLinus Torvalds 141831be3085SHerbert Xu if (ret == 1) 141976e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 142031be3085SHerbert Xu 142131be3085SHerbert Xu return ret; 14221da177e4SLinus Torvalds } 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds 142542f811b8SHerbert Xu #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \ 142642f811b8SHerbert Xu { \ 142742f811b8SHerbert Xu .ctl_name = NET_IPV4_CONF_ ## attr, \ 142842f811b8SHerbert Xu .procname = name, \ 142942f811b8SHerbert Xu .data = ipv4_devconf.data + \ 143042f811b8SHerbert Xu NET_IPV4_CONF_ ## attr - 1, \ 143142f811b8SHerbert Xu .maxlen = sizeof(int), \ 143242f811b8SHerbert Xu .mode = mval, \ 143342f811b8SHerbert Xu .proc_handler = proc, \ 143442f811b8SHerbert Xu .strategy = sysctl, \ 143531be3085SHerbert Xu .extra1 = &ipv4_devconf, \ 143642f811b8SHerbert Xu } 143742f811b8SHerbert Xu 143842f811b8SHerbert Xu #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \ 143931be3085SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \ 144031be3085SHerbert Xu devinet_conf_sysctl) 144142f811b8SHerbert Xu 144242f811b8SHerbert Xu #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \ 144331be3085SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \ 144431be3085SHerbert Xu devinet_conf_sysctl) 144542f811b8SHerbert Xu 144642f811b8SHerbert Xu #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \ 144742f811b8SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl) 144842f811b8SHerbert Xu 144942f811b8SHerbert Xu #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \ 145042f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \ 145142f811b8SHerbert Xu ipv4_doint_and_flush_strategy) 145242f811b8SHerbert Xu 14531da177e4SLinus Torvalds static struct devinet_sysctl_table { 14541da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 1455bfada697SPavel Emelyanov struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX]; 1456bfada697SPavel Emelyanov char *dev_name; 14571da177e4SLinus Torvalds } devinet_sysctl = { 14581da177e4SLinus Torvalds .devinet_vars = { 145942f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding", 146031be3085SHerbert Xu devinet_sysctl_forward, 146131be3085SHerbert Xu devinet_conf_sysctl), 146242f811b8SHerbert Xu DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"), 146342f811b8SHerbert Xu 146442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"), 146542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"), 146642f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"), 146742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"), 146842f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"), 146942f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE, 147042f811b8SHerbert Xu "accept_source_route"), 147142f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"), 147242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"), 147342f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"), 147442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"), 147542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"), 147642f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"), 147742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"), 147842f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"), 147942f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"), 1480eefef1cfSStephen Hemminger DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"), 148142f811b8SHerbert Xu 148242f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"), 148342f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"), 148442f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION, 148542f811b8SHerbert Xu "force_igmp_version"), 148642f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES, 148742f811b8SHerbert Xu "promote_secondaries"), 14881da177e4SLinus Torvalds }, 14891da177e4SLinus Torvalds }; 14901da177e4SLinus Torvalds 1491ea40b324SPavel Emelyanov static int __devinet_sysctl_register(struct net *net, char *dev_name, 1492ea40b324SPavel Emelyanov int ctl_name, struct ipv4_devconf *p) 14931da177e4SLinus Torvalds { 14941da177e4SLinus Torvalds int i; 14959fa89642SPavel Emelyanov struct devinet_sysctl_table *t; 14961da177e4SLinus Torvalds 1497bfada697SPavel Emelyanov #define DEVINET_CTL_PATH_DEV 3 1498bfada697SPavel Emelyanov 1499bfada697SPavel Emelyanov struct ctl_path devinet_ctl_path[] = { 1500bfada697SPavel Emelyanov { .procname = "net", .ctl_name = CTL_NET, }, 1501bfada697SPavel Emelyanov { .procname = "ipv4", .ctl_name = NET_IPV4, }, 1502bfada697SPavel Emelyanov { .procname = "conf", .ctl_name = NET_IPV4_CONF, }, 1503bfada697SPavel Emelyanov { /* to be set */ }, 1504bfada697SPavel Emelyanov { }, 1505bfada697SPavel Emelyanov }; 1506bfada697SPavel Emelyanov 15079fa89642SPavel Emelyanov t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL); 15081da177e4SLinus Torvalds if (!t) 15099fa89642SPavel Emelyanov goto out; 15109fa89642SPavel Emelyanov 15111da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 15121da177e4SLinus Torvalds t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 151331be3085SHerbert Xu t->devinet_vars[i].extra1 = p; 1514c0ce9fb3SPavel Emelyanov t->devinet_vars[i].extra2 = net; 15151da177e4SLinus Torvalds } 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds /* 15181da177e4SLinus Torvalds * Make a copy of dev_name, because '.procname' is regarded as const 15191da177e4SLinus Torvalds * by sysctl and we wouldn't want anyone to change it under our feet 15201da177e4SLinus Torvalds * (see SIOCSIFNAME). 15211da177e4SLinus Torvalds */ 1522bfada697SPavel Emelyanov t->dev_name = kstrdup(dev_name, GFP_KERNEL); 1523bfada697SPavel Emelyanov if (!t->dev_name) 15241da177e4SLinus Torvalds goto free; 15251da177e4SLinus Torvalds 1526bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name; 1527bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name; 15281da177e4SLinus Torvalds 1529752d14dcSPavel Emelyanov t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path, 1530bfada697SPavel Emelyanov t->devinet_vars); 15311da177e4SLinus Torvalds if (!t->sysctl_header) 15321da177e4SLinus Torvalds goto free_procname; 15331da177e4SLinus Torvalds 15341da177e4SLinus Torvalds p->sysctl = t; 1535ea40b324SPavel Emelyanov return 0; 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds free_procname: 1538bfada697SPavel Emelyanov kfree(t->dev_name); 15391da177e4SLinus Torvalds free: 15401da177e4SLinus Torvalds kfree(t); 15419fa89642SPavel Emelyanov out: 1542ea40b324SPavel Emelyanov return -ENOBUFS; 15431da177e4SLinus Torvalds } 15441da177e4SLinus Torvalds 154551602b2aSPavel Emelyanov static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf) 154666f27a52SPavel Emelyanov { 154751602b2aSPavel Emelyanov struct devinet_sysctl_table *t = cnf->sysctl; 154866f27a52SPavel Emelyanov 154951602b2aSPavel Emelyanov if (t == NULL) 155051602b2aSPavel Emelyanov return; 155151602b2aSPavel Emelyanov 155251602b2aSPavel Emelyanov cnf->sysctl = NULL; 15531da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 1554bfada697SPavel Emelyanov kfree(t->dev_name); 15551da177e4SLinus Torvalds kfree(t); 15561da177e4SLinus Torvalds } 155751602b2aSPavel Emelyanov 155851602b2aSPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev) 155951602b2aSPavel Emelyanov { 156051602b2aSPavel Emelyanov neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4, 156151602b2aSPavel Emelyanov NET_IPV4_NEIGH, "ipv4", NULL, NULL); 1562c346dca1SYOSHIFUJI Hideaki __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name, 1563c0ce9fb3SPavel Emelyanov idev->dev->ifindex, &idev->cnf); 156451602b2aSPavel Emelyanov } 156551602b2aSPavel Emelyanov 156651602b2aSPavel Emelyanov static void devinet_sysctl_unregister(struct in_device *idev) 156751602b2aSPavel Emelyanov { 156851602b2aSPavel Emelyanov __devinet_sysctl_unregister(&idev->cnf); 156951602b2aSPavel Emelyanov neigh_sysctl_unregister(idev->arp_parms); 15701da177e4SLinus Torvalds } 15711da177e4SLinus Torvalds 157268dd299bSPavel Emelyanov static struct ctl_table ctl_forward_entry[] = { 157368dd299bSPavel Emelyanov { 157468dd299bSPavel Emelyanov .ctl_name = NET_IPV4_FORWARD, 157568dd299bSPavel Emelyanov .procname = "ip_forward", 157668dd299bSPavel Emelyanov .data = &ipv4_devconf.data[ 157768dd299bSPavel Emelyanov NET_IPV4_CONF_FORWARDING - 1], 157868dd299bSPavel Emelyanov .maxlen = sizeof(int), 157968dd299bSPavel Emelyanov .mode = 0644, 158068dd299bSPavel Emelyanov .proc_handler = devinet_sysctl_forward, 158168dd299bSPavel Emelyanov .strategy = devinet_conf_sysctl, 158268dd299bSPavel Emelyanov .extra1 = &ipv4_devconf, 1583c0ce9fb3SPavel Emelyanov .extra2 = &init_net, 158468dd299bSPavel Emelyanov }, 158568dd299bSPavel Emelyanov { }, 158668dd299bSPavel Emelyanov }; 158768dd299bSPavel Emelyanov 1588752d14dcSPavel Emelyanov static __net_initdata struct ctl_path net_ipv4_path[] = { 158968dd299bSPavel Emelyanov { .procname = "net", .ctl_name = CTL_NET, }, 159068dd299bSPavel Emelyanov { .procname = "ipv4", .ctl_name = NET_IPV4, }, 159168dd299bSPavel Emelyanov { }, 159268dd299bSPavel Emelyanov }; 15932a75de0cSEric Dumazet #endif 159468dd299bSPavel Emelyanov 1595752d14dcSPavel Emelyanov static __net_init int devinet_init_net(struct net *net) 1596752d14dcSPavel Emelyanov { 1597752d14dcSPavel Emelyanov int err; 1598752d14dcSPavel Emelyanov struct ipv4_devconf *all, *dflt; 15992a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 16002a75de0cSEric Dumazet struct ctl_table *tbl = ctl_forward_entry; 1601752d14dcSPavel Emelyanov struct ctl_table_header *forw_hdr; 16022a75de0cSEric Dumazet #endif 1603752d14dcSPavel Emelyanov 1604752d14dcSPavel Emelyanov err = -ENOMEM; 1605752d14dcSPavel Emelyanov all = &ipv4_devconf; 1606752d14dcSPavel Emelyanov dflt = &ipv4_devconf_dflt; 1607752d14dcSPavel Emelyanov 1608752d14dcSPavel Emelyanov if (net != &init_net) { 1609752d14dcSPavel Emelyanov all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL); 1610752d14dcSPavel Emelyanov if (all == NULL) 1611752d14dcSPavel Emelyanov goto err_alloc_all; 1612752d14dcSPavel Emelyanov 1613752d14dcSPavel Emelyanov dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL); 1614752d14dcSPavel Emelyanov if (dflt == NULL) 1615752d14dcSPavel Emelyanov goto err_alloc_dflt; 1616752d14dcSPavel Emelyanov 16172a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 1618752d14dcSPavel Emelyanov tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL); 1619752d14dcSPavel Emelyanov if (tbl == NULL) 1620752d14dcSPavel Emelyanov goto err_alloc_ctl; 1621752d14dcSPavel Emelyanov 1622752d14dcSPavel Emelyanov tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1]; 1623752d14dcSPavel Emelyanov tbl[0].extra1 = all; 1624752d14dcSPavel Emelyanov tbl[0].extra2 = net; 16252a75de0cSEric Dumazet #endif 1626752d14dcSPavel Emelyanov } 1627752d14dcSPavel Emelyanov 1628752d14dcSPavel Emelyanov #ifdef CONFIG_SYSCTL 1629752d14dcSPavel Emelyanov err = __devinet_sysctl_register(net, "all", 1630752d14dcSPavel Emelyanov NET_PROTO_CONF_ALL, all); 1631752d14dcSPavel Emelyanov if (err < 0) 1632752d14dcSPavel Emelyanov goto err_reg_all; 1633752d14dcSPavel Emelyanov 1634752d14dcSPavel Emelyanov err = __devinet_sysctl_register(net, "default", 1635752d14dcSPavel Emelyanov NET_PROTO_CONF_DEFAULT, dflt); 1636752d14dcSPavel Emelyanov if (err < 0) 1637752d14dcSPavel Emelyanov goto err_reg_dflt; 1638752d14dcSPavel Emelyanov 1639752d14dcSPavel Emelyanov err = -ENOMEM; 1640752d14dcSPavel Emelyanov forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl); 1641752d14dcSPavel Emelyanov if (forw_hdr == NULL) 1642752d14dcSPavel Emelyanov goto err_reg_ctl; 16432a75de0cSEric Dumazet net->ipv4.forw_hdr = forw_hdr; 1644752d14dcSPavel Emelyanov #endif 1645752d14dcSPavel Emelyanov 1646752d14dcSPavel Emelyanov net->ipv4.devconf_all = all; 1647752d14dcSPavel Emelyanov net->ipv4.devconf_dflt = dflt; 1648752d14dcSPavel Emelyanov return 0; 1649752d14dcSPavel Emelyanov 1650752d14dcSPavel Emelyanov #ifdef CONFIG_SYSCTL 1651752d14dcSPavel Emelyanov err_reg_ctl: 1652752d14dcSPavel Emelyanov __devinet_sysctl_unregister(dflt); 1653752d14dcSPavel Emelyanov err_reg_dflt: 1654752d14dcSPavel Emelyanov __devinet_sysctl_unregister(all); 1655752d14dcSPavel Emelyanov err_reg_all: 1656752d14dcSPavel Emelyanov if (tbl != ctl_forward_entry) 1657752d14dcSPavel Emelyanov kfree(tbl); 1658752d14dcSPavel Emelyanov err_alloc_ctl: 16592a75de0cSEric Dumazet #endif 1660752d14dcSPavel Emelyanov if (dflt != &ipv4_devconf_dflt) 1661752d14dcSPavel Emelyanov kfree(dflt); 1662752d14dcSPavel Emelyanov err_alloc_dflt: 1663752d14dcSPavel Emelyanov if (all != &ipv4_devconf) 1664752d14dcSPavel Emelyanov kfree(all); 1665752d14dcSPavel Emelyanov err_alloc_all: 1666752d14dcSPavel Emelyanov return err; 1667752d14dcSPavel Emelyanov } 1668752d14dcSPavel Emelyanov 1669752d14dcSPavel Emelyanov static __net_exit void devinet_exit_net(struct net *net) 1670752d14dcSPavel Emelyanov { 16712a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 1672752d14dcSPavel Emelyanov struct ctl_table *tbl; 1673752d14dcSPavel Emelyanov 1674752d14dcSPavel Emelyanov tbl = net->ipv4.forw_hdr->ctl_table_arg; 1675752d14dcSPavel Emelyanov unregister_net_sysctl_table(net->ipv4.forw_hdr); 1676752d14dcSPavel Emelyanov __devinet_sysctl_unregister(net->ipv4.devconf_dflt); 1677752d14dcSPavel Emelyanov __devinet_sysctl_unregister(net->ipv4.devconf_all); 1678752d14dcSPavel Emelyanov kfree(tbl); 16792a75de0cSEric Dumazet #endif 1680752d14dcSPavel Emelyanov kfree(net->ipv4.devconf_dflt); 1681752d14dcSPavel Emelyanov kfree(net->ipv4.devconf_all); 1682752d14dcSPavel Emelyanov } 1683752d14dcSPavel Emelyanov 1684752d14dcSPavel Emelyanov static __net_initdata struct pernet_operations devinet_ops = { 1685752d14dcSPavel Emelyanov .init = devinet_init_net, 1686752d14dcSPavel Emelyanov .exit = devinet_exit_net, 1687752d14dcSPavel Emelyanov }; 1688752d14dcSPavel Emelyanov 16891da177e4SLinus Torvalds void __init devinet_init(void) 16901da177e4SLinus Torvalds { 1691752d14dcSPavel Emelyanov register_pernet_subsys(&devinet_ops); 1692752d14dcSPavel Emelyanov 16931da177e4SLinus Torvalds register_gifconf(PF_INET, inet_gifconf); 16941da177e4SLinus Torvalds register_netdevice_notifier(&ip_netdev_notifier); 169563f3444fSThomas Graf 169663f3444fSThomas Graf rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL); 169763f3444fSThomas Graf rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL); 169863f3444fSThomas Graf rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr); 16991da177e4SLinus Torvalds } 17001da177e4SLinus Torvalds 1701