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> 535a0e3ad6STejun Heo #include <linux/slab.h> 541da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 551da177e4SLinus Torvalds #include <linux/sysctl.h> 561da177e4SLinus Torvalds #endif 571da177e4SLinus Torvalds #include <linux/kmod.h> 581da177e4SLinus Torvalds 5914c85021SArnaldo Carvalho de Melo #include <net/arp.h> 601da177e4SLinus Torvalds #include <net/ip.h> 611da177e4SLinus Torvalds #include <net/route.h> 621da177e4SLinus Torvalds #include <net/ip_fib.h> 6363f3444fSThomas Graf #include <net/rtnetlink.h> 64752d14dcSPavel Emelyanov #include <net/net_namespace.h> 651da177e4SLinus Torvalds 660027ba84SAdrian Bunk static struct ipv4_devconf ipv4_devconf = { 6742f811b8SHerbert Xu .data = { 6802291680SEric W. Biederman [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1, 6902291680SEric W. Biederman [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1, 7002291680SEric W. Biederman [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1, 7102291680SEric W. Biederman [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1, 7242f811b8SHerbert Xu }, 731da177e4SLinus Torvalds }; 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds static struct ipv4_devconf ipv4_devconf_dflt = { 7642f811b8SHerbert Xu .data = { 7702291680SEric W. Biederman [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1, 7802291680SEric W. Biederman [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1, 7902291680SEric W. Biederman [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1, 8002291680SEric W. Biederman [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1, 8102291680SEric W. Biederman [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1, 8242f811b8SHerbert Xu }, 831da177e4SLinus Torvalds }; 841da177e4SLinus Torvalds 859355bbd6SPavel Emelyanov #define IPV4_DEVCONF_DFLT(net, attr) \ 869355bbd6SPavel Emelyanov IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr) 8742f811b8SHerbert Xu 88ef7c79edSPatrick McHardy static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = { 895c753978SThomas Graf [IFA_LOCAL] = { .type = NLA_U32 }, 905c753978SThomas Graf [IFA_ADDRESS] = { .type = NLA_U32 }, 915c753978SThomas Graf [IFA_BROADCAST] = { .type = NLA_U32 }, 925176f91eSThomas Graf [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 }, 935c753978SThomas Graf }; 945c753978SThomas Graf 95d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32); 961da177e4SLinus Torvalds 97e041c683SAlan Stern static BLOCKING_NOTIFIER_HEAD(inetaddr_chain); 981da177e4SLinus Torvalds static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 991da177e4SLinus Torvalds int destroy); 1001da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 10166f27a52SPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev); 10251602b2aSPavel Emelyanov static void devinet_sysctl_unregister(struct in_device *idev); 10351602b2aSPavel Emelyanov #else 10451602b2aSPavel Emelyanov static inline void devinet_sysctl_register(struct in_device *idev) 10551602b2aSPavel Emelyanov { 10651602b2aSPavel Emelyanov } 10751602b2aSPavel Emelyanov static inline void devinet_sysctl_unregister(struct in_device *idev) 10851602b2aSPavel Emelyanov { 10951602b2aSPavel Emelyanov } 1101da177e4SLinus Torvalds #endif 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds /* Locks all the inet devices. */ 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds static struct in_ifaddr *inet_alloc_ifa(void) 1151da177e4SLinus Torvalds { 11693adcc80SAlexey Dobriyan return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL); 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds static void inet_rcu_free_ifa(struct rcu_head *head) 1201da177e4SLinus Torvalds { 1211da177e4SLinus Torvalds struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 1221da177e4SLinus Torvalds if (ifa->ifa_dev) 1231da177e4SLinus Torvalds in_dev_put(ifa->ifa_dev); 1241da177e4SLinus Torvalds kfree(ifa); 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds static inline void inet_free_ifa(struct in_ifaddr *ifa) 1281da177e4SLinus Torvalds { 1291da177e4SLinus Torvalds call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds void in_dev_finish_destroy(struct in_device *idev) 1331da177e4SLinus Torvalds { 1341da177e4SLinus Torvalds struct net_device *dev = idev->dev; 1351da177e4SLinus Torvalds 136547b792cSIlpo Järvinen WARN_ON(idev->ifa_list); 137547b792cSIlpo Järvinen WARN_ON(idev->mc_list); 1381da177e4SLinus Torvalds #ifdef NET_REFCNT_DEBUG 1391da177e4SLinus Torvalds printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", 1401da177e4SLinus Torvalds idev, dev ? dev->name : "NIL"); 1411da177e4SLinus Torvalds #endif 1421da177e4SLinus Torvalds dev_put(dev); 1431da177e4SLinus Torvalds if (!idev->dead) 1449f9354b9SEric Dumazet pr_err("Freeing alive in_device %p\n", idev); 1459f9354b9SEric Dumazet else 1461da177e4SLinus Torvalds kfree(idev); 1471da177e4SLinus Torvalds } 1489f9354b9SEric Dumazet EXPORT_SYMBOL(in_dev_finish_destroy); 1491da177e4SLinus Torvalds 15071e27da9SHerbert Xu static struct in_device *inetdev_init(struct net_device *dev) 1511da177e4SLinus Torvalds { 1521da177e4SLinus Torvalds struct in_device *in_dev; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds ASSERT_RTNL(); 1551da177e4SLinus Torvalds 1560da974f4SPanagiotis Issaris in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL); 1571da177e4SLinus Torvalds if (!in_dev) 1581da177e4SLinus Torvalds goto out; 159c346dca1SYOSHIFUJI Hideaki memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt, 1609355bbd6SPavel Emelyanov sizeof(in_dev->cnf)); 1611da177e4SLinus Torvalds in_dev->cnf.sysctl = NULL; 1621da177e4SLinus Torvalds in_dev->dev = dev; 1639f9354b9SEric Dumazet in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl); 1649f9354b9SEric Dumazet if (!in_dev->arp_parms) 1651da177e4SLinus Torvalds goto out_kfree; 1660187bdfbSBen Hutchings if (IPV4_DEVCONF(in_dev->cnf, FORWARDING)) 1670187bdfbSBen Hutchings dev_disable_lro(dev); 1681da177e4SLinus Torvalds /* Reference in_dev->dev */ 1691da177e4SLinus Torvalds dev_hold(dev); 17030c4cf57SDavid L Stevens /* Account for reference dev->ip_ptr (below) */ 1711da177e4SLinus Torvalds in_dev_hold(in_dev); 1721da177e4SLinus Torvalds 17366f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 1741da177e4SLinus Torvalds ip_mc_init_dev(in_dev); 1751da177e4SLinus Torvalds if (dev->flags & IFF_UP) 1761da177e4SLinus Torvalds ip_mc_up(in_dev); 177483479ecSJarek Poplawski 17830c4cf57SDavid L Stevens /* we can receive as soon as ip_ptr is set -- do this last */ 17930c4cf57SDavid L Stevens rcu_assign_pointer(dev->ip_ptr, in_dev); 180483479ecSJarek Poplawski out: 1811da177e4SLinus Torvalds return in_dev; 1821da177e4SLinus Torvalds out_kfree: 1831da177e4SLinus Torvalds kfree(in_dev); 1841da177e4SLinus Torvalds in_dev = NULL; 1851da177e4SLinus Torvalds goto out; 1861da177e4SLinus Torvalds } 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds static void in_dev_rcu_put(struct rcu_head *head) 1891da177e4SLinus Torvalds { 1901da177e4SLinus Torvalds struct in_device *idev = container_of(head, struct in_device, rcu_head); 1911da177e4SLinus Torvalds in_dev_put(idev); 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds static void inetdev_destroy(struct in_device *in_dev) 1951da177e4SLinus Torvalds { 1961da177e4SLinus Torvalds struct in_ifaddr *ifa; 1971da177e4SLinus Torvalds struct net_device *dev; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds ASSERT_RTNL(); 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds dev = in_dev->dev; 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds in_dev->dead = 1; 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds ip_mc_destroy_dev(in_dev); 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds while ((ifa = in_dev->ifa_list) != NULL) { 2081da177e4SLinus Torvalds inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 2091da177e4SLinus Torvalds inet_free_ifa(ifa); 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 21295ae6b22SEric Dumazet rcu_assign_pointer(dev->ip_ptr, NULL); 2131da177e4SLinus Torvalds 21451602b2aSPavel Emelyanov devinet_sysctl_unregister(in_dev); 2151da177e4SLinus Torvalds neigh_parms_release(&arp_tbl, in_dev->arp_parms); 2161da177e4SLinus Torvalds arp_ifdown(dev); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 2191da177e4SLinus Torvalds } 2201da177e4SLinus Torvalds 221ff428d72SAl Viro int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b) 2221da177e4SLinus Torvalds { 2231da177e4SLinus Torvalds rcu_read_lock(); 2241da177e4SLinus Torvalds for_primary_ifa(in_dev) { 2251da177e4SLinus Torvalds if (inet_ifa_match(a, ifa)) { 2261da177e4SLinus Torvalds if (!b || inet_ifa_match(b, ifa)) { 2271da177e4SLinus Torvalds rcu_read_unlock(); 2281da177e4SLinus Torvalds return 1; 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds } endfor_ifa(in_dev); 2321da177e4SLinus Torvalds rcu_read_unlock(); 2331da177e4SLinus Torvalds return 0; 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds 236d6062cbbSThomas Graf static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 237d6062cbbSThomas Graf int destroy, struct nlmsghdr *nlh, u32 pid) 2381da177e4SLinus Torvalds { 2398f937c60SHarald Welte struct in_ifaddr *promote = NULL; 2400ff60a45SJamal Hadi Salim struct in_ifaddr *ifa, *ifa1 = *ifap; 2410ff60a45SJamal Hadi Salim struct in_ifaddr *last_prim = in_dev->ifa_list; 2420ff60a45SJamal Hadi Salim struct in_ifaddr *prev_prom = NULL; 2430ff60a45SJamal Hadi Salim int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds ASSERT_RTNL(); 2461da177e4SLinus Torvalds 2478f937c60SHarald Welte /* 1. Deleting primary ifaddr forces deletion all secondaries 2488f937c60SHarald Welte * unless alias promotion is set 2498f937c60SHarald Welte **/ 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 2521da177e4SLinus Torvalds struct in_ifaddr **ifap1 = &ifa1->ifa_next; 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds while ((ifa = *ifap1) != NULL) { 2550ff60a45SJamal Hadi Salim if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 2560ff60a45SJamal Hadi Salim ifa1->ifa_scope <= ifa->ifa_scope) 2570ff60a45SJamal Hadi Salim last_prim = ifa; 2580ff60a45SJamal Hadi Salim 2591da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 2601da177e4SLinus Torvalds ifa1->ifa_mask != ifa->ifa_mask || 2611da177e4SLinus Torvalds !inet_ifa_match(ifa1->ifa_address, ifa)) { 2621da177e4SLinus Torvalds ifap1 = &ifa->ifa_next; 2630ff60a45SJamal Hadi Salim prev_prom = ifa; 2641da177e4SLinus Torvalds continue; 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2670ff60a45SJamal Hadi Salim if (!do_promote) { 2681da177e4SLinus Torvalds *ifap1 = ifa->ifa_next; 2691da177e4SLinus Torvalds 270d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid); 271e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 272e041c683SAlan Stern NETDEV_DOWN, ifa); 2731da177e4SLinus Torvalds inet_free_ifa(ifa); 2748f937c60SHarald Welte } else { 2758f937c60SHarald Welte promote = ifa; 2768f937c60SHarald Welte break; 2778f937c60SHarald Welte } 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds /* 2. Unlink it */ 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds *ifap = ifa1->ifa_next; 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds /* 3. Announce address deletion */ 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds /* Send message first, then call notifier. 2881da177e4SLinus Torvalds At first sight, FIB update triggered by notifier 2891da177e4SLinus Torvalds will refer to already deleted ifaddr, that could confuse 2901da177e4SLinus Torvalds netlink listeners. It is not true: look, gated sees 2911da177e4SLinus Torvalds that route deleted and if it still thinks that ifaddr 2921da177e4SLinus Torvalds is valid, it will try to restore deleted routes... Grr. 2931da177e4SLinus Torvalds So that, this order is correct. 2941da177e4SLinus Torvalds */ 295d6062cbbSThomas Graf rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid); 296e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 2970ff60a45SJamal Hadi Salim 2980ff60a45SJamal Hadi Salim if (promote) { 2990ff60a45SJamal Hadi Salim 3000ff60a45SJamal Hadi Salim if (prev_prom) { 3010ff60a45SJamal Hadi Salim prev_prom->ifa_next = promote->ifa_next; 3020ff60a45SJamal Hadi Salim promote->ifa_next = last_prim->ifa_next; 3030ff60a45SJamal Hadi Salim last_prim->ifa_next = promote; 3040ff60a45SJamal Hadi Salim } 3050ff60a45SJamal Hadi Salim 3060ff60a45SJamal Hadi Salim promote->ifa_flags &= ~IFA_F_SECONDARY; 307d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid); 308e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 309e041c683SAlan Stern NETDEV_UP, promote); 3100ff60a45SJamal Hadi Salim for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) { 3110ff60a45SJamal Hadi Salim if (ifa1->ifa_mask != ifa->ifa_mask || 3120ff60a45SJamal Hadi Salim !inet_ifa_match(ifa1->ifa_address, ifa)) 3130ff60a45SJamal Hadi Salim continue; 3140ff60a45SJamal Hadi Salim fib_add_ifaddr(ifa); 3150ff60a45SJamal Hadi Salim } 3160ff60a45SJamal Hadi Salim 3170ff60a45SJamal Hadi Salim } 3186363097cSHerbert Xu if (destroy) 3191da177e4SLinus Torvalds inet_free_ifa(ifa1); 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds 322d6062cbbSThomas Graf static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 323d6062cbbSThomas Graf int destroy) 324d6062cbbSThomas Graf { 325d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, destroy, NULL, 0); 326d6062cbbSThomas Graf } 327d6062cbbSThomas Graf 328d6062cbbSThomas Graf static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh, 329d6062cbbSThomas Graf u32 pid) 3301da177e4SLinus Torvalds { 3311da177e4SLinus Torvalds struct in_device *in_dev = ifa->ifa_dev; 3321da177e4SLinus Torvalds struct in_ifaddr *ifa1, **ifap, **last_primary; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds ASSERT_RTNL(); 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds if (!ifa->ifa_local) { 3371da177e4SLinus Torvalds inet_free_ifa(ifa); 3381da177e4SLinus Torvalds return 0; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds ifa->ifa_flags &= ~IFA_F_SECONDARY; 3421da177e4SLinus Torvalds last_primary = &in_dev->ifa_list; 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 3451da177e4SLinus Torvalds ifap = &ifa1->ifa_next) { 3461da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 3471da177e4SLinus Torvalds ifa->ifa_scope <= ifa1->ifa_scope) 3481da177e4SLinus Torvalds last_primary = &ifa1->ifa_next; 3491da177e4SLinus Torvalds if (ifa1->ifa_mask == ifa->ifa_mask && 3501da177e4SLinus Torvalds inet_ifa_match(ifa1->ifa_address, ifa)) { 3511da177e4SLinus Torvalds if (ifa1->ifa_local == ifa->ifa_local) { 3521da177e4SLinus Torvalds inet_free_ifa(ifa); 3531da177e4SLinus Torvalds return -EEXIST; 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds if (ifa1->ifa_scope != ifa->ifa_scope) { 3561da177e4SLinus Torvalds inet_free_ifa(ifa); 3571da177e4SLinus Torvalds return -EINVAL; 3581da177e4SLinus Torvalds } 3591da177e4SLinus Torvalds ifa->ifa_flags |= IFA_F_SECONDARY; 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 3641da177e4SLinus Torvalds net_srandom(ifa->ifa_local); 3651da177e4SLinus Torvalds ifap = last_primary; 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds ifa->ifa_next = *ifap; 3691da177e4SLinus Torvalds *ifap = ifa; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds /* Send message first, then call notifier. 3721da177e4SLinus Torvalds Notifier will trigger FIB update, so that 3731da177e4SLinus Torvalds listeners of netlink will know about new ifaddr */ 374d6062cbbSThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid); 375e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds return 0; 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds 380d6062cbbSThomas Graf static int inet_insert_ifa(struct in_ifaddr *ifa) 381d6062cbbSThomas Graf { 382d6062cbbSThomas Graf return __inet_insert_ifa(ifa, NULL, 0); 383d6062cbbSThomas Graf } 384d6062cbbSThomas Graf 3851da177e4SLinus Torvalds static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 3861da177e4SLinus Torvalds { 387e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds ASSERT_RTNL(); 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds if (!in_dev) { 3921da177e4SLinus Torvalds inet_free_ifa(ifa); 3931da177e4SLinus Torvalds return -ENOBUFS; 3941da177e4SLinus Torvalds } 39571e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 3961da177e4SLinus Torvalds if (ifa->ifa_dev != in_dev) { 397547b792cSIlpo Järvinen WARN_ON(ifa->ifa_dev); 3981da177e4SLinus Torvalds in_dev_hold(in_dev); 3991da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 4001da177e4SLinus Torvalds } 401f97c1e0cSJoe Perches if (ipv4_is_loopback(ifa->ifa_local)) 4021da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 4031da177e4SLinus Torvalds return inet_insert_ifa(ifa); 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds 4068723e1b4SEric Dumazet /* Caller must hold RCU or RTNL : 4078723e1b4SEric Dumazet * We dont take a reference on found in_device 4088723e1b4SEric Dumazet */ 4097fee0ca2SDenis V. Lunev struct in_device *inetdev_by_index(struct net *net, int ifindex) 4101da177e4SLinus Torvalds { 4111da177e4SLinus Torvalds struct net_device *dev; 4121da177e4SLinus Torvalds struct in_device *in_dev = NULL; 413c148fc2eSEric Dumazet 414c148fc2eSEric Dumazet rcu_read_lock(); 415c148fc2eSEric Dumazet dev = dev_get_by_index_rcu(net, ifindex); 4161da177e4SLinus Torvalds if (dev) 4178723e1b4SEric Dumazet in_dev = rcu_dereference_rtnl(dev->ip_ptr); 418c148fc2eSEric Dumazet rcu_read_unlock(); 4191da177e4SLinus Torvalds return in_dev; 4201da177e4SLinus Torvalds } 4219f9354b9SEric Dumazet EXPORT_SYMBOL(inetdev_by_index); 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 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 4601da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 461dfdd5fd4SThomas Graf if (tb[IFA_LOCAL] && 462a7a628c4SAl Viro ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL])) 4631da177e4SLinus Torvalds continue; 464dfdd5fd4SThomas Graf 465dfdd5fd4SThomas Graf if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label)) 466dfdd5fd4SThomas Graf continue; 467dfdd5fd4SThomas Graf 468dfdd5fd4SThomas Graf if (tb[IFA_ADDRESS] && 469dfdd5fd4SThomas Graf (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 470a7a628c4SAl Viro !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa))) 471dfdd5fd4SThomas Graf continue; 472dfdd5fd4SThomas Graf 473d6062cbbSThomas Graf __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid); 4741da177e4SLinus Torvalds return 0; 4751da177e4SLinus Torvalds } 476dfdd5fd4SThomas Graf 477dfdd5fd4SThomas Graf err = -EADDRNOTAVAIL; 478dfdd5fd4SThomas Graf errout: 479dfdd5fd4SThomas Graf return err; 4801da177e4SLinus Torvalds } 4811da177e4SLinus Torvalds 4824b8aa9abSDenis V. Lunev static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh) 4831da177e4SLinus Torvalds { 4845c753978SThomas Graf struct nlattr *tb[IFA_MAX+1]; 4855c753978SThomas Graf struct in_ifaddr *ifa; 4865c753978SThomas Graf struct ifaddrmsg *ifm; 4871da177e4SLinus Torvalds struct net_device *dev; 4881da177e4SLinus Torvalds struct in_device *in_dev; 4897b218574SDenis V. Lunev int err; 4901da177e4SLinus Torvalds 4915c753978SThomas Graf err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy); 4925c753978SThomas Graf if (err < 0) 4935c753978SThomas Graf goto errout; 4941da177e4SLinus Torvalds 4955c753978SThomas Graf ifm = nlmsg_data(nlh); 496c4e38f41SEvgeniy Polyakov err = -EINVAL; 4977b218574SDenis V. Lunev if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) 4985c753978SThomas Graf goto errout; 4991da177e4SLinus Torvalds 5004b8aa9abSDenis V. Lunev dev = __dev_get_by_index(net, ifm->ifa_index); 5015c753978SThomas Graf err = -ENODEV; 5027b218574SDenis V. Lunev if (dev == NULL) 5035c753978SThomas Graf goto errout; 5041da177e4SLinus Torvalds 5055c753978SThomas Graf in_dev = __in_dev_get_rtnl(dev); 5065c753978SThomas Graf err = -ENOBUFS; 5077b218574SDenis V. Lunev if (in_dev == NULL) 5085c753978SThomas Graf goto errout; 50971e27da9SHerbert Xu 5105c753978SThomas Graf ifa = inet_alloc_ifa(); 5117b218574SDenis V. Lunev if (ifa == NULL) 5125c753978SThomas Graf /* 5135c753978SThomas Graf * A potential indev allocation can be left alive, it stays 5145c753978SThomas Graf * assigned to its device and is destroy with it. 5155c753978SThomas Graf */ 5165c753978SThomas Graf goto errout; 5175c753978SThomas Graf 518a4e65d36SPavel Emelyanov ipv4_devconf_setall(in_dev); 5195c753978SThomas Graf in_dev_hold(in_dev); 5205c753978SThomas Graf 5215c753978SThomas Graf if (tb[IFA_ADDRESS] == NULL) 5225c753978SThomas Graf tb[IFA_ADDRESS] = tb[IFA_LOCAL]; 5235c753978SThomas Graf 5241da177e4SLinus Torvalds ifa->ifa_prefixlen = ifm->ifa_prefixlen; 5251da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 5261da177e4SLinus Torvalds ifa->ifa_flags = ifm->ifa_flags; 5271da177e4SLinus Torvalds ifa->ifa_scope = ifm->ifa_scope; 5281da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 5295c753978SThomas Graf 530a7a628c4SAl Viro ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]); 531a7a628c4SAl Viro ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]); 5325c753978SThomas Graf 5335c753978SThomas Graf if (tb[IFA_BROADCAST]) 534a7a628c4SAl Viro ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]); 5355c753978SThomas Graf 5365c753978SThomas Graf if (tb[IFA_LABEL]) 5375c753978SThomas Graf nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ); 5381da177e4SLinus Torvalds else 5391da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 5401da177e4SLinus Torvalds 5415c753978SThomas Graf return ifa; 5425c753978SThomas Graf 5435c753978SThomas Graf errout: 5445c753978SThomas Graf return ERR_PTR(err); 5455c753978SThomas Graf } 5465c753978SThomas Graf 5475c753978SThomas Graf static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 5485c753978SThomas Graf { 5493b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 5505c753978SThomas Graf struct in_ifaddr *ifa; 5515c753978SThomas Graf 5525c753978SThomas Graf ASSERT_RTNL(); 5535c753978SThomas Graf 5544b8aa9abSDenis V. Lunev ifa = rtm_to_ifaddr(net, nlh); 5555c753978SThomas Graf if (IS_ERR(ifa)) 5565c753978SThomas Graf return PTR_ERR(ifa); 5575c753978SThomas Graf 558d6062cbbSThomas Graf return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid); 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds /* 5621da177e4SLinus Torvalds * Determine a default network mask, based on the IP address. 5631da177e4SLinus Torvalds */ 5641da177e4SLinus Torvalds 5659f9354b9SEric Dumazet static inline int inet_abc_len(__be32 addr) 5661da177e4SLinus Torvalds { 5671da177e4SLinus Torvalds int rc = -1; /* Something else, probably a multicast. */ 5681da177e4SLinus Torvalds 569f97c1e0cSJoe Perches if (ipv4_is_zeronet(addr)) 5701da177e4SLinus Torvalds rc = 0; 5711da177e4SLinus Torvalds else { 572714e85beSAl Viro __u32 haddr = ntohl(addr); 5731da177e4SLinus Torvalds 574714e85beSAl Viro if (IN_CLASSA(haddr)) 5751da177e4SLinus Torvalds rc = 8; 576714e85beSAl Viro else if (IN_CLASSB(haddr)) 5771da177e4SLinus Torvalds rc = 16; 578714e85beSAl Viro else if (IN_CLASSC(haddr)) 5791da177e4SLinus Torvalds rc = 24; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds return rc; 5831da177e4SLinus Torvalds } 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds 586e5b13cb1SDenis V. Lunev int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg) 5871da177e4SLinus Torvalds { 5881da177e4SLinus Torvalds struct ifreq ifr; 5891da177e4SLinus Torvalds struct sockaddr_in sin_orig; 5901da177e4SLinus Torvalds struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 5911da177e4SLinus Torvalds struct in_device *in_dev; 5921da177e4SLinus Torvalds struct in_ifaddr **ifap = NULL; 5931da177e4SLinus Torvalds struct in_ifaddr *ifa = NULL; 5941da177e4SLinus Torvalds struct net_device *dev; 5951da177e4SLinus Torvalds char *colon; 5961da177e4SLinus Torvalds int ret = -EFAULT; 5971da177e4SLinus Torvalds int tryaddrmatch = 0; 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds /* 6001da177e4SLinus Torvalds * Fetch the caller's info block into kernel space 6011da177e4SLinus Torvalds */ 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 6041da177e4SLinus Torvalds goto out; 6051da177e4SLinus Torvalds ifr.ifr_name[IFNAMSIZ - 1] = 0; 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds /* save original address for comparison */ 6081da177e4SLinus Torvalds memcpy(&sin_orig, sin, sizeof(*sin)); 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds colon = strchr(ifr.ifr_name, ':'); 6111da177e4SLinus Torvalds if (colon) 6121da177e4SLinus Torvalds *colon = 0; 6131da177e4SLinus Torvalds 614e5b13cb1SDenis V. Lunev dev_load(net, ifr.ifr_name); 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds switch (cmd) { 6171da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6181da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6191da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 6201da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 6211da177e4SLinus Torvalds /* Note that these ioctls will not sleep, 6221da177e4SLinus Torvalds so that we do not impose a lock. 6231da177e4SLinus Torvalds One day we will be forced to put shlock here (I mean SMP) 6241da177e4SLinus Torvalds */ 6251da177e4SLinus Torvalds tryaddrmatch = (sin_orig.sin_family == AF_INET); 6261da177e4SLinus Torvalds memset(sin, 0, sizeof(*sin)); 6271da177e4SLinus Torvalds sin->sin_family = AF_INET; 6281da177e4SLinus Torvalds break; 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds case SIOCSIFFLAGS: 6311da177e4SLinus Torvalds ret = -EACCES; 6321da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6331da177e4SLinus Torvalds goto out; 6341da177e4SLinus Torvalds break; 6351da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 6361da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 6371da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 6381da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 6391da177e4SLinus Torvalds ret = -EACCES; 6401da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 6411da177e4SLinus Torvalds goto out; 6421da177e4SLinus Torvalds ret = -EINVAL; 6431da177e4SLinus Torvalds if (sin->sin_family != AF_INET) 6441da177e4SLinus Torvalds goto out; 6451da177e4SLinus Torvalds break; 6461da177e4SLinus Torvalds default: 6471da177e4SLinus Torvalds ret = -EINVAL; 6481da177e4SLinus Torvalds goto out; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds rtnl_lock(); 6521da177e4SLinus Torvalds 6531da177e4SLinus Torvalds ret = -ENODEV; 6549f9354b9SEric Dumazet dev = __dev_get_by_name(net, ifr.ifr_name); 6559f9354b9SEric Dumazet if (!dev) 6561da177e4SLinus Torvalds goto done; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds if (colon) 6591da177e4SLinus Torvalds *colon = ':'; 6601da177e4SLinus Torvalds 6619f9354b9SEric Dumazet in_dev = __in_dev_get_rtnl(dev); 6629f9354b9SEric Dumazet if (in_dev) { 6631da177e4SLinus Torvalds if (tryaddrmatch) { 6641da177e4SLinus Torvalds /* Matthias Andree */ 6651da177e4SLinus Torvalds /* compare label and address (4.4BSD style) */ 6661da177e4SLinus Torvalds /* note: we only do this for a limited set of ioctls 6671da177e4SLinus Torvalds and only if the original address family was AF_INET. 6681da177e4SLinus Torvalds This is checked above. */ 6691da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6701da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 6711da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 6721da177e4SLinus Torvalds sin_orig.sin_addr.s_addr == 6731da177e4SLinus Torvalds ifa->ifa_address) { 6741da177e4SLinus Torvalds break; /* found */ 6751da177e4SLinus Torvalds } 6761da177e4SLinus Torvalds } 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds /* we didn't get a match, maybe the application is 6791da177e4SLinus Torvalds 4.3BSD-style and passed in junk so we fall back to 6801da177e4SLinus Torvalds comparing just the label */ 6811da177e4SLinus Torvalds if (!ifa) { 6821da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6831da177e4SLinus Torvalds ifap = &ifa->ifa_next) 6841da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 6851da177e4SLinus Torvalds break; 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 6901da177e4SLinus Torvalds if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 6911da177e4SLinus Torvalds goto done; 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds switch (cmd) { 6941da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6951da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_local; 6961da177e4SLinus Torvalds goto rarok; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6991da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_broadcast; 7001da177e4SLinus Torvalds goto rarok; 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 7031da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_address; 7041da177e4SLinus Torvalds goto rarok; 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 7071da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_mask; 7081da177e4SLinus Torvalds goto rarok; 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds case SIOCSIFFLAGS: 7111da177e4SLinus Torvalds if (colon) { 7121da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 7131da177e4SLinus Torvalds if (!ifa) 7141da177e4SLinus Torvalds break; 7151da177e4SLinus Torvalds ret = 0; 7161da177e4SLinus Torvalds if (!(ifr.ifr_flags & IFF_UP)) 7171da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 1); 7181da177e4SLinus Torvalds break; 7191da177e4SLinus Torvalds } 7201da177e4SLinus Torvalds ret = dev_change_flags(dev, ifr.ifr_flags); 7211da177e4SLinus Torvalds break; 7221da177e4SLinus Torvalds 7231da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 7241da177e4SLinus Torvalds ret = -EINVAL; 7251da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7261da177e4SLinus Torvalds break; 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds if (!ifa) { 7291da177e4SLinus Torvalds ret = -ENOBUFS; 7309f9354b9SEric Dumazet ifa = inet_alloc_ifa(); 7319f9354b9SEric Dumazet if (!ifa) 7321da177e4SLinus Torvalds break; 7331da177e4SLinus Torvalds if (colon) 7341da177e4SLinus Torvalds memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 7351da177e4SLinus Torvalds else 7361da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 7371da177e4SLinus Torvalds } else { 7381da177e4SLinus Torvalds ret = 0; 7391da177e4SLinus Torvalds if (ifa->ifa_local == sin->sin_addr.s_addr) 7401da177e4SLinus Torvalds break; 7411da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7421da177e4SLinus Torvalds ifa->ifa_broadcast = 0; 743148f9729SBjorn Mork ifa->ifa_scope = 0; 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds if (!(dev->flags & IFF_POINTOPOINT)) { 7491da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 7501da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 7511da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 7521da177e4SLinus Torvalds ifa->ifa_prefixlen < 31) 7531da177e4SLinus Torvalds ifa->ifa_broadcast = ifa->ifa_address | 7541da177e4SLinus Torvalds ~ifa->ifa_mask; 7551da177e4SLinus Torvalds } else { 7561da177e4SLinus Torvalds ifa->ifa_prefixlen = 32; 7571da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(32); 7581da177e4SLinus Torvalds } 7591da177e4SLinus Torvalds ret = inet_set_ifa(dev, ifa); 7601da177e4SLinus Torvalds break; 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 7631da177e4SLinus Torvalds ret = 0; 7641da177e4SLinus Torvalds if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 7651da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7661da177e4SLinus Torvalds ifa->ifa_broadcast = sin->sin_addr.s_addr; 7671da177e4SLinus Torvalds inet_insert_ifa(ifa); 7681da177e4SLinus Torvalds } 7691da177e4SLinus Torvalds break; 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 7721da177e4SLinus Torvalds ret = 0; 7731da177e4SLinus Torvalds if (ifa->ifa_address == sin->sin_addr.s_addr) 7741da177e4SLinus Torvalds break; 7751da177e4SLinus Torvalds ret = -EINVAL; 7761da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7771da177e4SLinus Torvalds break; 7781da177e4SLinus Torvalds ret = 0; 7791da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7801da177e4SLinus Torvalds ifa->ifa_address = sin->sin_addr.s_addr; 7811da177e4SLinus Torvalds inet_insert_ifa(ifa); 7821da177e4SLinus Torvalds break; 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds /* 7871da177e4SLinus Torvalds * The mask we set must be legal. 7881da177e4SLinus Torvalds */ 7891da177e4SLinus Torvalds ret = -EINVAL; 7901da177e4SLinus Torvalds if (bad_mask(sin->sin_addr.s_addr, 0)) 7911da177e4SLinus Torvalds break; 7921da177e4SLinus Torvalds ret = 0; 7931da177e4SLinus Torvalds if (ifa->ifa_mask != sin->sin_addr.s_addr) { 794a144ea4bSAl Viro __be32 old_mask = ifa->ifa_mask; 7951da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7961da177e4SLinus Torvalds ifa->ifa_mask = sin->sin_addr.s_addr; 7971da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds /* See if current broadcast address matches 8001da177e4SLinus Torvalds * with current netmask, then recalculate 8011da177e4SLinus Torvalds * the broadcast address. Otherwise it's a 8021da177e4SLinus Torvalds * funny address, so don't touch it since 8031da177e4SLinus Torvalds * the user seems to know what (s)he's doing... 8041da177e4SLinus Torvalds */ 8051da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 8061da177e4SLinus Torvalds (ifa->ifa_prefixlen < 31) && 8071da177e4SLinus Torvalds (ifa->ifa_broadcast == 808dcab5e1eSDavid Engel (ifa->ifa_local|~old_mask))) { 8091da177e4SLinus Torvalds ifa->ifa_broadcast = (ifa->ifa_local | 8101da177e4SLinus Torvalds ~sin->sin_addr.s_addr); 8111da177e4SLinus Torvalds } 8121da177e4SLinus Torvalds inet_insert_ifa(ifa); 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds break; 8151da177e4SLinus Torvalds } 8161da177e4SLinus Torvalds done: 8171da177e4SLinus Torvalds rtnl_unlock(); 8181da177e4SLinus Torvalds out: 8191da177e4SLinus Torvalds return ret; 8201da177e4SLinus Torvalds rarok: 8211da177e4SLinus Torvalds rtnl_unlock(); 8221da177e4SLinus Torvalds ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 8231da177e4SLinus Torvalds goto out; 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 8271da177e4SLinus Torvalds { 828e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 8291da177e4SLinus Torvalds struct in_ifaddr *ifa; 8301da177e4SLinus Torvalds struct ifreq ifr; 8311da177e4SLinus Torvalds int done = 0; 8321da177e4SLinus Torvalds 8339f9354b9SEric Dumazet if (!in_dev) 8341da177e4SLinus Torvalds goto out; 8351da177e4SLinus Torvalds 8369f9354b9SEric Dumazet for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 8371da177e4SLinus Torvalds if (!buf) { 8381da177e4SLinus Torvalds done += sizeof(ifr); 8391da177e4SLinus Torvalds continue; 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds if (len < (int) sizeof(ifr)) 8421da177e4SLinus Torvalds break; 8431da177e4SLinus Torvalds memset(&ifr, 0, sizeof(struct ifreq)); 8441da177e4SLinus Torvalds if (ifa->ifa_label) 8451da177e4SLinus Torvalds strcpy(ifr.ifr_name, ifa->ifa_label); 8461da177e4SLinus Torvalds else 8471da177e4SLinus Torvalds strcpy(ifr.ifr_name, dev->name); 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 8501da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 8511da177e4SLinus Torvalds ifa->ifa_local; 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 8541da177e4SLinus Torvalds done = -EFAULT; 8551da177e4SLinus Torvalds break; 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds buf += sizeof(struct ifreq); 8581da177e4SLinus Torvalds len -= sizeof(struct ifreq); 8591da177e4SLinus Torvalds done += sizeof(struct ifreq); 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds out: 8621da177e4SLinus Torvalds return done; 8631da177e4SLinus Torvalds } 8641da177e4SLinus Torvalds 865a61ced5dSAl Viro __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope) 8661da177e4SLinus Torvalds { 867a61ced5dSAl Viro __be32 addr = 0; 8681da177e4SLinus Torvalds struct in_device *in_dev; 869c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(dev); 8701da177e4SLinus Torvalds 8711da177e4SLinus Torvalds rcu_read_lock(); 872e5ed6399SHerbert Xu in_dev = __in_dev_get_rcu(dev); 8731da177e4SLinus Torvalds if (!in_dev) 8741da177e4SLinus Torvalds goto no_in_dev; 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8771da177e4SLinus Torvalds if (ifa->ifa_scope > scope) 8781da177e4SLinus Torvalds continue; 8791da177e4SLinus Torvalds if (!dst || inet_ifa_match(dst, ifa)) { 8801da177e4SLinus Torvalds addr = ifa->ifa_local; 8811da177e4SLinus Torvalds break; 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds if (!addr) 8841da177e4SLinus Torvalds addr = ifa->ifa_local; 8851da177e4SLinus Torvalds } endfor_ifa(in_dev); 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds if (addr) 888c6d14c84SEric Dumazet goto out_unlock; 8899f9354b9SEric Dumazet no_in_dev: 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds /* Not loopback addresses on loopback should be preferred 8921da177e4SLinus Torvalds in this case. It is importnat that lo is the first interface 8931da177e4SLinus Torvalds in dev_base list. 8941da177e4SLinus Torvalds */ 895c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 8969f9354b9SEric Dumazet in_dev = __in_dev_get_rcu(dev); 8979f9354b9SEric Dumazet if (!in_dev) 8981da177e4SLinus Torvalds continue; 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds for_primary_ifa(in_dev) { 9011da177e4SLinus Torvalds if (ifa->ifa_scope != RT_SCOPE_LINK && 9021da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9031da177e4SLinus Torvalds addr = ifa->ifa_local; 904c6d14c84SEric Dumazet goto out_unlock; 9051da177e4SLinus Torvalds } 9061da177e4SLinus Torvalds } endfor_ifa(in_dev); 9071da177e4SLinus Torvalds } 908c6d14c84SEric Dumazet out_unlock: 9091da177e4SLinus Torvalds rcu_read_unlock(); 9101da177e4SLinus Torvalds return addr; 9111da177e4SLinus Torvalds } 9129f9354b9SEric Dumazet EXPORT_SYMBOL(inet_select_addr); 9131da177e4SLinus Torvalds 91460cad5daSAl Viro static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst, 91560cad5daSAl Viro __be32 local, int scope) 9161da177e4SLinus Torvalds { 9171da177e4SLinus Torvalds int same = 0; 918a144ea4bSAl Viro __be32 addr = 0; 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds for_ifa(in_dev) { 9211da177e4SLinus Torvalds if (!addr && 9221da177e4SLinus Torvalds (local == ifa->ifa_local || !local) && 9231da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 9241da177e4SLinus Torvalds addr = ifa->ifa_local; 9251da177e4SLinus Torvalds if (same) 9261da177e4SLinus Torvalds break; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds if (!same) { 9291da177e4SLinus Torvalds same = (!local || inet_ifa_match(local, ifa)) && 9301da177e4SLinus Torvalds (!dst || inet_ifa_match(dst, ifa)); 9311da177e4SLinus Torvalds if (same && addr) { 9321da177e4SLinus Torvalds if (local || !dst) 9331da177e4SLinus Torvalds break; 9341da177e4SLinus Torvalds /* Is the selected addr into dst subnet? */ 9351da177e4SLinus Torvalds if (inet_ifa_match(addr, ifa)) 9361da177e4SLinus Torvalds break; 9371da177e4SLinus Torvalds /* No, then can we use new local src? */ 9381da177e4SLinus Torvalds if (ifa->ifa_scope <= scope) { 9391da177e4SLinus Torvalds addr = ifa->ifa_local; 9401da177e4SLinus Torvalds break; 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds /* search for large dst subnet for addr */ 9431da177e4SLinus Torvalds same = 0; 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds } endfor_ifa(in_dev); 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds return same ? addr : 0; 9491da177e4SLinus Torvalds } 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds /* 9521da177e4SLinus Torvalds * Confirm that local IP address exists using wildcards: 9539bd85e32SDenis V. Lunev * - in_dev: only on this interface, 0=any interface 9541da177e4SLinus Torvalds * - dst: only in the same subnet as dst, 0=any dst 9551da177e4SLinus Torvalds * - local: address, 0=autoselect the local address 9561da177e4SLinus Torvalds * - scope: maximum allowed scope value for the local address 9571da177e4SLinus Torvalds */ 9589bd85e32SDenis V. Lunev __be32 inet_confirm_addr(struct in_device *in_dev, 9599bd85e32SDenis V. Lunev __be32 dst, __be32 local, int scope) 9601da177e4SLinus Torvalds { 96160cad5daSAl Viro __be32 addr = 0; 9629bd85e32SDenis V. Lunev struct net_device *dev; 96339a6d063SDenis V. Lunev struct net *net; 9641da177e4SLinus Torvalds 96539a6d063SDenis V. Lunev if (scope != RT_SCOPE_LINK) 9669bd85e32SDenis V. Lunev return confirm_addr_indev(in_dev, dst, local, scope); 9671da177e4SLinus Torvalds 968c346dca1SYOSHIFUJI Hideaki net = dev_net(in_dev->dev); 9691da177e4SLinus Torvalds rcu_read_lock(); 970c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 9719f9354b9SEric Dumazet in_dev = __in_dev_get_rcu(dev); 9729f9354b9SEric Dumazet if (in_dev) { 9731da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9741da177e4SLinus Torvalds if (addr) 9751da177e4SLinus Torvalds break; 9761da177e4SLinus Torvalds } 9771da177e4SLinus Torvalds } 9781da177e4SLinus Torvalds rcu_read_unlock(); 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds return addr; 9811da177e4SLinus Torvalds } 9821da177e4SLinus Torvalds 9831da177e4SLinus Torvalds /* 9841da177e4SLinus Torvalds * Device notifier 9851da177e4SLinus Torvalds */ 9861da177e4SLinus Torvalds 9871da177e4SLinus Torvalds int register_inetaddr_notifier(struct notifier_block *nb) 9881da177e4SLinus Torvalds { 989e041c683SAlan Stern return blocking_notifier_chain_register(&inetaddr_chain, nb); 9901da177e4SLinus Torvalds } 9919f9354b9SEric Dumazet EXPORT_SYMBOL(register_inetaddr_notifier); 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds int unregister_inetaddr_notifier(struct notifier_block *nb) 9941da177e4SLinus Torvalds { 995e041c683SAlan Stern return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 9961da177e4SLinus Torvalds } 9979f9354b9SEric Dumazet EXPORT_SYMBOL(unregister_inetaddr_notifier); 9981da177e4SLinus Torvalds 9999f9354b9SEric Dumazet /* Rename ifa_labels for a device name change. Make some effort to preserve 10009f9354b9SEric Dumazet * existing alias numbering and to create unique labels if possible. 10011da177e4SLinus Torvalds */ 10021da177e4SLinus Torvalds static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 10031da177e4SLinus Torvalds { 10041da177e4SLinus Torvalds struct in_ifaddr *ifa; 10051da177e4SLinus Torvalds int named = 0; 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 10081da177e4SLinus Torvalds char old[IFNAMSIZ], *dot; 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds memcpy(old, ifa->ifa_label, IFNAMSIZ); 10111da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10121da177e4SLinus Torvalds if (named++ == 0) 1013573bf470SThomas Graf goto skip; 101444344b2aSMark McLoughlin dot = strchr(old, ':'); 10151da177e4SLinus Torvalds if (dot == NULL) { 10161da177e4SLinus Torvalds sprintf(old, ":%d", named); 10171da177e4SLinus Torvalds dot = old; 10181da177e4SLinus Torvalds } 10199f9354b9SEric Dumazet if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) 10201da177e4SLinus Torvalds strcat(ifa->ifa_label, dot); 10219f9354b9SEric Dumazet else 10221da177e4SLinus Torvalds strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 1023573bf470SThomas Graf skip: 1024573bf470SThomas Graf rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0); 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds } 10271da177e4SLinus Torvalds 102806770843SBreno Leitao static inline bool inetdev_valid_mtu(unsigned mtu) 102906770843SBreno Leitao { 103006770843SBreno Leitao return mtu >= 68; 103106770843SBreno Leitao } 103206770843SBreno Leitao 10331da177e4SLinus Torvalds /* Called only under RTNL semaphore */ 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds static int inetdev_event(struct notifier_block *this, unsigned long event, 10361da177e4SLinus Torvalds void *ptr) 10371da177e4SLinus Torvalds { 10381da177e4SLinus Torvalds struct net_device *dev = ptr; 1039e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds ASSERT_RTNL(); 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds if (!in_dev) { 10448030f544SHerbert Xu if (event == NETDEV_REGISTER) { 10451da177e4SLinus Torvalds in_dev = inetdev_init(dev); 10468d76527eSHerbert Xu if (!in_dev) 1047b217d616SHerbert Xu return notifier_from_errno(-ENOMEM); 10480cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 104942f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOXFRM, 1); 105042f811b8SHerbert Xu IN_DEV_CONF_SET(in_dev, NOPOLICY, 1); 10511da177e4SLinus Torvalds } 105206770843SBreno Leitao } else if (event == NETDEV_CHANGEMTU) { 105306770843SBreno Leitao /* Re-enabling IP */ 105406770843SBreno Leitao if (inetdev_valid_mtu(dev->mtu)) 105506770843SBreno Leitao in_dev = inetdev_init(dev); 10568030f544SHerbert Xu } 10571da177e4SLinus Torvalds goto out; 10581da177e4SLinus Torvalds } 10591da177e4SLinus Torvalds 10601da177e4SLinus Torvalds switch (event) { 10611da177e4SLinus Torvalds case NETDEV_REGISTER: 10621da177e4SLinus Torvalds printk(KERN_DEBUG "inetdev_event: bug\n"); 106395ae6b22SEric Dumazet rcu_assign_pointer(dev->ip_ptr, NULL); 10641da177e4SLinus Torvalds break; 10651da177e4SLinus Torvalds case NETDEV_UP: 106606770843SBreno Leitao if (!inetdev_valid_mtu(dev->mtu)) 10671da177e4SLinus Torvalds break; 10680cc217e1SEric W. Biederman if (dev->flags & IFF_LOOPBACK) { 10699f9354b9SEric Dumazet struct in_ifaddr *ifa = inet_alloc_ifa(); 10709f9354b9SEric Dumazet 10719f9354b9SEric Dumazet if (ifa) { 10721da177e4SLinus Torvalds ifa->ifa_local = 10731da177e4SLinus Torvalds ifa->ifa_address = htonl(INADDR_LOOPBACK); 10741da177e4SLinus Torvalds ifa->ifa_prefixlen = 8; 10751da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(8); 10761da177e4SLinus Torvalds in_dev_hold(in_dev); 10771da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 10781da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 10791da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10801da177e4SLinus Torvalds inet_insert_ifa(ifa); 10811da177e4SLinus Torvalds } 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds ip_mc_up(in_dev); 1084eefef1cfSStephen Hemminger /* fall through */ 108506c4648dSIan Campbell case NETDEV_NOTIFY_PEERS: 1086eefef1cfSStephen Hemminger case NETDEV_CHANGEADDR: 1087a21090cfSStephen Hemminger /* Send gratuitous ARP to notify of link change */ 1088a21090cfSStephen Hemminger if (IN_DEV_ARP_NOTIFY(in_dev)) { 1089a21090cfSStephen Hemminger struct in_ifaddr *ifa = in_dev->ifa_list; 1090a21090cfSStephen Hemminger 1091a21090cfSStephen Hemminger if (ifa) 1092eefef1cfSStephen Hemminger arp_send(ARPOP_REQUEST, ETH_P_ARP, 1093a21090cfSStephen Hemminger ifa->ifa_address, dev, 1094a21090cfSStephen Hemminger ifa->ifa_address, NULL, 1095a21090cfSStephen Hemminger dev->dev_addr, NULL); 1096a21090cfSStephen Hemminger } 10971da177e4SLinus Torvalds break; 10981da177e4SLinus Torvalds case NETDEV_DOWN: 10991da177e4SLinus Torvalds ip_mc_down(in_dev); 11001da177e4SLinus Torvalds break; 110193d9b7d7SJiri Pirko case NETDEV_PRE_TYPE_CHANGE: 110275c78500SMoni Shoua ip_mc_unmap(in_dev); 110375c78500SMoni Shoua break; 110493d9b7d7SJiri Pirko case NETDEV_POST_TYPE_CHANGE: 110575c78500SMoni Shoua ip_mc_remap(in_dev); 110675c78500SMoni Shoua break; 11071da177e4SLinus Torvalds case NETDEV_CHANGEMTU: 110806770843SBreno Leitao if (inetdev_valid_mtu(dev->mtu)) 11091da177e4SLinus Torvalds break; 111006770843SBreno Leitao /* disable IP when MTU is not enough */ 11111da177e4SLinus Torvalds case NETDEV_UNREGISTER: 11121da177e4SLinus Torvalds inetdev_destroy(in_dev); 11131da177e4SLinus Torvalds break; 11141da177e4SLinus Torvalds case NETDEV_CHANGENAME: 11151da177e4SLinus Torvalds /* Do not notify about label change, this event is 11161da177e4SLinus Torvalds * not interesting to applications using netlink. 11171da177e4SLinus Torvalds */ 11181da177e4SLinus Torvalds inetdev_changename(dev, in_dev); 11191da177e4SLinus Torvalds 112051602b2aSPavel Emelyanov devinet_sysctl_unregister(in_dev); 112166f27a52SPavel Emelyanov devinet_sysctl_register(in_dev); 11221da177e4SLinus Torvalds break; 11231da177e4SLinus Torvalds } 11241da177e4SLinus Torvalds out: 11251da177e4SLinus Torvalds return NOTIFY_DONE; 11261da177e4SLinus Torvalds } 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds static struct notifier_block ip_netdev_notifier = { 11291da177e4SLinus Torvalds .notifier_call = inetdev_event, 11301da177e4SLinus Torvalds }; 11311da177e4SLinus Torvalds 1132339bf98fSThomas Graf static inline size_t inet_nlmsg_size(void) 1133339bf98fSThomas Graf { 1134339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 1135339bf98fSThomas Graf + nla_total_size(4) /* IFA_ADDRESS */ 1136339bf98fSThomas Graf + nla_total_size(4) /* IFA_LOCAL */ 1137339bf98fSThomas Graf + nla_total_size(4) /* IFA_BROADCAST */ 1138339bf98fSThomas Graf + nla_total_size(IFNAMSIZ); /* IFA_LABEL */ 1139339bf98fSThomas Graf } 1140339bf98fSThomas Graf 11411da177e4SLinus Torvalds static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1142b6544c0bSJamal Hadi Salim u32 pid, u32 seq, int event, unsigned int flags) 11431da177e4SLinus Torvalds { 11441da177e4SLinus Torvalds struct ifaddrmsg *ifm; 11451da177e4SLinus Torvalds struct nlmsghdr *nlh; 11461da177e4SLinus Torvalds 114747f68512SThomas Graf nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags); 114847f68512SThomas Graf if (nlh == NULL) 114926932566SPatrick McHardy return -EMSGSIZE; 115047f68512SThomas Graf 115147f68512SThomas Graf ifm = nlmsg_data(nlh); 11521da177e4SLinus Torvalds ifm->ifa_family = AF_INET; 11531da177e4SLinus Torvalds ifm->ifa_prefixlen = ifa->ifa_prefixlen; 11541da177e4SLinus Torvalds ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT; 11551da177e4SLinus Torvalds ifm->ifa_scope = ifa->ifa_scope; 11561da177e4SLinus Torvalds ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 11571da177e4SLinus Torvalds 115847f68512SThomas Graf if (ifa->ifa_address) 1159a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address); 116047f68512SThomas Graf 116147f68512SThomas Graf if (ifa->ifa_local) 1162a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local); 116347f68512SThomas Graf 116447f68512SThomas Graf if (ifa->ifa_broadcast) 1165a7a628c4SAl Viro NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast); 116647f68512SThomas Graf 116747f68512SThomas Graf if (ifa->ifa_label[0]) 116847f68512SThomas Graf NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label); 116947f68512SThomas Graf 117047f68512SThomas Graf return nlmsg_end(skb, nlh); 117147f68512SThomas Graf 117247f68512SThomas Graf nla_put_failure: 117326932566SPatrick McHardy nlmsg_cancel(skb, nlh); 117426932566SPatrick McHardy return -EMSGSIZE; 11751da177e4SLinus Torvalds } 11761da177e4SLinus Torvalds 11771da177e4SLinus Torvalds static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 11781da177e4SLinus Torvalds { 11793b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 1180eec4df98SEric Dumazet int h, s_h; 1181eec4df98SEric Dumazet int idx, s_idx; 1182eec4df98SEric Dumazet int ip_idx, s_ip_idx; 11831da177e4SLinus Torvalds struct net_device *dev; 11841da177e4SLinus Torvalds struct in_device *in_dev; 11851da177e4SLinus Torvalds struct in_ifaddr *ifa; 1186eec4df98SEric Dumazet struct hlist_head *head; 1187eec4df98SEric Dumazet struct hlist_node *node; 11881da177e4SLinus Torvalds 1189eec4df98SEric Dumazet s_h = cb->args[0]; 1190eec4df98SEric Dumazet s_idx = idx = cb->args[1]; 1191eec4df98SEric Dumazet s_ip_idx = ip_idx = cb->args[2]; 1192eec4df98SEric Dumazet 1193eec4df98SEric Dumazet for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 11947562f876SPavel Emelianov idx = 0; 1195eec4df98SEric Dumazet head = &net->dev_index_head[h]; 1196eec4df98SEric Dumazet rcu_read_lock(); 1197eec4df98SEric Dumazet hlist_for_each_entry_rcu(dev, node, head, index_hlist) { 11981da177e4SLinus Torvalds if (idx < s_idx) 11997562f876SPavel Emelianov goto cont; 12004b97efdfSPatrick McHardy if (h > s_h || idx > s_idx) 12011da177e4SLinus Torvalds s_ip_idx = 0; 1202eec4df98SEric Dumazet in_dev = __in_dev_get_rcu(dev); 12039f9354b9SEric Dumazet if (!in_dev) 12047562f876SPavel Emelianov goto cont; 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 12071da177e4SLinus Torvalds ifa = ifa->ifa_next, ip_idx++) { 12081da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 1209596e4150SStephen Hemminger continue; 1210eec4df98SEric Dumazet if (inet_fill_ifaddr(skb, ifa, 1211eec4df98SEric Dumazet NETLINK_CB(cb->skb).pid, 12121da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 1213eec4df98SEric Dumazet RTM_NEWADDR, NLM_F_MULTI) <= 0) { 1214eec4df98SEric Dumazet rcu_read_unlock(); 12151da177e4SLinus Torvalds goto done; 12161da177e4SLinus Torvalds } 1217eec4df98SEric Dumazet } 12187562f876SPavel Emelianov cont: 12197562f876SPavel Emelianov idx++; 12201da177e4SLinus Torvalds } 1221eec4df98SEric Dumazet rcu_read_unlock(); 1222eec4df98SEric Dumazet } 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds done: 1225eec4df98SEric Dumazet cb->args[0] = h; 1226eec4df98SEric Dumazet cb->args[1] = idx; 1227eec4df98SEric Dumazet cb->args[2] = ip_idx; 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds return skb->len; 12301da177e4SLinus Torvalds } 12311da177e4SLinus Torvalds 1232d6062cbbSThomas Graf static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh, 1233d6062cbbSThomas Graf u32 pid) 12341da177e4SLinus Torvalds { 123547f68512SThomas Graf struct sk_buff *skb; 1236d6062cbbSThomas Graf u32 seq = nlh ? nlh->nlmsg_seq : 0; 1237d6062cbbSThomas Graf int err = -ENOBUFS; 12384b8aa9abSDenis V. Lunev struct net *net; 12391da177e4SLinus Torvalds 1240c346dca1SYOSHIFUJI Hideaki net = dev_net(ifa->ifa_dev->dev); 1241339bf98fSThomas Graf skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL); 124247f68512SThomas Graf if (skb == NULL) 1243d6062cbbSThomas Graf goto errout; 1244d6062cbbSThomas Graf 1245d6062cbbSThomas Graf err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0); 124626932566SPatrick McHardy if (err < 0) { 124726932566SPatrick McHardy /* -EMSGSIZE implies BUG in inet_nlmsg_size() */ 124826932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 124926932566SPatrick McHardy kfree_skb(skb); 125026932566SPatrick McHardy goto errout; 125126932566SPatrick McHardy } 12521ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL); 12531ce85fe4SPablo Neira Ayuso return; 1254d6062cbbSThomas Graf errout: 1255d6062cbbSThomas Graf if (err < 0) 12564b8aa9abSDenis V. Lunev rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err); 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 12601da177e4SLinus Torvalds 1261c0ce9fb3SPavel Emelyanov static void devinet_copy_dflt_conf(struct net *net, int i) 126231be3085SHerbert Xu { 126331be3085SHerbert Xu struct net_device *dev; 126431be3085SHerbert Xu 126531be3085SHerbert Xu rcu_read_lock(); 1266c6d14c84SEric Dumazet for_each_netdev_rcu(net, dev) { 1267c6d14c84SEric Dumazet struct in_device *in_dev; 1268c6d14c84SEric Dumazet 126931be3085SHerbert Xu in_dev = __in_dev_get_rcu(dev); 127031be3085SHerbert Xu if (in_dev && !test_bit(i, in_dev->cnf.state)) 12719355bbd6SPavel Emelyanov in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i]; 1272c6d14c84SEric Dumazet } 127331be3085SHerbert Xu rcu_read_unlock(); 127431be3085SHerbert Xu } 127531be3085SHerbert Xu 1276c6d14c84SEric Dumazet /* called with RTNL locked */ 1277c0ce9fb3SPavel Emelyanov static void inet_forward_change(struct net *net) 127868dd299bSPavel Emelyanov { 127968dd299bSPavel Emelyanov struct net_device *dev; 1280586f1211SPavel Emelyanov int on = IPV4_DEVCONF_ALL(net, FORWARDING); 128168dd299bSPavel Emelyanov 1282586f1211SPavel Emelyanov IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on; 12839355bbd6SPavel Emelyanov IPV4_DEVCONF_DFLT(net, FORWARDING) = on; 128468dd299bSPavel Emelyanov 1285c0ce9fb3SPavel Emelyanov for_each_netdev(net, dev) { 128668dd299bSPavel Emelyanov struct in_device *in_dev; 12870187bdfbSBen Hutchings if (on) 12880187bdfbSBen Hutchings dev_disable_lro(dev); 128968dd299bSPavel Emelyanov rcu_read_lock(); 129068dd299bSPavel Emelyanov in_dev = __in_dev_get_rcu(dev); 129168dd299bSPavel Emelyanov if (in_dev) 129268dd299bSPavel Emelyanov IN_DEV_CONF_SET(in_dev, FORWARDING, on); 129368dd299bSPavel Emelyanov rcu_read_unlock(); 129468dd299bSPavel Emelyanov } 129568dd299bSPavel Emelyanov } 129668dd299bSPavel Emelyanov 129731be3085SHerbert Xu static int devinet_conf_proc(ctl_table *ctl, int write, 12988d65af78SAlexey Dobriyan void __user *buffer, 129931be3085SHerbert Xu size_t *lenp, loff_t *ppos) 130031be3085SHerbert Xu { 13018d65af78SAlexey Dobriyan int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 130231be3085SHerbert Xu 130331be3085SHerbert Xu if (write) { 130431be3085SHerbert Xu struct ipv4_devconf *cnf = ctl->extra1; 1305c0ce9fb3SPavel Emelyanov struct net *net = ctl->extra2; 130631be3085SHerbert Xu int i = (int *)ctl->data - cnf->data; 130731be3085SHerbert Xu 130831be3085SHerbert Xu set_bit(i, cnf->state); 130931be3085SHerbert Xu 13109355bbd6SPavel Emelyanov if (cnf == net->ipv4.devconf_dflt) 1311c0ce9fb3SPavel Emelyanov devinet_copy_dflt_conf(net, i); 131231be3085SHerbert Xu } 131331be3085SHerbert Xu 131431be3085SHerbert Xu return ret; 131531be3085SHerbert Xu } 131631be3085SHerbert Xu 13171da177e4SLinus Torvalds static int devinet_sysctl_forward(ctl_table *ctl, int write, 13188d65af78SAlexey Dobriyan void __user *buffer, 13191da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13201da177e4SLinus Torvalds { 13211da177e4SLinus Torvalds int *valp = ctl->data; 13221da177e4SLinus Torvalds int val = *valp; 132388af182eSEric W. Biederman loff_t pos = *ppos; 13248d65af78SAlexey Dobriyan int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds if (write && *valp != val) { 1327c0ce9fb3SPavel Emelyanov struct net *net = ctl->extra2; 1328c0ce9fb3SPavel Emelyanov 13290187bdfbSBen Hutchings if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) { 133088af182eSEric W. Biederman if (!rtnl_trylock()) { 133188af182eSEric W. Biederman /* Restore the original values before restarting */ 133288af182eSEric W. Biederman *valp = val; 133388af182eSEric W. Biederman *ppos = pos; 13349b8adb5eSEric W. Biederman return restart_syscall(); 133588af182eSEric W. Biederman } 13360187bdfbSBen Hutchings if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) { 1337c0ce9fb3SPavel Emelyanov inet_forward_change(net); 13380187bdfbSBen Hutchings } else if (*valp) { 13390187bdfbSBen Hutchings struct ipv4_devconf *cnf = ctl->extra1; 13400187bdfbSBen Hutchings struct in_device *idev = 13410187bdfbSBen Hutchings container_of(cnf, struct in_device, cnf); 13420187bdfbSBen Hutchings dev_disable_lro(idev->dev); 13430187bdfbSBen Hutchings } 13440187bdfbSBen Hutchings rtnl_unlock(); 134576e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 13461da177e4SLinus Torvalds } 13470187bdfbSBen Hutchings } 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds return ret; 13501da177e4SLinus Torvalds } 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds int ipv4_doint_and_flush(ctl_table *ctl, int write, 13538d65af78SAlexey Dobriyan void __user *buffer, 13541da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 13551da177e4SLinus Torvalds { 13561da177e4SLinus Torvalds int *valp = ctl->data; 13571da177e4SLinus Torvalds int val = *valp; 13588d65af78SAlexey Dobriyan int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 135976e6ebfbSDenis V. Lunev struct net *net = ctl->extra2; 13601da177e4SLinus Torvalds 13611da177e4SLinus Torvalds if (write && *valp != val) 136276e6ebfbSDenis V. Lunev rt_cache_flush(net, 0); 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds return ret; 13651da177e4SLinus Torvalds } 13661da177e4SLinus Torvalds 1367f8572d8fSEric W. Biederman #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \ 136842f811b8SHerbert Xu { \ 136942f811b8SHerbert Xu .procname = name, \ 137042f811b8SHerbert Xu .data = ipv4_devconf.data + \ 137102291680SEric W. Biederman IPV4_DEVCONF_ ## attr - 1, \ 137242f811b8SHerbert Xu .maxlen = sizeof(int), \ 137342f811b8SHerbert Xu .mode = mval, \ 137442f811b8SHerbert Xu .proc_handler = proc, \ 137531be3085SHerbert Xu .extra1 = &ipv4_devconf, \ 137642f811b8SHerbert Xu } 137742f811b8SHerbert Xu 137842f811b8SHerbert Xu #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \ 1379f8572d8fSEric W. Biederman DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc) 138042f811b8SHerbert Xu 138142f811b8SHerbert Xu #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \ 1382f8572d8fSEric W. Biederman DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc) 138342f811b8SHerbert Xu 1384f8572d8fSEric W. Biederman #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \ 1385f8572d8fSEric W. Biederman DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc) 138642f811b8SHerbert Xu 138742f811b8SHerbert Xu #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \ 1388f8572d8fSEric W. Biederman DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush) 138942f811b8SHerbert Xu 13901da177e4SLinus Torvalds static struct devinet_sysctl_table { 13911da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 139202291680SEric W. Biederman struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX]; 1393bfada697SPavel Emelyanov char *dev_name; 13941da177e4SLinus Torvalds } devinet_sysctl = { 13951da177e4SLinus Torvalds .devinet_vars = { 139642f811b8SHerbert Xu DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding", 1397f8572d8fSEric W. Biederman devinet_sysctl_forward), 139842f811b8SHerbert Xu DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"), 139942f811b8SHerbert Xu 140042f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"), 140142f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"), 140242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"), 140342f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"), 140442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"), 140542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE, 140642f811b8SHerbert Xu "accept_source_route"), 14078153a10cSPatrick McHardy DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"), 140828f6aeeaSJamal Hadi Salim DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"), 140942f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"), 141042f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"), 141142f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"), 141242f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"), 141342f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"), 141442f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"), 141542f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"), 141642f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"), 141742f811b8SHerbert Xu DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"), 1418eefef1cfSStephen Hemminger DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"), 141965324144SJesper Dangaard Brouer DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"), 142042f811b8SHerbert Xu 142142f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"), 142242f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"), 142342f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION, 142442f811b8SHerbert Xu "force_igmp_version"), 142542f811b8SHerbert Xu DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES, 142642f811b8SHerbert Xu "promote_secondaries"), 14271da177e4SLinus Torvalds }, 14281da177e4SLinus Torvalds }; 14291da177e4SLinus Torvalds 1430ea40b324SPavel Emelyanov static int __devinet_sysctl_register(struct net *net, char *dev_name, 1431f8572d8fSEric W. Biederman struct ipv4_devconf *p) 14321da177e4SLinus Torvalds { 14331da177e4SLinus Torvalds int i; 14349fa89642SPavel Emelyanov struct devinet_sysctl_table *t; 14351da177e4SLinus Torvalds 1436bfada697SPavel Emelyanov #define DEVINET_CTL_PATH_DEV 3 1437bfada697SPavel Emelyanov 1438bfada697SPavel Emelyanov struct ctl_path devinet_ctl_path[] = { 1439f8572d8fSEric W. Biederman { .procname = "net", }, 1440f8572d8fSEric W. Biederman { .procname = "ipv4", }, 1441f8572d8fSEric W. Biederman { .procname = "conf", }, 1442bfada697SPavel Emelyanov { /* to be set */ }, 1443bfada697SPavel Emelyanov { }, 1444bfada697SPavel Emelyanov }; 1445bfada697SPavel Emelyanov 14469fa89642SPavel Emelyanov t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL); 14471da177e4SLinus Torvalds if (!t) 14489fa89642SPavel Emelyanov goto out; 14499fa89642SPavel Emelyanov 14501da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 14511da177e4SLinus Torvalds t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 145231be3085SHerbert Xu t->devinet_vars[i].extra1 = p; 1453c0ce9fb3SPavel Emelyanov t->devinet_vars[i].extra2 = net; 14541da177e4SLinus Torvalds } 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds /* 14571da177e4SLinus Torvalds * Make a copy of dev_name, because '.procname' is regarded as const 14581da177e4SLinus Torvalds * by sysctl and we wouldn't want anyone to change it under our feet 14591da177e4SLinus Torvalds * (see SIOCSIFNAME). 14601da177e4SLinus Torvalds */ 1461bfada697SPavel Emelyanov t->dev_name = kstrdup(dev_name, GFP_KERNEL); 1462bfada697SPavel Emelyanov if (!t->dev_name) 14631da177e4SLinus Torvalds goto free; 14641da177e4SLinus Torvalds 1465bfada697SPavel Emelyanov devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name; 14661da177e4SLinus Torvalds 1467752d14dcSPavel Emelyanov t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path, 1468bfada697SPavel Emelyanov t->devinet_vars); 14691da177e4SLinus Torvalds if (!t->sysctl_header) 14701da177e4SLinus Torvalds goto free_procname; 14711da177e4SLinus Torvalds 14721da177e4SLinus Torvalds p->sysctl = t; 1473ea40b324SPavel Emelyanov return 0; 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds free_procname: 1476bfada697SPavel Emelyanov kfree(t->dev_name); 14771da177e4SLinus Torvalds free: 14781da177e4SLinus Torvalds kfree(t); 14799fa89642SPavel Emelyanov out: 1480ea40b324SPavel Emelyanov return -ENOBUFS; 14811da177e4SLinus Torvalds } 14821da177e4SLinus Torvalds 148351602b2aSPavel Emelyanov static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf) 148466f27a52SPavel Emelyanov { 148551602b2aSPavel Emelyanov struct devinet_sysctl_table *t = cnf->sysctl; 148666f27a52SPavel Emelyanov 148751602b2aSPavel Emelyanov if (t == NULL) 148851602b2aSPavel Emelyanov return; 148951602b2aSPavel Emelyanov 149051602b2aSPavel Emelyanov cnf->sysctl = NULL; 14911da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 1492bfada697SPavel Emelyanov kfree(t->dev_name); 14931da177e4SLinus Torvalds kfree(t); 14941da177e4SLinus Torvalds } 149551602b2aSPavel Emelyanov 149651602b2aSPavel Emelyanov static void devinet_sysctl_register(struct in_device *idev) 149751602b2aSPavel Emelyanov { 149854716e3bSEric W. Biederman neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL); 1499c346dca1SYOSHIFUJI Hideaki __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name, 1500f8572d8fSEric W. Biederman &idev->cnf); 150151602b2aSPavel Emelyanov } 150251602b2aSPavel Emelyanov 150351602b2aSPavel Emelyanov static void devinet_sysctl_unregister(struct in_device *idev) 150451602b2aSPavel Emelyanov { 150551602b2aSPavel Emelyanov __devinet_sysctl_unregister(&idev->cnf); 150651602b2aSPavel Emelyanov neigh_sysctl_unregister(idev->arp_parms); 15071da177e4SLinus Torvalds } 15081da177e4SLinus Torvalds 150968dd299bSPavel Emelyanov static struct ctl_table ctl_forward_entry[] = { 151068dd299bSPavel Emelyanov { 151168dd299bSPavel Emelyanov .procname = "ip_forward", 151268dd299bSPavel Emelyanov .data = &ipv4_devconf.data[ 151302291680SEric W. Biederman IPV4_DEVCONF_FORWARDING - 1], 151468dd299bSPavel Emelyanov .maxlen = sizeof(int), 151568dd299bSPavel Emelyanov .mode = 0644, 151668dd299bSPavel Emelyanov .proc_handler = devinet_sysctl_forward, 151768dd299bSPavel Emelyanov .extra1 = &ipv4_devconf, 1518c0ce9fb3SPavel Emelyanov .extra2 = &init_net, 151968dd299bSPavel Emelyanov }, 152068dd299bSPavel Emelyanov { }, 152168dd299bSPavel Emelyanov }; 152268dd299bSPavel Emelyanov 1523752d14dcSPavel Emelyanov static __net_initdata struct ctl_path net_ipv4_path[] = { 1524f8572d8fSEric W. Biederman { .procname = "net", }, 1525f8572d8fSEric W. Biederman { .procname = "ipv4", }, 152668dd299bSPavel Emelyanov { }, 152768dd299bSPavel Emelyanov }; 15282a75de0cSEric Dumazet #endif 152968dd299bSPavel Emelyanov 1530752d14dcSPavel Emelyanov static __net_init int devinet_init_net(struct net *net) 1531752d14dcSPavel Emelyanov { 1532752d14dcSPavel Emelyanov int err; 1533752d14dcSPavel Emelyanov struct ipv4_devconf *all, *dflt; 15342a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 15352a75de0cSEric Dumazet struct ctl_table *tbl = ctl_forward_entry; 1536752d14dcSPavel Emelyanov struct ctl_table_header *forw_hdr; 15372a75de0cSEric Dumazet #endif 1538752d14dcSPavel Emelyanov 1539752d14dcSPavel Emelyanov err = -ENOMEM; 1540752d14dcSPavel Emelyanov all = &ipv4_devconf; 1541752d14dcSPavel Emelyanov dflt = &ipv4_devconf_dflt; 1542752d14dcSPavel Emelyanov 154309ad9bc7SOctavian Purdila if (!net_eq(net, &init_net)) { 1544752d14dcSPavel Emelyanov all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL); 1545752d14dcSPavel Emelyanov if (all == NULL) 1546752d14dcSPavel Emelyanov goto err_alloc_all; 1547752d14dcSPavel Emelyanov 1548752d14dcSPavel Emelyanov dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL); 1549752d14dcSPavel Emelyanov if (dflt == NULL) 1550752d14dcSPavel Emelyanov goto err_alloc_dflt; 1551752d14dcSPavel Emelyanov 15522a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 1553752d14dcSPavel Emelyanov tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL); 1554752d14dcSPavel Emelyanov if (tbl == NULL) 1555752d14dcSPavel Emelyanov goto err_alloc_ctl; 1556752d14dcSPavel Emelyanov 155702291680SEric W. Biederman tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1]; 1558752d14dcSPavel Emelyanov tbl[0].extra1 = all; 1559752d14dcSPavel Emelyanov tbl[0].extra2 = net; 15602a75de0cSEric Dumazet #endif 1561752d14dcSPavel Emelyanov } 1562752d14dcSPavel Emelyanov 1563752d14dcSPavel Emelyanov #ifdef CONFIG_SYSCTL 1564f8572d8fSEric W. Biederman err = __devinet_sysctl_register(net, "all", all); 1565752d14dcSPavel Emelyanov if (err < 0) 1566752d14dcSPavel Emelyanov goto err_reg_all; 1567752d14dcSPavel Emelyanov 1568f8572d8fSEric W. Biederman err = __devinet_sysctl_register(net, "default", dflt); 1569752d14dcSPavel Emelyanov if (err < 0) 1570752d14dcSPavel Emelyanov goto err_reg_dflt; 1571752d14dcSPavel Emelyanov 1572752d14dcSPavel Emelyanov err = -ENOMEM; 1573752d14dcSPavel Emelyanov forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl); 1574752d14dcSPavel Emelyanov if (forw_hdr == NULL) 1575752d14dcSPavel Emelyanov goto err_reg_ctl; 15762a75de0cSEric Dumazet net->ipv4.forw_hdr = forw_hdr; 1577752d14dcSPavel Emelyanov #endif 1578752d14dcSPavel Emelyanov 1579752d14dcSPavel Emelyanov net->ipv4.devconf_all = all; 1580752d14dcSPavel Emelyanov net->ipv4.devconf_dflt = dflt; 1581752d14dcSPavel Emelyanov return 0; 1582752d14dcSPavel Emelyanov 1583752d14dcSPavel Emelyanov #ifdef CONFIG_SYSCTL 1584752d14dcSPavel Emelyanov err_reg_ctl: 1585752d14dcSPavel Emelyanov __devinet_sysctl_unregister(dflt); 1586752d14dcSPavel Emelyanov err_reg_dflt: 1587752d14dcSPavel Emelyanov __devinet_sysctl_unregister(all); 1588752d14dcSPavel Emelyanov err_reg_all: 1589752d14dcSPavel Emelyanov if (tbl != ctl_forward_entry) 1590752d14dcSPavel Emelyanov kfree(tbl); 1591752d14dcSPavel Emelyanov err_alloc_ctl: 15922a75de0cSEric Dumazet #endif 1593752d14dcSPavel Emelyanov if (dflt != &ipv4_devconf_dflt) 1594752d14dcSPavel Emelyanov kfree(dflt); 1595752d14dcSPavel Emelyanov err_alloc_dflt: 1596752d14dcSPavel Emelyanov if (all != &ipv4_devconf) 1597752d14dcSPavel Emelyanov kfree(all); 1598752d14dcSPavel Emelyanov err_alloc_all: 1599752d14dcSPavel Emelyanov return err; 1600752d14dcSPavel Emelyanov } 1601752d14dcSPavel Emelyanov 1602752d14dcSPavel Emelyanov static __net_exit void devinet_exit_net(struct net *net) 1603752d14dcSPavel Emelyanov { 16042a75de0cSEric Dumazet #ifdef CONFIG_SYSCTL 1605752d14dcSPavel Emelyanov struct ctl_table *tbl; 1606752d14dcSPavel Emelyanov 1607752d14dcSPavel Emelyanov tbl = net->ipv4.forw_hdr->ctl_table_arg; 1608752d14dcSPavel Emelyanov unregister_net_sysctl_table(net->ipv4.forw_hdr); 1609752d14dcSPavel Emelyanov __devinet_sysctl_unregister(net->ipv4.devconf_dflt); 1610752d14dcSPavel Emelyanov __devinet_sysctl_unregister(net->ipv4.devconf_all); 1611752d14dcSPavel Emelyanov kfree(tbl); 16122a75de0cSEric Dumazet #endif 1613752d14dcSPavel Emelyanov kfree(net->ipv4.devconf_dflt); 1614752d14dcSPavel Emelyanov kfree(net->ipv4.devconf_all); 1615752d14dcSPavel Emelyanov } 1616752d14dcSPavel Emelyanov 1617752d14dcSPavel Emelyanov static __net_initdata struct pernet_operations devinet_ops = { 1618752d14dcSPavel Emelyanov .init = devinet_init_net, 1619752d14dcSPavel Emelyanov .exit = devinet_exit_net, 1620752d14dcSPavel Emelyanov }; 1621752d14dcSPavel Emelyanov 16221da177e4SLinus Torvalds void __init devinet_init(void) 16231da177e4SLinus Torvalds { 1624752d14dcSPavel Emelyanov register_pernet_subsys(&devinet_ops); 1625752d14dcSPavel Emelyanov 16261da177e4SLinus Torvalds register_gifconf(PF_INET, inet_gifconf); 16271da177e4SLinus Torvalds register_netdevice_notifier(&ip_netdev_notifier); 162863f3444fSThomas Graf 162963f3444fSThomas Graf rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL); 163063f3444fSThomas Graf rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL); 163163f3444fSThomas Graf rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr); 16321da177e4SLinus Torvalds } 16331da177e4SLinus Torvalds 1634