blob: bdbf68bb2e2d194fcdf94553bd41a4ac9f184d7c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NET3 IP device support routines.
3 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Derived from the IP parts of dev.c 1.0.19
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
13 *
14 * Additional Authors:
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
17 *
18 * Changes:
19 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
20 * lists.
21 * Cyrus Durgin: updated for kmod
22 * Matthias Andree: in devinet_ioctl, compare label and
23 * address (4.4BSD alias style support),
24 * fall back to comparing just the label
25 * if no match found.
26 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080031#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/module.h>
33#include <linux/types.h>
34#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/string.h>
36#include <linux/mm.h>
37#include <linux/socket.h>
38#include <linux/sockios.h>
39#include <linux/in.h>
40#include <linux/errno.h>
41#include <linux/interrupt.h>
Thomas Graf18237302006-08-04 23:04:54 -070042#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/if_ether.h>
44#include <linux/inet.h>
45#include <linux/netdevice.h>
46#include <linux/etherdevice.h>
47#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/init.h>
49#include <linux/notifier.h>
50#include <linux/inetdevice.h>
51#include <linux/igmp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090052#include <linux/slab.h>
David S. Millerfd23c3b2011-02-18 12:42:28 -080053#include <linux/hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#ifdef CONFIG_SYSCTL
55#include <linux/sysctl.h>
56#endif
57#include <linux/kmod.h>
Nicolas Dichteledc9e742012-10-25 22:28:52 +000058#include <linux/netconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020060#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <net/ip.h>
62#include <net/route.h>
63#include <net/ip_fib.h>
Thomas Graf63f34442007-03-22 11:55:17 -070064#include <net/rtnetlink.h>
Pavel Emelyanov752d14d2007-12-16 13:31:47 -080065#include <net/net_namespace.h>
Jiri Pirko5c766d62013-01-24 09:41:41 +000066#include <net/addrconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
David S. Miller406b6f92011-03-22 21:56:23 -070068#include "fib_lookup.h"
69
Adrian Bunk0027ba82008-01-31 17:17:31 -080070static struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070071 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000072 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
73 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
74 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
75 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
William Manley26900482013-08-06 19:03:15 +010076 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
77 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
Herbert Xu42f811b2007-06-04 23:34:44 -070078 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070079};
80
81static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070082 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000083 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
84 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
85 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
86 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
87 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
William Manley26900482013-08-06 19:03:15 +010088 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
89 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
Herbert Xu42f811b2007-06-04 23:34:44 -070090 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070091};
92
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -080093#define IPV4_DEVCONF_DFLT(net, attr) \
94 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
Herbert Xu42f811b2007-06-04 23:34:44 -070095
Patrick McHardyef7c79e2007-06-05 12:38:30 -070096static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
Thomas Graf5c753972006-08-04 23:03:53 -070097 [IFA_LOCAL] = { .type = NLA_U32 },
98 [IFA_ADDRESS] = { .type = NLA_U32 },
99 [IFA_BROADCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -0700100 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Jiri Pirko5c766d62013-01-24 09:41:41 +0000101 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
Jiri Pirkoad6c8132013-12-08 12:16:10 +0100102 [IFA_FLAGS] = { .type = NLA_U32 },
Thomas Graf5c753972006-08-04 23:03:53 -0700103};
104
Eric Dumazet40384992012-08-03 21:06:50 +0000105#define IN4_ADDR_HSIZE_SHIFT 8
106#define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
107
David S. Millerfd23c3b2011-02-18 12:42:28 -0800108static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
109static DEFINE_SPINLOCK(inet_addr_hash_lock);
110
Eric Dumazet40384992012-08-03 21:06:50 +0000111static u32 inet_addr_hash(struct net *net, __be32 addr)
David S. Millerfd23c3b2011-02-18 12:42:28 -0800112{
Eric Dumazet40384992012-08-03 21:06:50 +0000113 u32 val = (__force u32) addr ^ net_hash_mix(net);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800114
Eric Dumazet40384992012-08-03 21:06:50 +0000115 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800116}
117
118static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
119{
Eric Dumazet40384992012-08-03 21:06:50 +0000120 u32 hash = inet_addr_hash(net, ifa->ifa_local);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800121
122 spin_lock(&inet_addr_hash_lock);
123 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
124 spin_unlock(&inet_addr_hash_lock);
125}
126
127static void inet_hash_remove(struct in_ifaddr *ifa)
128{
129 spin_lock(&inet_addr_hash_lock);
130 hlist_del_init_rcu(&ifa->hash);
131 spin_unlock(&inet_addr_hash_lock);
132}
133
David S. Miller9435eb12011-02-18 12:43:09 -0800134/**
135 * __ip_dev_find - find the first device with a given source address.
136 * @net: the net namespace
137 * @addr: the source address
138 * @devref: if true, take a reference on the found device
139 *
140 * If a caller uses devref=false, it should be protected by RCU, or RTNL
141 */
142struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
143{
Eric Dumazet40384992012-08-03 21:06:50 +0000144 u32 hash = inet_addr_hash(net, addr);
David S. Miller9435eb12011-02-18 12:43:09 -0800145 struct net_device *result = NULL;
146 struct in_ifaddr *ifa;
David S. Miller9435eb12011-02-18 12:43:09 -0800147
148 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800149 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
David S. Millere0660082011-03-03 11:24:19 -0800150 if (ifa->ifa_local == addr) {
Eric Dumazet40384992012-08-03 21:06:50 +0000151 struct net_device *dev = ifa->ifa_dev->dev;
152
153 if (!net_eq(dev_net(dev), net))
154 continue;
David S. Miller9435eb12011-02-18 12:43:09 -0800155 result = dev;
156 break;
157 }
158 }
David S. Miller406b6f92011-03-22 21:56:23 -0700159 if (!result) {
160 struct flowi4 fl4 = { .daddr = addr };
161 struct fib_result res = { 0 };
162 struct fib_table *local;
163
164 /* Fallback to FIB local table so that communication
165 * over loopback subnets work.
166 */
167 local = fib_get_table(net, RT_TABLE_LOCAL);
168 if (local &&
169 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
170 res.type == RTN_LOCAL)
171 result = FIB_RES_DEV(res);
172 }
David S. Miller9435eb12011-02-18 12:43:09 -0800173 if (result && devref)
174 dev_hold(result);
175 rcu_read_unlock();
176 return result;
177}
178EXPORT_SYMBOL(__ip_dev_find);
179
Thomas Grafd6062cb2006-08-15 00:33:59 -0700180static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Alan Sterne041c682006-03-27 01:16:30 -0800182static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
184 int destroy);
185#ifdef CONFIG_SYSCTL
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100186static void devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800187static void devinet_sysctl_unregister(struct in_device *idev);
188#else
Eric Dumazet40384992012-08-03 21:06:50 +0000189static void devinet_sysctl_register(struct in_device *idev)
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800190{
191}
Eric Dumazet40384992012-08-03 21:06:50 +0000192static void devinet_sysctl_unregister(struct in_device *idev)
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800193{
194}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195#endif
196
197/* Locks all the inet devices. */
198
199static struct in_ifaddr *inet_alloc_ifa(void)
200{
Alexey Dobriyan93adcc82008-10-28 13:25:09 -0700201 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
204static void inet_rcu_free_ifa(struct rcu_head *head)
205{
206 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
207 if (ifa->ifa_dev)
208 in_dev_put(ifa->ifa_dev);
209 kfree(ifa);
210}
211
Eric Dumazet40384992012-08-03 21:06:50 +0000212static void inet_free_ifa(struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
215}
216
217void in_dev_finish_destroy(struct in_device *idev)
218{
219 struct net_device *dev = idev->dev;
220
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700221 WARN_ON(idev->ifa_list);
222 WARN_ON(idev->mc_list);
Eric Dumazete9897072013-06-07 08:48:57 -0700223 kfree(rcu_dereference_protected(idev->mc_hash, 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224#ifdef NET_REFCNT_DEBUG
Joe Perches91df42b2012-05-15 14:11:54 +0000225 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226#endif
227 dev_put(dev);
228 if (!idev->dead)
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800229 pr_err("Freeing alive in_device %p\n", idev);
230 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 kfree(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800233EXPORT_SYMBOL(in_dev_finish_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Herbert Xu71e27da2007-06-04 23:36:06 -0700235static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 struct in_device *in_dev;
238
239 ASSERT_RTNL();
240
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700241 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (!in_dev)
243 goto out;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900244 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800245 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 in_dev->cnf.sysctl = NULL;
247 in_dev->dev = dev;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800248 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
249 if (!in_dev->arp_parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 goto out_kfree;
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700251 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
252 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 /* Reference in_dev->dev */
254 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800255 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100258 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 ip_mc_init_dev(in_dev);
260 if (dev->flags & IFF_UP)
261 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800262
David L Stevens30c4cf52007-01-04 12:31:14 -0800263 /* we can receive as soon as ip_ptr is set -- do this last */
Eric Dumazetcf778b02012-01-12 04:41:32 +0000264 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800265out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return in_dev;
267out_kfree:
268 kfree(in_dev);
269 in_dev = NULL;
270 goto out;
271}
272
273static void in_dev_rcu_put(struct rcu_head *head)
274{
275 struct in_device *idev = container_of(head, struct in_device, rcu_head);
276 in_dev_put(idev);
277}
278
279static void inetdev_destroy(struct in_device *in_dev)
280{
281 struct in_ifaddr *ifa;
282 struct net_device *dev;
283
284 ASSERT_RTNL();
285
286 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 in_dev->dead = 1;
289
290 ip_mc_destroy_dev(in_dev);
291
292 while ((ifa = in_dev->ifa_list) != NULL) {
293 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
294 inet_free_ifa(ifa);
295 }
296
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000297 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800299 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
301 arp_ifdown(dev);
302
303 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
304}
305
Al Viroff428d72006-09-26 22:13:35 -0700306int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
308 rcu_read_lock();
309 for_primary_ifa(in_dev) {
310 if (inet_ifa_match(a, ifa)) {
311 if (!b || inet_ifa_match(b, ifa)) {
312 rcu_read_unlock();
313 return 1;
314 }
315 }
316 } endfor_ifa(in_dev);
317 rcu_read_unlock();
318 return 0;
319}
320
Thomas Grafd6062cb2006-08-15 00:33:59 -0700321static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000322 int destroy, struct nlmsghdr *nlh, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Harald Welte8f937c62005-05-29 20:23:46 -0700324 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800325 struct in_ifaddr *ifa, *ifa1 = *ifap;
326 struct in_ifaddr *last_prim = in_dev->ifa_list;
327 struct in_ifaddr *prev_prom = NULL;
328 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 ASSERT_RTNL();
331
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900332 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700333 * unless alias promotion is set
334 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
336 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
338
339 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900340 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800341 ifa1->ifa_scope <= ifa->ifa_scope)
342 last_prim = ifa;
343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
345 ifa1->ifa_mask != ifa->ifa_mask ||
346 !inet_ifa_match(ifa1->ifa_address, ifa)) {
347 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800348 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 continue;
350 }
351
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800352 if (!do_promote) {
David S. Millerfd23c3b2011-02-18 12:42:28 -0800353 inet_hash_remove(ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700354 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Eric W. Biederman15e47302012-09-07 20:12:54 +0000356 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800357 blocking_notifier_call_chain(&inetaddr_chain,
358 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700359 inet_free_ifa(ifa);
360 } else {
361 promote = ifa;
362 break;
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
365 }
366
Julian Anastasov2d230e22011-03-19 12:13:52 +0000367 /* On promotion all secondaries from subnet are changing
368 * the primary IP, we must remove all their routes silently
369 * and later to add them back with new prefsrc. Do this
370 * while all addresses are on the device list.
371 */
372 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
373 if (ifa1->ifa_mask == ifa->ifa_mask &&
374 inet_ifa_match(ifa1->ifa_address, ifa))
375 fib_del_ifaddr(ifa, ifa1);
376 }
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 /* 2. Unlink it */
379
380 *ifap = ifa1->ifa_next;
David S. Millerfd23c3b2011-02-18 12:42:28 -0800381 inet_hash_remove(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 /* 3. Announce address deletion */
384
385 /* Send message first, then call notifier.
386 At first sight, FIB update triggered by notifier
387 will refer to already deleted ifaddr, that could confuse
388 netlink listeners. It is not true: look, gated sees
389 that route deleted and if it still thinks that ifaddr
390 is valid, it will try to restore deleted routes... Grr.
391 So that, this order is correct.
392 */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000393 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800394 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800395
396 if (promote) {
Julian Anastasov04024b92011-03-19 12:13:54 +0000397 struct in_ifaddr *next_sec = promote->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800398
399 if (prev_prom) {
400 prev_prom->ifa_next = promote->ifa_next;
401 promote->ifa_next = last_prim->ifa_next;
402 last_prim->ifa_next = promote;
403 }
404
405 promote->ifa_flags &= ~IFA_F_SECONDARY;
Eric W. Biederman15e47302012-09-07 20:12:54 +0000406 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800407 blocking_notifier_call_chain(&inetaddr_chain,
408 NETDEV_UP, promote);
Julian Anastasov04024b92011-03-19 12:13:54 +0000409 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800410 if (ifa1->ifa_mask != ifa->ifa_mask ||
411 !inet_ifa_match(ifa1->ifa_address, ifa))
412 continue;
413 fib_add_ifaddr(ifa);
414 }
415
416 }
Herbert Xu63630972007-06-07 18:35:38 -0700417 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
Thomas Grafd6062cb2006-08-15 00:33:59 -0700421static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
422 int destroy)
423{
424 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
425}
426
Jiri Pirko5c766d62013-01-24 09:41:41 +0000427static void check_lifetime(struct work_struct *work);
428
429static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
430
Thomas Grafd6062cb2006-08-15 00:33:59 -0700431static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000432 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
434 struct in_device *in_dev = ifa->ifa_dev;
435 struct in_ifaddr *ifa1, **ifap, **last_primary;
436
437 ASSERT_RTNL();
438
439 if (!ifa->ifa_local) {
440 inet_free_ifa(ifa);
441 return 0;
442 }
443
444 ifa->ifa_flags &= ~IFA_F_SECONDARY;
445 last_primary = &in_dev->ifa_list;
446
447 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
448 ifap = &ifa1->ifa_next) {
449 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
450 ifa->ifa_scope <= ifa1->ifa_scope)
451 last_primary = &ifa1->ifa_next;
452 if (ifa1->ifa_mask == ifa->ifa_mask &&
453 inet_ifa_match(ifa1->ifa_address, ifa)) {
454 if (ifa1->ifa_local == ifa->ifa_local) {
455 inet_free_ifa(ifa);
456 return -EEXIST;
457 }
458 if (ifa1->ifa_scope != ifa->ifa_scope) {
459 inet_free_ifa(ifa);
460 return -EINVAL;
461 }
462 ifa->ifa_flags |= IFA_F_SECONDARY;
463 }
464 }
465
466 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
Aruna-Hewapathirane63862b52014-01-11 07:15:59 -0500467 prandom_seed((__force u32) ifa->ifa_local);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 ifap = last_primary;
469 }
470
471 ifa->ifa_next = *ifap;
472 *ifap = ifa;
473
David S. Millerfd23c3b2011-02-18 12:42:28 -0800474 inet_hash_insert(dev_net(in_dev->dev), ifa);
475
Jiri Pirko5c766d62013-01-24 09:41:41 +0000476 cancel_delayed_work(&check_lifetime_work);
viresh kumar906e0732014-01-22 12:23:32 +0530477 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 /* Send message first, then call notifier.
480 Notifier will trigger FIB update, so that
481 listeners of netlink will know about new ifaddr */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000482 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800483 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 return 0;
486}
487
Thomas Grafd6062cb2006-08-15 00:33:59 -0700488static int inet_insert_ifa(struct in_ifaddr *ifa)
489{
490 return __inet_insert_ifa(ifa, NULL, 0);
491}
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
494{
Herbert Xue5ed6392005-10-03 14:35:55 -0700495 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 ASSERT_RTNL();
498
499 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700500 inet_free_ifa(ifa);
501 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700503 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100504 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700506 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 in_dev_hold(in_dev);
508 ifa->ifa_dev = in_dev;
509 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800510 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 ifa->ifa_scope = RT_SCOPE_HOST;
512 return inet_insert_ifa(ifa);
513}
514
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000515/* Caller must hold RCU or RTNL :
516 * We dont take a reference on found in_device
517 */
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800518struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
520 struct net_device *dev;
521 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000522
523 rcu_read_lock();
524 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000526 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000527 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 return in_dev;
529}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800530EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532/* Called only from RTNL semaphored context. No locks. */
533
Al Viro60cad5d2006-09-26 22:17:09 -0700534struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
535 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
537 ASSERT_RTNL();
538
539 for_primary_ifa(in_dev) {
540 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
541 return ifa;
542 } endfor_ifa(in_dev);
543 return NULL;
544}
545
Thomas Graf661d2962013-03-21 07:45:29 +0000546static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900548 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700549 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700551 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700553 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 ASSERT_RTNL();
556
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700557 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
558 if (err < 0)
559 goto errout;
560
561 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800562 in_dev = inetdev_by_index(net, ifm->ifa_index);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700563 if (in_dev == NULL) {
564 err = -ENODEV;
565 goto errout;
566 }
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
569 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700570 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700571 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700573
574 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
575 continue;
576
577 if (tb[IFA_ADDRESS] &&
578 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700579 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700580 continue;
581
Eric W. Biederman15e47302012-09-07 20:12:54 +0000582 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 return 0;
584 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700585
586 err = -EADDRNOTAVAIL;
587errout:
588 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589}
590
Jiri Pirko5c766d62013-01-24 09:41:41 +0000591#define INFINITY_LIFE_TIME 0xFFFFFFFF
592
593static void check_lifetime(struct work_struct *work)
594{
595 unsigned long now, next, next_sec, next_sched;
596 struct in_ifaddr *ifa;
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000597 struct hlist_node *n;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000598 int i;
599
600 now = jiffies;
601 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
602
Jiri Pirko5c766d62013-01-24 09:41:41 +0000603 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000604 bool change_needed = false;
605
606 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800607 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
Jiri Pirko5c766d62013-01-24 09:41:41 +0000608 unsigned long age;
609
610 if (ifa->ifa_flags & IFA_F_PERMANENT)
611 continue;
612
613 /* We try to batch several events at once. */
614 age = (now - ifa->ifa_tstamp +
615 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
616
617 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
618 age >= ifa->ifa_valid_lft) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000619 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000620 } else if (ifa->ifa_preferred_lft ==
621 INFINITY_LIFE_TIME) {
622 continue;
623 } else if (age >= ifa->ifa_preferred_lft) {
624 if (time_before(ifa->ifa_tstamp +
625 ifa->ifa_valid_lft * HZ, next))
626 next = ifa->ifa_tstamp +
627 ifa->ifa_valid_lft * HZ;
628
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000629 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
630 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000631 } else if (time_before(ifa->ifa_tstamp +
632 ifa->ifa_preferred_lft * HZ,
633 next)) {
634 next = ifa->ifa_tstamp +
635 ifa->ifa_preferred_lft * HZ;
636 }
637 }
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000638 rcu_read_unlock();
639 if (!change_needed)
640 continue;
641 rtnl_lock();
642 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
643 unsigned long age;
644
645 if (ifa->ifa_flags & IFA_F_PERMANENT)
646 continue;
647
648 /* We try to batch several events at once. */
649 age = (now - ifa->ifa_tstamp +
650 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
651
652 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
653 age >= ifa->ifa_valid_lft) {
654 struct in_ifaddr **ifap;
655
656 for (ifap = &ifa->ifa_dev->ifa_list;
657 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
658 if (*ifap == ifa) {
659 inet_del_ifa(ifa->ifa_dev,
660 ifap, 1);
661 break;
662 }
663 }
664 } else if (ifa->ifa_preferred_lft !=
665 INFINITY_LIFE_TIME &&
666 age >= ifa->ifa_preferred_lft &&
667 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
668 ifa->ifa_flags |= IFA_F_DEPRECATED;
669 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
670 }
671 }
672 rtnl_unlock();
Jiri Pirko5c766d62013-01-24 09:41:41 +0000673 }
Jiri Pirko5c766d62013-01-24 09:41:41 +0000674
675 next_sec = round_jiffies_up(next);
676 next_sched = next;
677
678 /* If rounded timeout is accurate enough, accept it. */
679 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
680 next_sched = next_sec;
681
682 now = jiffies;
683 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
684 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
685 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
686
viresh kumar906e0732014-01-22 12:23:32 +0530687 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
688 next_sched - now);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000689}
690
691static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
692 __u32 prefered_lft)
693{
694 unsigned long timeout;
695
696 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
697
698 timeout = addrconf_timeout_fixup(valid_lft, HZ);
699 if (addrconf_finite_timeout(timeout))
700 ifa->ifa_valid_lft = timeout;
701 else
702 ifa->ifa_flags |= IFA_F_PERMANENT;
703
704 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
705 if (addrconf_finite_timeout(timeout)) {
706 if (timeout == 0)
707 ifa->ifa_flags |= IFA_F_DEPRECATED;
708 ifa->ifa_preferred_lft = timeout;
709 }
710 ifa->ifa_tstamp = jiffies;
711 if (!ifa->ifa_cstamp)
712 ifa->ifa_cstamp = ifa->ifa_tstamp;
713}
714
715static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
716 __u32 *pvalid_lft, __u32 *pprefered_lft)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Thomas Graf5c753972006-08-04 23:03:53 -0700718 struct nlattr *tb[IFA_MAX+1];
719 struct in_ifaddr *ifa;
720 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 struct net_device *dev;
722 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800723 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
Thomas Graf5c753972006-08-04 23:03:53 -0700725 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
726 if (err < 0)
727 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Thomas Graf5c753972006-08-04 23:03:53 -0700729 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800730 err = -EINVAL;
731 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700732 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800734 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800735 err = -ENODEV;
736 if (dev == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700737 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Thomas Graf5c753972006-08-04 23:03:53 -0700739 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800740 err = -ENOBUFS;
741 if (in_dev == NULL)
Herbert Xu71e27da2007-06-04 23:36:06 -0700742 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
Thomas Graf5c753972006-08-04 23:03:53 -0700744 ifa = inet_alloc_ifa();
Denis V. Lunev7b218572008-01-31 18:47:00 -0800745 if (ifa == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700746 /*
747 * A potential indev allocation can be left alive, it stays
748 * assigned to its device and is destroy with it.
749 */
Thomas Graf5c753972006-08-04 23:03:53 -0700750 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700751
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800752 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100753 neigh_parms_data_state_setall(in_dev->arp_parms);
Thomas Graf5c753972006-08-04 23:03:53 -0700754 in_dev_hold(in_dev);
755
756 if (tb[IFA_ADDRESS] == NULL)
757 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
758
David S. Millerfd23c3b2011-02-18 12:42:28 -0800759 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
761 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Jiri Pirkoad6c8132013-12-08 12:16:10 +0100762 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
763 ifm->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700765 ifa->ifa_dev = in_dev;
766
Al Viroa7a628c2006-09-26 22:16:43 -0700767 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
768 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700769
770 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700771 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700772
Thomas Graf5c753972006-08-04 23:03:53 -0700773 if (tb[IFA_LABEL])
774 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 else
776 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
777
Jiri Pirko5c766d62013-01-24 09:41:41 +0000778 if (tb[IFA_CACHEINFO]) {
779 struct ifa_cacheinfo *ci;
780
781 ci = nla_data(tb[IFA_CACHEINFO]);
782 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
783 err = -EINVAL;
Daniel Borkmann446266b2013-08-02 11:32:43 +0200784 goto errout_free;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000785 }
786 *pvalid_lft = ci->ifa_valid;
787 *pprefered_lft = ci->ifa_prefered;
788 }
789
Thomas Graf5c753972006-08-04 23:03:53 -0700790 return ifa;
791
Daniel Borkmann446266b2013-08-02 11:32:43 +0200792errout_free:
793 inet_free_ifa(ifa);
Thomas Graf5c753972006-08-04 23:03:53 -0700794errout:
795 return ERR_PTR(err);
796}
797
Jiri Pirko5c766d62013-01-24 09:41:41 +0000798static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
799{
800 struct in_device *in_dev = ifa->ifa_dev;
801 struct in_ifaddr *ifa1, **ifap;
802
803 if (!ifa->ifa_local)
804 return NULL;
805
806 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
807 ifap = &ifa1->ifa_next) {
808 if (ifa1->ifa_mask == ifa->ifa_mask &&
809 inet_ifa_match(ifa1->ifa_address, ifa) &&
810 ifa1->ifa_local == ifa->ifa_local)
811 return ifa1;
812 }
813 return NULL;
814}
815
Thomas Graf661d2962013-03-21 07:45:29 +0000816static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Graf5c753972006-08-04 23:03:53 -0700817{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900818 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700819 struct in_ifaddr *ifa;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000820 struct in_ifaddr *ifa_existing;
821 __u32 valid_lft = INFINITY_LIFE_TIME;
822 __u32 prefered_lft = INFINITY_LIFE_TIME;
Thomas Graf5c753972006-08-04 23:03:53 -0700823
824 ASSERT_RTNL();
825
Jiri Pirko5c766d62013-01-24 09:41:41 +0000826 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
Thomas Graf5c753972006-08-04 23:03:53 -0700827 if (IS_ERR(ifa))
828 return PTR_ERR(ifa);
829
Jiri Pirko5c766d62013-01-24 09:41:41 +0000830 ifa_existing = find_matching_ifa(ifa);
831 if (!ifa_existing) {
832 /* It would be best to check for !NLM_F_CREATE here but
833 * userspace alreay relies on not having to provide this.
834 */
835 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
836 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
837 } else {
838 inet_free_ifa(ifa);
839
840 if (nlh->nlmsg_flags & NLM_F_EXCL ||
841 !(nlh->nlmsg_flags & NLM_F_REPLACE))
842 return -EEXIST;
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000843 ifa = ifa_existing;
844 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
Jiri Pirko05a324b2013-04-04 23:39:38 +0000845 cancel_delayed_work(&check_lifetime_work);
viresh kumar906e0732014-01-22 12:23:32 +0530846 queue_delayed_work(system_power_efficient_wq,
847 &check_lifetime_work, 0);
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000848 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
849 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000850 }
851 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
854/*
855 * Determine a default network mask, based on the IP address.
856 */
857
Eric Dumazet40384992012-08-03 21:06:50 +0000858static int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
860 int rc = -1; /* Something else, probably a multicast. */
861
Joe Perchesf97c1e02007-12-16 13:45:43 -0800862 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900863 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 else {
Al Viro714e85b2006-11-14 20:51:49 -0800865 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Al Viro714e85b2006-11-14 20:51:49 -0800867 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800869 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800871 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 rc = 24;
873 }
874
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900875 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876}
877
878
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800879int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
881 struct ifreq ifr;
882 struct sockaddr_in sin_orig;
883 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
884 struct in_device *in_dev;
885 struct in_ifaddr **ifap = NULL;
886 struct in_ifaddr *ifa = NULL;
887 struct net_device *dev;
888 char *colon;
889 int ret = -EFAULT;
890 int tryaddrmatch = 0;
891
892 /*
893 * Fetch the caller's info block into kernel space
894 */
895
896 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
897 goto out;
898 ifr.ifr_name[IFNAMSIZ - 1] = 0;
899
900 /* save original address for comparison */
901 memcpy(&sin_orig, sin, sizeof(*sin));
902
903 colon = strchr(ifr.ifr_name, ':');
904 if (colon)
905 *colon = 0;
906
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800907 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
Stephen Hemminger132adf52007-03-08 20:44:43 -0800909 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 case SIOCGIFADDR: /* Get interface address */
911 case SIOCGIFBRDADDR: /* Get the broadcast address */
912 case SIOCGIFDSTADDR: /* Get the destination address */
913 case SIOCGIFNETMASK: /* Get the netmask for the interface */
914 /* Note that these ioctls will not sleep,
915 so that we do not impose a lock.
916 One day we will be forced to put shlock here (I mean SMP)
917 */
918 tryaddrmatch = (sin_orig.sin_family == AF_INET);
919 memset(sin, 0, sizeof(*sin));
920 sin->sin_family = AF_INET;
921 break;
922
923 case SIOCSIFFLAGS:
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000924 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000925 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 goto out;
927 break;
928 case SIOCSIFADDR: /* Set interface address (and family) */
929 case SIOCSIFBRDADDR: /* Set the broadcast address */
930 case SIOCSIFDSTADDR: /* Set the destination address */
931 case SIOCSIFNETMASK: /* Set the netmask for the interface */
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000932 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000933 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 goto out;
935 ret = -EINVAL;
936 if (sin->sin_family != AF_INET)
937 goto out;
938 break;
939 default:
940 ret = -EINVAL;
941 goto out;
942 }
943
944 rtnl_lock();
945
946 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800947 dev = __dev_get_by_name(net, ifr.ifr_name);
948 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 goto done;
950
951 if (colon)
952 *colon = ':';
953
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800954 in_dev = __in_dev_get_rtnl(dev);
955 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 if (tryaddrmatch) {
957 /* Matthias Andree */
958 /* compare label and address (4.4BSD style) */
959 /* note: we only do this for a limited set of ioctls
960 and only if the original address family was AF_INET.
961 This is checked above. */
962 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
963 ifap = &ifa->ifa_next) {
964 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
965 sin_orig.sin_addr.s_addr ==
David S. Miller6c91afe2011-03-09 13:27:16 -0800966 ifa->ifa_local) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 break; /* found */
968 }
969 }
970 }
971 /* we didn't get a match, maybe the application is
972 4.3BSD-style and passed in junk so we fall back to
973 comparing just the label */
974 if (!ifa) {
975 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
976 ifap = &ifa->ifa_next)
977 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
978 break;
979 }
980 }
981
982 ret = -EADDRNOTAVAIL;
983 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
984 goto done;
985
Stephen Hemminger132adf52007-03-08 20:44:43 -0800986 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 case SIOCGIFADDR: /* Get interface address */
988 sin->sin_addr.s_addr = ifa->ifa_local;
989 goto rarok;
990
991 case SIOCGIFBRDADDR: /* Get the broadcast address */
992 sin->sin_addr.s_addr = ifa->ifa_broadcast;
993 goto rarok;
994
995 case SIOCGIFDSTADDR: /* Get the destination address */
996 sin->sin_addr.s_addr = ifa->ifa_address;
997 goto rarok;
998
999 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1000 sin->sin_addr.s_addr = ifa->ifa_mask;
1001 goto rarok;
1002
1003 case SIOCSIFFLAGS:
1004 if (colon) {
1005 ret = -EADDRNOTAVAIL;
1006 if (!ifa)
1007 break;
1008 ret = 0;
1009 if (!(ifr.ifr_flags & IFF_UP))
1010 inet_del_ifa(in_dev, ifap, 1);
1011 break;
1012 }
1013 ret = dev_change_flags(dev, ifr.ifr_flags);
1014 break;
1015
1016 case SIOCSIFADDR: /* Set interface address (and family) */
1017 ret = -EINVAL;
1018 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1019 break;
1020
1021 if (!ifa) {
1022 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001023 ifa = inet_alloc_ifa();
1024 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 break;
Xi Wangc7e2e1d2013-01-05 11:19:24 +00001026 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 if (colon)
1028 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1029 else
1030 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1031 } else {
1032 ret = 0;
1033 if (ifa->ifa_local == sin->sin_addr.s_addr)
1034 break;
1035 inet_del_ifa(in_dev, ifap, 0);
1036 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -08001037 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
1039
1040 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1041
1042 if (!(dev->flags & IFF_POINTOPOINT)) {
1043 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1044 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1045 if ((dev->flags & IFF_BROADCAST) &&
1046 ifa->ifa_prefixlen < 31)
1047 ifa->ifa_broadcast = ifa->ifa_address |
1048 ~ifa->ifa_mask;
1049 } else {
1050 ifa->ifa_prefixlen = 32;
1051 ifa->ifa_mask = inet_make_mask(32);
1052 }
Jiri Pirko5c766d62013-01-24 09:41:41 +00001053 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 ret = inet_set_ifa(dev, ifa);
1055 break;
1056
1057 case SIOCSIFBRDADDR: /* Set the broadcast address */
1058 ret = 0;
1059 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1060 inet_del_ifa(in_dev, ifap, 0);
1061 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1062 inet_insert_ifa(ifa);
1063 }
1064 break;
1065
1066 case SIOCSIFDSTADDR: /* Set the destination address */
1067 ret = 0;
1068 if (ifa->ifa_address == sin->sin_addr.s_addr)
1069 break;
1070 ret = -EINVAL;
1071 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1072 break;
1073 ret = 0;
1074 inet_del_ifa(in_dev, ifap, 0);
1075 ifa->ifa_address = sin->sin_addr.s_addr;
1076 inet_insert_ifa(ifa);
1077 break;
1078
1079 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1080
1081 /*
1082 * The mask we set must be legal.
1083 */
1084 ret = -EINVAL;
1085 if (bad_mask(sin->sin_addr.s_addr, 0))
1086 break;
1087 ret = 0;
1088 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -07001089 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 inet_del_ifa(in_dev, ifap, 0);
1091 ifa->ifa_mask = sin->sin_addr.s_addr;
1092 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1093
1094 /* See if current broadcast address matches
1095 * with current netmask, then recalculate
1096 * the broadcast address. Otherwise it's a
1097 * funny address, so don't touch it since
1098 * the user seems to know what (s)he's doing...
1099 */
1100 if ((dev->flags & IFF_BROADCAST) &&
1101 (ifa->ifa_prefixlen < 31) &&
1102 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -05001103 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 ifa->ifa_broadcast = (ifa->ifa_local |
1105 ~sin->sin_addr.s_addr);
1106 }
1107 inet_insert_ifa(ifa);
1108 }
1109 break;
1110 }
1111done:
1112 rtnl_unlock();
1113out:
1114 return ret;
1115rarok:
1116 rtnl_unlock();
1117 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1118 goto out;
1119}
1120
1121static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1122{
Herbert Xue5ed6392005-10-03 14:35:55 -07001123 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 struct in_ifaddr *ifa;
1125 struct ifreq ifr;
1126 int done = 0;
1127
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001128 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 goto out;
1130
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001131 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 if (!buf) {
1133 done += sizeof(ifr);
1134 continue;
1135 }
1136 if (len < (int) sizeof(ifr))
1137 break;
1138 memset(&ifr, 0, sizeof(struct ifreq));
Dan Carpenter4299c8a2013-07-29 22:15:19 +03001139 strcpy(ifr.ifr_name, ifa->ifa_label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
1141 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1142 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1143 ifa->ifa_local;
1144
1145 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1146 done = -EFAULT;
1147 break;
1148 }
1149 buf += sizeof(struct ifreq);
1150 len -= sizeof(struct ifreq);
1151 done += sizeof(struct ifreq);
1152 }
1153out:
1154 return done;
1155}
1156
Al Viroa61ced52006-09-26 21:27:54 -07001157__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158{
Al Viroa61ced52006-09-26 21:27:54 -07001159 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001161 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
1163 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -07001164 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 if (!in_dev)
1166 goto no_in_dev;
1167
1168 for_primary_ifa(in_dev) {
1169 if (ifa->ifa_scope > scope)
1170 continue;
1171 if (!dst || inet_ifa_match(dst, ifa)) {
1172 addr = ifa->ifa_local;
1173 break;
1174 }
1175 if (!addr)
1176 addr = ifa->ifa_local;
1177 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001180 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001181no_in_dev:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
1183 /* Not loopback addresses on loopback should be preferred
1184 in this case. It is importnat that lo is the first interface
1185 in dev_base list.
1186 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001187 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001188 in_dev = __in_dev_get_rcu(dev);
1189 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 continue;
1191
1192 for_primary_ifa(in_dev) {
1193 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1194 ifa->ifa_scope <= scope) {
1195 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001196 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 }
1198 } endfor_ifa(in_dev);
1199 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001200out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 return addr;
1203}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001204EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205
Al Viro60cad5d2006-09-26 22:17:09 -07001206static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1207 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208{
1209 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -07001210 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
1212 for_ifa(in_dev) {
1213 if (!addr &&
1214 (local == ifa->ifa_local || !local) &&
1215 ifa->ifa_scope <= scope) {
1216 addr = ifa->ifa_local;
1217 if (same)
1218 break;
1219 }
1220 if (!same) {
1221 same = (!local || inet_ifa_match(local, ifa)) &&
1222 (!dst || inet_ifa_match(dst, ifa));
1223 if (same && addr) {
1224 if (local || !dst)
1225 break;
1226 /* Is the selected addr into dst subnet? */
1227 if (inet_ifa_match(addr, ifa))
1228 break;
1229 /* No, then can we use new local src? */
1230 if (ifa->ifa_scope <= scope) {
1231 addr = ifa->ifa_local;
1232 break;
1233 }
1234 /* search for large dst subnet for addr */
1235 same = 0;
1236 }
1237 }
1238 } endfor_ifa(in_dev);
1239
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001240 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241}
1242
1243/*
1244 * Confirm that local IP address exists using wildcards:
Nicolas Dichtelb601fa12013-12-10 15:02:40 +01001245 * - net: netns to check, cannot be NULL
1246 * - in_dev: only on this interface, NULL=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 * - dst: only in the same subnet as dst, 0=any dst
1248 * - local: address, 0=autoselect the local address
1249 * - scope: maximum allowed scope value for the local address
1250 */
Nicolas Dichtelb601fa12013-12-10 15:02:40 +01001251__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001252 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253{
Al Viro60cad5d2006-09-26 22:17:09 -07001254 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001255 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Nicolas Dichtelb601fa12013-12-10 15:02:40 +01001257 if (in_dev != NULL)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001258 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001261 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001262 in_dev = __in_dev_get_rcu(dev);
1263 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 addr = confirm_addr_indev(in_dev, dst, local, scope);
1265 if (addr)
1266 break;
1267 }
1268 }
1269 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
1271 return addr;
1272}
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00001273EXPORT_SYMBOL(inet_confirm_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275/*
1276 * Device notifier
1277 */
1278
1279int register_inetaddr_notifier(struct notifier_block *nb)
1280{
Alan Sterne041c682006-03-27 01:16:30 -08001281 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001283EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
1285int unregister_inetaddr_notifier(struct notifier_block *nb)
1286{
Alan Sterne041c682006-03-27 01:16:30 -08001287 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001289EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001291/* Rename ifa_labels for a device name change. Make some effort to preserve
1292 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293*/
1294static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001295{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 struct in_ifaddr *ifa;
1297 int named = 0;
1298
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001299 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1300 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
1302 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001303 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001305 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001306 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001307 if (dot == NULL) {
1308 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 dot = old;
1310 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001311 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001312 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001313 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001314 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001315skip:
1316 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001317 }
1318}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Eric Dumazet40384992012-08-03 21:06:50 +00001320static bool inetdev_valid_mtu(unsigned int mtu)
Breno Leitao06770842008-09-02 17:28:58 -07001321{
1322 return mtu >= 68;
1323}
1324
Ian Campbelld11327ad2011-02-11 07:44:16 +00001325static void inetdev_send_gratuitous_arp(struct net_device *dev,
1326 struct in_device *in_dev)
1327
1328{
Zoltan Kissb76d0782011-07-24 13:09:30 +00001329 struct in_ifaddr *ifa;
Ian Campbelld11327ad2011-02-11 07:44:16 +00001330
Zoltan Kissb76d0782011-07-24 13:09:30 +00001331 for (ifa = in_dev->ifa_list; ifa;
1332 ifa = ifa->ifa_next) {
1333 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1334 ifa->ifa_local, dev,
1335 ifa->ifa_local, NULL,
1336 dev->dev_addr, NULL);
1337 }
Ian Campbelld11327ad2011-02-11 07:44:16 +00001338}
1339
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340/* Called only under RTNL semaphore */
1341
1342static int inetdev_event(struct notifier_block *this, unsigned long event,
1343 void *ptr)
1344{
Jiri Pirko351638e2013-05-28 01:30:21 +00001345 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Eric Dumazet748e2d92012-08-22 21:50:59 +00001346 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
1348 ASSERT_RTNL();
1349
1350 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001351 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001353 if (!in_dev)
1354 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001355 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001356 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1357 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001358 }
Breno Leitao06770842008-09-02 17:28:58 -07001359 } else if (event == NETDEV_CHANGEMTU) {
1360 /* Re-enabling IP */
1361 if (inetdev_valid_mtu(dev->mtu))
1362 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 }
1364 goto out;
1365 }
1366
1367 switch (event) {
1368 case NETDEV_REGISTER:
Joe Perches91df42b2012-05-15 14:11:54 +00001369 pr_debug("%s: bug\n", __func__);
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +00001370 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 break;
1372 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001373 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001375 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001376 struct in_ifaddr *ifa = inet_alloc_ifa();
1377
1378 if (ifa) {
David S. Millerfd23c3b2011-02-18 12:42:28 -08001379 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 ifa->ifa_local =
1381 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1382 ifa->ifa_prefixlen = 8;
1383 ifa->ifa_mask = inet_make_mask(8);
1384 in_dev_hold(in_dev);
1385 ifa->ifa_dev = in_dev;
1386 ifa->ifa_scope = RT_SCOPE_HOST;
1387 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Jiri Pirko5c766d62013-01-24 09:41:41 +00001388 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1389 INFINITY_LIFE_TIME);
Jiri Pirkodfd15822014-01-07 15:55:45 +01001390 ipv4_devconf_setall(in_dev);
1391 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 inet_insert_ifa(ifa);
1393 }
1394 }
1395 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001396 /* fall through */
1397 case NETDEV_CHANGEADDR:
Ian Campbelld11327ad2011-02-11 07:44:16 +00001398 if (!IN_DEV_ARP_NOTIFY(in_dev))
1399 break;
1400 /* fall through */
1401 case NETDEV_NOTIFY_PEERS:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001402 /* Send gratuitous ARP to notify of link change */
Ian Campbelld11327ad2011-02-11 07:44:16 +00001403 inetdev_send_gratuitous_arp(dev, in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 break;
1405 case NETDEV_DOWN:
1406 ip_mc_down(in_dev);
1407 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001408 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001409 ip_mc_unmap(in_dev);
1410 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001411 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001412 ip_mc_remap(in_dev);
1413 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001415 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 break;
Breno Leitao06770842008-09-02 17:28:58 -07001417 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 case NETDEV_UNREGISTER:
1419 inetdev_destroy(in_dev);
1420 break;
1421 case NETDEV_CHANGENAME:
1422 /* Do not notify about label change, this event is
1423 * not interesting to applications using netlink.
1424 */
1425 inetdev_changename(dev, in_dev);
1426
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001427 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001428 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 break;
1430 }
1431out:
1432 return NOTIFY_DONE;
1433}
1434
1435static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001436 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437};
1438
Eric Dumazet40384992012-08-03 21:06:50 +00001439static size_t inet_nlmsg_size(void)
Thomas Graf339bf982006-11-10 14:10:15 -08001440{
1441 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1442 + nla_total_size(4) /* IFA_ADDRESS */
1443 + nla_total_size(4) /* IFA_LOCAL */
1444 + nla_total_size(4) /* IFA_BROADCAST */
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001445 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
Geert Uytterhoeven63b5f152014-02-05 08:38:25 +01001446 + nla_total_size(4) /* IFA_FLAGS */
1447 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
Thomas Graf339bf982006-11-10 14:10:15 -08001448}
1449
Jiri Pirko5c766d62013-01-24 09:41:41 +00001450static inline u32 cstamp_delta(unsigned long cstamp)
1451{
1452 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1453}
1454
1455static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1456 unsigned long tstamp, u32 preferred, u32 valid)
1457{
1458 struct ifa_cacheinfo ci;
1459
1460 ci.cstamp = cstamp_delta(cstamp);
1461 ci.tstamp = cstamp_delta(tstamp);
1462 ci.ifa_prefered = preferred;
1463 ci.ifa_valid = valid;
1464
1465 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1466}
1467
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001469 u32 portid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470{
1471 struct ifaddrmsg *ifm;
1472 struct nlmsghdr *nlh;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001473 u32 preferred, valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Eric W. Biederman15e47302012-09-07 20:12:54 +00001475 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
Thomas Graf47f68512006-08-04 23:04:36 -07001476 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001477 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001478
1479 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 ifm->ifa_family = AF_INET;
1481 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001482 ifm->ifa_flags = ifa->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 ifm->ifa_scope = ifa->ifa_scope;
1484 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
Jiri Pirko5c766d62013-01-24 09:41:41 +00001486 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1487 preferred = ifa->ifa_preferred_lft;
1488 valid = ifa->ifa_valid_lft;
1489 if (preferred != INFINITY_LIFE_TIME) {
1490 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1491
1492 if (preferred > tval)
1493 preferred -= tval;
1494 else
1495 preferred = 0;
1496 if (valid != INFINITY_LIFE_TIME) {
1497 if (valid > tval)
1498 valid -= tval;
1499 else
1500 valid = 0;
1501 }
1502 }
1503 } else {
1504 preferred = INFINITY_LIFE_TIME;
1505 valid = INFINITY_LIFE_TIME;
1506 }
David S. Millerf3756b72012-04-01 20:39:02 -04001507 if ((ifa->ifa_address &&
1508 nla_put_be32(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1509 (ifa->ifa_local &&
1510 nla_put_be32(skb, IFA_LOCAL, ifa->ifa_local)) ||
1511 (ifa->ifa_broadcast &&
1512 nla_put_be32(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1513 (ifa->ifa_label[0] &&
Jiri Pirko5c766d62013-01-24 09:41:41 +00001514 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001515 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
Jiri Pirko5c766d62013-01-24 09:41:41 +00001516 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1517 preferred, valid))
David S. Millerf3756b72012-04-01 20:39:02 -04001518 goto nla_put_failure;
Thomas Graf47f68512006-08-04 23:04:36 -07001519
1520 return nlmsg_end(skb, nlh);
1521
1522nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001523 nlmsg_cancel(skb, nlh);
1524 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525}
1526
1527static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1528{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001529 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001530 int h, s_h;
1531 int idx, s_idx;
1532 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 struct net_device *dev;
1534 struct in_device *in_dev;
1535 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001536 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
Eric Dumazeteec4df92009-11-12 07:44:25 +00001538 s_h = cb->args[0];
1539 s_idx = idx = cb->args[1];
1540 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
Eric Dumazeteec4df92009-11-12 07:44:25 +00001542 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1543 idx = 0;
1544 head = &net->dev_index_head[h];
1545 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001546 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1547 net->dev_base_seq;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001548 hlist_for_each_entry_rcu(dev, head, index_hlist) {
Eric Dumazeteec4df92009-11-12 07:44:25 +00001549 if (idx < s_idx)
1550 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001551 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001552 s_ip_idx = 0;
1553 in_dev = __in_dev_get_rcu(dev);
1554 if (!in_dev)
1555 goto cont;
1556
1557 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1558 ifa = ifa->ifa_next, ip_idx++) {
1559 if (ip_idx < s_ip_idx)
1560 continue;
1561 if (inet_fill_ifaddr(skb, ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001562 NETLINK_CB(cb->skb).portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 cb->nlh->nlmsg_seq,
Eric Dumazeteec4df92009-11-12 07:44:25 +00001564 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1565 rcu_read_unlock();
1566 goto done;
1567 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001568 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Eric Dumazeteec4df92009-11-12 07:44:25 +00001569 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001570cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001571 idx++;
1572 }
1573 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 }
1575
1576done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001577 cb->args[0] = h;
1578 cb->args[1] = idx;
1579 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
1581 return skb->len;
1582}
1583
Jianjun Kong539afed2008-11-03 02:48:48 -08001584static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001585 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586{
Thomas Graf47f68512006-08-04 23:04:36 -07001587 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001588 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1589 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001590 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001592 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001593 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001594 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001595 goto errout;
1596
Eric W. Biederman15e47302012-09-07 20:12:54 +00001597 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001598 if (err < 0) {
1599 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1600 WARN_ON(err == -EMSGSIZE);
1601 kfree_skb(skb);
1602 goto errout;
1603 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00001604 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001605 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001606errout:
1607 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001608 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609}
1610
Thomas Graf9f0f7272010-11-16 04:32:48 +00001611static size_t inet_get_link_af_size(const struct net_device *dev)
1612{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001613 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001614
1615 if (!in_dev)
1616 return 0;
1617
1618 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1619}
1620
1621static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
1622{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001623 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001624 struct nlattr *nla;
1625 int i;
1626
1627 if (!in_dev)
1628 return -ENODATA;
1629
1630 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1631 if (nla == NULL)
1632 return -EMSGSIZE;
1633
1634 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1635 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1636
1637 return 0;
1638}
1639
1640static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1641 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1642};
1643
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001644static int inet_validate_link_af(const struct net_device *dev,
1645 const struct nlattr *nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001646{
Thomas Graf9f0f7272010-11-16 04:32:48 +00001647 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1648 int err, rem;
1649
Eric Dumazetf7fce742010-12-01 06:03:06 +00001650 if (dev && !__in_dev_get_rtnl(dev))
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001651 return -EAFNOSUPPORT;
Thomas Graf9f0f7272010-11-16 04:32:48 +00001652
1653 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1654 if (err < 0)
1655 return err;
1656
1657 if (tb[IFLA_INET_CONF]) {
1658 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1659 int cfgid = nla_type(a);
1660
1661 if (nla_len(a) < 4)
1662 return -EINVAL;
1663
1664 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1665 return -EINVAL;
1666 }
1667 }
1668
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001669 return 0;
1670}
1671
1672static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1673{
Eric Dumazetf7fce742010-12-01 06:03:06 +00001674 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001675 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1676 int rem;
1677
1678 if (!in_dev)
1679 return -EAFNOSUPPORT;
1680
1681 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1682 BUG();
1683
Thomas Graf9f0f7272010-11-16 04:32:48 +00001684 if (tb[IFLA_INET_CONF]) {
1685 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1686 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1687 }
1688
1689 return 0;
1690}
1691
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001692static int inet_netconf_msgsize_devconf(int type)
1693{
1694 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1695 + nla_total_size(4); /* NETCONFA_IFINDEX */
1696
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001697 /* type -1 is used for ALL */
1698 if (type == -1 || type == NETCONFA_FORWARDING)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001699 size += nla_total_size(4);
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001700 if (type == -1 || type == NETCONFA_RP_FILTER)
1701 size += nla_total_size(4);
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001702 if (type == -1 || type == NETCONFA_MC_FORWARDING)
1703 size += nla_total_size(4);
stephen hemminger09aea5d2013-12-17 22:35:52 -08001704 if (type == -1 || type == NETCONFA_PROXY_NEIGH)
stephen hemmingerf085ff12013-12-12 13:06:50 -08001705 size += nla_total_size(4);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001706
1707 return size;
1708}
1709
1710static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1711 struct ipv4_devconf *devconf, u32 portid,
1712 u32 seq, int event, unsigned int flags,
1713 int type)
1714{
1715 struct nlmsghdr *nlh;
1716 struct netconfmsg *ncm;
1717
1718 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1719 flags);
1720 if (nlh == NULL)
1721 return -EMSGSIZE;
1722
1723 ncm = nlmsg_data(nlh);
1724 ncm->ncm_family = AF_INET;
1725
1726 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1727 goto nla_put_failure;
1728
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001729 /* type -1 is used for ALL */
1730 if ((type == -1 || type == NETCONFA_FORWARDING) &&
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001731 nla_put_s32(skb, NETCONFA_FORWARDING,
1732 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1733 goto nla_put_failure;
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001734 if ((type == -1 || type == NETCONFA_RP_FILTER) &&
1735 nla_put_s32(skb, NETCONFA_RP_FILTER,
1736 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1737 goto nla_put_failure;
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001738 if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
1739 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1740 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1741 goto nla_put_failure;
stephen hemminger09aea5d2013-12-17 22:35:52 -08001742 if ((type == -1 || type == NETCONFA_PROXY_NEIGH) &&
1743 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08001744 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1745 goto nla_put_failure;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001746
1747 return nlmsg_end(skb, nlh);
1748
1749nla_put_failure:
1750 nlmsg_cancel(skb, nlh);
1751 return -EMSGSIZE;
1752}
1753
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001754void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
1755 struct ipv4_devconf *devconf)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001756{
1757 struct sk_buff *skb;
1758 int err = -ENOBUFS;
1759
1760 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_ATOMIC);
1761 if (skb == NULL)
1762 goto errout;
1763
1764 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1765 RTM_NEWNETCONF, 0, type);
1766 if (err < 0) {
1767 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1768 WARN_ON(err == -EMSGSIZE);
1769 kfree_skb(skb);
1770 goto errout;
1771 }
1772 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_ATOMIC);
1773 return;
1774errout:
1775 if (err < 0)
1776 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1777}
1778
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001779static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1780 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1781 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001782 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
stephen hemminger09aea5d2013-12-17 22:35:52 -08001783 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001784};
1785
1786static int inet_netconf_get_devconf(struct sk_buff *in_skb,
Thomas Graf661d2962013-03-21 07:45:29 +00001787 struct nlmsghdr *nlh)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001788{
1789 struct net *net = sock_net(in_skb->sk);
1790 struct nlattr *tb[NETCONFA_MAX+1];
1791 struct netconfmsg *ncm;
1792 struct sk_buff *skb;
1793 struct ipv4_devconf *devconf;
1794 struct in_device *in_dev;
1795 struct net_device *dev;
1796 int ifindex;
1797 int err;
1798
1799 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1800 devconf_ipv4_policy);
1801 if (err < 0)
1802 goto errout;
1803
1804 err = EINVAL;
1805 if (!tb[NETCONFA_IFINDEX])
1806 goto errout;
1807
1808 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1809 switch (ifindex) {
1810 case NETCONFA_IFINDEX_ALL:
1811 devconf = net->ipv4.devconf_all;
1812 break;
1813 case NETCONFA_IFINDEX_DEFAULT:
1814 devconf = net->ipv4.devconf_dflt;
1815 break;
1816 default:
1817 dev = __dev_get_by_index(net, ifindex);
1818 if (dev == NULL)
1819 goto errout;
1820 in_dev = __in_dev_get_rtnl(dev);
1821 if (in_dev == NULL)
1822 goto errout;
1823 devconf = &in_dev->cnf;
1824 break;
1825 }
1826
1827 err = -ENOBUFS;
1828 skb = nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC);
1829 if (skb == NULL)
1830 goto errout;
1831
1832 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1833 NETLINK_CB(in_skb).portid,
1834 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1835 -1);
1836 if (err < 0) {
1837 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1838 WARN_ON(err == -EMSGSIZE);
1839 kfree_skb(skb);
1840 goto errout;
1841 }
1842 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1843errout:
1844 return err;
1845}
1846
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001847static int inet_netconf_dump_devconf(struct sk_buff *skb,
1848 struct netlink_callback *cb)
1849{
1850 struct net *net = sock_net(skb->sk);
1851 int h, s_h;
1852 int idx, s_idx;
1853 struct net_device *dev;
1854 struct in_device *in_dev;
1855 struct hlist_head *head;
1856
1857 s_h = cb->args[0];
1858 s_idx = idx = cb->args[1];
1859
1860 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1861 idx = 0;
1862 head = &net->dev_index_head[h];
1863 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001864 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1865 net->dev_base_seq;
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001866 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1867 if (idx < s_idx)
1868 goto cont;
1869 in_dev = __in_dev_get_rcu(dev);
1870 if (!in_dev)
1871 goto cont;
1872
1873 if (inet_netconf_fill_devconf(skb, dev->ifindex,
1874 &in_dev->cnf,
1875 NETLINK_CB(cb->skb).portid,
1876 cb->nlh->nlmsg_seq,
1877 RTM_NEWNETCONF,
1878 NLM_F_MULTI,
1879 -1) <= 0) {
1880 rcu_read_unlock();
1881 goto done;
1882 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001883 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001884cont:
1885 idx++;
1886 }
1887 rcu_read_unlock();
1888 }
1889 if (h == NETDEV_HASHENTRIES) {
1890 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
1891 net->ipv4.devconf_all,
1892 NETLINK_CB(cb->skb).portid,
1893 cb->nlh->nlmsg_seq,
1894 RTM_NEWNETCONF, NLM_F_MULTI,
1895 -1) <= 0)
1896 goto done;
1897 else
1898 h++;
1899 }
1900 if (h == NETDEV_HASHENTRIES + 1) {
1901 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
1902 net->ipv4.devconf_dflt,
1903 NETLINK_CB(cb->skb).portid,
1904 cb->nlh->nlmsg_seq,
1905 RTM_NEWNETCONF, NLM_F_MULTI,
1906 -1) <= 0)
1907 goto done;
1908 else
1909 h++;
1910 }
1911done:
1912 cb->args[0] = h;
1913 cb->args[1] = idx;
1914
1915 return skb->len;
1916}
1917
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918#ifdef CONFIG_SYSCTL
1919
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001920static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001921{
1922 struct net_device *dev;
1923
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001924 rcu_read_lock();
1925 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001926 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001927
Herbert Xu31be3082007-06-04 23:35:37 -07001928 in_dev = __in_dev_get_rcu(dev);
1929 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001930 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001931 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001932 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07001933}
1934
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001935/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001936static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001937{
1938 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001939 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001940
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001941 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001942 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001943 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1944 NETCONFA_IFINDEX_ALL,
1945 net->ipv4.devconf_all);
1946 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1947 NETCONFA_IFINDEX_DEFAULT,
1948 net->ipv4.devconf_dflt);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001949
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001950 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001951 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001952 if (on)
1953 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001954 rcu_read_lock();
1955 in_dev = __in_dev_get_rcu(dev);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001956 if (in_dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001957 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001958 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1959 dev->ifindex, &in_dev->cnf);
1960 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001961 rcu_read_unlock();
1962 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001963}
1964
stephen hemmingerf085ff12013-12-12 13:06:50 -08001965static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
1966{
1967 if (cnf == net->ipv4.devconf_dflt)
1968 return NETCONFA_IFINDEX_DEFAULT;
1969 else if (cnf == net->ipv4.devconf_all)
1970 return NETCONFA_IFINDEX_ALL;
1971 else {
1972 struct in_device *idev
1973 = container_of(cnf, struct in_device, cnf);
1974 return idev->dev->ifindex;
1975 }
1976}
1977
Joe Perchesfe2c6332013-06-11 23:04:25 -07001978static int devinet_conf_proc(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001979 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07001980 size_t *lenp, loff_t *ppos)
1981{
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00001982 int old_value = *(int *)ctl->data;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001983 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00001984 int new_value = *(int *)ctl->data;
Herbert Xu31be3082007-06-04 23:35:37 -07001985
1986 if (write) {
1987 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001988 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001989 int i = (int *)ctl->data - cnf->data;
stephen hemmingerf085ff12013-12-12 13:06:50 -08001990 int ifindex;
Herbert Xu31be3082007-06-04 23:35:37 -07001991
1992 set_bit(i, cnf->state);
1993
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001994 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001995 devinet_copy_dflt_conf(net, i);
Thomas Grafd0daebc32012-06-12 00:44:01 +00001996 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
1997 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00001998 if ((new_value == 0) && (old_value != 0))
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00001999 rt_cache_flush(net);
stephen hemmingerf085ff12013-12-12 13:06:50 -08002000
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002001 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2002 new_value != old_value) {
stephen hemmingerf085ff12013-12-12 13:06:50 -08002003 ifindex = devinet_conf_ifindex(net, cnf);
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002004 inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
2005 ifindex, cnf);
2006 }
stephen hemmingerf085ff12013-12-12 13:06:50 -08002007 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2008 new_value != old_value) {
2009 ifindex = devinet_conf_ifindex(net, cnf);
stephen hemminger09aea5d2013-12-17 22:35:52 -08002010 inet_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08002011 ifindex, cnf);
2012 }
Herbert Xu31be3082007-06-04 23:35:37 -07002013 }
2014
2015 return ret;
2016}
2017
Joe Perchesfe2c6332013-06-11 23:04:25 -07002018static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002019 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 size_t *lenp, loff_t *ppos)
2021{
2022 int *valp = ctl->data;
2023 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00002024 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002025 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026
2027 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002028 struct net *net = ctl->extra2;
2029
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002030 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00002031 if (!rtnl_trylock()) {
2032 /* Restore the original values before restarting */
2033 *valp = val;
2034 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00002035 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00002036 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002037 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2038 inet_forward_change(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002039 } else {
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002040 struct ipv4_devconf *cnf = ctl->extra1;
2041 struct in_device *idev =
2042 container_of(cnf, struct in_device, cnf);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002043 if (*valp)
2044 dev_disable_lro(idev->dev);
2045 inet_netconf_notify_devconf(net,
2046 NETCONFA_FORWARDING,
2047 idev->dev->ifindex,
2048 cnf);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002049 }
2050 rtnl_unlock();
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002051 rt_cache_flush(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002052 } else
2053 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2054 NETCONFA_IFINDEX_DEFAULT,
2055 net->ipv4.devconf_dflt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 }
2057
2058 return ret;
2059}
2060
Joe Perchesfe2c6332013-06-11 23:04:25 -07002061static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
David S. Miller323e1262010-12-12 21:55:08 -08002062 void __user *buffer,
2063 size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064{
2065 int *valp = ctl->data;
2066 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002067 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07002068 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069
2070 if (write && *valp != val)
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002071 rt_cache_flush(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072
2073 return ret;
2074}
2075
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002076#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07002077 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07002078 .procname = name, \
2079 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00002080 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002081 .maxlen = sizeof(int), \
2082 .mode = mval, \
2083 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07002084 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002085 }
2086
2087#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002088 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002089
2090#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002091 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002092
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002093#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2094 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002095
2096#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002097 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07002098
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099static struct devinet_sysctl_table {
2100 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00002101 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102} devinet_sysctl = {
2103 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07002104 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002105 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07002106 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2107
2108 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2109 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2110 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2111 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2112 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2113 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2114 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00002115 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08002116 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002117 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2118 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2119 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2120 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2121 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2122 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2123 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2124 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2125 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08002126 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00002127 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
William Manley5c6fe012013-08-06 19:03:14 +01002128 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2129 "force_igmp_version"),
William Manley26900482013-08-06 19:03:15 +01002130 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2131 "igmpv2_unsolicited_report_interval"),
2132 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2133 "igmpv3_unsolicited_report_interval"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002134
2135 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2136 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002137 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2138 "promote_secondaries"),
Thomas Grafd0daebc32012-06-12 00:44:01 +00002139 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2140 "route_localnet"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142};
2143
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002144static int __devinet_sysctl_register(struct net *net, char *dev_name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002145 struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146{
2147 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002148 struct devinet_sysctl_table *t;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002149 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11002150
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002151 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002153 goto out;
2154
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2156 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07002157 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002158 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 }
2160
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002161 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002163 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 if (!t->sysctl_header)
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002165 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
2167 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002168 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002170free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002172out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002173 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174}
2175
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002176static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
2177{
2178 struct devinet_sysctl_table *t = cnf->sysctl;
2179
2180 if (t == NULL)
2181 return;
2182
2183 cnf->sysctl = NULL;
Lucian Adrian Grijincuff538812011-05-01 01:44:01 +00002184 unregister_net_sysctl_table(t->sysctl_header);
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002185 kfree(t);
2186}
2187
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002188static void devinet_sysctl_register(struct in_device *idev)
2189{
Jiri Pirko73af6142013-12-07 19:26:55 +01002190 neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002191 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002192 &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002193}
2194
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002195static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002197 __devinet_sysctl_unregister(&idev->cnf);
2198 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002201static struct ctl_table ctl_forward_entry[] = {
2202 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002203 .procname = "ip_forward",
2204 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00002205 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002206 .maxlen = sizeof(int),
2207 .mode = 0644,
2208 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002209 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002210 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002211 },
2212 { },
2213};
Eric Dumazet2a75de02008-01-05 23:08:49 -08002214#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002215
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002216static __net_init int devinet_init_net(struct net *net)
2217{
2218 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002219 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002220#ifdef CONFIG_SYSCTL
2221 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002222 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002223#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002224
2225 err = -ENOMEM;
2226 all = &ipv4_devconf;
2227 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002228
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002229 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002230 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2231 if (all == NULL)
2232 goto err_alloc_all;
2233
2234 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2235 if (dflt == NULL)
2236 goto err_alloc_dflt;
2237
Eric Dumazet2a75de02008-01-05 23:08:49 -08002238#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002239 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2240 if (tbl == NULL)
2241 goto err_alloc_ctl;
2242
Eric W. Biederman02291682010-02-14 03:25:51 +00002243 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002244 tbl[0].extra1 = all;
2245 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002246#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002247 }
2248
2249#ifdef CONFIG_SYSCTL
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002250 err = __devinet_sysctl_register(net, "all", all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002251 if (err < 0)
2252 goto err_reg_all;
2253
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002254 err = __devinet_sysctl_register(net, "default", dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002255 if (err < 0)
2256 goto err_reg_dflt;
2257
2258 err = -ENOMEM;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002259 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002260 if (forw_hdr == NULL)
2261 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002262 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002263#endif
2264
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002265 net->ipv4.devconf_all = all;
2266 net->ipv4.devconf_dflt = dflt;
2267 return 0;
2268
2269#ifdef CONFIG_SYSCTL
2270err_reg_ctl:
2271 __devinet_sysctl_unregister(dflt);
2272err_reg_dflt:
2273 __devinet_sysctl_unregister(all);
2274err_reg_all:
2275 if (tbl != ctl_forward_entry)
2276 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002277err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08002278#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002279 if (dflt != &ipv4_devconf_dflt)
2280 kfree(dflt);
2281err_alloc_dflt:
2282 if (all != &ipv4_devconf)
2283 kfree(all);
2284err_alloc_all:
2285 return err;
2286}
2287
2288static __net_exit void devinet_exit_net(struct net *net)
2289{
Eric Dumazet2a75de02008-01-05 23:08:49 -08002290#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002291 struct ctl_table *tbl;
2292
2293 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002294 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2295 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
2296 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002297 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08002298#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002299 kfree(net->ipv4.devconf_dflt);
2300 kfree(net->ipv4.devconf_all);
2301}
2302
2303static __net_initdata struct pernet_operations devinet_ops = {
2304 .init = devinet_init_net,
2305 .exit = devinet_exit_net,
2306};
2307
Thomas Graf9f0f7272010-11-16 04:32:48 +00002308static struct rtnl_af_ops inet_af_ops = {
2309 .family = AF_INET,
2310 .fill_link_af = inet_fill_link_af,
2311 .get_link_af_size = inet_get_link_af_size,
Thomas Grafcf7afbf2010-11-22 01:31:54 +00002312 .validate_link_af = inet_validate_link_af,
2313 .set_link_af = inet_set_link_af,
Thomas Graf9f0f7272010-11-16 04:32:48 +00002314};
2315
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316void __init devinet_init(void)
2317{
David S. Millerfd23c3b2011-02-18 12:42:28 -08002318 int i;
2319
2320 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2321 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2322
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002323 register_pernet_subsys(&devinet_ops);
2324
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 register_gifconf(PF_INET, inet_gifconf);
2326 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07002327
viresh kumar906e0732014-01-22 12:23:32 +05302328 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
Jiri Pirko5c766d62013-01-24 09:41:41 +00002329
Thomas Graf9f0f7272010-11-16 04:32:48 +00002330 rtnl_af_register(&inet_af_ops);
2331
Greg Rosec7ac8672011-06-10 01:27:09 +00002332 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
2333 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
2334 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
Nicolas Dichtel9e551112012-10-25 22:28:53 +00002335 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
Nicolas Dichtel7a674202013-03-05 23:42:06 +00002336 inet_netconf_dump_devconf, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337}
2338