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 { 1150da974f4SPanagiotis Issaris struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL); 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds if (ifa) { 1181da177e4SLinus Torvalds INIT_RCU_HEAD(&ifa->rcu_head); 1191da177e4SLinus Torvalds } 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds return ifa; 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds static void inet_rcu_free_ifa(struct rcu_head *head) 1251da177e4SLinus Torvalds { 1261da177e4SLinus Torvalds struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 1271da177e4SLinus Torvalds if (ifa->ifa_dev) 1281da177e4SLinus Torvalds in_dev_put(ifa->ifa_dev); 1291da177e4SLinus Torvalds kfree(ifa); 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds static inline void inet_free_ifa(struct in_ifaddr *ifa) 1331da177e4SLinus Torvalds { 1341da177e4SLinus Torvalds call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds void in_dev_finish_destroy(struct in_device *idev) 1381da177e4SLinus Torvalds { 1391da177e4SLinus Torvalds struct net_device *dev = idev->dev; 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds BUG_TRAP(!idev->ifa_list); 1421da177e4SLinus Torvalds BUG_TRAP(!idev->mc_list); 1431da177e4SLinus Torvalds #ifdef NET_REFCNT_DEBUG 1441da177e4SLinus Torvalds printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", 1451da177e4SLinus Torvalds idev, dev ? dev->name : "NIL"); 1461da177e4SLinus Torvalds #endif 1471da177e4SLinus Torvalds dev_put(dev); 1481da177e4SLinus Torvalds if (!idev->dead) 1491da177e4SLinus Torvalds printk("Freeing alive in_device %p\n", idev); 1501da177e4SLinus Torvalds else { 1511da177e4SLinus Torvalds kfree(idev); 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 15571e27da9SHerbert Xu static struct in_device *inetdev_init(struct net_device *dev) 1561da177e4SLinus Torvalds { 1571da177e4SLinus Torvalds struct in_device *in_dev; 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds ASSERT_RTNL(); 1601da177e4SLinus Torvalds 1610da974f4SPanagiotis Issaris in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL); 1621da177e4SLinus Torvalds if (!in_dev) 1631da177e4SLinus Torvalds goto out; 1641da177e4SLinus Torvalds INIT_RCU_HEAD(&in_dev->rcu_head); 165c346dca1SYOSHIFUJI Hideaki memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt, 1669355bbd6SPavel Emelyanov sizeof(in_dev->cnf)); 1671da177e4SLinus Torvalds in_dev->cnf.sysctl = NULL; 1681da177e4SLinus Torvalds in_dev->dev = dev; 1691da177e4SLinus Torvalds if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL) 1701da177e4SLinus Torvalds goto out_kfree; 1710187bdfbSBen Hutchings if (IPV4_DEVCONF(in_dev->cnf, FORWARDING)) 1720187bdfbSBen Hutchings dev_disable_lro(dev); 1731da177e4SLinus Torvalds /* Reference in_dev->dev */ 1741da177e4SLinus Torvalds dev_hold(dev); 17530c4cf57SDavid L Stevens /* Account for reference dev->ip_ptr (below) */ 1761da177e4SLinus Torvalds in_dev_hold(in_dev); 1771da177e4SLinus Torvalds 17866f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 1791da177e4SLinus Torvalds ip_mc_init_dev(in_dev); 1801da177e4SLinus Torvalds if (dev->flags & IFF_UP) 1811da177e4SLinus Torvalds ip_mc_up(in_dev); 182483479ecSJarek Poplawski 18330c4cf57SDavid L Stevens /* we can receive as soon as ip_ptr is set -- do this last */ 18430c4cf57SDavid L Stevens rcu_assign_pointer(dev->ip_ptr, in_dev); 185483479ecSJarek Poplawski out: 1861da177e4SLinus Torvalds return in_dev; 1871da177e4SLinus Torvalds out_kfree: 1881da177e4SLinus Torvalds kfree(in_dev); 1891da177e4SLinus Torvalds in_dev = NULL; 1901da177e4SLinus Torvalds goto out; 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds static void in_dev_rcu_put(struct rcu_head *head) 1941da177e4SLinus Torvalds { 1951da177e4SLinus Torvalds struct in_device *idev = container_of(head, struct in_device, rcu_head); 1961da177e4SLinus Torvalds in_dev_put(idev); 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds static void inetdev_destroy(struct in_device *in_dev) 2001da177e4SLinus Torvalds { 2011da177e4SLinus Torvalds struct in_ifaddr *ifa; 2021da177e4SLinus Torvalds struct net_device *dev; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds ASSERT_RTNL(); 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds dev = in_dev->dev; 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds in_dev->dead = 1; 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds ip_mc_destroy_dev(in_dev); 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds while ((ifa = in_dev->ifa_list) != NULL) { 2131da177e4SLinus Torvalds inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 2141da177e4SLinus Torvalds inet_free_ifa(ifa); 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds dev->ip_ptr = NULL; 2181da177e4SLinus Torvalds 21951602b2aSPavel Emelyanov devinet_sysctl_unregister(in_dev); 2201da177e4SLinus Torvalds neigh_parms_release(&arp_tbl, in_dev->arp_parms); 2211da177e4SLinus Torvalds arp_ifdown(dev); 2221da177e4SLinus Torvalds 2231da177e4SLinus Torvalds call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds 226ff428d72SAl Viro int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b) 2271da177e4SLinus Torvalds { 2281da177e4SLinus Torvalds rcu_read_lock(); 2291da177e4SLinus Torvalds for_primary_ifa(in_dev) { 2301da177e4SLinus Torvalds if (inet_ifa_match(a, ifa)) { 2311da177e4SLinus Torvalds if (!b || inet_ifa_match(b, ifa)) { 2321da177e4SLinus Torvalds rcu_read_unlock(); 2331da177e4SLinus Torvalds return 1; 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds } endfor_ifa(in_dev); 2371da177e4SLinus Torvalds rcu_read_unlock(); 2381da177e4SLinus Torvalds return 0; 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 241d6062cbbSThomas Graf static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 242d6062cbbSThomas Graf int destroy, struct nlmsghdr *nlh, u32 pid) 2431da177e4SLinus Torvalds { 2448f937c60SHarald Welte struct in_ifaddr *promote = NULL; 2450ff60a45SJamal Hadi Salim struct in_ifaddr *ifa, *ifa1 = *ifap; 2460ff60a45SJamal Hadi Salim struct in_ifaddr *last_prim = in_dev->ifa_list; 2470ff60a45SJamal Hadi Salim struct in_ifaddr *prev_prom = NULL; 2480ff60a45SJamal Hadi Salim int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds ASSERT_RTNL(); 2511da177e4SLinus Torvalds 2528f937c60SHarald Welte /* 1. Deleting primary ifaddr forces deletion all secondaries 2538f937c60SHarald Welte * unless alias promotion is set 2548f937c60SHarald Welte **/ 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 2571da177e4SLinus Torvalds struct in_ifaddr **ifap1 = &ifa1->ifa_next; 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds while ((ifa = *ifap1) != NULL) { 2600ff60a45SJamal Hadi Salim if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 2610ff60a45SJamal Hadi Salim ifa1->ifa_scope <= ifa->ifa_scope) 2620ff60a45SJamal Hadi Salim last_prim = ifa; 2630ff60a45SJamal Hadi Salim 2641da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 2651da177e4SLinus Torvalds ifa1->ifa_mask != ifa->ifa_mask || 2661da177e4SLinus Torvalds !inet_ifa_match(ifa1->ifa_address, ifa)) { 2671da177e4SLinus Torvalds ifap1 = &ifa->ifa_next; 2680ff60a45SJamal Hadi Salim prev_prom = ifa; 2691da177e4SLinus Torvalds continue; 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 2720ff60a45SJamal Hadi Salim if (!do_promote) { 2731da177e4SLinus Torvalds *ifap1 = ifa->ifa_next; 2741da177e4SLinus Torvalds 275d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid); 276e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 277e041c683SAlan Stern NETDEV_DOWN, ifa); 2781da177e4SLinus Torvalds inet_free_ifa(ifa); 2798f937c60SHarald Welte } else { 2808f937c60SHarald Welte promote = ifa; 2818f937c60SHarald Welte break; 2828f937c60SHarald Welte } 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds /* 2. Unlink it */ 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds *ifap = ifa1->ifa_next; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds /* 3. Announce address deletion */ 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds /* Send message first, then call notifier. 2931da177e4SLinus Torvalds At first sight, FIB update triggered by notifier 2941da177e4SLinus Torvalds will refer to already deleted ifaddr, that could confuse 2951da177e4SLinus Torvalds netlink listeners. It is not true: look, gated sees 2961da177e4SLinus Torvalds that route deleted and if it still thinks that ifaddr 2971da177e4SLinus Torvalds is valid, it will try to restore deleted routes... Grr. 2981da177e4SLinus Torvalds So that, this order is correct. 2991da177e4SLinus Torvalds */ 300d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid); 301e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 3020ff60a45SJamal Hadi Salim 3030ff60a45SJamal Hadi Salim if (promote) { 3040ff60a45SJamal Hadi Salim 3050ff60a45SJamal Hadi Salim if (prev_prom) { 3060ff60a45SJamal Hadi Salim prev_prom->ifa_next = promote->ifa_next; 3070ff60a45SJamal Hadi Salim promote->ifa_next = last_prim->ifa_next; 3080ff60a45SJamal Hadi Salim last_prim->ifa_next = promote; 3090ff60a45SJamal Hadi Salim } 3100ff60a45SJamal Hadi Salim 3110ff60a45SJamal Hadi Salim promote->ifa_flags &= ~IFA_F_SECONDARY; 312d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid); 313e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 314e041c683SAlan Stern NETDEV_UP, promote); 3150ff60a45SJamal Hadi Salim for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) { 3160ff60a45SJamal Hadi Salim if (ifa1->ifa_mask != ifa->ifa_mask || 3170ff60a45SJamal Hadi Salim !inet_ifa_match(ifa1->ifa_address, ifa)) 3180ff60a45SJamal Hadi Salim continue; 3190ff60a45SJamal Hadi Salim fib_add_ifaddr(ifa); 3200ff60a45SJamal Hadi Salim } 3210ff60a45SJamal Hadi Salim 3220ff60a45SJamal Hadi Salim } 3236363097cSHerbert Xu if (destroy) 3241da177e4SLinus Torvalds inet_free_ifa(ifa1); 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 327d6062cbbSThomas Graf static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 328d6062cbbSThomas Graf int destroy) 329d6062cbbSThomas Graf { 330d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, destroy, NULL, 0); 331d6062cbbSThomas Graf } 332d6062cbbSThomas Graf 333d6062cbbSThomas Graf static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh, 334d6062cbbSThomas Graf u32 pid) 3351da177e4SLinus Torvalds { 3361da177e4SLinus Torvalds struct in_device *in_dev = ifa->ifa_dev; 3371da177e4SLinus Torvalds struct in_ifaddr *ifa1, **ifap, **last_primary; 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds ASSERT_RTNL(); 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds if (!ifa->ifa_local) { 3421da177e4SLinus Torvalds inet_free_ifa(ifa); 3431da177e4SLinus Torvalds return 0; 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds ifa->ifa_flags &= ~IFA_F_SECONDARY; 3471da177e4SLinus Torvalds last_primary = &in_dev->ifa_list; 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 3501da177e4SLinus Torvalds ifap = &ifa1->ifa_next) { 3511da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 3521da177e4SLinus Torvalds ifa->ifa_scope <= ifa1->ifa_scope) 3531da177e4SLinus Torvalds last_primary = &ifa1->ifa_next; 3541da177e4SLinus Torvalds if (ifa1->ifa_mask == ifa->ifa_mask && 3551da177e4SLinus Torvalds inet_ifa_match(ifa1->ifa_address, ifa)) { 3561da177e4SLinus Torvalds if (ifa1->ifa_local == ifa->ifa_local) { 3571da177e4SLinus Torvalds inet_free_ifa(ifa); 3581da177e4SLinus Torvalds return -EEXIST; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds if (ifa1->ifa_scope != ifa->ifa_scope) { 3611da177e4SLinus Torvalds inet_free_ifa(ifa); 3621da177e4SLinus Torvalds return -EINVAL; 3631da177e4SLinus Torvalds } 3641da177e4SLinus Torvalds ifa->ifa_flags |= IFA_F_SECONDARY; 3651da177e4SLinus Torvalds } 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 3691da177e4SLinus Torvalds net_srandom(ifa->ifa_local); 3701da177e4SLinus Torvalds ifap = last_primary; 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds ifa->ifa_next = *ifap; 3741da177e4SLinus Torvalds *ifap = ifa; 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds /* Send message first, then call notifier. 3771da177e4SLinus Torvalds Notifier will trigger FIB update, so that 3781da177e4SLinus Torvalds listeners of netlink will know about new ifaddr */ 379d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid); 380e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds return 0; 3831da177e4SLinus Torvalds } 3841da177e4SLinus Torvalds 385d6062cbbSThomas Graf static int inet_insert_ifa(struct in_ifaddr *ifa) 386d6062cbbSThomas Graf { 387d6062cbbSThomas Graf return __inet_insert_ifa(ifa, NULL, 0); 388d6062cbbSThomas Graf } 389d6062cbbSThomas Graf 3901da177e4SLinus Torvalds static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 3911da177e4SLinus Torvalds { 392e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds ASSERT_RTNL(); 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds if (!in_dev) { 3971da177e4SLinus Torvalds inet_free_ifa(ifa); 3981da177e4SLinus Torvalds return -ENOBUFS; 3991da177e4SLinus Torvalds } 40071e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 4011da177e4SLinus Torvalds if (ifa->ifa_dev != in_dev) { 4021da177e4SLinus Torvalds BUG_TRAP(!ifa->ifa_dev); 4031da177e4SLinus Torvalds in_dev_hold(in_dev); 4041da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 4051da177e4SLinus Torvalds } 406f97c1e0cSJoe Perches if (ipv4_is_loopback(ifa->ifa_local)) 4071da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 4081da177e4SLinus Torvalds return inet_insert_ifa(ifa); 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds 4117fee0ca2SDenis V. Lunev struct in_device *inetdev_by_index(struct net *net, int ifindex) 4121da177e4SLinus Torvalds { 4131da177e4SLinus Torvalds struct net_device *dev; 4141da177e4SLinus Torvalds struct in_device *in_dev = NULL; 4151da177e4SLinus Torvalds read_lock(&dev_base_lock); 4167fee0ca2SDenis V. Lunev dev = __dev_get_by_index(net, ifindex); 4171da177e4SLinus Torvalds if (dev) 4181da177e4SLinus Torvalds in_dev = in_dev_get(dev); 4191da177e4SLinus Torvalds read_unlock(&dev_base_lock); 4201da177e4SLinus Torvalds return in_dev; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds /* Called only from RTNL semaphored context. No locks. */ 4241da177e4SLinus Torvalds 42560cad5daSAl Viro struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix, 42660cad5daSAl Viro __be32 mask) 4271da177e4SLinus Torvalds { 4281da177e4SLinus Torvalds ASSERT_RTNL(); 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds for_primary_ifa(in_dev) { 4311da177e4SLinus Torvalds if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa)) 4321da177e4SLinus Torvalds return ifa; 4331da177e4SLinus Torvalds } endfor_ifa(in_dev); 4341da177e4SLinus Torvalds return NULL; 4351da177e4SLinus Torvalds } 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 4381da177e4SLinus Torvalds { 4393b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 440dfdd5fd4SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4411da177e4SLinus Torvalds struct in_device *in_dev; 442dfdd5fd4SThomas Graf struct ifaddrmsg *ifm; 4431da177e4SLinus Torvalds struct in_ifaddr *ifa, **ifap; 444dfdd5fd4SThomas Graf int err = -EINVAL; 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds ASSERT_RTNL(); 4471da177e4SLinus Torvalds 448dfdd5fd4SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 449dfdd5fd4SThomas Graf if (err < 0) 450dfdd5fd4SThomas Graf goto errout; 451dfdd5fd4SThomas Graf 452dfdd5fd4SThomas Graf ifm = nlmsg_data(nlh); 4537fee0ca2SDenis V. Lunev in_dev = inetdev_by_index(net, ifm->ifa_index); 454dfdd5fd4SThomas Graf if (in_dev == NULL) { 455dfdd5fd4SThomas Graf err = -ENODEV; 456dfdd5fd4SThomas Graf goto errout; 457dfdd5fd4SThomas Graf } 458dfdd5fd4SThomas Graf 4591da177e4SLinus Torvalds __in_dev_put(in_dev); 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 4621da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 463dfdd5fd4SThomas Graf if (tb[IFA_LOCAL] && 464a7a628c4SAl Viro ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL])) 4651da177e4SLinus Torvalds continue; 466dfdd5fd4SThomas Graf 467dfdd5fd4SThomas Graf if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) 468dfdd5fd4SThomas Graf continue; 469dfdd5fd4SThomas Graf 470dfdd5fd4SThomas Graf if (tb[IFA_ADDRESS] && 471dfdd5fd4SThomas Graf (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 472a7a628c4SAl Viro !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa))) 473dfdd5fd4SThomas Graf continue; 474dfdd5fd4SThomas Graf 475d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid); 4761da177e4SLinus Torvalds return 0; 4771da177e4SLinus Torvalds } 478dfdd5fd4SThomas Graf 479dfdd5fd4SThomas Graf err = -EADDRNOTAVAIL; 480dfdd5fd4SThomas Graf errout: 481dfdd5fd4SThomas Graf return err; 4821da177e4SLinus Torvalds } 4831da177e4SLinus Torvalds 4844b8aa9abSDenis V. Lunev static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh) 4851da177e4SLinus Torvalds { 4865c753978SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4875c753978SThomas Graf struct in_ifaddr *ifa; 4885c753978SThomas Graf struct ifaddrmsg *ifm; 4891da177e4SLinus Torvalds struct net_device *dev; 4901da177e4SLinus Torvalds struct in_device *in_dev; 4917b218574SDenis V. Lunev int err; 4921da177e4SLinus Torvalds 4935c753978SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 4945c753978SThomas Graf if (err < 0) 4955c753978SThomas Graf goto errout; 4961da177e4SLinus Torvalds 4975c753978SThomas Graf ifm = nlmsg_data(nlh); 498c4e38f41SEvgeniy Polyakov err = -EINVAL; 4997b218574SDenis V. Lunev if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) 5005c753978SThomas Graf goto errout; 5011da177e4SLinus Torvalds 5024b8aa9abSDenis V. Lunev dev = __dev_get_by_index(net, ifm->ifa_index); 5035c753978SThomas Graf err = -ENODEV; 5047b218574SDenis V. Lunev if (dev == NULL) 5055c753978SThomas Graf goto errout; 5061da177e4SLinus Torvalds 5075c753978SThomas Graf in_dev = __in_dev_get_rtnl(dev); 5085c753978SThomas Graf err = -ENOBUFS; 5097b218574SDenis V. Lunev if (in_dev == NULL) 5105c753978SThomas Graf goto errout; 51171e27da9SHerbert Xu 5125c753978SThomas Graf ifa = inet_alloc_ifa(); 5137b218574SDenis V. Lunev if (ifa == NULL) 5145c753978SThomas Graf /* 5155c753978SThomas Graf * A potential indev allocation can be left alive, it stays 5165c753978SThomas Graf * assigned to its device and is destroy with it. 5175c753978SThomas Graf */ 5185c753978SThomas Graf goto errout; 5195c753978SThomas Graf 520a4e65d36SPavel Emelyanov ipv4_devconf_setall(in_dev); 5215c753978SThomas Graf in_dev_hold(in_dev); 5225c753978SThomas Graf 5235c753978SThomas Graf if (tb[IFA_ADDRESS] == NULL) 5245c753978SThomas Graf tb[IFA_ADDRESS] = tb[IFA_LOCAL]; 5255c753978SThomas Graf 5261da177e4SLinus Torvalds ifa->ifa_prefixlen = ifm->ifa_prefixlen; 5271da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 5281da177e4SLinus Torvalds ifa->ifa_flags = ifm->ifa_flags; 5291da177e4SLinus Torvalds ifa->ifa_scope = ifm->ifa_scope; 5301da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 5315c753978SThomas Graf 532a7a628c4SAl Viro ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]); 533a7a628c4SAl Viro ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]); 5345c753978SThomas Graf 5355c753978SThomas Graf if (tb[IFA_BROADCAST]) 536a7a628c4SAl Viro ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]); 5375c753978SThomas Graf 5385c753978SThomas Graf if (tb[IFA_LABEL]) 5395c753978SThomas Graf nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ); 5401da177e4SLinus Torvalds else 5411da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 5421da177e4SLinus Torvalds 5435c753978SThomas Graf return ifa; 5445c753978SThomas Graf 5455c753978SThomas Graf errout: 5465c753978SThomas Graf return ERR_PTR(err); 5475c753978SThomas Graf } 5485c753978SThomas Graf 5495c753978SThomas Graf static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 5505c753978SThomas Graf { 5513b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 5525c753978SThomas Graf struct in_ifaddr *ifa; 5535c753978SThomas Graf 5545c753978SThomas Graf ASSERT_RTNL(); 5555c753978SThomas Graf 5564b8aa9abSDenis V. Lunev ifa = rtm_to_ifaddr(net, nlh); 5575c753978SThomas Graf if (IS_ERR(ifa)) 5585c753978SThomas Graf return PTR_ERR(ifa); 5595c753978SThomas Graf 560d6062cbbSThomas Graf return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid); 5611da177e4SLinus Torvalds } 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds /* 5641da177e4SLinus Torvalds * Determine a default network mask, based on the IP address. 5651da177e4SLinus Torvalds */ 5661da177e4SLinus Torvalds 567714e85beSAl Viro static __inline__ int inet_abc_len(__be32 addr) 5681da177e4SLinus Torvalds { 5691da177e4SLinus Torvalds int rc = -1; /* Something else, probably a multicast. */ 5701da177e4SLinus Torvalds 571f97c1e0cSJoe Perches if (ipv4_is_zeronet(addr)) 5721da177e4SLinus Torvalds rc = 0; 5731da177e4SLinus Torvalds else { 574714e85beSAl Viro __u32 haddr = ntohl(addr); 5751da177e4SLinus Torvalds 576714e85beSAl Viro if (IN_CLASSA(haddr)) 5771da177e4SLinus Torvalds rc = 8; 578714e85beSAl Viro else if (IN_CLASSB(haddr)) 5791da177e4SLinus Torvalds rc = 16; 580714e85beSAl Viro else if (IN_CLASSC(haddr)) 5811da177e4SLinus Torvalds rc = 24; 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds return rc; 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds 588e5b13cb1SDenis V. Lunev int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg) 5891da177e4SLinus Torvalds { 5901da177e4SLinus Torvalds struct ifreq ifr; 5911da177e4SLinus Torvalds struct sockaddr_in sin_orig; 5921da177e4SLinus Torvalds struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 5931da177e4SLinus Torvalds struct in_device *in_dev; 5941da177e4SLinus Torvalds struct in_ifaddr **ifap = NULL; 5951da177e4SLinus Torvalds struct in_ifaddr *ifa = NULL; 5961da177e4SLinus Torvalds struct net_device *dev; 5971da177e4SLinus Torvalds char *colon; 5981da177e4SLinus Torvalds int ret = -EFAULT; 5991da177e4SLinus Torvalds int tryaddrmatch = 0; 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds /* 6021da177e4SLinus Torvalds * Fetch the caller's info block into kernel space 6031da177e4SLinus Torvalds */ 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 6061da177e4SLinus Torvalds goto out; 6071da177e4SLinus Torvalds ifr.ifr_name[IFNAMSIZ - 1] = 0; 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds /* save original address for comparison */ 6101da177e4SLinus Torvalds memcpy(&sin_orig, sin, sizeof(*sin)); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds colon = strchr(ifr.ifr_name, ':'); 6131da177e4SLinus Torvalds if (colon) 6141da177e4SLinus Torvalds *colon = 0; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds #ifdef CONFIG_KMOD 617e5b13cb1SDenis V. Lunev dev_load(net, ifr.ifr_name); 6181da177e4SLinus Torvalds #endif 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds switch (cmd) { 6211da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6221da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6231da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 6241da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 6251da177e4SLinus Torvalds /* Note that these ioctls will not sleep, 6261da177e4SLinus Torvalds so that we do not impose a lock. 6271da177e4SLinus Torvalds One day we will be forced to put shlock here (I mean SMP) 6281da177e4SLinus Torvalds */ 6291da177e4SLinus Torvalds tryaddrmatch = (sin_orig.sin_family == AF_INET); 6301da177e4SLinus Torvalds memset(sin, 0, sizeof(*sin)); 6311da177e4SLinus Torvalds sin->sin_family = AF_INET; 6321da177e4SLinus Torvalds break; 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds case SIOCSIFFLAGS: 6351da177e4SLinus Torvalds ret = -EACCES; 6361da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6371da177e4SLinus Torvalds goto out; 6381da177e4SLinus Torvalds break; 6391da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 6401da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 6411da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 6421da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 6431da177e4SLinus Torvalds ret = -EACCES; 6441da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6451da177e4SLinus Torvalds goto out; 6461da177e4SLinus Torvalds ret = -EINVAL; 6471da177e4SLinus Torvalds if (sin->sin_family != AF_INET) 6481da177e4SLinus Torvalds goto out; 6491da177e4SLinus Torvalds break; 6501da177e4SLinus Torvalds default: 6511da177e4SLinus Torvalds ret = -EINVAL; 6521da177e4SLinus Torvalds goto out; 6531da177e4SLinus Torvalds } 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds rtnl_lock(); 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds ret = -ENODEV; 658e5b13cb1SDenis V. Lunev if ((dev = __dev_get_by_name(net, ifr.ifr_name)) == NULL) 6591da177e4SLinus Torvalds goto done; 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds if (colon) 6621da177e4SLinus Torvalds *colon = ':'; 6631da177e4SLinus Torvalds 664e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 6651da177e4SLinus Torvalds if (tryaddrmatch) { 6661da177e4SLinus Torvalds /* Matthias Andree */ 6671da177e4SLinus Torvalds /* compare label and address (4.4BSD style) */ 6681da177e4SLinus Torvalds /* note: we only do this for a limited set of ioctls 6691da177e4SLinus Torvalds and only if the original address family was AF_INET. 6701da177e4SLinus Torvalds This is checked above. */ 6711da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6721da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 6731da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 6741da177e4SLinus Torvalds sin_orig.sin_addr.s_addr == 6751da177e4SLinus Torvalds ifa->ifa_address) { 6761da177e4SLinus Torvalds break; /* found */ 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds /* we didn't get a match, maybe the application is 6811da177e4SLinus Torvalds 4.3BSD-style and passed in junk so we fall back to 6821da177e4SLinus Torvalds comparing just the label */ 6831da177e4SLinus Torvalds if (!ifa) { 6841da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6851da177e4SLinus Torvalds ifap = &ifa->ifa_next) 6861da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 6871da177e4SLinus Torvalds break; 6881da177e4SLinus Torvalds } 6891da177e4SLinus Torvalds } 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 6921da177e4SLinus Torvalds if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 6931da177e4SLinus Torvalds goto done; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds switch (cmd) { 6961da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6971da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_local; 6981da177e4SLinus Torvalds goto rarok; 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 7011da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_broadcast; 7021da177e4SLinus Torvalds goto rarok; 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 7051da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_address; 7061da177e4SLinus Torvalds goto rarok; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 7091da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_mask; 7101da177e4SLinus Torvalds goto rarok; 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds case SIOCSIFFLAGS: 7131da177e4SLinus Torvalds if (colon) { 7141da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 7151da177e4SLinus Torvalds if (!ifa) 7161da177e4SLinus Torvalds break; 7171da177e4SLinus Torvalds ret = 0; 7181da177e4SLinus Torvalds if (!(ifr.ifr_flags & IFF_UP)) 7191da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 1); 7201da177e4SLinus Torvalds break; 7211da177e4SLinus Torvalds } 7221da177e4SLinus Torvalds ret = dev_change_flags(dev, ifr.ifr_flags); 7231da177e4SLinus Torvalds break; 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 7261da177e4SLinus Torvalds ret = -EINVAL; 7271da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7281da177e4SLinus Torvalds break; 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds if (!ifa) { 7311da177e4SLinus Torvalds ret = -ENOBUFS; 7321da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) == NULL) 7331da177e4SLinus Torvalds break; 7341da177e4SLinus Torvalds if (colon) 7351da177e4SLinus Torvalds memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 7361da177e4SLinus Torvalds else 7371da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 7381da177e4SLinus Torvalds } else { 7391da177e4SLinus Torvalds ret = 0; 7401da177e4SLinus Torvalds if (ifa->ifa_local == sin->sin_addr.s_addr) 7411da177e4SLinus Torvalds break; 7421da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7431da177e4SLinus Torvalds ifa->ifa_broadcast = 0; 744148f9729SBjorn Mork ifa->ifa_scope = 0; 7451da177e4SLinus Torvalds } 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds if (!(dev->flags & IFF_POINTOPOINT)) { 7501da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 7511da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 7521da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 7531da177e4SLinus Torvalds ifa->ifa_prefixlen < 31) 7541da177e4SLinus Torvalds ifa->ifa_broadcast = ifa->ifa_address | 7551da177e4SLinus Torvalds ~ifa->ifa_mask; 7561da177e4SLinus Torvalds } else { 7571da177e4SLinus Torvalds ifa->ifa_prefixlen = 32; 7581da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(32); 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds ret = inet_set_ifa(dev, ifa); 7611da177e4SLinus Torvalds break; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 7641da177e4SLinus Torvalds ret = 0; 7651da177e4SLinus Torvalds if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 7661da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7671da177e4SLinus Torvalds ifa->ifa_broadcast = sin->sin_addr.s_addr; 7681da177e4SLinus Torvalds inet_insert_ifa(ifa); 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds break; 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 7731da177e4SLinus Torvalds ret = 0; 7741da177e4SLinus Torvalds if (ifa->ifa_address == sin->sin_addr.s_addr) 7751da177e4SLinus Torvalds break; 7761da177e4SLinus Torvalds ret = -EINVAL; 7771da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7781da177e4SLinus Torvalds break; 7791da177e4SLinus Torvalds ret = 0; 7801da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7811da177e4SLinus Torvalds ifa->ifa_address = sin->sin_addr.s_addr; 7821da177e4SLinus Torvalds inet_insert_ifa(ifa); 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds /* 7881da177e4SLinus Torvalds * The mask we set must be legal. 7891da177e4SLinus Torvalds */ 7901da177e4SLinus Torvalds ret = -EINVAL; 7911da177e4SLinus Torvalds if (bad_mask(sin->sin_addr.s_addr, 0)) 7921da177e4SLinus Torvalds break; 7931da177e4SLinus Torvalds ret = 0; 7941da177e4SLinus Torvalds if (ifa->ifa_mask != sin->sin_addr.s_addr) { 795a144ea4bSAl Viro __be32 old_mask = ifa->ifa_mask; 7961da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7971da177e4SLinus Torvalds ifa->ifa_mask = sin->sin_addr.s_addr; 7981da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds /* See if current broadcast address matches 8011da177e4SLinus Torvalds * with current netmask, then recalculate 8021da177e4SLinus Torvalds * the broadcast address. Otherwise it's a 8031da177e4SLinus Torvalds * funny address, so don't touch it since 8041da177e4SLinus Torvalds * the user seems to know what (s)he's doing... 8051da177e4SLinus Torvalds */ 8061da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 8071da177e4SLinus Torvalds (ifa->ifa_prefixlen < 31) && 8081da177e4SLinus Torvalds (ifa->ifa_broadcast == 809dcab5e1eSDavid Engel (ifa->ifa_local|~old_mask))) { 8101da177e4SLinus Torvalds ifa->ifa_broadcast = (ifa->ifa_local | 8111da177e4SLinus Torvalds ~sin->sin_addr.s_addr); 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds inet_insert_ifa(ifa); 8141da177e4SLinus Torvalds } 8151da177e4SLinus Torvalds break; 8161da177e4SLinus Torvalds } 8171da177e4SLinus Torvalds done: 8181da177e4SLinus Torvalds rtnl_unlock(); 8191da177e4SLinus Torvalds out: 8201da177e4SLinus Torvalds return ret; 8211da177e4SLinus Torvalds rarok: 8221da177e4SLinus Torvalds rtnl_unlock(); 8231da177e4SLinus Torvalds ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 8241da177e4SLinus Torvalds goto out; 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 8281da177e4SLinus Torvalds { 829e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 8301da177e4SLinus Torvalds struct in_ifaddr *ifa; 8311da177e4SLinus Torvalds struct ifreq ifr; 8321da177e4SLinus Torvalds int done = 0; 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds if (!in_dev || (ifa = in_dev->ifa_list) == NULL) 8351da177e4SLinus Torvalds goto out; 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds for (; ifa; ifa = ifa->ifa_next) { 8381da177e4SLinus Torvalds if (!buf) { 8391da177e4SLinus Torvalds done += sizeof(ifr); 8401da177e4SLinus Torvalds continue; 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds if (len < (int) sizeof(ifr)) 8431da177e4SLinus Torvalds break; 8441da177e4SLinus Torvalds memset(&ifr, 0, sizeof(struct ifreq)); 8451da177e4SLinus Torvalds if (ifa->ifa_label) 8461da177e4SLinus Torvalds strcpy(ifr.ifr_name, ifa->ifa_label); 8471da177e4SLinus Torvalds else 8481da177e4SLinus Torvalds strcpy(ifr.ifr_name, dev->name); 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 8511da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 8521da177e4SLinus Torvalds ifa->ifa_local; 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 8551da177e4SLinus Torvalds done = -EFAULT; 8561da177e4SLinus Torvalds break; 8571da177e4SLinus Torvalds } 8581da177e4SLinus Torvalds buf += sizeof(struct ifreq); 8591da177e4SLinus Torvalds len -= sizeof(struct ifreq); 8601da177e4SLinus Torvalds done += sizeof(struct ifreq); 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds out: 8631da177e4SLinus Torvalds return done; 8641da177e4SLinus Torvalds } 8651da177e4SLinus Torvalds 866a61ced5dSAl Viro __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope) 8671da177e4SLinus Torvalds { 868a61ced5dSAl Viro __be32 addr = 0; 8691da177e4SLinus Torvalds struct in_device *in_dev; 870c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds rcu_read_lock(); 873e5ed6399SHerbert Xu in_dev = __in_dev_get_rcu(dev); 8741da177e4SLinus Torvalds if (!in_dev) 8751da177e4SLinus Torvalds goto no_in_dev; 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8781da177e4SLinus Torvalds if (ifa->ifa_scope > scope) 8791da177e4SLinus Torvalds continue; 8801da177e4SLinus Torvalds if (!dst || inet_ifa_match(dst, ifa)) { 8811da177e4SLinus Torvalds addr = ifa->ifa_local; 8821da177e4SLinus Torvalds break; 8831da177e4SLinus Torvalds } 8841da177e4SLinus Torvalds if (!addr) 8851da177e4SLinus Torvalds addr = ifa->ifa_local; 8861da177e4SLinus Torvalds } endfor_ifa(in_dev); 8871da177e4SLinus Torvalds no_in_dev: 8881da177e4SLinus Torvalds rcu_read_unlock(); 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds if (addr) 8911da177e4SLinus Torvalds goto out; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds /* Not loopback addresses on loopback should be preferred 8941da177e4SLinus Torvalds in this case. It is importnat that lo is the first interface 8951da177e4SLinus Torvalds in dev_base list. 8961da177e4SLinus Torvalds */ 8971da177e4SLinus Torvalds read_lock(&dev_base_lock); 8981da177e4SLinus Torvalds rcu_read_lock(); 899c4544c72SDenis V. Lunev for_each_netdev(net, dev) { 900e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev)) == NULL) 9011da177e4SLinus Torvalds continue; 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds for_primary_ifa(in_dev) { 9041da177e4SLinus Torvalds if (ifa->ifa_scope != RT_SCOPE_LINK && 9051da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9061da177e4SLinus Torvalds addr = ifa->ifa_local; 9071da177e4SLinus Torvalds goto out_unlock_both; 9081da177e4SLinus Torvalds } 9091da177e4SLinus Torvalds } endfor_ifa(in_dev); 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds out_unlock_both: 9121da177e4SLinus Torvalds read_unlock(&dev_base_lock); 9131da177e4SLinus Torvalds rcu_read_unlock(); 9141da177e4SLinus Torvalds out: 9151da177e4SLinus Torvalds return addr; 9161da177e4SLinus Torvalds } 9171da177e4SLinus Torvalds 91860cad5daSAl Viro static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst, 91960cad5daSAl Viro __be32 local, int scope) 9201da177e4SLinus Torvalds { 9211da177e4SLinus Torvalds int same = 0; 922a144ea4bSAl Viro __be32 addr = 0; 9231da177e4SLinus Torvalds 9241da177e4SLinus Torvalds for_ifa(in_dev) { 9251da177e4SLinus Torvalds if (!addr && 9261da177e4SLinus Torvalds (local == ifa->ifa_local || !local) && 9271da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9281da177e4SLinus Torvalds addr = ifa->ifa_local; 9291da177e4SLinus Torvalds if (same) 9301da177e4SLinus Torvalds break; 9311da177e4SLinus Torvalds } 9321da177e4SLinus Torvalds if (!same) { 9331da177e4SLinus Torvalds same = (!local || inet_ifa_match(local, ifa)) && 9341da177e4SLinus Torvalds (!dst || inet_ifa_match(dst, ifa)); 9351da177e4SLinus Torvalds if (same && addr) { 9361da177e4SLinus Torvalds if (local || !dst) 9371da177e4SLinus Torvalds break; 9381da177e4SLinus Torvalds /* Is the selected addr into dst subnet? */ 9391da177e4SLinus Torvalds if (inet_ifa_match(addr, ifa)) 9401da177e4SLinus Torvalds break; 9411da177e4SLinus Torvalds /* No, then can we use new local src? */ 9421da177e4SLinus Torvalds if (ifa->ifa_scope <= scope) { 9431da177e4SLinus Torvalds addr = ifa->ifa_local; 9441da177e4SLinus Torvalds break; 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds /* search for large dst subnet for addr */ 9471da177e4SLinus Torvalds same = 0; 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds } 9501da177e4SLinus Torvalds } endfor_ifa(in_dev); 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds return same? addr : 0; 9531da177e4SLinus Torvalds } 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds /* 9561da177e4SLinus Torvalds * Confirm that local IP address exists using wildcards: 9579bd85e32SDenis V. Lunev * - in_dev: only on this interface, 0=any interface 9581da177e4SLinus Torvalds * - dst: only in the same subnet as dst, 0=any dst 9591da177e4SLinus Torvalds * - local: address, 0=autoselect the local address 9601da177e4SLinus Torvalds * - scope: maximum allowed scope value for the local address 9611da177e4SLinus Torvalds */ 9629bd85e32SDenis V. Lunev __be32 inet_confirm_addr(struct in_device *in_dev, 9639bd85e32SDenis V. Lunev __be32 dst, __be32 local, int scope) 9641da177e4SLinus Torvalds { 96560cad5daSAl Viro __be32 addr = 0; 9669bd85e32SDenis V. Lunev struct net_device *dev; 96739a6d063SDenis V. Lunev struct net *net; 9681da177e4SLinus Torvalds 96939a6d063SDenis V. Lunev if (scope != RT_SCOPE_LINK) 9709bd85e32SDenis V. Lunev return confirm_addr_indev(in_dev, dst, local, scope); 9711da177e4SLinus Torvalds 972c346dca1SYOSHIFUJI Hideaki net = dev_net(in_dev->dev); 9731da177e4SLinus Torvalds read_lock(&dev_base_lock); 9741da177e4SLinus Torvalds rcu_read_lock(); 97539a6d063SDenis V. Lunev for_each_netdev(net, dev) { 976e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev))) { 9771da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9781da177e4SLinus Torvalds if (addr) 9791da177e4SLinus Torvalds break; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds } 9821da177e4SLinus Torvalds rcu_read_unlock(); 9831da177e4SLinus Torvalds read_unlock(&dev_base_lock); 9841da177e4SLinus Torvalds 9851da177e4SLinus Torvalds return addr; 9861da177e4SLinus Torvalds } 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds /* 9891da177e4SLinus Torvalds * Device notifier 9901da177e4SLinus Torvalds */ 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds int register_inetaddr_notifier(struct notifier_block *nb) 9931da177e4SLinus Torvalds { 994e041c683SAlan Stern return blocking_notifier_chain_register(&inetaddr_chain, nb); 9951da177e4SLinus Torvalds } 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds int unregister_inetaddr_notifier(struct notifier_block *nb) 9981da177e4SLinus Torvalds { 999e041c683SAlan Stern return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 10001da177e4SLinus Torvalds } 10011da177e4SLinus Torvalds 10021da177e4SLinus Torvalds /* Rename ifa_labels for a device name change. Make some effort to preserve existing 10031da177e4SLinus Torvalds * alias numbering and to create unique labels if possible. 10041da177e4SLinus Torvalds */ 10051da177e4SLinus Torvalds static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 10061da177e4SLinus Torvalds { 10071da177e4SLinus Torvalds struct in_ifaddr *ifa; 10081da177e4SLinus Torvalds int named = 0; 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 10111da177e4SLinus Torvalds char old[IFNAMSIZ], *dot; 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds memcpy(old, ifa->ifa_label, IFNAMSIZ); 10141da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10151da177e4SLinus Torvalds if (named++ == 0) 1016573bf470SThomas Graf goto skip; 101744344b2aSMark McLoughlin dot = strchr(old, ':'); 10181da177e4SLinus Torvalds if (dot == NULL) { 10191da177e4SLinus Torvalds sprintf(old, ":%d", named); 10201da177e4SLinus Torvalds dot = old; 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) { 10231da177e4SLinus Torvalds strcat(ifa->ifa_label, dot); 10241da177e4SLinus Torvalds } else { 10251da177e4SLinus Torvalds strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 10261da177e4SLinus Torvalds } 1027573bf470SThomas Graf skip: 1028573bf470SThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0); 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds } 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds /* Called only under RTNL semaphore */ 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds static int inetdev_event(struct notifier_block *this, unsigned long event, 10351da177e4SLinus Torvalds void *ptr) 10361da177e4SLinus Torvalds { 10371da177e4SLinus Torvalds struct net_device *dev = ptr; 1038e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds ASSERT_RTNL(); 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds if (!in_dev) { 10438030f544SHerbert Xu if (event == NETDEV_REGISTER) { 10441da177e4SLinus Torvalds in_dev = inetdev_init(dev); 10458d76527eSHerbert Xu if (!in_dev) 1046b217d616SHerbert Xu return notifier_from_errno(-ENOMEM); 10470cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 104842f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOXFRM, 1); 104942f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOPOLICY, 1); 10501da177e4SLinus Torvalds } 10518030f544SHerbert Xu } 10521da177e4SLinus Torvalds goto out; 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds 10551da177e4SLinus Torvalds switch (event) { 10561da177e4SLinus Torvalds case NETDEV_REGISTER: 10571da177e4SLinus Torvalds printk(KERN_DEBUG "inetdev_event: bug\n"); 10581da177e4SLinus Torvalds dev->ip_ptr = NULL; 10591da177e4SLinus Torvalds break; 10601da177e4SLinus Torvalds case NETDEV_UP: 10611da177e4SLinus Torvalds if (dev->mtu < 68) 10621da177e4SLinus Torvalds break; 10630cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 10641da177e4SLinus Torvalds struct in_ifaddr *ifa; 10651da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) != NULL) { 10661da177e4SLinus Torvalds ifa->ifa_local = 10671da177e4SLinus Torvalds ifa->ifa_address = htonl(INADDR_LOOPBACK); 10681da177e4SLinus Torvalds ifa->ifa_prefixlen = 8; 10691da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(8); 10701da177e4SLinus Torvalds in_dev_hold(in_dev); 10711da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 10721da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 10731da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10741da177e4SLinus Torvalds inet_insert_ifa(ifa); 10751da177e4SLinus Torvalds } 10761da177e4SLinus Torvalds } 10771da177e4SLinus Torvalds ip_mc_up(in_dev); 10781da177e4SLinus Torvalds break; 10791da177e4SLinus Torvalds case NETDEV_DOWN: 10801da177e4SLinus Torvalds ip_mc_down(in_dev); 10811da177e4SLinus Torvalds break; 10821da177e4SLinus Torvalds case NETDEV_CHANGEMTU: 10831da177e4SLinus Torvalds if (dev->mtu >= 68) 10841da177e4SLinus Torvalds break; 10851da177e4SLinus Torvalds /* MTU falled under 68, disable IP */ 10861da177e4SLinus Torvalds case NETDEV_UNREGISTER: 10871da177e4SLinus Torvalds inetdev_destroy(in_dev); 10881da177e4SLinus Torvalds break; 10891da177e4SLinus Torvalds case NETDEV_CHANGENAME: 10901da177e4SLinus Torvalds /* Do not notify about label change, this event is 10911da177e4SLinus Torvalds * not interesting to applications using netlink. 10921da177e4SLinus Torvalds */ 10931da177e4SLinus Torvalds inetdev_changename(dev, in_dev); 10941da177e4SLinus Torvalds 109551602b2aSPavel Emelyanov devinet_sysctl_unregister(in_dev); 109666f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 10971da177e4SLinus Torvalds break; 10981da177e4SLinus Torvalds } 10991da177e4SLinus Torvalds out: 11001da177e4SLinus Torvalds return NOTIFY_DONE; 11011da177e4SLinus Torvalds } 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds static struct notifier_block ip_netdev_notifier = { 11041da177e4SLinus Torvalds .notifier_call =inetdev_event, 11051da177e4SLinus Torvalds }; 11061da177e4SLinus Torvalds 1107339bf98fSThomas Graf static inline size_t inet_nlmsg_size(void) 1108339bf98fSThomas Graf { 1109339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 1110339bf98fSThomas Graf + nla_total_size(4) /* IFA_ADDRESS */ 1111339bf98fSThomas Graf + nla_total_size(4) /* IFA_LOCAL */ 1112339bf98fSThomas Graf + nla_total_size(4) /* IFA_BROADCAST */ 1113339bf98fSThomas Graf + nla_total_size(IFNAMSIZ); /* IFA_LABEL */ 1114339bf98fSThomas Graf } 1115339bf98fSThomas Graf 11161da177e4SLinus Torvalds static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1117b6544c0bSJamal Hadi Salim u32 pid, u32 seq, int event, unsigned int flags) 11181da177e4SLinus Torvalds { 11191da177e4SLinus Torvalds struct ifaddrmsg *ifm; 11201da177e4SLinus Torvalds struct nlmsghdr *nlh; 11211da177e4SLinus Torvalds 112247f68512SThomas Graf nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags); 112347f68512SThomas Graf if (nlh == NULL) 112426932566SPatrick McHardy return -EMSGSIZE; 112547f68512SThomas Graf 112647f68512SThomas Graf ifm = nlmsg_data(nlh); 11271da177e4SLinus Torvalds ifm->ifa_family = AF_INET; 11281da177e4SLinus Torvalds ifm->ifa_prefixlen = ifa->ifa_prefixlen; 11291da177e4SLinus Torvalds ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT; 11301da177e4SLinus Torvalds ifm->ifa_scope = ifa->ifa_scope; 11311da177e4SLinus Torvalds ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 11321da177e4SLinus Torvalds 113347f68512SThomas Graf if (ifa->ifa_address) 1134a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address); 113547f68512SThomas Graf 113647f68512SThomas Graf if (ifa->ifa_local) 1137a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local); 113847f68512SThomas Graf 113947f68512SThomas Graf if (ifa->ifa_broadcast) 1140a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast); 114147f68512SThomas Graf 114247f68512SThomas Graf if (ifa->ifa_label[0]) 114347f68512SThomas Graf NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label); 114447f68512SThomas Graf 114547f68512SThomas Graf return nlmsg_end(skb, nlh); 114647f68512SThomas Graf 114747f68512SThomas Graf nla_put_failure: 114826932566SPatrick McHardy nlmsg_cancel(skb, nlh); 114926932566SPatrick McHardy return -EMSGSIZE; 11501da177e4SLinus Torvalds } 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 11531da177e4SLinus Torvalds { 11543b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 11551da177e4SLinus Torvalds int idx, ip_idx; 11561da177e4SLinus Torvalds struct net_device *dev; 11571da177e4SLinus Torvalds struct in_device *in_dev; 11581da177e4SLinus Torvalds struct in_ifaddr *ifa; 11591da177e4SLinus Torvalds int s_ip_idx, s_idx = cb->args[0]; 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds s_ip_idx = ip_idx = cb->args[1]; 11627562f876SPavel Emelianov idx = 0; 11634b8aa9abSDenis V. Lunev for_each_netdev(net, dev) { 11641da177e4SLinus Torvalds if (idx < s_idx) 11657562f876SPavel Emelianov goto cont; 11661da177e4SLinus Torvalds if (idx > s_idx) 11671da177e4SLinus Torvalds s_ip_idx = 0; 11686313c1e0SPatrick McHardy if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) 11697562f876SPavel Emelianov goto cont; 11701da177e4SLinus Torvalds 11711da177e4SLinus Torvalds for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 11721da177e4SLinus Torvalds ifa = ifa->ifa_next, ip_idx++) { 11731da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 1174596e4150SStephen Hemminger continue; 11751da177e4SLinus Torvalds if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid, 11761da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 11776313c1e0SPatrick McHardy RTM_NEWADDR, NLM_F_MULTI) <= 0) 11781da177e4SLinus Torvalds goto done; 11791da177e4SLinus Torvalds } 11807562f876SPavel Emelianov cont: 11817562f876SPavel Emelianov idx++; 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds done: 11851da177e4SLinus Torvalds cb->args[0] = idx; 11861da177e4SLinus Torvalds cb->args[1] = ip_idx; 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds return skb->len; 11891da177e4SLinus Torvalds } 11901da177e4SLinus Torvalds 1191d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh, 1192d6062cbbSThomas Graf u32 pid) 11931da177e4SLinus Torvalds { 119447f68512SThomas Graf struct sk_buff *skb; 1195d6062cbbSThomas Graf u32 seq = nlh ? nlh->nlmsg_seq : 0; 1196d6062cbbSThomas Graf int err = -ENOBUFS; 11974b8aa9abSDenis V. Lunev struct net *net; 11981da177e4SLinus Torvalds 1199c346dca1SYOSHIFUJI Hideaki net = dev_net(ifa->ifa_dev->dev); 1200339bf98fSThomas Graf skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL); 120147f68512SThomas Graf if (skb == NULL) 1202d6062cbbSThomas Graf goto errout; 1203d6062cbbSThomas Graf 1204d6062cbbSThomas Graf err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0); 120526932566SPatrick McHardy if (err < 0) { 120626932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet_nlmsg_size() */ 120726932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 120826932566SPatrick McHardy kfree_skb(skb); 120926932566SPatrick McHardy goto errout; 121026932566SPatrick McHardy } 12114b8aa9abSDenis V. Lunev err = rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL); 1212d6062cbbSThomas Graf errout: 1213d6062cbbSThomas Graf if (err < 0) 12144b8aa9abSDenis V. Lunev rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err); 12151da177e4SLinus Torvalds } 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 12181da177e4SLinus Torvalds 1219c0ce9fb3SPavel Emelyanov static void devinet_copy_dflt_conf(struct net *net, int i) 122031be3085SHerbert Xu { 122131be3085SHerbert Xu struct net_device *dev; 122231be3085SHerbert Xu 122331be3085SHerbert Xu read_lock(&dev_base_lock); 1224c0ce9fb3SPavel Emelyanov for_each_netdev(net, dev) { 122531be3085SHerbert Xu struct in_device *in_dev; 122631be3085SHerbert Xu rcu_read_lock(); 122731be3085SHerbert Xu in_dev = __in_dev_get_rcu(dev); 122831be3085SHerbert Xu if (in_dev && !test_bit(i, in_dev->cnf.state)) 12299355bbd6SPavel Emelyanov in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i]; 123031be3085SHerbert Xu rcu_read_unlock(); 123131be3085SHerbert Xu } 123231be3085SHerbert Xu read_unlock(&dev_base_lock); 123331be3085SHerbert Xu } 123431be3085SHerbert Xu 1235c0ce9fb3SPavel Emelyanov static void inet_forward_change(struct net *net) 123668dd299bSPavel Emelyanov { 123768dd299bSPavel Emelyanov struct net_device *dev; 1238586f1211SPavel Emelyanov int on = IPV4_DEVCONF_ALL(net, FORWARDING); 123968dd299bSPavel Emelyanov 1240586f1211SPavel Emelyanov IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on; 12419355bbd6SPavel Emelyanov IPV4_DEVCONF_DFLT(net, FORWARDING) = on; 124268dd299bSPavel Emelyanov 124368dd299bSPavel Emelyanov read_lock(&dev_base_lock); 1244c0ce9fb3SPavel Emelyanov for_each_netdev(net, dev) { 124568dd299bSPavel Emelyanov struct in_device *in_dev; 12460187bdfbSBen Hutchings if (on) 12470187bdfbSBen Hutchings dev_disable_lro(dev); 124868dd299bSPavel Emelyanov rcu_read_lock(); 124968dd299bSPavel Emelyanov in_dev = __in_dev_get_rcu(dev); 125068dd299bSPavel Emelyanov if (in_dev) 125168dd299bSPavel Emelyanov IN_DEV_CONF_SET(in_dev, FORWARDING, on); 125268dd299bSPavel Emelyanov rcu_read_unlock(); 125368dd299bSPavel Emelyanov } 125468dd299bSPavel Emelyanov read_unlock(&dev_base_lock); 125568dd299bSPavel Emelyanov } 125668dd299bSPavel Emelyanov 125731be3085SHerbert Xu static int devinet_conf_proc(ctl_table *ctl, int write, 125831be3085SHerbert Xu struct file* filp, void __user *buffer, 125931be3085SHerbert Xu size_t *lenp, loff_t *ppos) 126031be3085SHerbert Xu { 126131be3085SHerbert Xu int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 126231be3085SHerbert Xu 126331be3085SHerbert Xu if (write) { 126431be3085SHerbert Xu struct ipv4_devconf *cnf = ctl->extra1; 1265c0ce9fb3SPavel Emelyanov struct net *net = ctl->extra2; 126631be3085SHerbert Xu int i = (int *)ctl->data - cnf->data; 126731be3085SHerbert Xu 126831be3085SHerbert Xu set_bit(i, cnf->state); 126931be3085SHerbert Xu 12709355bbd6SPavel Emelyanov if (cnf == net->ipv4.devconf_dflt) 1271c0ce9fb3SPavel Emelyanov devinet_copy_dflt_conf(net, i); 127231be3085SHerbert Xu } 127331be3085SHerbert Xu 127431be3085SHerbert Xu return ret; 127531be3085SHerbert Xu } 127631be3085SHerbert Xu 127731be3085SHerbert Xu static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen, 127831be3085SHerbert Xu void __user *oldval, size_t __user *oldlenp, 127931be3085SHerbert Xu void __user *newval, size_t newlen) 128031be3085SHerbert Xu { 128131be3085SHerbert Xu struct ipv4_devconf *cnf; 1282c0ce9fb3SPavel Emelyanov struct net *net; 128331be3085SHerbert Xu int *valp = table->data; 128431be3085SHerbert Xu int new; 128531be3085SHerbert Xu int i; 128631be3085SHerbert Xu 128731be3085SHerbert Xu if (!newval || !newlen) 128831be3085SHerbert Xu return 0; 128931be3085SHerbert Xu 129031be3085SHerbert Xu if (newlen != sizeof(int)) 129131be3085SHerbert Xu return -EINVAL; 129231be3085SHerbert Xu 129331be3085SHerbert Xu if (get_user(new, (int __user *)newval)) 129431be3085SHerbert Xu return -EFAULT; 129531be3085SHerbert Xu 129631be3085SHerbert Xu if (new == *valp) 129731be3085SHerbert Xu return 0; 129831be3085SHerbert Xu 129931be3085SHerbert Xu if (oldval && oldlenp) { 130031be3085SHerbert Xu size_t len; 130131be3085SHerbert Xu 130231be3085SHerbert Xu if (get_user(len, oldlenp)) 130331be3085SHerbert Xu return -EFAULT; 130431be3085SHerbert Xu 130531be3085SHerbert Xu if (len) { 130631be3085SHerbert Xu if (len > table->maxlen) 130731be3085SHerbert Xu len = table->maxlen; 130831be3085SHerbert Xu if (copy_to_user(oldval, valp, len)) 130931be3085SHerbert Xu return -EFAULT; 131031be3085SHerbert Xu if (put_user(len, oldlenp)) 131131be3085SHerbert Xu return -EFAULT; 131231be3085SHerbert Xu } 131331be3085SHerbert Xu } 131431be3085SHerbert Xu 131531be3085SHerbert Xu *valp = new; 131631be3085SHerbert Xu 131731be3085SHerbert Xu cnf = table->extra1; 1318c0ce9fb3SPavel Emelyanov net = table->extra2; 131931be3085SHerbert Xu i = (int *)table->data - cnf->data; 132031be3085SHerbert Xu 132131be3085SHerbert Xu set_bit(i, cnf->state); 132231be3085SHerbert Xu 13239355bbd6SPavel Emelyanov if (cnf == net->ipv4.devconf_dflt) 1324c0ce9fb3SPavel Emelyanov devinet_copy_dflt_conf(net, i); 132531be3085SHerbert Xu 132631be3085SHerbert Xu return 1; 132731be3085SHerbert Xu } 132831be3085SHerbert Xu 13291da177e4SLinus Torvalds static int devinet_sysctl_forward(ctl_table *ctl, int write, 13301da177e4SLinus Torvalds struct file* filp, void __user *buffer, 13311da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13321da177e4SLinus Torvalds { 13331da177e4SLinus Torvalds int *valp = ctl->data; 13341da177e4SLinus Torvalds int val = *valp; 13351da177e4SLinus Torvalds int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 13361da177e4SLinus Torvalds 13371da177e4SLinus Torvalds if (write && *valp != val) { 1338c0ce9fb3SPavel Emelyanov struct net *net = ctl->extra2; 1339c0ce9fb3SPavel Emelyanov 13400187bdfbSBen Hutchings if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) { 13410187bdfbSBen Hutchings rtnl_lock(); 13420187bdfbSBen Hutchings if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) { 1343c0ce9fb3SPavel Emelyanov inet_forward_change(net); 13440187bdfbSBen Hutchings } else if (*valp) { 13450187bdfbSBen Hutchings struct ipv4_devconf *cnf = ctl->extra1; 13460187bdfbSBen Hutchings struct in_device *idev = 13470187bdfbSBen Hutchings container_of(cnf, struct in_device, cnf); 13480187bdfbSBen Hutchings dev_disable_lro(idev->dev); 13490187bdfbSBen Hutchings } 13500187bdfbSBen Hutchings rtnl_unlock(); 135176e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 13521da177e4SLinus Torvalds } 13530187bdfbSBen Hutchings } 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds return ret; 13561da177e4SLinus Torvalds } 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds int ipv4_doint_and_flush(ctl_table *ctl, int write, 13591da177e4SLinus Torvalds struct file* filp, void __user *buffer, 13601da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13611da177e4SLinus Torvalds { 13621da177e4SLinus Torvalds int *valp = ctl->data; 13631da177e4SLinus Torvalds int val = *valp; 13641da177e4SLinus Torvalds int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 136576e6ebfbSDenis V. Lunev struct net *net = ctl->extra2; 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds if (write && *valp != val) 136876e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 13691da177e4SLinus Torvalds 13701da177e4SLinus Torvalds return ret; 13711da177e4SLinus Torvalds } 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen, 13741da177e4SLinus Torvalds void __user *oldval, size_t __user *oldlenp, 13751f29bcd7SAlexey Dobriyan void __user *newval, size_t newlen) 13761da177e4SLinus Torvalds { 137731be3085SHerbert Xu int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp, 137831be3085SHerbert Xu newval, newlen); 137976e6ebfbSDenis V. Lunev struct net *net = table->extra2; 13801da177e4SLinus Torvalds 138131be3085SHerbert Xu if (ret == 1) 138276e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 138331be3085SHerbert Xu 138431be3085SHerbert Xu return ret; 13851da177e4SLinus Torvalds } 13861da177e4SLinus Torvalds 13871da177e4SLinus Torvalds 138842f811b8SHerbert Xu #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \ 138942f811b8SHerbert Xu { \ 139042f811b8SHerbert Xu .ctl_name = NET_IPV4_CONF_ ## attr, \ 139142f811b8SHerbert Xu .procname = name, \ 139242f811b8SHerbert Xu .data = ipv4_devconf.data + \ 139342f811b8SHerbert Xu NET_IPV4_CONF_ ## attr - 1, \ 139442f811b8SHerbert Xu .maxlen = sizeof(int), \ 139542f811b8SHerbert Xu .mode = mval, \ 139642f811b8SHerbert Xu .proc_handler = proc, \ 139742f811b8SHerbert Xu .strategy = sysctl, \ 139831be3085SHerbert Xu .extra1 = &ipv4_devconf, \ 139942f811b8SHerbert Xu } 140042f811b8SHerbert Xu 140142f811b8SHerbert Xu #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \ 140231be3085SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \ 140331be3085SHerbert Xu devinet_conf_sysctl) 140442f811b8SHerbert Xu 140542f811b8SHerbert Xu #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \ 140631be3085SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \ 140731be3085SHerbert Xu devinet_conf_sysctl) 140842f811b8SHerbert Xu 140942f811b8SHerbert Xu #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \ 141042f811b8SHerbert Xu DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl) 141142f811b8SHerbert Xu 141242f811b8SHerbert Xu #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \ 141342f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \ 141442f811b8SHerbert Xu ipv4_doint_and_flush_strategy) 141542f811b8SHerbert Xu 14161da177e4SLinus Torvalds static struct devinet_sysctl_table { 14171da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 1418bfada697SPavel Emelyanov struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX]; 1419bfada697SPavel Emelyanov char *dev_name; 14201da177e4SLinus Torvalds } devinet_sysctl = { 14211da177e4SLinus Torvalds .devinet_vars = { 142242f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding", 142331be3085SHerbert Xu devinet_sysctl_forward, 142431be3085SHerbert Xu devinet_conf_sysctl), 142542f811b8SHerbert Xu DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"), 142642f811b8SHerbert Xu 142742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"), 142842f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"), 142942f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"), 143042f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"), 143142f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"), 143242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE, 143342f811b8SHerbert Xu "accept_source_route"), 143442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"), 143542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"), 143642f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"), 143742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"), 143842f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"), 143942f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"), 144042f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"), 144142f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"), 144242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"), 144342f811b8SHerbert Xu 144442f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"), 144542f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"), 144642f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION, 144742f811b8SHerbert Xu "force_igmp_version"), 144842f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES, 144942f811b8SHerbert Xu "promote_secondaries"), 14501da177e4SLinus Torvalds }, 14511da177e4SLinus Torvalds }; 14521da177e4SLinus Torvalds 1453ea40b324SPavel Emelyanov static int __devinet_sysctl_register(struct net *net, char *dev_name, 1454ea40b324SPavel Emelyanov int ctl_name, struct ipv4_devconf *p) 14551da177e4SLinus Torvalds { 14561da177e4SLinus Torvalds int i; 14579fa89642SPavel Emelyanov struct devinet_sysctl_table *t; 14581da177e4SLinus Torvalds 1459bfada697SPavel Emelyanov #define DEVINET_CTL_PATH_DEV 3 1460bfada697SPavel Emelyanov 1461bfada697SPavel Emelyanov struct ctl_path devinet_ctl_path[] = { 1462bfada697SPavel Emelyanov { .procname = "net", .ctl_name = CTL_NET, }, 1463bfada697SPavel Emelyanov { .procname = "ipv4", .ctl_name = NET_IPV4, }, 1464bfada697SPavel Emelyanov { .procname = "conf", .ctl_name = NET_IPV4_CONF, }, 1465bfada697SPavel Emelyanov { /* to be set */ }, 1466bfada697SPavel Emelyanov { }, 1467bfada697SPavel Emelyanov }; 1468bfada697SPavel Emelyanov 14699fa89642SPavel Emelyanov t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL); 14701da177e4SLinus Torvalds if (!t) 14719fa89642SPavel Emelyanov goto out; 14729fa89642SPavel Emelyanov 14731da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 14741da177e4SLinus Torvalds t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 147531be3085SHerbert Xu t->devinet_vars[i].extra1 = p; 1476c0ce9fb3SPavel Emelyanov t->devinet_vars[i].extra2 = net; 14771da177e4SLinus Torvalds } 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds /* 14801da177e4SLinus Torvalds * Make a copy of dev_name, because '.procname' is regarded as const 14811da177e4SLinus Torvalds * by sysctl and we wouldn't want anyone to change it under our feet 14821da177e4SLinus Torvalds * (see SIOCSIFNAME). 14831da177e4SLinus Torvalds */ 1484bfada697SPavel Emelyanov t->dev_name = kstrdup(dev_name, GFP_KERNEL); 1485bfada697SPavel Emelyanov if (!t->dev_name) 14861da177e4SLinus Torvalds goto free; 14871da177e4SLinus Torvalds 1488bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name; 1489bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name; 14901da177e4SLinus Torvalds 1491752d14dcSPavel Emelyanov t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path, 1492bfada697SPavel Emelyanov t->devinet_vars); 14931da177e4SLinus Torvalds if (!t->sysctl_header) 14941da177e4SLinus Torvalds goto free_procname; 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds p->sysctl = t; 1497ea40b324SPavel Emelyanov return 0; 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds free_procname: 1500bfada697SPavel Emelyanov kfree(t->dev_name); 15011da177e4SLinus Torvalds free: 15021da177e4SLinus Torvalds kfree(t); 15039fa89642SPavel Emelyanov out: 1504ea40b324SPavel Emelyanov return -ENOBUFS; 15051da177e4SLinus Torvalds } 15061da177e4SLinus Torvalds 150751602b2aSPavel Emelyanov static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf) 150866f27a52SPavel Emelyanov { 150951602b2aSPavel Emelyanov struct devinet_sysctl_table *t = cnf->sysctl; 151066f27a52SPavel Emelyanov 151151602b2aSPavel Emelyanov if (t == NULL) 151251602b2aSPavel Emelyanov return; 151351602b2aSPavel Emelyanov 151451602b2aSPavel Emelyanov cnf->sysctl = NULL; 15151da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 1516bfada697SPavel Emelyanov kfree(t->dev_name); 15171da177e4SLinus Torvalds kfree(t); 15181da177e4SLinus Torvalds } 151951602b2aSPavel Emelyanov 152051602b2aSPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev) 152151602b2aSPavel Emelyanov { 152251602b2aSPavel Emelyanov neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4, 152351602b2aSPavel Emelyanov NET_IPV4_NEIGH, "ipv4", NULL, NULL); 1524c346dca1SYOSHIFUJI Hideaki __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name, 1525c0ce9fb3SPavel Emelyanov idev->dev->ifindex, &idev->cnf); 152651602b2aSPavel Emelyanov } 152751602b2aSPavel Emelyanov 152851602b2aSPavel Emelyanov static void devinet_sysctl_unregister(struct in_device *idev) 152951602b2aSPavel Emelyanov { 153051602b2aSPavel Emelyanov __devinet_sysctl_unregister(&idev->cnf); 153151602b2aSPavel Emelyanov neigh_sysctl_unregister(idev->arp_parms); 15321da177e4SLinus Torvalds } 15331da177e4SLinus Torvalds 153468dd299bSPavel Emelyanov static struct ctl_table ctl_forward_entry[] = { 153568dd299bSPavel Emelyanov { 153668dd299bSPavel Emelyanov .ctl_name = NET_IPV4_FORWARD, 153768dd299bSPavel Emelyanov .procname = "ip_forward", 153868dd299bSPavel Emelyanov .data = &ipv4_devconf.data[ 153968dd299bSPavel Emelyanov NET_IPV4_CONF_FORWARDING - 1], 154068dd299bSPavel Emelyanov .maxlen = sizeof(int), 154168dd299bSPavel Emelyanov .mode = 0644, 154268dd299bSPavel Emelyanov .proc_handler = devinet_sysctl_forward, 154368dd299bSPavel Emelyanov .strategy = devinet_conf_sysctl, 154468dd299bSPavel Emelyanov .extra1 = &ipv4_devconf, 1545c0ce9fb3SPavel Emelyanov .extra2 = &init_net, 154668dd299bSPavel Emelyanov }, 154768dd299bSPavel Emelyanov { }, 154868dd299bSPavel Emelyanov }; 154968dd299bSPavel Emelyanov 1550752d14dcSPavel Emelyanov static __net_initdata struct ctl_path net_ipv4_path[] = { 155168dd299bSPavel Emelyanov { .procname = "net", .ctl_name = CTL_NET, }, 155268dd299bSPavel Emelyanov { .procname = "ipv4", .ctl_name = NET_IPV4, }, 155368dd299bSPavel Emelyanov { }, 155468dd299bSPavel Emelyanov }; 15552a75de0cSEric Dumazet #endif 155668dd299bSPavel Emelyanov 1557752d14dcSPavel Emelyanov static __net_init int devinet_init_net(struct net *net) 1558752d14dcSPavel Emelyanov { 1559752d14dcSPavel Emelyanov int err; 1560752d14dcSPavel Emelyanov struct ipv4_devconf *all, *dflt; 15612a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 15622a75de0cSEric Dumazet struct ctl_table *tbl = ctl_forward_entry; 1563752d14dcSPavel Emelyanov struct ctl_table_header *forw_hdr; 15642a75de0cSEric Dumazet #endif 1565752d14dcSPavel Emelyanov 1566752d14dcSPavel Emelyanov err = -ENOMEM; 1567752d14dcSPavel Emelyanov all = &ipv4_devconf; 1568752d14dcSPavel Emelyanov dflt = &ipv4_devconf_dflt; 1569752d14dcSPavel Emelyanov 1570752d14dcSPavel Emelyanov if (net != &init_net) { 1571752d14dcSPavel Emelyanov all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL); 1572752d14dcSPavel Emelyanov if (all == NULL) 1573752d14dcSPavel Emelyanov goto err_alloc_all; 1574752d14dcSPavel Emelyanov 1575752d14dcSPavel Emelyanov dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL); 1576752d14dcSPavel Emelyanov if (dflt == NULL) 1577752d14dcSPavel Emelyanov goto err_alloc_dflt; 1578752d14dcSPavel Emelyanov 15792a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 1580752d14dcSPavel Emelyanov tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL); 1581752d14dcSPavel Emelyanov if (tbl == NULL) 1582752d14dcSPavel Emelyanov goto err_alloc_ctl; 1583752d14dcSPavel Emelyanov 1584752d14dcSPavel Emelyanov tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1]; 1585752d14dcSPavel Emelyanov tbl[0].extra1 = all; 1586752d14dcSPavel Emelyanov tbl[0].extra2 = net; 15872a75de0cSEric Dumazet #endif 1588752d14dcSPavel Emelyanov } 1589752d14dcSPavel Emelyanov 1590752d14dcSPavel Emelyanov #ifdef CONFIG_SYSCTL 1591752d14dcSPavel Emelyanov err = __devinet_sysctl_register(net, "all", 1592752d14dcSPavel Emelyanov NET_PROTO_CONF_ALL, all); 1593752d14dcSPavel Emelyanov if (err < 0) 1594752d14dcSPavel Emelyanov goto err_reg_all; 1595752d14dcSPavel Emelyanov 1596752d14dcSPavel Emelyanov err = __devinet_sysctl_register(net, "default", 1597752d14dcSPavel Emelyanov NET_PROTO_CONF_DEFAULT, dflt); 1598752d14dcSPavel Emelyanov if (err < 0) 1599752d14dcSPavel Emelyanov goto err_reg_dflt; 1600752d14dcSPavel Emelyanov 1601752d14dcSPavel Emelyanov err = -ENOMEM; 1602752d14dcSPavel Emelyanov forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl); 1603752d14dcSPavel Emelyanov if (forw_hdr == NULL) 1604752d14dcSPavel Emelyanov goto err_reg_ctl; 16052a75de0cSEric Dumazet net->ipv4.forw_hdr = forw_hdr; 1606752d14dcSPavel Emelyanov #endif 1607752d14dcSPavel Emelyanov 1608752d14dcSPavel Emelyanov net->ipv4.devconf_all = all; 1609752d14dcSPavel Emelyanov net->ipv4.devconf_dflt = dflt; 1610752d14dcSPavel Emelyanov return 0; 1611752d14dcSPavel Emelyanov 1612752d14dcSPavel Emelyanov #ifdef CONFIG_SYSCTL 1613752d14dcSPavel Emelyanov err_reg_ctl: 1614752d14dcSPavel Emelyanov __devinet_sysctl_unregister(dflt); 1615752d14dcSPavel Emelyanov err_reg_dflt: 1616752d14dcSPavel Emelyanov __devinet_sysctl_unregister(all); 1617752d14dcSPavel Emelyanov err_reg_all: 1618752d14dcSPavel Emelyanov if (tbl != ctl_forward_entry) 1619752d14dcSPavel Emelyanov kfree(tbl); 1620752d14dcSPavel Emelyanov err_alloc_ctl: 16212a75de0cSEric Dumazet #endif 1622752d14dcSPavel Emelyanov if (dflt != &ipv4_devconf_dflt) 1623752d14dcSPavel Emelyanov kfree(dflt); 1624752d14dcSPavel Emelyanov err_alloc_dflt: 1625752d14dcSPavel Emelyanov if (all != &ipv4_devconf) 1626752d14dcSPavel Emelyanov kfree(all); 1627752d14dcSPavel Emelyanov err_alloc_all: 1628752d14dcSPavel Emelyanov return err; 1629752d14dcSPavel Emelyanov } 1630752d14dcSPavel Emelyanov 1631752d14dcSPavel Emelyanov static __net_exit void devinet_exit_net(struct net *net) 1632752d14dcSPavel Emelyanov { 16332a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 1634752d14dcSPavel Emelyanov struct ctl_table *tbl; 1635752d14dcSPavel Emelyanov 1636752d14dcSPavel Emelyanov tbl = net->ipv4.forw_hdr->ctl_table_arg; 1637752d14dcSPavel Emelyanov unregister_net_sysctl_table(net->ipv4.forw_hdr); 1638752d14dcSPavel Emelyanov __devinet_sysctl_unregister(net->ipv4.devconf_dflt); 1639752d14dcSPavel Emelyanov __devinet_sysctl_unregister(net->ipv4.devconf_all); 1640752d14dcSPavel Emelyanov kfree(tbl); 16412a75de0cSEric Dumazet #endif 1642752d14dcSPavel Emelyanov kfree(net->ipv4.devconf_dflt); 1643752d14dcSPavel Emelyanov kfree(net->ipv4.devconf_all); 1644752d14dcSPavel Emelyanov } 1645752d14dcSPavel Emelyanov 1646752d14dcSPavel Emelyanov static __net_initdata struct pernet_operations devinet_ops = { 1647752d14dcSPavel Emelyanov .init = devinet_init_net, 1648752d14dcSPavel Emelyanov .exit = devinet_exit_net, 1649752d14dcSPavel Emelyanov }; 1650752d14dcSPavel Emelyanov 16511da177e4SLinus Torvalds void __init devinet_init(void) 16521da177e4SLinus Torvalds { 1653752d14dcSPavel Emelyanov register_pernet_subsys(&devinet_ops); 1654752d14dcSPavel Emelyanov 16551da177e4SLinus Torvalds register_gifconf(PF_INET, inet_gifconf); 16561da177e4SLinus Torvalds register_netdevice_notifier(&ip_netdev_notifier); 165763f3444fSThomas Graf 165863f3444fSThomas Graf rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL); 165963f3444fSThomas Graf rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL); 166063f3444fSThomas Graf rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr); 16611da177e4SLinus Torvalds } 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds EXPORT_SYMBOL(in_dev_finish_destroy); 16641da177e4SLinus Torvalds EXPORT_SYMBOL(inet_select_addr); 16651da177e4SLinus Torvalds EXPORT_SYMBOL(inetdev_by_index); 16661da177e4SLinus Torvalds EXPORT_SYMBOL(register_inetaddr_notifier); 16671da177e4SLinus Torvalds EXPORT_SYMBOL(unregister_inetaddr_notifier); 1668