11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET3 IP device support routines. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: $Id: devinet.c,v 1.44 2001/10/31 21:55:54 davem Exp $ 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 71da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 81da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 91da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds * Derived from the IP parts of dev.c 1.0.19 1202c30a84SJesper Juhl * Authors: Ross Biro 131da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 141da177e4SLinus Torvalds * Mark Evans, <evansmp@uhura.aston.ac.uk> 151da177e4SLinus Torvalds * 161da177e4SLinus Torvalds * Additional Authors: 171da177e4SLinus Torvalds * Alan Cox, <gw4pts@gw4pts.ampr.org> 181da177e4SLinus Torvalds * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 191da177e4SLinus Torvalds * 201da177e4SLinus Torvalds * Changes: 211da177e4SLinus Torvalds * Alexey Kuznetsov: pa_* fields are replaced with ifaddr 221da177e4SLinus Torvalds * lists. 231da177e4SLinus Torvalds * Cyrus Durgin: updated for kmod 241da177e4SLinus Torvalds * Matthias Andree: in devinet_ioctl, compare label and 251da177e4SLinus Torvalds * address (4.4BSD alias style support), 261da177e4SLinus Torvalds * fall back to comparing just the label 271da177e4SLinus Torvalds * if no match found. 281da177e4SLinus Torvalds */ 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <asm/uaccess.h> 321da177e4SLinus Torvalds #include <asm/system.h> 331da177e4SLinus Torvalds #include <linux/bitops.h> 344fc268d2SRandy Dunlap #include <linux/capability.h> 351da177e4SLinus Torvalds #include <linux/module.h> 361da177e4SLinus Torvalds #include <linux/types.h> 371da177e4SLinus Torvalds #include <linux/kernel.h> 381da177e4SLinus Torvalds #include <linux/sched.h> 391da177e4SLinus Torvalds #include <linux/string.h> 401da177e4SLinus Torvalds #include <linux/mm.h> 411da177e4SLinus Torvalds #include <linux/socket.h> 421da177e4SLinus Torvalds #include <linux/sockios.h> 431da177e4SLinus Torvalds #include <linux/in.h> 441da177e4SLinus Torvalds #include <linux/errno.h> 451da177e4SLinus Torvalds #include <linux/interrupt.h> 461da177e4SLinus Torvalds #include <linux/if_ether.h> 471da177e4SLinus Torvalds #include <linux/inet.h> 481da177e4SLinus Torvalds #include <linux/netdevice.h> 491da177e4SLinus Torvalds #include <linux/etherdevice.h> 501da177e4SLinus Torvalds #include <linux/skbuff.h> 511da177e4SLinus Torvalds #include <linux/rtnetlink.h> 521da177e4SLinus Torvalds #include <linux/init.h> 531da177e4SLinus Torvalds #include <linux/notifier.h> 541da177e4SLinus Torvalds #include <linux/inetdevice.h> 551da177e4SLinus Torvalds #include <linux/igmp.h> 561da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 571da177e4SLinus Torvalds #include <linux/sysctl.h> 581da177e4SLinus Torvalds #endif 591da177e4SLinus Torvalds #include <linux/kmod.h> 601da177e4SLinus Torvalds 6114c85021SArnaldo Carvalho de Melo #include <net/arp.h> 621da177e4SLinus Torvalds #include <net/ip.h> 631da177e4SLinus Torvalds #include <net/route.h> 641da177e4SLinus Torvalds #include <net/ip_fib.h> 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds struct ipv4_devconf ipv4_devconf = { 671da177e4SLinus Torvalds .accept_redirects = 1, 681da177e4SLinus Torvalds .send_redirects = 1, 691da177e4SLinus Torvalds .secure_redirects = 1, 701da177e4SLinus Torvalds .shared_media = 1, 711da177e4SLinus Torvalds }; 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds static struct ipv4_devconf ipv4_devconf_dflt = { 741da177e4SLinus Torvalds .accept_redirects = 1, 751da177e4SLinus Torvalds .send_redirects = 1, 761da177e4SLinus Torvalds .secure_redirects = 1, 771da177e4SLinus Torvalds .shared_media = 1, 781da177e4SLinus Torvalds .accept_source_route = 1, 791da177e4SLinus Torvalds }; 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds static void rtmsg_ifa(int event, struct in_ifaddr *); 821da177e4SLinus Torvalds 83e041c683SAlan Stern static BLOCKING_NOTIFIER_HEAD(inetaddr_chain); 841da177e4SLinus Torvalds static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 851da177e4SLinus Torvalds int destroy); 861da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 871da177e4SLinus Torvalds static void devinet_sysctl_register(struct in_device *in_dev, 881da177e4SLinus Torvalds struct ipv4_devconf *p); 891da177e4SLinus Torvalds static void devinet_sysctl_unregister(struct ipv4_devconf *p); 901da177e4SLinus Torvalds #endif 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds /* Locks all the inet devices. */ 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds static struct in_ifaddr *inet_alloc_ifa(void) 951da177e4SLinus Torvalds { 96*0da974f4SPanagiotis Issaris struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL); 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds if (ifa) { 991da177e4SLinus Torvalds INIT_RCU_HEAD(&ifa->rcu_head); 1001da177e4SLinus Torvalds } 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds return ifa; 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds static void inet_rcu_free_ifa(struct rcu_head *head) 1061da177e4SLinus Torvalds { 1071da177e4SLinus Torvalds struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head); 1081da177e4SLinus Torvalds if (ifa->ifa_dev) 1091da177e4SLinus Torvalds in_dev_put(ifa->ifa_dev); 1101da177e4SLinus Torvalds kfree(ifa); 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static inline void inet_free_ifa(struct in_ifaddr *ifa) 1141da177e4SLinus Torvalds { 1151da177e4SLinus Torvalds call_rcu(&ifa->rcu_head, inet_rcu_free_ifa); 1161da177e4SLinus Torvalds } 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds void in_dev_finish_destroy(struct in_device *idev) 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds struct net_device *dev = idev->dev; 1211da177e4SLinus Torvalds 1221da177e4SLinus Torvalds BUG_TRAP(!idev->ifa_list); 1231da177e4SLinus Torvalds BUG_TRAP(!idev->mc_list); 1241da177e4SLinus Torvalds #ifdef NET_REFCNT_DEBUG 1251da177e4SLinus Torvalds printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", 1261da177e4SLinus Torvalds idev, dev ? dev->name : "NIL"); 1271da177e4SLinus Torvalds #endif 1281da177e4SLinus Torvalds dev_put(dev); 1291da177e4SLinus Torvalds if (!idev->dead) 1301da177e4SLinus Torvalds printk("Freeing alive in_device %p\n", idev); 1311da177e4SLinus Torvalds else { 1321da177e4SLinus Torvalds kfree(idev); 1331da177e4SLinus Torvalds } 1341da177e4SLinus Torvalds } 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds struct in_device *inetdev_init(struct net_device *dev) 1371da177e4SLinus Torvalds { 1381da177e4SLinus Torvalds struct in_device *in_dev; 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds ASSERT_RTNL(); 1411da177e4SLinus Torvalds 142*0da974f4SPanagiotis Issaris in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL); 1431da177e4SLinus Torvalds if (!in_dev) 1441da177e4SLinus Torvalds goto out; 1451da177e4SLinus Torvalds INIT_RCU_HEAD(&in_dev->rcu_head); 1461da177e4SLinus Torvalds memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf)); 1471da177e4SLinus Torvalds in_dev->cnf.sysctl = NULL; 1481da177e4SLinus Torvalds in_dev->dev = dev; 1491da177e4SLinus Torvalds if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL) 1501da177e4SLinus Torvalds goto out_kfree; 1511da177e4SLinus Torvalds /* Reference in_dev->dev */ 1521da177e4SLinus Torvalds dev_hold(dev); 1531da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 1541da177e4SLinus Torvalds neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 1551da177e4SLinus Torvalds NET_IPV4_NEIGH, "ipv4", NULL, NULL); 1561da177e4SLinus Torvalds #endif 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds /* Account for reference dev->ip_ptr */ 1591da177e4SLinus Torvalds in_dev_hold(in_dev); 1601da177e4SLinus Torvalds rcu_assign_pointer(dev->ip_ptr, in_dev); 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 1631da177e4SLinus Torvalds devinet_sysctl_register(in_dev, &in_dev->cnf); 1641da177e4SLinus Torvalds #endif 1651da177e4SLinus Torvalds ip_mc_init_dev(in_dev); 1661da177e4SLinus Torvalds if (dev->flags & IFF_UP) 1671da177e4SLinus Torvalds ip_mc_up(in_dev); 1681da177e4SLinus Torvalds out: 1691da177e4SLinus Torvalds return in_dev; 1701da177e4SLinus Torvalds out_kfree: 1711da177e4SLinus Torvalds kfree(in_dev); 1721da177e4SLinus Torvalds in_dev = NULL; 1731da177e4SLinus Torvalds goto out; 1741da177e4SLinus Torvalds } 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds static void in_dev_rcu_put(struct rcu_head *head) 1771da177e4SLinus Torvalds { 1781da177e4SLinus Torvalds struct in_device *idev = container_of(head, struct in_device, rcu_head); 1791da177e4SLinus Torvalds in_dev_put(idev); 1801da177e4SLinus Torvalds } 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds static void inetdev_destroy(struct in_device *in_dev) 1831da177e4SLinus Torvalds { 1841da177e4SLinus Torvalds struct in_ifaddr *ifa; 1851da177e4SLinus Torvalds struct net_device *dev; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds ASSERT_RTNL(); 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds dev = in_dev->dev; 1901da177e4SLinus Torvalds if (dev == &loopback_dev) 1911da177e4SLinus Torvalds return; 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds in_dev->dead = 1; 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds ip_mc_destroy_dev(in_dev); 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds while ((ifa = in_dev->ifa_list) != NULL) { 1981da177e4SLinus Torvalds inet_del_ifa(in_dev, &in_dev->ifa_list, 0); 1991da177e4SLinus Torvalds inet_free_ifa(ifa); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 2031da177e4SLinus Torvalds devinet_sysctl_unregister(&in_dev->cnf); 2041da177e4SLinus Torvalds #endif 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds dev->ip_ptr = NULL; 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 2091da177e4SLinus Torvalds neigh_sysctl_unregister(in_dev->arp_parms); 2101da177e4SLinus Torvalds #endif 2111da177e4SLinus Torvalds neigh_parms_release(&arp_tbl, in_dev->arp_parms); 2121da177e4SLinus Torvalds arp_ifdown(dev); 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds call_rcu(&in_dev->rcu_head, in_dev_rcu_put); 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b) 2181da177e4SLinus Torvalds { 2191da177e4SLinus Torvalds rcu_read_lock(); 2201da177e4SLinus Torvalds for_primary_ifa(in_dev) { 2211da177e4SLinus Torvalds if (inet_ifa_match(a, ifa)) { 2221da177e4SLinus Torvalds if (!b || inet_ifa_match(b, ifa)) { 2231da177e4SLinus Torvalds rcu_read_unlock(); 2241da177e4SLinus Torvalds return 1; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds } endfor_ifa(in_dev); 2281da177e4SLinus Torvalds rcu_read_unlock(); 2291da177e4SLinus Torvalds return 0; 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, 2331da177e4SLinus Torvalds int destroy) 2341da177e4SLinus Torvalds { 2358f937c60SHarald Welte struct in_ifaddr *promote = NULL; 2360ff60a45SJamal Hadi Salim struct in_ifaddr *ifa, *ifa1 = *ifap; 2370ff60a45SJamal Hadi Salim struct in_ifaddr *last_prim = in_dev->ifa_list; 2380ff60a45SJamal Hadi Salim struct in_ifaddr *prev_prom = NULL; 2390ff60a45SJamal Hadi Salim int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev); 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds ASSERT_RTNL(); 2421da177e4SLinus Torvalds 2438f937c60SHarald Welte /* 1. Deleting primary ifaddr forces deletion all secondaries 2448f937c60SHarald Welte * unless alias promotion is set 2458f937c60SHarald Welte **/ 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) { 2481da177e4SLinus Torvalds struct in_ifaddr **ifap1 = &ifa1->ifa_next; 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds while ((ifa = *ifap1) != NULL) { 2510ff60a45SJamal Hadi Salim if (!(ifa->ifa_flags & IFA_F_SECONDARY) && 2520ff60a45SJamal Hadi Salim ifa1->ifa_scope <= ifa->ifa_scope) 2530ff60a45SJamal Hadi Salim last_prim = ifa; 2540ff60a45SJamal Hadi Salim 2551da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY) || 2561da177e4SLinus Torvalds ifa1->ifa_mask != ifa->ifa_mask || 2571da177e4SLinus Torvalds !inet_ifa_match(ifa1->ifa_address, ifa)) { 2581da177e4SLinus Torvalds ifap1 = &ifa->ifa_next; 2590ff60a45SJamal Hadi Salim prev_prom = ifa; 2601da177e4SLinus Torvalds continue; 2611da177e4SLinus Torvalds } 2621da177e4SLinus Torvalds 2630ff60a45SJamal Hadi Salim if (!do_promote) { 2641da177e4SLinus Torvalds *ifap1 = ifa->ifa_next; 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds rtmsg_ifa(RTM_DELADDR, ifa); 267e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 268e041c683SAlan Stern NETDEV_DOWN, ifa); 2691da177e4SLinus Torvalds inet_free_ifa(ifa); 2708f937c60SHarald Welte } else { 2718f937c60SHarald Welte promote = ifa; 2728f937c60SHarald Welte break; 2738f937c60SHarald Welte } 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds /* 2. Unlink it */ 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds *ifap = ifa1->ifa_next; 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds /* 3. Announce address deletion */ 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds /* Send message first, then call notifier. 2841da177e4SLinus Torvalds At first sight, FIB update triggered by notifier 2851da177e4SLinus Torvalds will refer to already deleted ifaddr, that could confuse 2861da177e4SLinus Torvalds netlink listeners. It is not true: look, gated sees 2871da177e4SLinus Torvalds that route deleted and if it still thinks that ifaddr 2881da177e4SLinus Torvalds is valid, it will try to restore deleted routes... Grr. 2891da177e4SLinus Torvalds So that, this order is correct. 2901da177e4SLinus Torvalds */ 2911da177e4SLinus Torvalds rtmsg_ifa(RTM_DELADDR, ifa1); 292e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1); 2930ff60a45SJamal Hadi Salim 2940ff60a45SJamal Hadi Salim if (promote) { 2950ff60a45SJamal Hadi Salim 2960ff60a45SJamal Hadi Salim if (prev_prom) { 2970ff60a45SJamal Hadi Salim prev_prom->ifa_next = promote->ifa_next; 2980ff60a45SJamal Hadi Salim promote->ifa_next = last_prim->ifa_next; 2990ff60a45SJamal Hadi Salim last_prim->ifa_next = promote; 3000ff60a45SJamal Hadi Salim } 3010ff60a45SJamal Hadi Salim 3020ff60a45SJamal Hadi Salim promote->ifa_flags &= ~IFA_F_SECONDARY; 3030ff60a45SJamal Hadi Salim rtmsg_ifa(RTM_NEWADDR, promote); 304e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, 305e041c683SAlan Stern NETDEV_UP, promote); 3060ff60a45SJamal Hadi Salim for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) { 3070ff60a45SJamal Hadi Salim if (ifa1->ifa_mask != ifa->ifa_mask || 3080ff60a45SJamal Hadi Salim !inet_ifa_match(ifa1->ifa_address, ifa)) 3090ff60a45SJamal Hadi Salim continue; 3100ff60a45SJamal Hadi Salim fib_add_ifaddr(ifa); 3110ff60a45SJamal Hadi Salim } 3120ff60a45SJamal Hadi Salim 3130ff60a45SJamal Hadi Salim } 3141da177e4SLinus Torvalds if (destroy) { 3151da177e4SLinus Torvalds inet_free_ifa(ifa1); 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds if (!in_dev->ifa_list) 3181da177e4SLinus Torvalds inetdev_destroy(in_dev); 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds static int inet_insert_ifa(struct in_ifaddr *ifa) 3231da177e4SLinus Torvalds { 3241da177e4SLinus Torvalds struct in_device *in_dev = ifa->ifa_dev; 3251da177e4SLinus Torvalds struct in_ifaddr *ifa1, **ifap, **last_primary; 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds ASSERT_RTNL(); 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds if (!ifa->ifa_local) { 3301da177e4SLinus Torvalds inet_free_ifa(ifa); 3311da177e4SLinus Torvalds return 0; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds ifa->ifa_flags &= ~IFA_F_SECONDARY; 3351da177e4SLinus Torvalds last_primary = &in_dev->ifa_list; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL; 3381da177e4SLinus Torvalds ifap = &ifa1->ifa_next) { 3391da177e4SLinus Torvalds if (!(ifa1->ifa_flags & IFA_F_SECONDARY) && 3401da177e4SLinus Torvalds ifa->ifa_scope <= ifa1->ifa_scope) 3411da177e4SLinus Torvalds last_primary = &ifa1->ifa_next; 3421da177e4SLinus Torvalds if (ifa1->ifa_mask == ifa->ifa_mask && 3431da177e4SLinus Torvalds inet_ifa_match(ifa1->ifa_address, ifa)) { 3441da177e4SLinus Torvalds if (ifa1->ifa_local == ifa->ifa_local) { 3451da177e4SLinus Torvalds inet_free_ifa(ifa); 3461da177e4SLinus Torvalds return -EEXIST; 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds if (ifa1->ifa_scope != ifa->ifa_scope) { 3491da177e4SLinus Torvalds inet_free_ifa(ifa); 3501da177e4SLinus Torvalds return -EINVAL; 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds ifa->ifa_flags |= IFA_F_SECONDARY; 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds if (!(ifa->ifa_flags & IFA_F_SECONDARY)) { 3571da177e4SLinus Torvalds net_srandom(ifa->ifa_local); 3581da177e4SLinus Torvalds ifap = last_primary; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds ifa->ifa_next = *ifap; 3621da177e4SLinus Torvalds *ifap = ifa; 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds /* Send message first, then call notifier. 3651da177e4SLinus Torvalds Notifier will trigger FIB update, so that 3661da177e4SLinus Torvalds listeners of netlink will know about new ifaddr */ 3671da177e4SLinus Torvalds rtmsg_ifa(RTM_NEWADDR, ifa); 368e041c683SAlan Stern blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa); 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds return 0; 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa) 3741da177e4SLinus Torvalds { 375e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds ASSERT_RTNL(); 3781da177e4SLinus Torvalds 3791da177e4SLinus Torvalds if (!in_dev) { 3801da177e4SLinus Torvalds in_dev = inetdev_init(dev); 3811da177e4SLinus Torvalds if (!in_dev) { 3821da177e4SLinus Torvalds inet_free_ifa(ifa); 3831da177e4SLinus Torvalds return -ENOBUFS; 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds if (ifa->ifa_dev != in_dev) { 3871da177e4SLinus Torvalds BUG_TRAP(!ifa->ifa_dev); 3881da177e4SLinus Torvalds in_dev_hold(in_dev); 3891da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds if (LOOPBACK(ifa->ifa_local)) 3921da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 3931da177e4SLinus Torvalds return inet_insert_ifa(ifa); 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds struct in_device *inetdev_by_index(int ifindex) 3971da177e4SLinus Torvalds { 3981da177e4SLinus Torvalds struct net_device *dev; 3991da177e4SLinus Torvalds struct in_device *in_dev = NULL; 4001da177e4SLinus Torvalds read_lock(&dev_base_lock); 4011da177e4SLinus Torvalds dev = __dev_get_by_index(ifindex); 4021da177e4SLinus Torvalds if (dev) 4031da177e4SLinus Torvalds in_dev = in_dev_get(dev); 4041da177e4SLinus Torvalds read_unlock(&dev_base_lock); 4051da177e4SLinus Torvalds return in_dev; 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds /* Called only from RTNL semaphored context. No locks. */ 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix, 4111da177e4SLinus Torvalds u32 mask) 4121da177e4SLinus Torvalds { 4131da177e4SLinus Torvalds ASSERT_RTNL(); 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds for_primary_ifa(in_dev) { 4161da177e4SLinus Torvalds if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa)) 4171da177e4SLinus Torvalds return ifa; 4181da177e4SLinus Torvalds } endfor_ifa(in_dev); 4191da177e4SLinus Torvalds return NULL; 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 4231da177e4SLinus Torvalds { 4241da177e4SLinus Torvalds struct rtattr **rta = arg; 4251da177e4SLinus Torvalds struct in_device *in_dev; 4261da177e4SLinus Torvalds struct ifaddrmsg *ifm = NLMSG_DATA(nlh); 4271da177e4SLinus Torvalds struct in_ifaddr *ifa, **ifap; 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds ASSERT_RTNL(); 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL) 4321da177e4SLinus Torvalds goto out; 4331da177e4SLinus Torvalds __in_dev_put(in_dev); 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 4361da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 4371da177e4SLinus Torvalds if ((rta[IFA_LOCAL - 1] && 4381da177e4SLinus Torvalds memcmp(RTA_DATA(rta[IFA_LOCAL - 1]), 4391da177e4SLinus Torvalds &ifa->ifa_local, 4)) || 4401da177e4SLinus Torvalds (rta[IFA_LABEL - 1] && 4411da177e4SLinus Torvalds rtattr_strcmp(rta[IFA_LABEL - 1], ifa->ifa_label)) || 4421da177e4SLinus Torvalds (rta[IFA_ADDRESS - 1] && 4431da177e4SLinus Torvalds (ifm->ifa_prefixlen != ifa->ifa_prefixlen || 4441da177e4SLinus Torvalds !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]), 4451da177e4SLinus Torvalds ifa)))) 4461da177e4SLinus Torvalds continue; 4471da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 1); 4481da177e4SLinus Torvalds return 0; 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds out: 4511da177e4SLinus Torvalds return -EADDRNOTAVAIL; 4521da177e4SLinus Torvalds } 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 4551da177e4SLinus Torvalds { 4561da177e4SLinus Torvalds struct rtattr **rta = arg; 4571da177e4SLinus Torvalds struct net_device *dev; 4581da177e4SLinus Torvalds struct in_device *in_dev; 4591da177e4SLinus Torvalds struct ifaddrmsg *ifm = NLMSG_DATA(nlh); 4601da177e4SLinus Torvalds struct in_ifaddr *ifa; 4611da177e4SLinus Torvalds int rc = -EINVAL; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds ASSERT_RTNL(); 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1]) 4661da177e4SLinus Torvalds goto out; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds rc = -ENODEV; 4691da177e4SLinus Torvalds if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL) 4701da177e4SLinus Torvalds goto out; 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds rc = -ENOBUFS; 473e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) { 4741da177e4SLinus Torvalds in_dev = inetdev_init(dev); 4751da177e4SLinus Torvalds if (!in_dev) 4761da177e4SLinus Torvalds goto out; 4771da177e4SLinus Torvalds } 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) == NULL) 4801da177e4SLinus Torvalds goto out; 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds if (!rta[IFA_ADDRESS - 1]) 4831da177e4SLinus Torvalds rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1]; 4841da177e4SLinus Torvalds memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4); 4851da177e4SLinus Torvalds memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4); 4861da177e4SLinus Torvalds ifa->ifa_prefixlen = ifm->ifa_prefixlen; 4871da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen); 4881da177e4SLinus Torvalds if (rta[IFA_BROADCAST - 1]) 4891da177e4SLinus Torvalds memcpy(&ifa->ifa_broadcast, 4901da177e4SLinus Torvalds RTA_DATA(rta[IFA_BROADCAST - 1]), 4); 4911da177e4SLinus Torvalds if (rta[IFA_ANYCAST - 1]) 4921da177e4SLinus Torvalds memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4); 4931da177e4SLinus Torvalds ifa->ifa_flags = ifm->ifa_flags; 4941da177e4SLinus Torvalds ifa->ifa_scope = ifm->ifa_scope; 4951da177e4SLinus Torvalds in_dev_hold(in_dev); 4961da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 4971da177e4SLinus Torvalds if (rta[IFA_LABEL - 1]) 4981da177e4SLinus Torvalds rtattr_strlcpy(ifa->ifa_label, rta[IFA_LABEL - 1], IFNAMSIZ); 4991da177e4SLinus Torvalds else 5001da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds rc = inet_insert_ifa(ifa); 5031da177e4SLinus Torvalds out: 5041da177e4SLinus Torvalds return rc; 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds /* 5081da177e4SLinus Torvalds * Determine a default network mask, based on the IP address. 5091da177e4SLinus Torvalds */ 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds static __inline__ int inet_abc_len(u32 addr) 5121da177e4SLinus Torvalds { 5131da177e4SLinus Torvalds int rc = -1; /* Something else, probably a multicast. */ 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds if (ZERONET(addr)) 5161da177e4SLinus Torvalds rc = 0; 5171da177e4SLinus Torvalds else { 5181da177e4SLinus Torvalds addr = ntohl(addr); 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds if (IN_CLASSA(addr)) 5211da177e4SLinus Torvalds rc = 8; 5221da177e4SLinus Torvalds else if (IN_CLASSB(addr)) 5231da177e4SLinus Torvalds rc = 16; 5241da177e4SLinus Torvalds else if (IN_CLASSC(addr)) 5251da177e4SLinus Torvalds rc = 24; 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds return rc; 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds int devinet_ioctl(unsigned int cmd, void __user *arg) 5331da177e4SLinus Torvalds { 5341da177e4SLinus Torvalds struct ifreq ifr; 5351da177e4SLinus Torvalds struct sockaddr_in sin_orig; 5361da177e4SLinus Torvalds struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr; 5371da177e4SLinus Torvalds struct in_device *in_dev; 5381da177e4SLinus Torvalds struct in_ifaddr **ifap = NULL; 5391da177e4SLinus Torvalds struct in_ifaddr *ifa = NULL; 5401da177e4SLinus Torvalds struct net_device *dev; 5411da177e4SLinus Torvalds char *colon; 5421da177e4SLinus Torvalds int ret = -EFAULT; 5431da177e4SLinus Torvalds int tryaddrmatch = 0; 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds /* 5461da177e4SLinus Torvalds * Fetch the caller's info block into kernel space 5471da177e4SLinus Torvalds */ 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 5501da177e4SLinus Torvalds goto out; 5511da177e4SLinus Torvalds ifr.ifr_name[IFNAMSIZ - 1] = 0; 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds /* save original address for comparison */ 5541da177e4SLinus Torvalds memcpy(&sin_orig, sin, sizeof(*sin)); 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds colon = strchr(ifr.ifr_name, ':'); 5571da177e4SLinus Torvalds if (colon) 5581da177e4SLinus Torvalds *colon = 0; 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds #ifdef CONFIG_KMOD 5611da177e4SLinus Torvalds dev_load(ifr.ifr_name); 5621da177e4SLinus Torvalds #endif 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds switch(cmd) { 5651da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 5661da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 5671da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 5681da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 5691da177e4SLinus Torvalds /* Note that these ioctls will not sleep, 5701da177e4SLinus Torvalds so that we do not impose a lock. 5711da177e4SLinus Torvalds One day we will be forced to put shlock here (I mean SMP) 5721da177e4SLinus Torvalds */ 5731da177e4SLinus Torvalds tryaddrmatch = (sin_orig.sin_family == AF_INET); 5741da177e4SLinus Torvalds memset(sin, 0, sizeof(*sin)); 5751da177e4SLinus Torvalds sin->sin_family = AF_INET; 5761da177e4SLinus Torvalds break; 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds case SIOCSIFFLAGS: 5791da177e4SLinus Torvalds ret = -EACCES; 5801da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 5811da177e4SLinus Torvalds goto out; 5821da177e4SLinus Torvalds break; 5831da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 5841da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 5851da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 5861da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 5871da177e4SLinus Torvalds ret = -EACCES; 5881da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) 5891da177e4SLinus Torvalds goto out; 5901da177e4SLinus Torvalds ret = -EINVAL; 5911da177e4SLinus Torvalds if (sin->sin_family != AF_INET) 5921da177e4SLinus Torvalds goto out; 5931da177e4SLinus Torvalds break; 5941da177e4SLinus Torvalds default: 5951da177e4SLinus Torvalds ret = -EINVAL; 5961da177e4SLinus Torvalds goto out; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds rtnl_lock(); 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds ret = -ENODEV; 6021da177e4SLinus Torvalds if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL) 6031da177e4SLinus Torvalds goto done; 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds if (colon) 6061da177e4SLinus Torvalds *colon = ':'; 6071da177e4SLinus Torvalds 608e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 6091da177e4SLinus Torvalds if (tryaddrmatch) { 6101da177e4SLinus Torvalds /* Matthias Andree */ 6111da177e4SLinus Torvalds /* compare label and address (4.4BSD style) */ 6121da177e4SLinus Torvalds /* note: we only do this for a limited set of ioctls 6131da177e4SLinus Torvalds and only if the original address family was AF_INET. 6141da177e4SLinus Torvalds This is checked above. */ 6151da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6161da177e4SLinus Torvalds ifap = &ifa->ifa_next) { 6171da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label) && 6181da177e4SLinus Torvalds sin_orig.sin_addr.s_addr == 6191da177e4SLinus Torvalds ifa->ifa_address) { 6201da177e4SLinus Torvalds break; /* found */ 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds /* we didn't get a match, maybe the application is 6251da177e4SLinus Torvalds 4.3BSD-style and passed in junk so we fall back to 6261da177e4SLinus Torvalds comparing just the label */ 6271da177e4SLinus Torvalds if (!ifa) { 6281da177e4SLinus Torvalds for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; 6291da177e4SLinus Torvalds ifap = &ifa->ifa_next) 6301da177e4SLinus Torvalds if (!strcmp(ifr.ifr_name, ifa->ifa_label)) 6311da177e4SLinus Torvalds break; 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 6361da177e4SLinus Torvalds if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) 6371da177e4SLinus Torvalds goto done; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds switch(cmd) { 6401da177e4SLinus Torvalds case SIOCGIFADDR: /* Get interface address */ 6411da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_local; 6421da177e4SLinus Torvalds goto rarok; 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds case SIOCGIFBRDADDR: /* Get the broadcast address */ 6451da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_broadcast; 6461da177e4SLinus Torvalds goto rarok; 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds case SIOCGIFDSTADDR: /* Get the destination address */ 6491da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_address; 6501da177e4SLinus Torvalds goto rarok; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds case SIOCGIFNETMASK: /* Get the netmask for the interface */ 6531da177e4SLinus Torvalds sin->sin_addr.s_addr = ifa->ifa_mask; 6541da177e4SLinus Torvalds goto rarok; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds case SIOCSIFFLAGS: 6571da177e4SLinus Torvalds if (colon) { 6581da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 6591da177e4SLinus Torvalds if (!ifa) 6601da177e4SLinus Torvalds break; 6611da177e4SLinus Torvalds ret = 0; 6621da177e4SLinus Torvalds if (!(ifr.ifr_flags & IFF_UP)) 6631da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 1); 6641da177e4SLinus Torvalds break; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds ret = dev_change_flags(dev, ifr.ifr_flags); 6671da177e4SLinus Torvalds break; 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds case SIOCSIFADDR: /* Set interface address (and family) */ 6701da177e4SLinus Torvalds ret = -EINVAL; 6711da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 6721da177e4SLinus Torvalds break; 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds if (!ifa) { 6751da177e4SLinus Torvalds ret = -ENOBUFS; 6761da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) == NULL) 6771da177e4SLinus Torvalds break; 6781da177e4SLinus Torvalds if (colon) 6791da177e4SLinus Torvalds memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ); 6801da177e4SLinus Torvalds else 6811da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 6821da177e4SLinus Torvalds } else { 6831da177e4SLinus Torvalds ret = 0; 6841da177e4SLinus Torvalds if (ifa->ifa_local == sin->sin_addr.s_addr) 6851da177e4SLinus Torvalds break; 6861da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 6871da177e4SLinus Torvalds ifa->ifa_broadcast = 0; 6881da177e4SLinus Torvalds ifa->ifa_anycast = 0; 6891da177e4SLinus Torvalds } 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr; 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds if (!(dev->flags & IFF_POINTOPOINT)) { 6941da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address); 6951da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen); 6961da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 6971da177e4SLinus Torvalds ifa->ifa_prefixlen < 31) 6981da177e4SLinus Torvalds ifa->ifa_broadcast = ifa->ifa_address | 6991da177e4SLinus Torvalds ~ifa->ifa_mask; 7001da177e4SLinus Torvalds } else { 7011da177e4SLinus Torvalds ifa->ifa_prefixlen = 32; 7021da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(32); 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds ret = inet_set_ifa(dev, ifa); 7051da177e4SLinus Torvalds break; 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds case SIOCSIFBRDADDR: /* Set the broadcast address */ 7081da177e4SLinus Torvalds ret = 0; 7091da177e4SLinus Torvalds if (ifa->ifa_broadcast != sin->sin_addr.s_addr) { 7101da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7111da177e4SLinus Torvalds ifa->ifa_broadcast = sin->sin_addr.s_addr; 7121da177e4SLinus Torvalds inet_insert_ifa(ifa); 7131da177e4SLinus Torvalds } 7141da177e4SLinus Torvalds break; 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds case SIOCSIFDSTADDR: /* Set the destination address */ 7171da177e4SLinus Torvalds ret = 0; 7181da177e4SLinus Torvalds if (ifa->ifa_address == sin->sin_addr.s_addr) 7191da177e4SLinus Torvalds break; 7201da177e4SLinus Torvalds ret = -EINVAL; 7211da177e4SLinus Torvalds if (inet_abc_len(sin->sin_addr.s_addr) < 0) 7221da177e4SLinus Torvalds break; 7231da177e4SLinus Torvalds ret = 0; 7241da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7251da177e4SLinus Torvalds ifa->ifa_address = sin->sin_addr.s_addr; 7261da177e4SLinus Torvalds inet_insert_ifa(ifa); 7271da177e4SLinus Torvalds break; 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds case SIOCSIFNETMASK: /* Set the netmask for the interface */ 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds /* 7321da177e4SLinus Torvalds * The mask we set must be legal. 7331da177e4SLinus Torvalds */ 7341da177e4SLinus Torvalds ret = -EINVAL; 7351da177e4SLinus Torvalds if (bad_mask(sin->sin_addr.s_addr, 0)) 7361da177e4SLinus Torvalds break; 7371da177e4SLinus Torvalds ret = 0; 7381da177e4SLinus Torvalds if (ifa->ifa_mask != sin->sin_addr.s_addr) { 739dcab5e1eSDavid Engel u32 old_mask = ifa->ifa_mask; 7401da177e4SLinus Torvalds inet_del_ifa(in_dev, ifap, 0); 7411da177e4SLinus Torvalds ifa->ifa_mask = sin->sin_addr.s_addr; 7421da177e4SLinus Torvalds ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask); 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds /* See if current broadcast address matches 7451da177e4SLinus Torvalds * with current netmask, then recalculate 7461da177e4SLinus Torvalds * the broadcast address. Otherwise it's a 7471da177e4SLinus Torvalds * funny address, so don't touch it since 7481da177e4SLinus Torvalds * the user seems to know what (s)he's doing... 7491da177e4SLinus Torvalds */ 7501da177e4SLinus Torvalds if ((dev->flags & IFF_BROADCAST) && 7511da177e4SLinus Torvalds (ifa->ifa_prefixlen < 31) && 7521da177e4SLinus Torvalds (ifa->ifa_broadcast == 753dcab5e1eSDavid Engel (ifa->ifa_local|~old_mask))) { 7541da177e4SLinus Torvalds ifa->ifa_broadcast = (ifa->ifa_local | 7551da177e4SLinus Torvalds ~sin->sin_addr.s_addr); 7561da177e4SLinus Torvalds } 7571da177e4SLinus Torvalds inet_insert_ifa(ifa); 7581da177e4SLinus Torvalds } 7591da177e4SLinus Torvalds break; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds done: 7621da177e4SLinus Torvalds rtnl_unlock(); 7631da177e4SLinus Torvalds out: 7641da177e4SLinus Torvalds return ret; 7651da177e4SLinus Torvalds rarok: 7661da177e4SLinus Torvalds rtnl_unlock(); 7671da177e4SLinus Torvalds ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0; 7681da177e4SLinus Torvalds goto out; 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds static int inet_gifconf(struct net_device *dev, char __user *buf, int len) 7721da177e4SLinus Torvalds { 773e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 7741da177e4SLinus Torvalds struct in_ifaddr *ifa; 7751da177e4SLinus Torvalds struct ifreq ifr; 7761da177e4SLinus Torvalds int done = 0; 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds if (!in_dev || (ifa = in_dev->ifa_list) == NULL) 7791da177e4SLinus Torvalds goto out; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds for (; ifa; ifa = ifa->ifa_next) { 7821da177e4SLinus Torvalds if (!buf) { 7831da177e4SLinus Torvalds done += sizeof(ifr); 7841da177e4SLinus Torvalds continue; 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds if (len < (int) sizeof(ifr)) 7871da177e4SLinus Torvalds break; 7881da177e4SLinus Torvalds memset(&ifr, 0, sizeof(struct ifreq)); 7891da177e4SLinus Torvalds if (ifa->ifa_label) 7901da177e4SLinus Torvalds strcpy(ifr.ifr_name, ifa->ifa_label); 7911da177e4SLinus Torvalds else 7921da177e4SLinus Torvalds strcpy(ifr.ifr_name, dev->name); 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET; 7951da177e4SLinus Torvalds (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr = 7961da177e4SLinus Torvalds ifa->ifa_local; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) { 7991da177e4SLinus Torvalds done = -EFAULT; 8001da177e4SLinus Torvalds break; 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds buf += sizeof(struct ifreq); 8031da177e4SLinus Torvalds len -= sizeof(struct ifreq); 8041da177e4SLinus Torvalds done += sizeof(struct ifreq); 8051da177e4SLinus Torvalds } 8061da177e4SLinus Torvalds out: 8071da177e4SLinus Torvalds return done; 8081da177e4SLinus Torvalds } 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope) 8111da177e4SLinus Torvalds { 8121da177e4SLinus Torvalds u32 addr = 0; 8131da177e4SLinus Torvalds struct in_device *in_dev; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds rcu_read_lock(); 816e5ed6399SHerbert Xu in_dev = __in_dev_get_rcu(dev); 8171da177e4SLinus Torvalds if (!in_dev) 8181da177e4SLinus Torvalds goto no_in_dev; 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8211da177e4SLinus Torvalds if (ifa->ifa_scope > scope) 8221da177e4SLinus Torvalds continue; 8231da177e4SLinus Torvalds if (!dst || inet_ifa_match(dst, ifa)) { 8241da177e4SLinus Torvalds addr = ifa->ifa_local; 8251da177e4SLinus Torvalds break; 8261da177e4SLinus Torvalds } 8271da177e4SLinus Torvalds if (!addr) 8281da177e4SLinus Torvalds addr = ifa->ifa_local; 8291da177e4SLinus Torvalds } endfor_ifa(in_dev); 8301da177e4SLinus Torvalds no_in_dev: 8311da177e4SLinus Torvalds rcu_read_unlock(); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds if (addr) 8341da177e4SLinus Torvalds goto out; 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds /* Not loopback addresses on loopback should be preferred 8371da177e4SLinus Torvalds in this case. It is importnat that lo is the first interface 8381da177e4SLinus Torvalds in dev_base list. 8391da177e4SLinus Torvalds */ 8401da177e4SLinus Torvalds read_lock(&dev_base_lock); 8411da177e4SLinus Torvalds rcu_read_lock(); 8421da177e4SLinus Torvalds for (dev = dev_base; dev; dev = dev->next) { 843e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev)) == NULL) 8441da177e4SLinus Torvalds continue; 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds for_primary_ifa(in_dev) { 8471da177e4SLinus Torvalds if (ifa->ifa_scope != RT_SCOPE_LINK && 8481da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 8491da177e4SLinus Torvalds addr = ifa->ifa_local; 8501da177e4SLinus Torvalds goto out_unlock_both; 8511da177e4SLinus Torvalds } 8521da177e4SLinus Torvalds } endfor_ifa(in_dev); 8531da177e4SLinus Torvalds } 8541da177e4SLinus Torvalds out_unlock_both: 8551da177e4SLinus Torvalds read_unlock(&dev_base_lock); 8561da177e4SLinus Torvalds rcu_read_unlock(); 8571da177e4SLinus Torvalds out: 8581da177e4SLinus Torvalds return addr; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst, 8621da177e4SLinus Torvalds u32 local, int scope) 8631da177e4SLinus Torvalds { 8641da177e4SLinus Torvalds int same = 0; 8651da177e4SLinus Torvalds u32 addr = 0; 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds for_ifa(in_dev) { 8681da177e4SLinus Torvalds if (!addr && 8691da177e4SLinus Torvalds (local == ifa->ifa_local || !local) && 8701da177e4SLinus Torvalds ifa->ifa_scope <= scope) { 8711da177e4SLinus Torvalds addr = ifa->ifa_local; 8721da177e4SLinus Torvalds if (same) 8731da177e4SLinus Torvalds break; 8741da177e4SLinus Torvalds } 8751da177e4SLinus Torvalds if (!same) { 8761da177e4SLinus Torvalds same = (!local || inet_ifa_match(local, ifa)) && 8771da177e4SLinus Torvalds (!dst || inet_ifa_match(dst, ifa)); 8781da177e4SLinus Torvalds if (same && addr) { 8791da177e4SLinus Torvalds if (local || !dst) 8801da177e4SLinus Torvalds break; 8811da177e4SLinus Torvalds /* Is the selected addr into dst subnet? */ 8821da177e4SLinus Torvalds if (inet_ifa_match(addr, ifa)) 8831da177e4SLinus Torvalds break; 8841da177e4SLinus Torvalds /* No, then can we use new local src? */ 8851da177e4SLinus Torvalds if (ifa->ifa_scope <= scope) { 8861da177e4SLinus Torvalds addr = ifa->ifa_local; 8871da177e4SLinus Torvalds break; 8881da177e4SLinus Torvalds } 8891da177e4SLinus Torvalds /* search for large dst subnet for addr */ 8901da177e4SLinus Torvalds same = 0; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds } 8931da177e4SLinus Torvalds } endfor_ifa(in_dev); 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds return same? addr : 0; 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds /* 8991da177e4SLinus Torvalds * Confirm that local IP address exists using wildcards: 9001da177e4SLinus Torvalds * - dev: only on this interface, 0=any interface 9011da177e4SLinus Torvalds * - dst: only in the same subnet as dst, 0=any dst 9021da177e4SLinus Torvalds * - local: address, 0=autoselect the local address 9031da177e4SLinus Torvalds * - scope: maximum allowed scope value for the local address 9041da177e4SLinus Torvalds */ 9051da177e4SLinus Torvalds u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope) 9061da177e4SLinus Torvalds { 9071da177e4SLinus Torvalds u32 addr = 0; 9081da177e4SLinus Torvalds struct in_device *in_dev; 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds if (dev) { 9111da177e4SLinus Torvalds rcu_read_lock(); 912e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev))) 9131da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9141da177e4SLinus Torvalds rcu_read_unlock(); 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds return addr; 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds read_lock(&dev_base_lock); 9201da177e4SLinus Torvalds rcu_read_lock(); 9211da177e4SLinus Torvalds for (dev = dev_base; dev; dev = dev->next) { 922e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev))) { 9231da177e4SLinus Torvalds addr = confirm_addr_indev(in_dev, dst, local, scope); 9241da177e4SLinus Torvalds if (addr) 9251da177e4SLinus Torvalds break; 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds rcu_read_unlock(); 9291da177e4SLinus Torvalds read_unlock(&dev_base_lock); 9301da177e4SLinus Torvalds 9311da177e4SLinus Torvalds return addr; 9321da177e4SLinus Torvalds } 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds /* 9351da177e4SLinus Torvalds * Device notifier 9361da177e4SLinus Torvalds */ 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds int register_inetaddr_notifier(struct notifier_block *nb) 9391da177e4SLinus Torvalds { 940e041c683SAlan Stern return blocking_notifier_chain_register(&inetaddr_chain, nb); 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds int unregister_inetaddr_notifier(struct notifier_block *nb) 9441da177e4SLinus Torvalds { 945e041c683SAlan Stern return blocking_notifier_chain_unregister(&inetaddr_chain, nb); 9461da177e4SLinus Torvalds } 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds /* Rename ifa_labels for a device name change. Make some effort to preserve existing 9491da177e4SLinus Torvalds * alias numbering and to create unique labels if possible. 9501da177e4SLinus Torvalds */ 9511da177e4SLinus Torvalds static void inetdev_changename(struct net_device *dev, struct in_device *in_dev) 9521da177e4SLinus Torvalds { 9531da177e4SLinus Torvalds struct in_ifaddr *ifa; 9541da177e4SLinus Torvalds int named = 0; 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) { 9571da177e4SLinus Torvalds char old[IFNAMSIZ], *dot; 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds memcpy(old, ifa->ifa_label, IFNAMSIZ); 9601da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 9611da177e4SLinus Torvalds if (named++ == 0) 9621da177e4SLinus Torvalds continue; 9631da177e4SLinus Torvalds dot = strchr(ifa->ifa_label, ':'); 9641da177e4SLinus Torvalds if (dot == NULL) { 9651da177e4SLinus Torvalds sprintf(old, ":%d", named); 9661da177e4SLinus Torvalds dot = old; 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) { 9691da177e4SLinus Torvalds strcat(ifa->ifa_label, dot); 9701da177e4SLinus Torvalds } else { 9711da177e4SLinus Torvalds strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot); 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds } 9741da177e4SLinus Torvalds } 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds /* Called only under RTNL semaphore */ 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds static int inetdev_event(struct notifier_block *this, unsigned long event, 9791da177e4SLinus Torvalds void *ptr) 9801da177e4SLinus Torvalds { 9811da177e4SLinus Torvalds struct net_device *dev = ptr; 982e5ed6399SHerbert Xu struct in_device *in_dev = __in_dev_get_rtnl(dev); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds ASSERT_RTNL(); 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds if (!in_dev) { 9871da177e4SLinus Torvalds if (event == NETDEV_REGISTER && dev == &loopback_dev) { 9881da177e4SLinus Torvalds in_dev = inetdev_init(dev); 9891da177e4SLinus Torvalds if (!in_dev) 9901da177e4SLinus Torvalds panic("devinet: Failed to create loopback\n"); 9911da177e4SLinus Torvalds in_dev->cnf.no_xfrm = 1; 9921da177e4SLinus Torvalds in_dev->cnf.no_policy = 1; 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds goto out; 9951da177e4SLinus Torvalds } 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds switch (event) { 9981da177e4SLinus Torvalds case NETDEV_REGISTER: 9991da177e4SLinus Torvalds printk(KERN_DEBUG "inetdev_event: bug\n"); 10001da177e4SLinus Torvalds dev->ip_ptr = NULL; 10011da177e4SLinus Torvalds break; 10021da177e4SLinus Torvalds case NETDEV_UP: 10031da177e4SLinus Torvalds if (dev->mtu < 68) 10041da177e4SLinus Torvalds break; 10051da177e4SLinus Torvalds if (dev == &loopback_dev) { 10061da177e4SLinus Torvalds struct in_ifaddr *ifa; 10071da177e4SLinus Torvalds if ((ifa = inet_alloc_ifa()) != NULL) { 10081da177e4SLinus Torvalds ifa->ifa_local = 10091da177e4SLinus Torvalds ifa->ifa_address = htonl(INADDR_LOOPBACK); 10101da177e4SLinus Torvalds ifa->ifa_prefixlen = 8; 10111da177e4SLinus Torvalds ifa->ifa_mask = inet_make_mask(8); 10121da177e4SLinus Torvalds in_dev_hold(in_dev); 10131da177e4SLinus Torvalds ifa->ifa_dev = in_dev; 10141da177e4SLinus Torvalds ifa->ifa_scope = RT_SCOPE_HOST; 10151da177e4SLinus Torvalds memcpy(ifa->ifa_label, dev->name, IFNAMSIZ); 10161da177e4SLinus Torvalds inet_insert_ifa(ifa); 10171da177e4SLinus Torvalds } 10181da177e4SLinus Torvalds } 10191da177e4SLinus Torvalds ip_mc_up(in_dev); 10201da177e4SLinus Torvalds break; 10211da177e4SLinus Torvalds case NETDEV_DOWN: 10221da177e4SLinus Torvalds ip_mc_down(in_dev); 10231da177e4SLinus Torvalds break; 10241da177e4SLinus Torvalds case NETDEV_CHANGEMTU: 10251da177e4SLinus Torvalds if (dev->mtu >= 68) 10261da177e4SLinus Torvalds break; 10271da177e4SLinus Torvalds /* MTU falled under 68, disable IP */ 10281da177e4SLinus Torvalds case NETDEV_UNREGISTER: 10291da177e4SLinus Torvalds inetdev_destroy(in_dev); 10301da177e4SLinus Torvalds break; 10311da177e4SLinus Torvalds case NETDEV_CHANGENAME: 10321da177e4SLinus Torvalds /* Do not notify about label change, this event is 10331da177e4SLinus Torvalds * not interesting to applications using netlink. 10341da177e4SLinus Torvalds */ 10351da177e4SLinus Torvalds inetdev_changename(dev, in_dev); 10361da177e4SLinus Torvalds 10371da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 10381da177e4SLinus Torvalds devinet_sysctl_unregister(&in_dev->cnf); 10391da177e4SLinus Torvalds neigh_sysctl_unregister(in_dev->arp_parms); 10401da177e4SLinus Torvalds neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, 10411da177e4SLinus Torvalds NET_IPV4_NEIGH, "ipv4", NULL, NULL); 10421da177e4SLinus Torvalds devinet_sysctl_register(in_dev, &in_dev->cnf); 10431da177e4SLinus Torvalds #endif 10441da177e4SLinus Torvalds break; 10451da177e4SLinus Torvalds } 10461da177e4SLinus Torvalds out: 10471da177e4SLinus Torvalds return NOTIFY_DONE; 10481da177e4SLinus Torvalds } 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds static struct notifier_block ip_netdev_notifier = { 10511da177e4SLinus Torvalds .notifier_call =inetdev_event, 10521da177e4SLinus Torvalds }; 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa, 1055b6544c0bSJamal Hadi Salim u32 pid, u32 seq, int event, unsigned int flags) 10561da177e4SLinus Torvalds { 10571da177e4SLinus Torvalds struct ifaddrmsg *ifm; 10581da177e4SLinus Torvalds struct nlmsghdr *nlh; 10591da177e4SLinus Torvalds unsigned char *b = skb->tail; 10601da177e4SLinus Torvalds 1061b6544c0bSJamal Hadi Salim nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*ifm), flags); 10621da177e4SLinus Torvalds ifm = NLMSG_DATA(nlh); 10631da177e4SLinus Torvalds ifm->ifa_family = AF_INET; 10641da177e4SLinus Torvalds ifm->ifa_prefixlen = ifa->ifa_prefixlen; 10651da177e4SLinus Torvalds ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT; 10661da177e4SLinus Torvalds ifm->ifa_scope = ifa->ifa_scope; 10671da177e4SLinus Torvalds ifm->ifa_index = ifa->ifa_dev->dev->ifindex; 10681da177e4SLinus Torvalds if (ifa->ifa_address) 10691da177e4SLinus Torvalds RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address); 10701da177e4SLinus Torvalds if (ifa->ifa_local) 10711da177e4SLinus Torvalds RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local); 10721da177e4SLinus Torvalds if (ifa->ifa_broadcast) 10731da177e4SLinus Torvalds RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast); 10741da177e4SLinus Torvalds if (ifa->ifa_anycast) 10751da177e4SLinus Torvalds RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast); 10761da177e4SLinus Torvalds if (ifa->ifa_label[0]) 10771da177e4SLinus Torvalds RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label); 10781da177e4SLinus Torvalds nlh->nlmsg_len = skb->tail - b; 10791da177e4SLinus Torvalds return skb->len; 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds nlmsg_failure: 10821da177e4SLinus Torvalds rtattr_failure: 10831da177e4SLinus Torvalds skb_trim(skb, b - skb->data); 10841da177e4SLinus Torvalds return -1; 10851da177e4SLinus Torvalds } 10861da177e4SLinus Torvalds 10871da177e4SLinus Torvalds static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb) 10881da177e4SLinus Torvalds { 10891da177e4SLinus Torvalds int idx, ip_idx; 10901da177e4SLinus Torvalds struct net_device *dev; 10911da177e4SLinus Torvalds struct in_device *in_dev; 10921da177e4SLinus Torvalds struct in_ifaddr *ifa; 10931da177e4SLinus Torvalds int s_ip_idx, s_idx = cb->args[0]; 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds s_ip_idx = ip_idx = cb->args[1]; 10961da177e4SLinus Torvalds read_lock(&dev_base_lock); 10971da177e4SLinus Torvalds for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) { 10981da177e4SLinus Torvalds if (idx < s_idx) 10991da177e4SLinus Torvalds continue; 11001da177e4SLinus Torvalds if (idx > s_idx) 11011da177e4SLinus Torvalds s_ip_idx = 0; 11021da177e4SLinus Torvalds rcu_read_lock(); 1103e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev)) == NULL) { 11041da177e4SLinus Torvalds rcu_read_unlock(); 11051da177e4SLinus Torvalds continue; 11061da177e4SLinus Torvalds } 11071da177e4SLinus Torvalds 11081da177e4SLinus Torvalds for (ifa = in_dev->ifa_list, ip_idx = 0; ifa; 11091da177e4SLinus Torvalds ifa = ifa->ifa_next, ip_idx++) { 11101da177e4SLinus Torvalds if (ip_idx < s_ip_idx) 11111da177e4SLinus Torvalds continue; 11121da177e4SLinus Torvalds if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid, 11131da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 1114b6544c0bSJamal Hadi Salim RTM_NEWADDR, NLM_F_MULTI) <= 0) { 11151da177e4SLinus Torvalds rcu_read_unlock(); 11161da177e4SLinus Torvalds goto done; 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds rcu_read_unlock(); 11201da177e4SLinus Torvalds } 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds done: 11231da177e4SLinus Torvalds read_unlock(&dev_base_lock); 11241da177e4SLinus Torvalds cb->args[0] = idx; 11251da177e4SLinus Torvalds cb->args[1] = ip_idx; 11261da177e4SLinus Torvalds 11271da177e4SLinus Torvalds return skb->len; 11281da177e4SLinus Torvalds } 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds static void rtmsg_ifa(int event, struct in_ifaddr* ifa) 11311da177e4SLinus Torvalds { 11321da177e4SLinus Torvalds int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128); 11331da177e4SLinus Torvalds struct sk_buff *skb = alloc_skb(size, GFP_KERNEL); 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds if (!skb) 1136ac6d439dSPatrick McHardy netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS); 113728633514SAlexey Kuznetsov else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) { 11381da177e4SLinus Torvalds kfree_skb(skb); 1139ac6d439dSPatrick McHardy netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL); 11401da177e4SLinus Torvalds } else { 1141ac6d439dSPatrick McHardy netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL); 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds } 11441da177e4SLinus Torvalds 1145db46edc6SThomas Graf static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = { 1146db46edc6SThomas Graf [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, }, 1147db46edc6SThomas Graf [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, }, 1148db46edc6SThomas Graf [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, }, 1149db46edc6SThomas Graf [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, }, 1150db46edc6SThomas Graf [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, }, 1151db46edc6SThomas Graf [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute, 1152db46edc6SThomas Graf .dumpit = inet_dump_fib, }, 11531da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTIPLE_TABLES 1154db46edc6SThomas Graf [RTM_NEWRULE - RTM_BASE] = { .doit = inet_rtm_newrule, }, 1155db46edc6SThomas Graf [RTM_DELRULE - RTM_BASE] = { .doit = inet_rtm_delrule, }, 1156db46edc6SThomas Graf [RTM_GETRULE - RTM_BASE] = { .dumpit = inet_dump_rules, }, 11571da177e4SLinus Torvalds #endif 11581da177e4SLinus Torvalds }; 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds void inet_forward_change(void) 11631da177e4SLinus Torvalds { 11641da177e4SLinus Torvalds struct net_device *dev; 11651da177e4SLinus Torvalds int on = ipv4_devconf.forwarding; 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds ipv4_devconf.accept_redirects = !on; 11681da177e4SLinus Torvalds ipv4_devconf_dflt.forwarding = on; 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds read_lock(&dev_base_lock); 11711da177e4SLinus Torvalds for (dev = dev_base; dev; dev = dev->next) { 11721da177e4SLinus Torvalds struct in_device *in_dev; 11731da177e4SLinus Torvalds rcu_read_lock(); 1174e5ed6399SHerbert Xu in_dev = __in_dev_get_rcu(dev); 11751da177e4SLinus Torvalds if (in_dev) 11761da177e4SLinus Torvalds in_dev->cnf.forwarding = on; 11771da177e4SLinus Torvalds rcu_read_unlock(); 11781da177e4SLinus Torvalds } 11791da177e4SLinus Torvalds read_unlock(&dev_base_lock); 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds rt_cache_flush(0); 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds static int devinet_sysctl_forward(ctl_table *ctl, int write, 11851da177e4SLinus Torvalds struct file* filp, void __user *buffer, 11861da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 11871da177e4SLinus Torvalds { 11881da177e4SLinus Torvalds int *valp = ctl->data; 11891da177e4SLinus Torvalds int val = *valp; 11901da177e4SLinus Torvalds int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds if (write && *valp != val) { 11931da177e4SLinus Torvalds if (valp == &ipv4_devconf.forwarding) 11941da177e4SLinus Torvalds inet_forward_change(); 11951da177e4SLinus Torvalds else if (valp != &ipv4_devconf_dflt.forwarding) 11961da177e4SLinus Torvalds rt_cache_flush(0); 11971da177e4SLinus Torvalds } 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds return ret; 12001da177e4SLinus Torvalds } 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds int ipv4_doint_and_flush(ctl_table *ctl, int write, 12031da177e4SLinus Torvalds struct file* filp, void __user *buffer, 12041da177e4SLinus Torvalds size_t *lenp, loff_t *ppos) 12051da177e4SLinus Torvalds { 12061da177e4SLinus Torvalds int *valp = ctl->data; 12071da177e4SLinus Torvalds int val = *valp; 12081da177e4SLinus Torvalds int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds if (write && *valp != val) 12111da177e4SLinus Torvalds rt_cache_flush(0); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds return ret; 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen, 12171da177e4SLinus Torvalds void __user *oldval, size_t __user *oldlenp, 12181da177e4SLinus Torvalds void __user *newval, size_t newlen, 12191da177e4SLinus Torvalds void **context) 12201da177e4SLinus Torvalds { 12211da177e4SLinus Torvalds int *valp = table->data; 12221da177e4SLinus Torvalds int new; 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds if (!newval || !newlen) 12251da177e4SLinus Torvalds return 0; 12261da177e4SLinus Torvalds 12271da177e4SLinus Torvalds if (newlen != sizeof(int)) 12281da177e4SLinus Torvalds return -EINVAL; 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds if (get_user(new, (int __user *)newval)) 12311da177e4SLinus Torvalds return -EFAULT; 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds if (new == *valp) 12341da177e4SLinus Torvalds return 0; 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds if (oldval && oldlenp) { 12371da177e4SLinus Torvalds size_t len; 12381da177e4SLinus Torvalds 12391da177e4SLinus Torvalds if (get_user(len, oldlenp)) 12401da177e4SLinus Torvalds return -EFAULT; 12411da177e4SLinus Torvalds 12421da177e4SLinus Torvalds if (len) { 12431da177e4SLinus Torvalds if (len > table->maxlen) 12441da177e4SLinus Torvalds len = table->maxlen; 12451da177e4SLinus Torvalds if (copy_to_user(oldval, valp, len)) 12461da177e4SLinus Torvalds return -EFAULT; 12471da177e4SLinus Torvalds if (put_user(len, oldlenp)) 12481da177e4SLinus Torvalds return -EFAULT; 12491da177e4SLinus Torvalds } 12501da177e4SLinus Torvalds } 12511da177e4SLinus Torvalds 12521da177e4SLinus Torvalds *valp = new; 12531da177e4SLinus Torvalds rt_cache_flush(0); 12541da177e4SLinus Torvalds return 1; 12551da177e4SLinus Torvalds } 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds static struct devinet_sysctl_table { 12591da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 12601da177e4SLinus Torvalds ctl_table devinet_vars[__NET_IPV4_CONF_MAX]; 12611da177e4SLinus Torvalds ctl_table devinet_dev[2]; 12621da177e4SLinus Torvalds ctl_table devinet_conf_dir[2]; 12631da177e4SLinus Torvalds ctl_table devinet_proto_dir[2]; 12641da177e4SLinus Torvalds ctl_table devinet_root_dir[2]; 12651da177e4SLinus Torvalds } devinet_sysctl = { 12661da177e4SLinus Torvalds .devinet_vars = { 12671da177e4SLinus Torvalds { 12681da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_FORWARDING, 12691da177e4SLinus Torvalds .procname = "forwarding", 12701da177e4SLinus Torvalds .data = &ipv4_devconf.forwarding, 12711da177e4SLinus Torvalds .maxlen = sizeof(int), 12721da177e4SLinus Torvalds .mode = 0644, 12731da177e4SLinus Torvalds .proc_handler = &devinet_sysctl_forward, 12741da177e4SLinus Torvalds }, 12751da177e4SLinus Torvalds { 12761da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_MC_FORWARDING, 12771da177e4SLinus Torvalds .procname = "mc_forwarding", 12781da177e4SLinus Torvalds .data = &ipv4_devconf.mc_forwarding, 12791da177e4SLinus Torvalds .maxlen = sizeof(int), 12801da177e4SLinus Torvalds .mode = 0444, 12811da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 12821da177e4SLinus Torvalds }, 12831da177e4SLinus Torvalds { 12841da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS, 12851da177e4SLinus Torvalds .procname = "accept_redirects", 12861da177e4SLinus Torvalds .data = &ipv4_devconf.accept_redirects, 12871da177e4SLinus Torvalds .maxlen = sizeof(int), 12881da177e4SLinus Torvalds .mode = 0644, 12891da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 12901da177e4SLinus Torvalds }, 12911da177e4SLinus Torvalds { 12921da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS, 12931da177e4SLinus Torvalds .procname = "secure_redirects", 12941da177e4SLinus Torvalds .data = &ipv4_devconf.secure_redirects, 12951da177e4SLinus Torvalds .maxlen = sizeof(int), 12961da177e4SLinus Torvalds .mode = 0644, 12971da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 12981da177e4SLinus Torvalds }, 12991da177e4SLinus Torvalds { 13001da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_SHARED_MEDIA, 13011da177e4SLinus Torvalds .procname = "shared_media", 13021da177e4SLinus Torvalds .data = &ipv4_devconf.shared_media, 13031da177e4SLinus Torvalds .maxlen = sizeof(int), 13041da177e4SLinus Torvalds .mode = 0644, 13051da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13061da177e4SLinus Torvalds }, 13071da177e4SLinus Torvalds { 13081da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_RP_FILTER, 13091da177e4SLinus Torvalds .procname = "rp_filter", 13101da177e4SLinus Torvalds .data = &ipv4_devconf.rp_filter, 13111da177e4SLinus Torvalds .maxlen = sizeof(int), 13121da177e4SLinus Torvalds .mode = 0644, 13131da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13141da177e4SLinus Torvalds }, 13151da177e4SLinus Torvalds { 13161da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS, 13171da177e4SLinus Torvalds .procname = "send_redirects", 13181da177e4SLinus Torvalds .data = &ipv4_devconf.send_redirects, 13191da177e4SLinus Torvalds .maxlen = sizeof(int), 13201da177e4SLinus Torvalds .mode = 0644, 13211da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13221da177e4SLinus Torvalds }, 13231da177e4SLinus Torvalds { 13241da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, 13251da177e4SLinus Torvalds .procname = "accept_source_route", 13261da177e4SLinus Torvalds .data = &ipv4_devconf.accept_source_route, 13271da177e4SLinus Torvalds .maxlen = sizeof(int), 13281da177e4SLinus Torvalds .mode = 0644, 13291da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13301da177e4SLinus Torvalds }, 13311da177e4SLinus Torvalds { 13321da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_PROXY_ARP, 13331da177e4SLinus Torvalds .procname = "proxy_arp", 13341da177e4SLinus Torvalds .data = &ipv4_devconf.proxy_arp, 13351da177e4SLinus Torvalds .maxlen = sizeof(int), 13361da177e4SLinus Torvalds .mode = 0644, 13371da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13381da177e4SLinus Torvalds }, 13391da177e4SLinus Torvalds { 13401da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_MEDIUM_ID, 13411da177e4SLinus Torvalds .procname = "medium_id", 13421da177e4SLinus Torvalds .data = &ipv4_devconf.medium_id, 13431da177e4SLinus Torvalds .maxlen = sizeof(int), 13441da177e4SLinus Torvalds .mode = 0644, 13451da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13461da177e4SLinus Torvalds }, 13471da177e4SLinus Torvalds { 13481da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_BOOTP_RELAY, 13491da177e4SLinus Torvalds .procname = "bootp_relay", 13501da177e4SLinus Torvalds .data = &ipv4_devconf.bootp_relay, 13511da177e4SLinus Torvalds .maxlen = sizeof(int), 13521da177e4SLinus Torvalds .mode = 0644, 13531da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13541da177e4SLinus Torvalds }, 13551da177e4SLinus Torvalds { 13561da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_LOG_MARTIANS, 13571da177e4SLinus Torvalds .procname = "log_martians", 13581da177e4SLinus Torvalds .data = &ipv4_devconf.log_martians, 13591da177e4SLinus Torvalds .maxlen = sizeof(int), 13601da177e4SLinus Torvalds .mode = 0644, 13611da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13621da177e4SLinus Torvalds }, 13631da177e4SLinus Torvalds { 13641da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_TAG, 13651da177e4SLinus Torvalds .procname = "tag", 13661da177e4SLinus Torvalds .data = &ipv4_devconf.tag, 13671da177e4SLinus Torvalds .maxlen = sizeof(int), 13681da177e4SLinus Torvalds .mode = 0644, 13691da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13701da177e4SLinus Torvalds }, 13711da177e4SLinus Torvalds { 13721da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_ARPFILTER, 13731da177e4SLinus Torvalds .procname = "arp_filter", 13741da177e4SLinus Torvalds .data = &ipv4_devconf.arp_filter, 13751da177e4SLinus Torvalds .maxlen = sizeof(int), 13761da177e4SLinus Torvalds .mode = 0644, 13771da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13781da177e4SLinus Torvalds }, 13791da177e4SLinus Torvalds { 13801da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE, 13811da177e4SLinus Torvalds .procname = "arp_announce", 13821da177e4SLinus Torvalds .data = &ipv4_devconf.arp_announce, 13831da177e4SLinus Torvalds .maxlen = sizeof(int), 13841da177e4SLinus Torvalds .mode = 0644, 13851da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13861da177e4SLinus Torvalds }, 13871da177e4SLinus Torvalds { 13881da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_ARP_IGNORE, 13891da177e4SLinus Torvalds .procname = "arp_ignore", 13901da177e4SLinus Torvalds .data = &ipv4_devconf.arp_ignore, 13911da177e4SLinus Torvalds .maxlen = sizeof(int), 13921da177e4SLinus Torvalds .mode = 0644, 13931da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 13941da177e4SLinus Torvalds }, 13951da177e4SLinus Torvalds { 1396abd596a4SNeil Horman .ctl_name = NET_IPV4_CONF_ARP_ACCEPT, 1397abd596a4SNeil Horman .procname = "arp_accept", 1398abd596a4SNeil Horman .data = &ipv4_devconf.arp_accept, 1399abd596a4SNeil Horman .maxlen = sizeof(int), 1400abd596a4SNeil Horman .mode = 0644, 1401abd596a4SNeil Horman .proc_handler = &proc_dointvec, 1402abd596a4SNeil Horman }, 1403abd596a4SNeil Horman { 14041da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_NOXFRM, 14051da177e4SLinus Torvalds .procname = "disable_xfrm", 14061da177e4SLinus Torvalds .data = &ipv4_devconf.no_xfrm, 14071da177e4SLinus Torvalds .maxlen = sizeof(int), 14081da177e4SLinus Torvalds .mode = 0644, 14091da177e4SLinus Torvalds .proc_handler = &ipv4_doint_and_flush, 14101da177e4SLinus Torvalds .strategy = &ipv4_doint_and_flush_strategy, 14111da177e4SLinus Torvalds }, 14121da177e4SLinus Torvalds { 14131da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_NOPOLICY, 14141da177e4SLinus Torvalds .procname = "disable_policy", 14151da177e4SLinus Torvalds .data = &ipv4_devconf.no_policy, 14161da177e4SLinus Torvalds .maxlen = sizeof(int), 14171da177e4SLinus Torvalds .mode = 0644, 14181da177e4SLinus Torvalds .proc_handler = &ipv4_doint_and_flush, 14191da177e4SLinus Torvalds .strategy = &ipv4_doint_and_flush_strategy, 14201da177e4SLinus Torvalds }, 14211da177e4SLinus Torvalds { 14221da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION, 14231da177e4SLinus Torvalds .procname = "force_igmp_version", 14241da177e4SLinus Torvalds .data = &ipv4_devconf.force_igmp_version, 14251da177e4SLinus Torvalds .maxlen = sizeof(int), 14261da177e4SLinus Torvalds .mode = 0644, 14271da177e4SLinus Torvalds .proc_handler = &ipv4_doint_and_flush, 14281da177e4SLinus Torvalds .strategy = &ipv4_doint_and_flush_strategy, 14291da177e4SLinus Torvalds }, 14308f937c60SHarald Welte { 14318f937c60SHarald Welte .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES, 14328f937c60SHarald Welte .procname = "promote_secondaries", 14338f937c60SHarald Welte .data = &ipv4_devconf.promote_secondaries, 14348f937c60SHarald Welte .maxlen = sizeof(int), 14358f937c60SHarald Welte .mode = 0644, 14368f937c60SHarald Welte .proc_handler = &ipv4_doint_and_flush, 14378f937c60SHarald Welte .strategy = &ipv4_doint_and_flush_strategy, 14388f937c60SHarald Welte }, 14391da177e4SLinus Torvalds }, 14401da177e4SLinus Torvalds .devinet_dev = { 14411da177e4SLinus Torvalds { 14421da177e4SLinus Torvalds .ctl_name = NET_PROTO_CONF_ALL, 14431da177e4SLinus Torvalds .procname = "all", 14441da177e4SLinus Torvalds .mode = 0555, 14451da177e4SLinus Torvalds .child = devinet_sysctl.devinet_vars, 14461da177e4SLinus Torvalds }, 14471da177e4SLinus Torvalds }, 14481da177e4SLinus Torvalds .devinet_conf_dir = { 14491da177e4SLinus Torvalds { 14501da177e4SLinus Torvalds .ctl_name = NET_IPV4_CONF, 14511da177e4SLinus Torvalds .procname = "conf", 14521da177e4SLinus Torvalds .mode = 0555, 14531da177e4SLinus Torvalds .child = devinet_sysctl.devinet_dev, 14541da177e4SLinus Torvalds }, 14551da177e4SLinus Torvalds }, 14561da177e4SLinus Torvalds .devinet_proto_dir = { 14571da177e4SLinus Torvalds { 14581da177e4SLinus Torvalds .ctl_name = NET_IPV4, 14591da177e4SLinus Torvalds .procname = "ipv4", 14601da177e4SLinus Torvalds .mode = 0555, 14611da177e4SLinus Torvalds .child = devinet_sysctl.devinet_conf_dir, 14621da177e4SLinus Torvalds }, 14631da177e4SLinus Torvalds }, 14641da177e4SLinus Torvalds .devinet_root_dir = { 14651da177e4SLinus Torvalds { 14661da177e4SLinus Torvalds .ctl_name = CTL_NET, 14671da177e4SLinus Torvalds .procname = "net", 14681da177e4SLinus Torvalds .mode = 0555, 14691da177e4SLinus Torvalds .child = devinet_sysctl.devinet_proto_dir, 14701da177e4SLinus Torvalds }, 14711da177e4SLinus Torvalds }, 14721da177e4SLinus Torvalds }; 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds static void devinet_sysctl_register(struct in_device *in_dev, 14751da177e4SLinus Torvalds struct ipv4_devconf *p) 14761da177e4SLinus Torvalds { 14771da177e4SLinus Torvalds int i; 14781da177e4SLinus Torvalds struct net_device *dev = in_dev ? in_dev->dev : NULL; 14791da177e4SLinus Torvalds struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 14801da177e4SLinus Torvalds char *dev_name = NULL; 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds if (!t) 14831da177e4SLinus Torvalds return; 14841da177e4SLinus Torvalds memcpy(t, &devinet_sysctl, sizeof(*t)); 14851da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) { 14861da177e4SLinus Torvalds t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf; 14871da177e4SLinus Torvalds t->devinet_vars[i].de = NULL; 14881da177e4SLinus Torvalds } 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds if (dev) { 14911da177e4SLinus Torvalds dev_name = dev->name; 14921da177e4SLinus Torvalds t->devinet_dev[0].ctl_name = dev->ifindex; 14931da177e4SLinus Torvalds } else { 14941da177e4SLinus Torvalds dev_name = "default"; 14951da177e4SLinus Torvalds t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT; 14961da177e4SLinus Torvalds } 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds /* 14991da177e4SLinus Torvalds * Make a copy of dev_name, because '.procname' is regarded as const 15001da177e4SLinus Torvalds * by sysctl and we wouldn't want anyone to change it under our feet 15011da177e4SLinus Torvalds * (see SIOCSIFNAME). 15021da177e4SLinus Torvalds */ 1503543537bdSPaulo Marques dev_name = kstrdup(dev_name, GFP_KERNEL); 15041da177e4SLinus Torvalds if (!dev_name) 15051da177e4SLinus Torvalds goto free; 15061da177e4SLinus Torvalds 15071da177e4SLinus Torvalds t->devinet_dev[0].procname = dev_name; 15081da177e4SLinus Torvalds t->devinet_dev[0].child = t->devinet_vars; 15091da177e4SLinus Torvalds t->devinet_dev[0].de = NULL; 15101da177e4SLinus Torvalds t->devinet_conf_dir[0].child = t->devinet_dev; 15111da177e4SLinus Torvalds t->devinet_conf_dir[0].de = NULL; 15121da177e4SLinus Torvalds t->devinet_proto_dir[0].child = t->devinet_conf_dir; 15131da177e4SLinus Torvalds t->devinet_proto_dir[0].de = NULL; 15141da177e4SLinus Torvalds t->devinet_root_dir[0].child = t->devinet_proto_dir; 15151da177e4SLinus Torvalds t->devinet_root_dir[0].de = NULL; 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0); 15181da177e4SLinus Torvalds if (!t->sysctl_header) 15191da177e4SLinus Torvalds goto free_procname; 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds p->sysctl = t; 15221da177e4SLinus Torvalds return; 15231da177e4SLinus Torvalds 15241da177e4SLinus Torvalds /* error path */ 15251da177e4SLinus Torvalds free_procname: 15261da177e4SLinus Torvalds kfree(dev_name); 15271da177e4SLinus Torvalds free: 15281da177e4SLinus Torvalds kfree(t); 15291da177e4SLinus Torvalds return; 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds 15321da177e4SLinus Torvalds static void devinet_sysctl_unregister(struct ipv4_devconf *p) 15331da177e4SLinus Torvalds { 15341da177e4SLinus Torvalds if (p->sysctl) { 15351da177e4SLinus Torvalds struct devinet_sysctl_table *t = p->sysctl; 15361da177e4SLinus Torvalds p->sysctl = NULL; 15371da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 15381da177e4SLinus Torvalds kfree(t->devinet_dev[0].procname); 15391da177e4SLinus Torvalds kfree(t); 15401da177e4SLinus Torvalds } 15411da177e4SLinus Torvalds } 15421da177e4SLinus Torvalds #endif 15431da177e4SLinus Torvalds 15441da177e4SLinus Torvalds void __init devinet_init(void) 15451da177e4SLinus Torvalds { 15461da177e4SLinus Torvalds register_gifconf(PF_INET, inet_gifconf); 15471da177e4SLinus Torvalds register_netdevice_notifier(&ip_netdev_notifier); 15481da177e4SLinus Torvalds rtnetlink_links[PF_INET] = inet_rtnetlink_table; 15491da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 15501da177e4SLinus Torvalds devinet_sysctl.sysctl_header = 15511da177e4SLinus Torvalds register_sysctl_table(devinet_sysctl.devinet_root_dir, 0); 15521da177e4SLinus Torvalds devinet_sysctl_register(NULL, &ipv4_devconf_dflt); 15531da177e4SLinus Torvalds #endif 15541da177e4SLinus Torvalds } 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds EXPORT_SYMBOL(in_dev_finish_destroy); 15571da177e4SLinus Torvalds EXPORT_SYMBOL(inet_select_addr); 15581da177e4SLinus Torvalds EXPORT_SYMBOL(inetdev_by_index); 15591da177e4SLinus Torvalds EXPORT_SYMBOL(register_inetaddr_notifier); 15601da177e4SLinus Torvalds EXPORT_SYMBOL(unregister_inetaddr_notifier); 1561