blob: 062a67ca9a212f6e8a966e5419c4a11867e601d9 [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];
David S. Millerfd23c3b2011-02-18 12:42:28 -0800109
Eric Dumazet6eada012015-03-18 14:05:33 -0700110static u32 inet_addr_hash(const struct net *net, __be32 addr)
David S. Millerfd23c3b2011-02-18 12:42:28 -0800111{
Eric Dumazet40384992012-08-03 21:06:50 +0000112 u32 val = (__force u32) addr ^ net_hash_mix(net);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800113
Eric Dumazet40384992012-08-03 21:06:50 +0000114 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800115}
116
117static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
118{
Eric Dumazet40384992012-08-03 21:06:50 +0000119 u32 hash = inet_addr_hash(net, ifa->ifa_local);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800120
WANG Cong32a4be42014-05-06 11:15:56 -0700121 ASSERT_RTNL();
David S. Millerfd23c3b2011-02-18 12:42:28 -0800122 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800123}
124
125static void inet_hash_remove(struct in_ifaddr *ifa)
126{
WANG Cong32a4be42014-05-06 11:15:56 -0700127 ASSERT_RTNL();
David S. Millerfd23c3b2011-02-18 12:42:28 -0800128 hlist_del_init_rcu(&ifa->hash);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800129}
130
David S. Miller9435eb12011-02-18 12:43:09 -0800131/**
132 * __ip_dev_find - find the first device with a given source address.
133 * @net: the net namespace
134 * @addr: the source address
135 * @devref: if true, take a reference on the found device
136 *
137 * If a caller uses devref=false, it should be protected by RCU, or RTNL
138 */
139struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
140{
Eric Dumazet40384992012-08-03 21:06:50 +0000141 u32 hash = inet_addr_hash(net, addr);
David S. Miller9435eb12011-02-18 12:43:09 -0800142 struct net_device *result = NULL;
143 struct in_ifaddr *ifa;
David S. Miller9435eb12011-02-18 12:43:09 -0800144
145 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800146 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
David S. Millere0660082011-03-03 11:24:19 -0800147 if (ifa->ifa_local == addr) {
Eric Dumazet40384992012-08-03 21:06:50 +0000148 struct net_device *dev = ifa->ifa_dev->dev;
149
150 if (!net_eq(dev_net(dev), net))
151 continue;
David S. Miller9435eb12011-02-18 12:43:09 -0800152 result = dev;
153 break;
154 }
155 }
David S. Miller406b6f92011-03-22 21:56:23 -0700156 if (!result) {
157 struct flowi4 fl4 = { .daddr = addr };
158 struct fib_result res = { 0 };
159 struct fib_table *local;
160
161 /* Fallback to FIB local table so that communication
162 * over loopback subnets work.
163 */
164 local = fib_get_table(net, RT_TABLE_LOCAL);
165 if (local &&
166 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
167 res.type == RTN_LOCAL)
168 result = FIB_RES_DEV(res);
169 }
David S. Miller9435eb12011-02-18 12:43:09 -0800170 if (result && devref)
171 dev_hold(result);
172 rcu_read_unlock();
173 return result;
174}
175EXPORT_SYMBOL(__ip_dev_find);
176
Thomas Grafd6062cb2006-08-15 00:33:59 -0700177static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Alan Sterne041c682006-03-27 01:16:30 -0800179static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
181 int destroy);
182#ifdef CONFIG_SYSCTL
WANG Cong20e61da2014-07-25 15:25:08 -0700183static int devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800184static void devinet_sysctl_unregister(struct in_device *idev);
185#else
WANG Cong20e61da2014-07-25 15:25:08 -0700186static int devinet_sysctl_register(struct in_device *idev)
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800187{
WANG Cong20e61da2014-07-25 15:25:08 -0700188 return 0;
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800189}
Eric Dumazet40384992012-08-03 21:06:50 +0000190static void devinet_sysctl_unregister(struct in_device *idev)
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800191{
192}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193#endif
194
195/* Locks all the inet devices. */
196
197static struct in_ifaddr *inet_alloc_ifa(void)
198{
Alexey Dobriyan93adcc82008-10-28 13:25:09 -0700199 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200}
201
202static void inet_rcu_free_ifa(struct rcu_head *head)
203{
204 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
205 if (ifa->ifa_dev)
206 in_dev_put(ifa->ifa_dev);
207 kfree(ifa);
208}
209
Eric Dumazet40384992012-08-03 21:06:50 +0000210static void inet_free_ifa(struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
212 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
213}
214
215void in_dev_finish_destroy(struct in_device *idev)
216{
217 struct net_device *dev = idev->dev;
218
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700219 WARN_ON(idev->ifa_list);
220 WARN_ON(idev->mc_list);
Eric Dumazete9897072013-06-07 08:48:57 -0700221 kfree(rcu_dereference_protected(idev->mc_hash, 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222#ifdef NET_REFCNT_DEBUG
Joe Perches91df42b2012-05-15 14:11:54 +0000223 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224#endif
225 dev_put(dev);
226 if (!idev->dead)
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800227 pr_err("Freeing alive in_device %p\n", idev);
228 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 kfree(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800231EXPORT_SYMBOL(in_dev_finish_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Herbert Xu71e27da2007-06-04 23:36:06 -0700233static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 struct in_device *in_dev;
WANG Cong20e61da2014-07-25 15:25:08 -0700236 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 ASSERT_RTNL();
239
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700240 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (!in_dev)
242 goto out;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900243 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800244 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 in_dev->cnf.sysctl = NULL;
246 in_dev->dev = dev;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800247 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
248 if (!in_dev->arp_parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 goto out_kfree;
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700250 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
251 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 /* Reference in_dev->dev */
253 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800254 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
WANG Cong20e61da2014-07-25 15:25:08 -0700257 err = devinet_sysctl_register(in_dev);
258 if (err) {
259 in_dev->dead = 1;
260 in_dev_put(in_dev);
261 in_dev = NULL;
262 goto out;
263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 ip_mc_init_dev(in_dev);
265 if (dev->flags & IFF_UP)
266 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800267
David L Stevens30c4cf52007-01-04 12:31:14 -0800268 /* we can receive as soon as ip_ptr is set -- do this last */
Eric Dumazetcf778b02012-01-12 04:41:32 +0000269 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800270out:
WANG Cong20e61da2014-07-25 15:25:08 -0700271 return in_dev ?: ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272out_kfree:
273 kfree(in_dev);
274 in_dev = NULL;
275 goto out;
276}
277
278static void in_dev_rcu_put(struct rcu_head *head)
279{
280 struct in_device *idev = container_of(head, struct in_device, rcu_head);
281 in_dev_put(idev);
282}
283
284static void inetdev_destroy(struct in_device *in_dev)
285{
286 struct in_ifaddr *ifa;
287 struct net_device *dev;
288
289 ASSERT_RTNL();
290
291 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 in_dev->dead = 1;
294
295 ip_mc_destroy_dev(in_dev);
296
297 while ((ifa = in_dev->ifa_list) != NULL) {
298 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
299 inet_free_ifa(ifa);
300 }
301
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000302 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800304 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
306 arp_ifdown(dev);
307
308 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
309}
310
Al Viroff428d72006-09-26 22:13:35 -0700311int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313 rcu_read_lock();
314 for_primary_ifa(in_dev) {
315 if (inet_ifa_match(a, ifa)) {
316 if (!b || inet_ifa_match(b, ifa)) {
317 rcu_read_unlock();
318 return 1;
319 }
320 }
321 } endfor_ifa(in_dev);
322 rcu_read_unlock();
323 return 0;
324}
325
Thomas Grafd6062cb2006-08-15 00:33:59 -0700326static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000327 int destroy, struct nlmsghdr *nlh, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
Harald Welte8f937c62005-05-29 20:23:46 -0700329 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800330 struct in_ifaddr *ifa, *ifa1 = *ifap;
331 struct in_ifaddr *last_prim = in_dev->ifa_list;
332 struct in_ifaddr *prev_prom = NULL;
333 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
335 ASSERT_RTNL();
336
David S. Millerfbd40ea2016-03-13 23:28:00 -0400337 if (in_dev->dead)
338 goto no_promotions;
339
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900340 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700341 * unless alias promotion is set
342 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
346
347 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900348 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800349 ifa1->ifa_scope <= ifa->ifa_scope)
350 last_prim = ifa;
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
353 ifa1->ifa_mask != ifa->ifa_mask ||
354 !inet_ifa_match(ifa1->ifa_address, ifa)) {
355 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800356 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 continue;
358 }
359
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800360 if (!do_promote) {
David S. Millerfd23c3b2011-02-18 12:42:28 -0800361 inet_hash_remove(ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700362 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Eric W. Biederman15e47302012-09-07 20:12:54 +0000364 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800365 blocking_notifier_call_chain(&inetaddr_chain,
366 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700367 inet_free_ifa(ifa);
368 } else {
369 promote = ifa;
370 break;
371 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 }
373 }
374
Julian Anastasov2d230e22011-03-19 12:13:52 +0000375 /* On promotion all secondaries from subnet are changing
376 * the primary IP, we must remove all their routes silently
377 * and later to add them back with new prefsrc. Do this
378 * while all addresses are on the device list.
379 */
380 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
381 if (ifa1->ifa_mask == ifa->ifa_mask &&
382 inet_ifa_match(ifa1->ifa_address, ifa))
383 fib_del_ifaddr(ifa, ifa1);
384 }
385
David S. Millerfbd40ea2016-03-13 23:28:00 -0400386no_promotions:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 /* 2. Unlink it */
388
389 *ifap = ifa1->ifa_next;
David S. Millerfd23c3b2011-02-18 12:42:28 -0800390 inet_hash_remove(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 /* 3. Announce address deletion */
393
394 /* Send message first, then call notifier.
395 At first sight, FIB update triggered by notifier
396 will refer to already deleted ifaddr, that could confuse
397 netlink listeners. It is not true: look, gated sees
398 that route deleted and if it still thinks that ifaddr
399 is valid, it will try to restore deleted routes... Grr.
400 So that, this order is correct.
401 */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000402 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800403 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800404
405 if (promote) {
Julian Anastasov04024b92011-03-19 12:13:54 +0000406 struct in_ifaddr *next_sec = promote->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800407
408 if (prev_prom) {
409 prev_prom->ifa_next = promote->ifa_next;
410 promote->ifa_next = last_prim->ifa_next;
411 last_prim->ifa_next = promote;
412 }
413
414 promote->ifa_flags &= ~IFA_F_SECONDARY;
Eric W. Biederman15e47302012-09-07 20:12:54 +0000415 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800416 blocking_notifier_call_chain(&inetaddr_chain,
417 NETDEV_UP, promote);
Julian Anastasov04024b92011-03-19 12:13:54 +0000418 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800419 if (ifa1->ifa_mask != ifa->ifa_mask ||
420 !inet_ifa_match(ifa1->ifa_address, ifa))
421 continue;
422 fib_add_ifaddr(ifa);
423 }
424
425 }
Herbert Xu63630972007-06-07 18:35:38 -0700426 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428}
429
Thomas Grafd6062cb2006-08-15 00:33:59 -0700430static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
431 int destroy)
432{
433 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
434}
435
Jiri Pirko5c766d62013-01-24 09:41:41 +0000436static void check_lifetime(struct work_struct *work);
437
438static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
439
Thomas Grafd6062cb2006-08-15 00:33:59 -0700440static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000441 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
443 struct in_device *in_dev = ifa->ifa_dev;
444 struct in_ifaddr *ifa1, **ifap, **last_primary;
445
446 ASSERT_RTNL();
447
448 if (!ifa->ifa_local) {
449 inet_free_ifa(ifa);
450 return 0;
451 }
452
453 ifa->ifa_flags &= ~IFA_F_SECONDARY;
454 last_primary = &in_dev->ifa_list;
455
456 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
457 ifap = &ifa1->ifa_next) {
458 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
459 ifa->ifa_scope <= ifa1->ifa_scope)
460 last_primary = &ifa1->ifa_next;
461 if (ifa1->ifa_mask == ifa->ifa_mask &&
462 inet_ifa_match(ifa1->ifa_address, ifa)) {
463 if (ifa1->ifa_local == ifa->ifa_local) {
464 inet_free_ifa(ifa);
465 return -EEXIST;
466 }
467 if (ifa1->ifa_scope != ifa->ifa_scope) {
468 inet_free_ifa(ifa);
469 return -EINVAL;
470 }
471 ifa->ifa_flags |= IFA_F_SECONDARY;
472 }
473 }
474
475 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
Aruna-Hewapathirane63862b52014-01-11 07:15:59 -0500476 prandom_seed((__force u32) ifa->ifa_local);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 ifap = last_primary;
478 }
479
480 ifa->ifa_next = *ifap;
481 *ifap = ifa;
482
David S. Millerfd23c3b2011-02-18 12:42:28 -0800483 inet_hash_insert(dev_net(in_dev->dev), ifa);
484
Jiri Pirko5c766d62013-01-24 09:41:41 +0000485 cancel_delayed_work(&check_lifetime_work);
viresh kumar906e0732014-01-22 12:23:32 +0530486 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 /* Send message first, then call notifier.
489 Notifier will trigger FIB update, so that
490 listeners of netlink will know about new ifaddr */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000491 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800492 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 return 0;
495}
496
Thomas Grafd6062cb2006-08-15 00:33:59 -0700497static int inet_insert_ifa(struct in_ifaddr *ifa)
498{
499 return __inet_insert_ifa(ifa, NULL, 0);
500}
501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
503{
Herbert Xue5ed6392005-10-03 14:35:55 -0700504 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 ASSERT_RTNL();
507
508 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700509 inet_free_ifa(ifa);
510 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700512 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100513 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700515 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 in_dev_hold(in_dev);
517 ifa->ifa_dev = in_dev;
518 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800519 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 ifa->ifa_scope = RT_SCOPE_HOST;
521 return inet_insert_ifa(ifa);
522}
523
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000524/* Caller must hold RCU or RTNL :
525 * We dont take a reference on found in_device
526 */
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800527struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528{
529 struct net_device *dev;
530 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000531
532 rcu_read_lock();
533 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 if (dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000535 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000536 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return in_dev;
538}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800539EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
541/* Called only from RTNL semaphored context. No locks. */
542
Al Viro60cad5d2006-09-26 22:17:09 -0700543struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
544 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
546 ASSERT_RTNL();
547
548 for_primary_ifa(in_dev) {
549 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
550 return ifa;
551 } endfor_ifa(in_dev);
552 return NULL;
553}
554
Madhu Challa93a714d2015-02-25 09:58:35 -0800555static int ip_mc_config(struct sock *sk, bool join, const struct in_ifaddr *ifa)
556{
557 struct ip_mreqn mreq = {
558 .imr_multiaddr.s_addr = ifa->ifa_address,
559 .imr_ifindex = ifa->ifa_dev->dev->ifindex,
560 };
561 int ret;
562
563 ASSERT_RTNL();
564
565 lock_sock(sk);
566 if (join)
Marcelo Ricardo Leitner54ff9ef2015-03-18 14:50:43 -0300567 ret = ip_mc_join_group(sk, &mreq);
Madhu Challa93a714d2015-02-25 09:58:35 -0800568 else
Marcelo Ricardo Leitner54ff9ef2015-03-18 14:50:43 -0300569 ret = ip_mc_leave_group(sk, &mreq);
Madhu Challa93a714d2015-02-25 09:58:35 -0800570 release_sock(sk);
571
572 return ret;
573}
574
Thomas Graf661d2962013-03-21 07:45:29 +0000575static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900577 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700578 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700580 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700582 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 ASSERT_RTNL();
585
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700586 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
587 if (err < 0)
588 goto errout;
589
590 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800591 in_dev = inetdev_by_index(net, ifm->ifa_index);
Ian Morris51456b22015-04-03 09:17:26 +0100592 if (!in_dev) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700593 err = -ENODEV;
594 goto errout;
595 }
596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
598 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700599 if (tb[IFA_LOCAL] &&
Jiri Benc67b61f62015-03-29 16:59:26 +0200600 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700602
603 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
604 continue;
605
606 if (tb[IFA_ADDRESS] &&
607 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Jiri Benc67b61f62015-03-29 16:59:26 +0200608 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700609 continue;
610
Madhu Challa93a714d2015-02-25 09:58:35 -0800611 if (ipv4_is_multicast(ifa->ifa_address))
612 ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
Eric W. Biederman15e47302012-09-07 20:12:54 +0000613 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return 0;
615 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700616
617 err = -EADDRNOTAVAIL;
618errout:
619 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620}
621
Jiri Pirko5c766d62013-01-24 09:41:41 +0000622#define INFINITY_LIFE_TIME 0xFFFFFFFF
623
624static void check_lifetime(struct work_struct *work)
625{
626 unsigned long now, next, next_sec, next_sched;
627 struct in_ifaddr *ifa;
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000628 struct hlist_node *n;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000629 int i;
630
631 now = jiffies;
632 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
633
Jiri Pirko5c766d62013-01-24 09:41:41 +0000634 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000635 bool change_needed = false;
636
637 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800638 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
Jiri Pirko5c766d62013-01-24 09:41:41 +0000639 unsigned long age;
640
641 if (ifa->ifa_flags & IFA_F_PERMANENT)
642 continue;
643
644 /* We try to batch several events at once. */
645 age = (now - ifa->ifa_tstamp +
646 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
647
648 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
649 age >= ifa->ifa_valid_lft) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000650 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000651 } else if (ifa->ifa_preferred_lft ==
652 INFINITY_LIFE_TIME) {
653 continue;
654 } else if (age >= ifa->ifa_preferred_lft) {
655 if (time_before(ifa->ifa_tstamp +
656 ifa->ifa_valid_lft * HZ, next))
657 next = ifa->ifa_tstamp +
658 ifa->ifa_valid_lft * HZ;
659
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000660 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
661 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000662 } else if (time_before(ifa->ifa_tstamp +
663 ifa->ifa_preferred_lft * HZ,
664 next)) {
665 next = ifa->ifa_tstamp +
666 ifa->ifa_preferred_lft * HZ;
667 }
668 }
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000669 rcu_read_unlock();
670 if (!change_needed)
671 continue;
672 rtnl_lock();
673 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
674 unsigned long age;
675
676 if (ifa->ifa_flags & IFA_F_PERMANENT)
677 continue;
678
679 /* We try to batch several events at once. */
680 age = (now - ifa->ifa_tstamp +
681 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
682
683 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
684 age >= ifa->ifa_valid_lft) {
685 struct in_ifaddr **ifap;
686
687 for (ifap = &ifa->ifa_dev->ifa_list;
688 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
689 if (*ifap == ifa) {
690 inet_del_ifa(ifa->ifa_dev,
691 ifap, 1);
692 break;
693 }
694 }
695 } else if (ifa->ifa_preferred_lft !=
696 INFINITY_LIFE_TIME &&
697 age >= ifa->ifa_preferred_lft &&
698 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
699 ifa->ifa_flags |= IFA_F_DEPRECATED;
700 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
701 }
702 }
703 rtnl_unlock();
Jiri Pirko5c766d62013-01-24 09:41:41 +0000704 }
Jiri Pirko5c766d62013-01-24 09:41:41 +0000705
706 next_sec = round_jiffies_up(next);
707 next_sched = next;
708
709 /* If rounded timeout is accurate enough, accept it. */
710 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
711 next_sched = next_sec;
712
713 now = jiffies;
714 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
715 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
716 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
717
viresh kumar906e0732014-01-22 12:23:32 +0530718 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
719 next_sched - now);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000720}
721
722static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
723 __u32 prefered_lft)
724{
725 unsigned long timeout;
726
727 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
728
729 timeout = addrconf_timeout_fixup(valid_lft, HZ);
730 if (addrconf_finite_timeout(timeout))
731 ifa->ifa_valid_lft = timeout;
732 else
733 ifa->ifa_flags |= IFA_F_PERMANENT;
734
735 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
736 if (addrconf_finite_timeout(timeout)) {
737 if (timeout == 0)
738 ifa->ifa_flags |= IFA_F_DEPRECATED;
739 ifa->ifa_preferred_lft = timeout;
740 }
741 ifa->ifa_tstamp = jiffies;
742 if (!ifa->ifa_cstamp)
743 ifa->ifa_cstamp = ifa->ifa_tstamp;
744}
745
746static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
747 __u32 *pvalid_lft, __u32 *pprefered_lft)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Thomas Graf5c753972006-08-04 23:03:53 -0700749 struct nlattr *tb[IFA_MAX+1];
750 struct in_ifaddr *ifa;
751 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 struct net_device *dev;
753 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800754 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Thomas Graf5c753972006-08-04 23:03:53 -0700756 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
757 if (err < 0)
758 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Thomas Graf5c753972006-08-04 23:03:53 -0700760 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800761 err = -EINVAL;
Ian Morris51456b22015-04-03 09:17:26 +0100762 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
Thomas Graf5c753972006-08-04 23:03:53 -0700763 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800765 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800766 err = -ENODEV;
Ian Morris51456b22015-04-03 09:17:26 +0100767 if (!dev)
Thomas Graf5c753972006-08-04 23:03:53 -0700768 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Thomas Graf5c753972006-08-04 23:03:53 -0700770 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800771 err = -ENOBUFS;
Ian Morris51456b22015-04-03 09:17:26 +0100772 if (!in_dev)
Herbert Xu71e27da2007-06-04 23:36:06 -0700773 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Thomas Graf5c753972006-08-04 23:03:53 -0700775 ifa = inet_alloc_ifa();
Ian Morris51456b22015-04-03 09:17:26 +0100776 if (!ifa)
Thomas Graf5c753972006-08-04 23:03:53 -0700777 /*
778 * A potential indev allocation can be left alive, it stays
779 * assigned to its device and is destroy with it.
780 */
Thomas Graf5c753972006-08-04 23:03:53 -0700781 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700782
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800783 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100784 neigh_parms_data_state_setall(in_dev->arp_parms);
Thomas Graf5c753972006-08-04 23:03:53 -0700785 in_dev_hold(in_dev);
786
Ian Morris51456b22015-04-03 09:17:26 +0100787 if (!tb[IFA_ADDRESS])
Thomas Graf5c753972006-08-04 23:03:53 -0700788 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
789
David S. Millerfd23c3b2011-02-18 12:42:28 -0800790 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
792 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Jiri Pirkoad6c8132013-12-08 12:16:10 +0100793 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
794 ifm->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700796 ifa->ifa_dev = in_dev;
797
Jiri Benc67b61f62015-03-29 16:59:26 +0200798 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
799 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700800
801 if (tb[IFA_BROADCAST])
Jiri Benc67b61f62015-03-29 16:59:26 +0200802 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700803
Thomas Graf5c753972006-08-04 23:03:53 -0700804 if (tb[IFA_LABEL])
805 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 else
807 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
808
Jiri Pirko5c766d62013-01-24 09:41:41 +0000809 if (tb[IFA_CACHEINFO]) {
810 struct ifa_cacheinfo *ci;
811
812 ci = nla_data(tb[IFA_CACHEINFO]);
813 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
814 err = -EINVAL;
Daniel Borkmann446266b2013-08-02 11:32:43 +0200815 goto errout_free;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000816 }
817 *pvalid_lft = ci->ifa_valid;
818 *pprefered_lft = ci->ifa_prefered;
819 }
820
Thomas Graf5c753972006-08-04 23:03:53 -0700821 return ifa;
822
Daniel Borkmann446266b2013-08-02 11:32:43 +0200823errout_free:
824 inet_free_ifa(ifa);
Thomas Graf5c753972006-08-04 23:03:53 -0700825errout:
826 return ERR_PTR(err);
827}
828
Jiri Pirko5c766d62013-01-24 09:41:41 +0000829static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
830{
831 struct in_device *in_dev = ifa->ifa_dev;
832 struct in_ifaddr *ifa1, **ifap;
833
834 if (!ifa->ifa_local)
835 return NULL;
836
837 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
838 ifap = &ifa1->ifa_next) {
839 if (ifa1->ifa_mask == ifa->ifa_mask &&
840 inet_ifa_match(ifa1->ifa_address, ifa) &&
841 ifa1->ifa_local == ifa->ifa_local)
842 return ifa1;
843 }
844 return NULL;
845}
846
Thomas Graf661d2962013-03-21 07:45:29 +0000847static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Graf5c753972006-08-04 23:03:53 -0700848{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900849 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700850 struct in_ifaddr *ifa;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000851 struct in_ifaddr *ifa_existing;
852 __u32 valid_lft = INFINITY_LIFE_TIME;
853 __u32 prefered_lft = INFINITY_LIFE_TIME;
Thomas Graf5c753972006-08-04 23:03:53 -0700854
855 ASSERT_RTNL();
856
Jiri Pirko5c766d62013-01-24 09:41:41 +0000857 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
Thomas Graf5c753972006-08-04 23:03:53 -0700858 if (IS_ERR(ifa))
859 return PTR_ERR(ifa);
860
Jiri Pirko5c766d62013-01-24 09:41:41 +0000861 ifa_existing = find_matching_ifa(ifa);
862 if (!ifa_existing) {
863 /* It would be best to check for !NLM_F_CREATE here but
stephen hemminger614d0562014-05-16 20:46:58 -0700864 * userspace already relies on not having to provide this.
Jiri Pirko5c766d62013-01-24 09:41:41 +0000865 */
866 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
Madhu Challa93a714d2015-02-25 09:58:35 -0800867 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
868 int ret = ip_mc_config(net->ipv4.mc_autojoin_sk,
869 true, ifa);
870
871 if (ret < 0) {
872 inet_free_ifa(ifa);
873 return ret;
874 }
875 }
Jiri Pirko5c766d62013-01-24 09:41:41 +0000876 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
877 } else {
878 inet_free_ifa(ifa);
879
880 if (nlh->nlmsg_flags & NLM_F_EXCL ||
881 !(nlh->nlmsg_flags & NLM_F_REPLACE))
882 return -EEXIST;
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000883 ifa = ifa_existing;
884 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
Jiri Pirko05a324b2013-04-04 23:39:38 +0000885 cancel_delayed_work(&check_lifetime_work);
viresh kumar906e0732014-01-22 12:23:32 +0530886 queue_delayed_work(system_power_efficient_wq,
887 &check_lifetime_work, 0);
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000888 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000889 }
890 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891}
892
893/*
894 * Determine a default network mask, based on the IP address.
895 */
896
Eric Dumazet40384992012-08-03 21:06:50 +0000897static int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898{
899 int rc = -1; /* Something else, probably a multicast. */
900
Joe Perchesf97c1e02007-12-16 13:45:43 -0800901 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900902 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 else {
Al Viro714e85b2006-11-14 20:51:49 -0800904 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
Al Viro714e85b2006-11-14 20:51:49 -0800906 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800908 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800910 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 rc = 24;
912 }
913
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900914 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
916
917
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800918int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
920 struct ifreq ifr;
921 struct sockaddr_in sin_orig;
922 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
923 struct in_device *in_dev;
924 struct in_ifaddr **ifap = NULL;
925 struct in_ifaddr *ifa = NULL;
926 struct net_device *dev;
927 char *colon;
928 int ret = -EFAULT;
929 int tryaddrmatch = 0;
930
931 /*
932 * Fetch the caller's info block into kernel space
933 */
934
935 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
936 goto out;
937 ifr.ifr_name[IFNAMSIZ - 1] = 0;
938
939 /* save original address for comparison */
940 memcpy(&sin_orig, sin, sizeof(*sin));
941
942 colon = strchr(ifr.ifr_name, ':');
943 if (colon)
944 *colon = 0;
945
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800946 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
Stephen Hemminger132adf52007-03-08 20:44:43 -0800948 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 case SIOCGIFADDR: /* Get interface address */
950 case SIOCGIFBRDADDR: /* Get the broadcast address */
951 case SIOCGIFDSTADDR: /* Get the destination address */
952 case SIOCGIFNETMASK: /* Get the netmask for the interface */
953 /* Note that these ioctls will not sleep,
954 so that we do not impose a lock.
955 One day we will be forced to put shlock here (I mean SMP)
956 */
957 tryaddrmatch = (sin_orig.sin_family == AF_INET);
958 memset(sin, 0, sizeof(*sin));
959 sin->sin_family = AF_INET;
960 break;
961
962 case SIOCSIFFLAGS:
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000963 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000964 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 goto out;
966 break;
967 case SIOCSIFADDR: /* Set interface address (and family) */
968 case SIOCSIFBRDADDR: /* Set the broadcast address */
969 case SIOCSIFDSTADDR: /* Set the destination address */
970 case SIOCSIFNETMASK: /* Set the netmask for the interface */
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000971 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000972 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 goto out;
974 ret = -EINVAL;
975 if (sin->sin_family != AF_INET)
976 goto out;
977 break;
978 default:
979 ret = -EINVAL;
980 goto out;
981 }
982
983 rtnl_lock();
984
985 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800986 dev = __dev_get_by_name(net, ifr.ifr_name);
987 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 goto done;
989
990 if (colon)
991 *colon = ':';
992
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800993 in_dev = __in_dev_get_rtnl(dev);
994 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 if (tryaddrmatch) {
996 /* Matthias Andree */
997 /* compare label and address (4.4BSD style) */
998 /* note: we only do this for a limited set of ioctls
999 and only if the original address family was AF_INET.
1000 This is checked above. */
1001 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1002 ifap = &ifa->ifa_next) {
1003 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
1004 sin_orig.sin_addr.s_addr ==
David S. Miller6c91afe2011-03-09 13:27:16 -08001005 ifa->ifa_local) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 break; /* found */
1007 }
1008 }
1009 }
1010 /* we didn't get a match, maybe the application is
1011 4.3BSD-style and passed in junk so we fall back to
1012 comparing just the label */
1013 if (!ifa) {
1014 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1015 ifap = &ifa->ifa_next)
1016 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
1017 break;
1018 }
1019 }
1020
1021 ret = -EADDRNOTAVAIL;
1022 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
1023 goto done;
1024
Stephen Hemminger132adf52007-03-08 20:44:43 -08001025 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 case SIOCGIFADDR: /* Get interface address */
1027 sin->sin_addr.s_addr = ifa->ifa_local;
1028 goto rarok;
1029
1030 case SIOCGIFBRDADDR: /* Get the broadcast address */
1031 sin->sin_addr.s_addr = ifa->ifa_broadcast;
1032 goto rarok;
1033
1034 case SIOCGIFDSTADDR: /* Get the destination address */
1035 sin->sin_addr.s_addr = ifa->ifa_address;
1036 goto rarok;
1037
1038 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1039 sin->sin_addr.s_addr = ifa->ifa_mask;
1040 goto rarok;
1041
1042 case SIOCSIFFLAGS:
1043 if (colon) {
1044 ret = -EADDRNOTAVAIL;
1045 if (!ifa)
1046 break;
1047 ret = 0;
1048 if (!(ifr.ifr_flags & IFF_UP))
1049 inet_del_ifa(in_dev, ifap, 1);
1050 break;
1051 }
1052 ret = dev_change_flags(dev, ifr.ifr_flags);
1053 break;
1054
1055 case SIOCSIFADDR: /* Set interface address (and family) */
1056 ret = -EINVAL;
1057 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1058 break;
1059
1060 if (!ifa) {
1061 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001062 ifa = inet_alloc_ifa();
1063 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 break;
Xi Wangc7e2e1d2013-01-05 11:19:24 +00001065 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 if (colon)
1067 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1068 else
1069 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1070 } else {
1071 ret = 0;
1072 if (ifa->ifa_local == sin->sin_addr.s_addr)
1073 break;
1074 inet_del_ifa(in_dev, ifap, 0);
1075 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -08001076 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 }
1078
1079 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1080
1081 if (!(dev->flags & IFF_POINTOPOINT)) {
1082 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1083 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1084 if ((dev->flags & IFF_BROADCAST) &&
1085 ifa->ifa_prefixlen < 31)
1086 ifa->ifa_broadcast = ifa->ifa_address |
1087 ~ifa->ifa_mask;
1088 } else {
1089 ifa->ifa_prefixlen = 32;
1090 ifa->ifa_mask = inet_make_mask(32);
1091 }
Jiri Pirko5c766d62013-01-24 09:41:41 +00001092 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 ret = inet_set_ifa(dev, ifa);
1094 break;
1095
1096 case SIOCSIFBRDADDR: /* Set the broadcast address */
1097 ret = 0;
1098 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1099 inet_del_ifa(in_dev, ifap, 0);
1100 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1101 inet_insert_ifa(ifa);
1102 }
1103 break;
1104
1105 case SIOCSIFDSTADDR: /* Set the destination address */
1106 ret = 0;
1107 if (ifa->ifa_address == sin->sin_addr.s_addr)
1108 break;
1109 ret = -EINVAL;
1110 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1111 break;
1112 ret = 0;
1113 inet_del_ifa(in_dev, ifap, 0);
1114 ifa->ifa_address = sin->sin_addr.s_addr;
1115 inet_insert_ifa(ifa);
1116 break;
1117
1118 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1119
1120 /*
1121 * The mask we set must be legal.
1122 */
1123 ret = -EINVAL;
1124 if (bad_mask(sin->sin_addr.s_addr, 0))
1125 break;
1126 ret = 0;
1127 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -07001128 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 inet_del_ifa(in_dev, ifap, 0);
1130 ifa->ifa_mask = sin->sin_addr.s_addr;
1131 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1132
1133 /* See if current broadcast address matches
1134 * with current netmask, then recalculate
1135 * the broadcast address. Otherwise it's a
1136 * funny address, so don't touch it since
1137 * the user seems to know what (s)he's doing...
1138 */
1139 if ((dev->flags & IFF_BROADCAST) &&
1140 (ifa->ifa_prefixlen < 31) &&
1141 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -05001142 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 ifa->ifa_broadcast = (ifa->ifa_local |
1144 ~sin->sin_addr.s_addr);
1145 }
1146 inet_insert_ifa(ifa);
1147 }
1148 break;
1149 }
1150done:
1151 rtnl_unlock();
1152out:
1153 return ret;
1154rarok:
1155 rtnl_unlock();
1156 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1157 goto out;
1158}
1159
1160static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1161{
Herbert Xue5ed6392005-10-03 14:35:55 -07001162 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 struct in_ifaddr *ifa;
1164 struct ifreq ifr;
1165 int done = 0;
1166
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001167 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 goto out;
1169
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001170 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 if (!buf) {
1172 done += sizeof(ifr);
1173 continue;
1174 }
1175 if (len < (int) sizeof(ifr))
1176 break;
1177 memset(&ifr, 0, sizeof(struct ifreq));
Dan Carpenter4299c8a2013-07-29 22:15:19 +03001178 strcpy(ifr.ifr_name, ifa->ifa_label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1181 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1182 ifa->ifa_local;
1183
1184 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1185 done = -EFAULT;
1186 break;
1187 }
1188 buf += sizeof(struct ifreq);
1189 len -= sizeof(struct ifreq);
1190 done += sizeof(struct ifreq);
1191 }
1192out:
1193 return done;
1194}
1195
Al Viroa61ced52006-09-26 21:27:54 -07001196__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197{
Al Viroa61ced52006-09-26 21:27:54 -07001198 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001200 struct net *net = dev_net(dev);
David Ahern3f2fb9a2016-02-24 11:47:02 -08001201 int master_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
1203 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -07001204 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 if (!in_dev)
1206 goto no_in_dev;
1207
1208 for_primary_ifa(in_dev) {
1209 if (ifa->ifa_scope > scope)
1210 continue;
1211 if (!dst || inet_ifa_match(dst, ifa)) {
1212 addr = ifa->ifa_local;
1213 break;
1214 }
1215 if (!addr)
1216 addr = ifa->ifa_local;
1217 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
1219 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001220 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001221no_in_dev:
David Ahern3f2fb9a2016-02-24 11:47:02 -08001222 master_idx = l3mdev_master_ifindex_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
David Lamparter17b693c2016-02-24 11:47:03 -08001224 /* For VRFs, the VRF device takes the place of the loopback device,
1225 * with addresses on it being preferred. Note in such cases the
1226 * loopback device will be among the devices that fail the master_idx
1227 * equality check in the loop below.
1228 */
1229 if (master_idx &&
1230 (dev = dev_get_by_index_rcu(net, master_idx)) &&
1231 (in_dev = __in_dev_get_rcu(dev))) {
1232 for_primary_ifa(in_dev) {
1233 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1234 ifa->ifa_scope <= scope) {
1235 addr = ifa->ifa_local;
1236 goto out_unlock;
1237 }
1238 } endfor_ifa(in_dev);
1239 }
1240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 /* Not loopback addresses on loopback should be preferred
Stephen Hemmingerca9f1fd2015-02-14 13:47:54 -05001242 in this case. It is important that lo is the first interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 in dev_base list.
1244 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001245 for_each_netdev_rcu(net, dev) {
David Ahern3f2fb9a2016-02-24 11:47:02 -08001246 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1247 continue;
1248
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001249 in_dev = __in_dev_get_rcu(dev);
1250 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 continue;
1252
1253 for_primary_ifa(in_dev) {
1254 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1255 ifa->ifa_scope <= scope) {
1256 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001257 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 }
1259 } endfor_ifa(in_dev);
1260 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001261out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 return addr;
1264}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001265EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
Al Viro60cad5d2006-09-26 22:17:09 -07001267static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1268 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269{
1270 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -07001271 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
1273 for_ifa(in_dev) {
1274 if (!addr &&
1275 (local == ifa->ifa_local || !local) &&
1276 ifa->ifa_scope <= scope) {
1277 addr = ifa->ifa_local;
1278 if (same)
1279 break;
1280 }
1281 if (!same) {
1282 same = (!local || inet_ifa_match(local, ifa)) &&
1283 (!dst || inet_ifa_match(dst, ifa));
1284 if (same && addr) {
1285 if (local || !dst)
1286 break;
1287 /* Is the selected addr into dst subnet? */
1288 if (inet_ifa_match(addr, ifa))
1289 break;
1290 /* No, then can we use new local src? */
1291 if (ifa->ifa_scope <= scope) {
1292 addr = ifa->ifa_local;
1293 break;
1294 }
1295 /* search for large dst subnet for addr */
1296 same = 0;
1297 }
1298 }
1299 } endfor_ifa(in_dev);
1300
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001301 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302}
1303
1304/*
1305 * Confirm that local IP address exists using wildcards:
Nicolas Dichtelb601fa12013-12-10 15:02:40 +01001306 * - net: netns to check, cannot be NULL
1307 * - in_dev: only on this interface, NULL=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 * - dst: only in the same subnet as dst, 0=any dst
1309 * - local: address, 0=autoselect the local address
1310 * - scope: maximum allowed scope value for the local address
1311 */
Nicolas Dichtelb601fa12013-12-10 15:02:40 +01001312__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001313 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314{
Al Viro60cad5d2006-09-26 22:17:09 -07001315 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001316 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
Ian Morris00db4122015-04-03 09:17:27 +01001318 if (in_dev)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001319 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001322 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001323 in_dev = __in_dev_get_rcu(dev);
1324 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 addr = confirm_addr_indev(in_dev, dst, local, scope);
1326 if (addr)
1327 break;
1328 }
1329 }
1330 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
1332 return addr;
1333}
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00001334EXPORT_SYMBOL(inet_confirm_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
1336/*
1337 * Device notifier
1338 */
1339
1340int register_inetaddr_notifier(struct notifier_block *nb)
1341{
Alan Sterne041c682006-03-27 01:16:30 -08001342 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001344EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
1346int unregister_inetaddr_notifier(struct notifier_block *nb)
1347{
Alan Sterne041c682006-03-27 01:16:30 -08001348 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001350EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001352/* Rename ifa_labels for a device name change. Make some effort to preserve
1353 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354*/
1355static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001356{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 struct in_ifaddr *ifa;
1358 int named = 0;
1359
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001360 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1361 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
1363 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001364 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001366 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001367 dot = strchr(old, ':');
Ian Morris51456b22015-04-03 09:17:26 +01001368 if (!dot) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001369 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 dot = old;
1371 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001372 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001373 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001374 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001375 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001376skip:
1377 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001378 }
1379}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
Eric Dumazet40384992012-08-03 21:06:50 +00001381static bool inetdev_valid_mtu(unsigned int mtu)
Breno Leitao06770842008-09-02 17:28:58 -07001382{
1383 return mtu >= 68;
1384}
1385
Ian Campbelld11327ad2011-02-11 07:44:16 +00001386static void inetdev_send_gratuitous_arp(struct net_device *dev,
1387 struct in_device *in_dev)
1388
1389{
Zoltan Kissb76d0782011-07-24 13:09:30 +00001390 struct in_ifaddr *ifa;
Ian Campbelld11327ad2011-02-11 07:44:16 +00001391
Zoltan Kissb76d0782011-07-24 13:09:30 +00001392 for (ifa = in_dev->ifa_list; ifa;
1393 ifa = ifa->ifa_next) {
1394 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1395 ifa->ifa_local, dev,
1396 ifa->ifa_local, NULL,
1397 dev->dev_addr, NULL);
1398 }
Ian Campbelld11327ad2011-02-11 07:44:16 +00001399}
1400
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401/* Called only under RTNL semaphore */
1402
1403static int inetdev_event(struct notifier_block *this, unsigned long event,
1404 void *ptr)
1405{
Jiri Pirko351638e2013-05-28 01:30:21 +00001406 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Eric Dumazet748e2d92012-08-22 21:50:59 +00001407 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409 ASSERT_RTNL();
1410
1411 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001412 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 in_dev = inetdev_init(dev);
WANG Cong20e61da2014-07-25 15:25:08 -07001414 if (IS_ERR(in_dev))
1415 return notifier_from_errno(PTR_ERR(in_dev));
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001416 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001417 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1418 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001419 }
Breno Leitao06770842008-09-02 17:28:58 -07001420 } else if (event == NETDEV_CHANGEMTU) {
1421 /* Re-enabling IP */
1422 if (inetdev_valid_mtu(dev->mtu))
1423 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 }
1425 goto out;
1426 }
1427
1428 switch (event) {
1429 case NETDEV_REGISTER:
Joe Perches91df42b2012-05-15 14:11:54 +00001430 pr_debug("%s: bug\n", __func__);
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +00001431 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 break;
1433 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001434 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001436 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001437 struct in_ifaddr *ifa = inet_alloc_ifa();
1438
1439 if (ifa) {
David S. Millerfd23c3b2011-02-18 12:42:28 -08001440 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 ifa->ifa_local =
1442 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1443 ifa->ifa_prefixlen = 8;
1444 ifa->ifa_mask = inet_make_mask(8);
1445 in_dev_hold(in_dev);
1446 ifa->ifa_dev = in_dev;
1447 ifa->ifa_scope = RT_SCOPE_HOST;
1448 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Jiri Pirko5c766d62013-01-24 09:41:41 +00001449 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1450 INFINITY_LIFE_TIME);
Jiri Pirkodfd15822014-01-07 15:55:45 +01001451 ipv4_devconf_setall(in_dev);
1452 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 inet_insert_ifa(ifa);
1454 }
1455 }
1456 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001457 /* fall through */
1458 case NETDEV_CHANGEADDR:
Ian Campbelld11327ad2011-02-11 07:44:16 +00001459 if (!IN_DEV_ARP_NOTIFY(in_dev))
1460 break;
1461 /* fall through */
1462 case NETDEV_NOTIFY_PEERS:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001463 /* Send gratuitous ARP to notify of link change */
Ian Campbelld11327ad2011-02-11 07:44:16 +00001464 inetdev_send_gratuitous_arp(dev, in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 break;
1466 case NETDEV_DOWN:
1467 ip_mc_down(in_dev);
1468 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001469 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001470 ip_mc_unmap(in_dev);
1471 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001472 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001473 ip_mc_remap(in_dev);
1474 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001476 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 break;
Breno Leitao06770842008-09-02 17:28:58 -07001478 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 case NETDEV_UNREGISTER:
1480 inetdev_destroy(in_dev);
1481 break;
1482 case NETDEV_CHANGENAME:
1483 /* Do not notify about label change, this event is
1484 * not interesting to applications using netlink.
1485 */
1486 inetdev_changename(dev, in_dev);
1487
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001488 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001489 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 break;
1491 }
1492out:
1493 return NOTIFY_DONE;
1494}
1495
1496static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001497 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498};
1499
Eric Dumazet40384992012-08-03 21:06:50 +00001500static size_t inet_nlmsg_size(void)
Thomas Graf339bf982006-11-10 14:10:15 -08001501{
1502 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1503 + nla_total_size(4) /* IFA_ADDRESS */
1504 + nla_total_size(4) /* IFA_LOCAL */
1505 + nla_total_size(4) /* IFA_BROADCAST */
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001506 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
Geert Uytterhoeven63b5f152014-02-05 08:38:25 +01001507 + nla_total_size(4) /* IFA_FLAGS */
1508 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
Thomas Graf339bf982006-11-10 14:10:15 -08001509}
1510
Jiri Pirko5c766d62013-01-24 09:41:41 +00001511static inline u32 cstamp_delta(unsigned long cstamp)
1512{
1513 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1514}
1515
1516static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1517 unsigned long tstamp, u32 preferred, u32 valid)
1518{
1519 struct ifa_cacheinfo ci;
1520
1521 ci.cstamp = cstamp_delta(cstamp);
1522 ci.tstamp = cstamp_delta(tstamp);
1523 ci.ifa_prefered = preferred;
1524 ci.ifa_valid = valid;
1525
1526 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1527}
1528
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001530 u32 portid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531{
1532 struct ifaddrmsg *ifm;
1533 struct nlmsghdr *nlh;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001534 u32 preferred, valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535
Eric W. Biederman15e47302012-09-07 20:12:54 +00001536 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
Ian Morris51456b22015-04-03 09:17:26 +01001537 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08001538 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001539
1540 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 ifm->ifa_family = AF_INET;
1542 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001543 ifm->ifa_flags = ifa->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 ifm->ifa_scope = ifa->ifa_scope;
1545 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
Jiri Pirko5c766d62013-01-24 09:41:41 +00001547 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1548 preferred = ifa->ifa_preferred_lft;
1549 valid = ifa->ifa_valid_lft;
1550 if (preferred != INFINITY_LIFE_TIME) {
1551 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1552
1553 if (preferred > tval)
1554 preferred -= tval;
1555 else
1556 preferred = 0;
1557 if (valid != INFINITY_LIFE_TIME) {
1558 if (valid > tval)
1559 valid -= tval;
1560 else
1561 valid = 0;
1562 }
1563 }
1564 } else {
1565 preferred = INFINITY_LIFE_TIME;
1566 valid = INFINITY_LIFE_TIME;
1567 }
David S. Millerf3756b72012-04-01 20:39:02 -04001568 if ((ifa->ifa_address &&
Jiri Benc930345e2015-03-29 16:59:25 +02001569 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
David S. Millerf3756b72012-04-01 20:39:02 -04001570 (ifa->ifa_local &&
Jiri Benc930345e2015-03-29 16:59:25 +02001571 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
David S. Millerf3756b72012-04-01 20:39:02 -04001572 (ifa->ifa_broadcast &&
Jiri Benc930345e2015-03-29 16:59:25 +02001573 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
David S. Millerf3756b72012-04-01 20:39:02 -04001574 (ifa->ifa_label[0] &&
Jiri Pirko5c766d62013-01-24 09:41:41 +00001575 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001576 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
Jiri Pirko5c766d62013-01-24 09:41:41 +00001577 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1578 preferred, valid))
David S. Millerf3756b72012-04-01 20:39:02 -04001579 goto nla_put_failure;
Thomas Graf47f68512006-08-04 23:04:36 -07001580
Johannes Berg053c0952015-01-16 22:09:00 +01001581 nlmsg_end(skb, nlh);
1582 return 0;
Thomas Graf47f68512006-08-04 23:04:36 -07001583
1584nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001585 nlmsg_cancel(skb, nlh);
1586 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587}
1588
1589static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1590{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001591 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001592 int h, s_h;
1593 int idx, s_idx;
1594 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 struct net_device *dev;
1596 struct in_device *in_dev;
1597 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001598 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Eric Dumazeteec4df92009-11-12 07:44:25 +00001600 s_h = cb->args[0];
1601 s_idx = idx = cb->args[1];
1602 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
Eric Dumazeteec4df92009-11-12 07:44:25 +00001604 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1605 idx = 0;
1606 head = &net->dev_index_head[h];
1607 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001608 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1609 net->dev_base_seq;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001610 hlist_for_each_entry_rcu(dev, head, index_hlist) {
Eric Dumazeteec4df92009-11-12 07:44:25 +00001611 if (idx < s_idx)
1612 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001613 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001614 s_ip_idx = 0;
1615 in_dev = __in_dev_get_rcu(dev);
1616 if (!in_dev)
1617 goto cont;
1618
1619 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1620 ifa = ifa->ifa_next, ip_idx++) {
1621 if (ip_idx < s_ip_idx)
1622 continue;
1623 if (inet_fill_ifaddr(skb, ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001624 NETLINK_CB(cb->skb).portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 cb->nlh->nlmsg_seq,
Johannes Berg053c0952015-01-16 22:09:00 +01001626 RTM_NEWADDR, NLM_F_MULTI) < 0) {
Eric Dumazeteec4df92009-11-12 07:44:25 +00001627 rcu_read_unlock();
1628 goto done;
1629 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001630 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Eric Dumazeteec4df92009-11-12 07:44:25 +00001631 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001632cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001633 idx++;
1634 }
1635 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 }
1637
1638done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001639 cb->args[0] = h;
1640 cb->args[1] = idx;
1641 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
1643 return skb->len;
1644}
1645
Jianjun Kong539afed2008-11-03 02:48:48 -08001646static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001647 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
Thomas Graf47f68512006-08-04 23:04:36 -07001649 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001650 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1651 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001652 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001654 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001655 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01001656 if (!skb)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001657 goto errout;
1658
Eric W. Biederman15e47302012-09-07 20:12:54 +00001659 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001660 if (err < 0) {
1661 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1662 WARN_ON(err == -EMSGSIZE);
1663 kfree_skb(skb);
1664 goto errout;
1665 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00001666 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001667 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001668errout:
1669 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001670 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671}
1672
Arad, Ronenb1974ed2015-10-19 09:23:28 -07001673static size_t inet_get_link_af_size(const struct net_device *dev,
1674 u32 ext_filter_mask)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001675{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001676 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001677
1678 if (!in_dev)
1679 return 0;
1680
1681 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1682}
1683
Sowmini Varadhand5566fd2015-09-11 16:48:48 -04001684static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1685 u32 ext_filter_mask)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001686{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001687 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001688 struct nlattr *nla;
1689 int i;
1690
1691 if (!in_dev)
1692 return -ENODATA;
1693
1694 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
Ian Morris51456b22015-04-03 09:17:26 +01001695 if (!nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001696 return -EMSGSIZE;
1697
1698 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1699 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1700
1701 return 0;
1702}
1703
1704static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1705 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1706};
1707
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001708static int inet_validate_link_af(const struct net_device *dev,
1709 const struct nlattr *nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001710{
Thomas Graf9f0f7272010-11-16 04:32:48 +00001711 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1712 int err, rem;
1713
Eric Dumazetf7fce742010-12-01 06:03:06 +00001714 if (dev && !__in_dev_get_rtnl(dev))
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001715 return -EAFNOSUPPORT;
Thomas Graf9f0f7272010-11-16 04:32:48 +00001716
1717 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1718 if (err < 0)
1719 return err;
1720
1721 if (tb[IFLA_INET_CONF]) {
1722 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1723 int cfgid = nla_type(a);
1724
1725 if (nla_len(a) < 4)
1726 return -EINVAL;
1727
1728 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1729 return -EINVAL;
1730 }
1731 }
1732
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001733 return 0;
1734}
1735
1736static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1737{
Eric Dumazetf7fce742010-12-01 06:03:06 +00001738 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001739 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1740 int rem;
1741
1742 if (!in_dev)
1743 return -EAFNOSUPPORT;
1744
1745 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1746 BUG();
1747
Thomas Graf9f0f7272010-11-16 04:32:48 +00001748 if (tb[IFLA_INET_CONF]) {
1749 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1750 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1751 }
1752
1753 return 0;
1754}
1755
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001756static int inet_netconf_msgsize_devconf(int type)
1757{
1758 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1759 + nla_total_size(4); /* NETCONFA_IFINDEX */
Zhang Shengju136ba622016-03-10 08:55:50 +00001760 bool all = false;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001761
Zhang Shengju136ba622016-03-10 08:55:50 +00001762 if (type == NETCONFA_ALL)
1763 all = true;
1764
1765 if (all || type == NETCONFA_FORWARDING)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001766 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001767 if (all || type == NETCONFA_RP_FILTER)
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001768 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001769 if (all || type == NETCONFA_MC_FORWARDING)
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001770 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001771 if (all || type == NETCONFA_PROXY_NEIGH)
stephen hemmingerf085ff12013-12-12 13:06:50 -08001772 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001773 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
Andy Gospodarek974d7af2015-07-07 13:56:57 -04001774 size += nla_total_size(4);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001775
1776 return size;
1777}
1778
1779static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1780 struct ipv4_devconf *devconf, u32 portid,
1781 u32 seq, int event, unsigned int flags,
1782 int type)
1783{
1784 struct nlmsghdr *nlh;
1785 struct netconfmsg *ncm;
Zhang Shengju136ba622016-03-10 08:55:50 +00001786 bool all = false;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001787
1788 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1789 flags);
Ian Morris51456b22015-04-03 09:17:26 +01001790 if (!nlh)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001791 return -EMSGSIZE;
1792
Zhang Shengju136ba622016-03-10 08:55:50 +00001793 if (type == NETCONFA_ALL)
1794 all = true;
1795
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001796 ncm = nlmsg_data(nlh);
1797 ncm->ncm_family = AF_INET;
1798
1799 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1800 goto nla_put_failure;
1801
Zhang Shengju136ba622016-03-10 08:55:50 +00001802 if ((all || type == NETCONFA_FORWARDING) &&
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001803 nla_put_s32(skb, NETCONFA_FORWARDING,
1804 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1805 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001806 if ((all || type == NETCONFA_RP_FILTER) &&
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001807 nla_put_s32(skb, NETCONFA_RP_FILTER,
1808 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1809 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001810 if ((all || type == NETCONFA_MC_FORWARDING) &&
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001811 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1812 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1813 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001814 if ((all || type == NETCONFA_PROXY_NEIGH) &&
stephen hemminger09aea5d2013-12-17 22:35:52 -08001815 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08001816 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1817 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001818 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
Andy Gospodarek974d7af2015-07-07 13:56:57 -04001819 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
1820 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
1821 goto nla_put_failure;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001822
Johannes Berg053c0952015-01-16 22:09:00 +01001823 nlmsg_end(skb, nlh);
1824 return 0;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001825
1826nla_put_failure:
1827 nlmsg_cancel(skb, nlh);
1828 return -EMSGSIZE;
1829}
1830
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001831void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
1832 struct ipv4_devconf *devconf)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001833{
1834 struct sk_buff *skb;
1835 int err = -ENOBUFS;
1836
Eric Dumazetfa178062016-07-08 05:18:24 +02001837 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01001838 if (!skb)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001839 goto errout;
1840
1841 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1842 RTM_NEWNETCONF, 0, type);
1843 if (err < 0) {
1844 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1845 WARN_ON(err == -EMSGSIZE);
1846 kfree_skb(skb);
1847 goto errout;
1848 }
Eric Dumazetfa178062016-07-08 05:18:24 +02001849 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001850 return;
1851errout:
1852 if (err < 0)
1853 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1854}
1855
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001856static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1857 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1858 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001859 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
stephen hemminger09aea5d2013-12-17 22:35:52 -08001860 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
Andy Gospodarek974d7af2015-07-07 13:56:57 -04001861 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001862};
1863
1864static int inet_netconf_get_devconf(struct sk_buff *in_skb,
Thomas Graf661d2962013-03-21 07:45:29 +00001865 struct nlmsghdr *nlh)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001866{
1867 struct net *net = sock_net(in_skb->sk);
1868 struct nlattr *tb[NETCONFA_MAX+1];
1869 struct netconfmsg *ncm;
1870 struct sk_buff *skb;
1871 struct ipv4_devconf *devconf;
1872 struct in_device *in_dev;
1873 struct net_device *dev;
1874 int ifindex;
1875 int err;
1876
1877 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1878 devconf_ipv4_policy);
1879 if (err < 0)
1880 goto errout;
1881
Anton Protopopova97eb332016-02-16 21:43:16 -05001882 err = -EINVAL;
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001883 if (!tb[NETCONFA_IFINDEX])
1884 goto errout;
1885
1886 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1887 switch (ifindex) {
1888 case NETCONFA_IFINDEX_ALL:
1889 devconf = net->ipv4.devconf_all;
1890 break;
1891 case NETCONFA_IFINDEX_DEFAULT:
1892 devconf = net->ipv4.devconf_dflt;
1893 break;
1894 default:
1895 dev = __dev_get_by_index(net, ifindex);
Ian Morris51456b22015-04-03 09:17:26 +01001896 if (!dev)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001897 goto errout;
1898 in_dev = __in_dev_get_rtnl(dev);
Ian Morris51456b22015-04-03 09:17:26 +01001899 if (!in_dev)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001900 goto errout;
1901 devconf = &in_dev->cnf;
1902 break;
1903 }
1904
1905 err = -ENOBUFS;
Eric Dumazetfa178062016-07-08 05:18:24 +02001906 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01001907 if (!skb)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001908 goto errout;
1909
1910 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1911 NETLINK_CB(in_skb).portid,
1912 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
Zhang Shengju136ba622016-03-10 08:55:50 +00001913 NETCONFA_ALL);
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001914 if (err < 0) {
1915 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1916 WARN_ON(err == -EMSGSIZE);
1917 kfree_skb(skb);
1918 goto errout;
1919 }
1920 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1921errout:
1922 return err;
1923}
1924
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001925static int inet_netconf_dump_devconf(struct sk_buff *skb,
1926 struct netlink_callback *cb)
1927{
1928 struct net *net = sock_net(skb->sk);
1929 int h, s_h;
1930 int idx, s_idx;
1931 struct net_device *dev;
1932 struct in_device *in_dev;
1933 struct hlist_head *head;
1934
1935 s_h = cb->args[0];
1936 s_idx = idx = cb->args[1];
1937
1938 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1939 idx = 0;
1940 head = &net->dev_index_head[h];
1941 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001942 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1943 net->dev_base_seq;
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001944 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1945 if (idx < s_idx)
1946 goto cont;
1947 in_dev = __in_dev_get_rcu(dev);
1948 if (!in_dev)
1949 goto cont;
1950
1951 if (inet_netconf_fill_devconf(skb, dev->ifindex,
1952 &in_dev->cnf,
1953 NETLINK_CB(cb->skb).portid,
1954 cb->nlh->nlmsg_seq,
1955 RTM_NEWNETCONF,
1956 NLM_F_MULTI,
Zhang Shengju136ba622016-03-10 08:55:50 +00001957 NETCONFA_ALL) < 0) {
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001958 rcu_read_unlock();
1959 goto done;
1960 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001961 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001962cont:
1963 idx++;
1964 }
1965 rcu_read_unlock();
1966 }
1967 if (h == NETDEV_HASHENTRIES) {
1968 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
1969 net->ipv4.devconf_all,
1970 NETLINK_CB(cb->skb).portid,
1971 cb->nlh->nlmsg_seq,
1972 RTM_NEWNETCONF, NLM_F_MULTI,
Zhang Shengju136ba622016-03-10 08:55:50 +00001973 NETCONFA_ALL) < 0)
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001974 goto done;
1975 else
1976 h++;
1977 }
1978 if (h == NETDEV_HASHENTRIES + 1) {
1979 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
1980 net->ipv4.devconf_dflt,
1981 NETLINK_CB(cb->skb).portid,
1982 cb->nlh->nlmsg_seq,
1983 RTM_NEWNETCONF, NLM_F_MULTI,
Zhang Shengju136ba622016-03-10 08:55:50 +00001984 NETCONFA_ALL) < 0)
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001985 goto done;
1986 else
1987 h++;
1988 }
1989done:
1990 cb->args[0] = h;
1991 cb->args[1] = idx;
1992
1993 return skb->len;
1994}
1995
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996#ifdef CONFIG_SYSCTL
1997
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001998static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001999{
2000 struct net_device *dev;
2001
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002002 rcu_read_lock();
2003 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07002004 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002005
Herbert Xu31be3082007-06-04 23:35:37 -07002006 in_dev = __in_dev_get_rcu(dev);
2007 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08002008 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07002009 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002010 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07002011}
2012
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002013/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002014static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002015{
2016 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08002017 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002018
Pavel Emelyanov586f1212007-12-16 13:32:48 -08002019 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08002020 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002021 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2022 NETCONFA_IFINDEX_ALL,
2023 net->ipv4.devconf_all);
2024 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2025 NETCONFA_IFINDEX_DEFAULT,
2026 net->ipv4.devconf_dflt);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002027
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002028 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002029 struct in_device *in_dev;
Eric Dumazetfa178062016-07-08 05:18:24 +02002030
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002031 if (on)
2032 dev_disable_lro(dev);
Eric Dumazetfa178062016-07-08 05:18:24 +02002033
2034 in_dev = __in_dev_get_rtnl(dev);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002035 if (in_dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002036 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002037 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2038 dev->ifindex, &in_dev->cnf);
2039 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002040 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002041}
2042
stephen hemmingerf085ff12013-12-12 13:06:50 -08002043static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2044{
2045 if (cnf == net->ipv4.devconf_dflt)
2046 return NETCONFA_IFINDEX_DEFAULT;
2047 else if (cnf == net->ipv4.devconf_all)
2048 return NETCONFA_IFINDEX_ALL;
2049 else {
2050 struct in_device *idev
2051 = container_of(cnf, struct in_device, cnf);
2052 return idev->dev->ifindex;
2053 }
2054}
2055
Joe Perchesfe2c6332013-06-11 23:04:25 -07002056static int devinet_conf_proc(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002057 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07002058 size_t *lenp, loff_t *ppos)
2059{
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00002060 int old_value = *(int *)ctl->data;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002061 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00002062 int new_value = *(int *)ctl->data;
Herbert Xu31be3082007-06-04 23:35:37 -07002063
2064 if (write) {
2065 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002066 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07002067 int i = (int *)ctl->data - cnf->data;
stephen hemmingerf085ff12013-12-12 13:06:50 -08002068 int ifindex;
Herbert Xu31be3082007-06-04 23:35:37 -07002069
2070 set_bit(i, cnf->state);
2071
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08002072 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002073 devinet_copy_dflt_conf(net, i);
Thomas Grafd0daebc32012-06-12 00:44:01 +00002074 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2075 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00002076 if ((new_value == 0) && (old_value != 0))
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002077 rt_cache_flush(net);
stephen hemmingerf085ff12013-12-12 13:06:50 -08002078
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002079 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2080 new_value != old_value) {
stephen hemmingerf085ff12013-12-12 13:06:50 -08002081 ifindex = devinet_conf_ifindex(net, cnf);
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002082 inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
2083 ifindex, cnf);
2084 }
stephen hemmingerf085ff12013-12-12 13:06:50 -08002085 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2086 new_value != old_value) {
2087 ifindex = devinet_conf_ifindex(net, cnf);
stephen hemminger09aea5d2013-12-17 22:35:52 -08002088 inet_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08002089 ifindex, cnf);
2090 }
Andy Gospodarek974d7af2015-07-07 13:56:57 -04002091 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2092 new_value != old_value) {
2093 ifindex = devinet_conf_ifindex(net, cnf);
2094 inet_netconf_notify_devconf(net, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2095 ifindex, cnf);
2096 }
Herbert Xu31be3082007-06-04 23:35:37 -07002097 }
2098
2099 return ret;
2100}
2101
Joe Perchesfe2c6332013-06-11 23:04:25 -07002102static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002103 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 size_t *lenp, loff_t *ppos)
2105{
2106 int *valp = ctl->data;
2107 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00002108 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002109 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110
2111 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002112 struct net *net = ctl->extra2;
2113
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002114 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00002115 if (!rtnl_trylock()) {
2116 /* Restore the original values before restarting */
2117 *valp = val;
2118 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00002119 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00002120 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002121 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2122 inet_forward_change(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002123 } else {
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002124 struct ipv4_devconf *cnf = ctl->extra1;
2125 struct in_device *idev =
2126 container_of(cnf, struct in_device, cnf);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002127 if (*valp)
2128 dev_disable_lro(idev->dev);
2129 inet_netconf_notify_devconf(net,
2130 NETCONFA_FORWARDING,
2131 idev->dev->ifindex,
2132 cnf);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002133 }
2134 rtnl_unlock();
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002135 rt_cache_flush(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002136 } else
2137 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2138 NETCONFA_IFINDEX_DEFAULT,
2139 net->ipv4.devconf_dflt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 }
2141
2142 return ret;
2143}
2144
Joe Perchesfe2c6332013-06-11 23:04:25 -07002145static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
David S. Miller323e1262010-12-12 21:55:08 -08002146 void __user *buffer,
2147 size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148{
2149 int *valp = ctl->data;
2150 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002151 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07002152 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
2154 if (write && *valp != val)
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002155 rt_cache_flush(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
2157 return ret;
2158}
2159
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002160#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07002161 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07002162 .procname = name, \
2163 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00002164 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002165 .maxlen = sizeof(int), \
2166 .mode = mval, \
2167 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07002168 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002169 }
2170
2171#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002172 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002173
2174#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002175 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002176
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002177#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2178 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002179
2180#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002181 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07002182
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183static struct devinet_sysctl_table {
2184 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00002185 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186} devinet_sysctl = {
2187 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07002188 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002189 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07002190 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2191
2192 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2193 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2194 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2195 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2196 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2197 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2198 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00002199 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08002200 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002201 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2202 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2203 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2204 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2205 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2206 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2207 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2208 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2209 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08002210 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00002211 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
William Manley5c6fe012013-08-06 19:03:14 +01002212 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2213 "force_igmp_version"),
William Manley26900482013-08-06 19:03:15 +01002214 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2215 "igmpv2_unsolicited_report_interval"),
2216 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2217 "igmpv3_unsolicited_report_interval"),
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04002218 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2219 "ignore_routes_with_linkdown"),
Johannes Berg97daf332016-02-04 13:31:18 +01002220 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2221 "drop_gratuitous_arp"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002222
2223 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2224 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002225 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2226 "promote_secondaries"),
Thomas Grafd0daebc32012-06-12 00:44:01 +00002227 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2228 "route_localnet"),
Johannes Berg12b74df2016-02-04 13:31:17 +01002229 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2230 "drop_unicast_in_l2_multicast"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232};
2233
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002234static int __devinet_sysctl_register(struct net *net, char *dev_name,
Nicolas Dichtel29c994e2016-08-30 10:09:22 +02002235 int ifindex, struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236{
2237 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002238 struct devinet_sysctl_table *t;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002239 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11002240
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002241 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002243 goto out;
2244
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2246 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07002247 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002248 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 }
2250
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002251 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002253 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 if (!t->sysctl_header)
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002255 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
2257 p->sysctl = t;
Nicolas Dichtel29c994e2016-08-30 10:09:22 +02002258
2259 inet_netconf_notify_devconf(net, NETCONFA_ALL, ifindex, p);
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002260 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002262free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002264out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002265 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266}
2267
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002268static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
2269{
2270 struct devinet_sysctl_table *t = cnf->sysctl;
2271
Ian Morris51456b22015-04-03 09:17:26 +01002272 if (!t)
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002273 return;
2274
2275 cnf->sysctl = NULL;
Lucian Adrian Grijincuff538812011-05-01 01:44:01 +00002276 unregister_net_sysctl_table(t->sysctl_header);
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002277 kfree(t);
2278}
2279
WANG Cong20e61da2014-07-25 15:25:08 -07002280static int devinet_sysctl_register(struct in_device *idev)
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002281{
WANG Cong20e61da2014-07-25 15:25:08 -07002282 int err;
2283
2284 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2285 return -EINVAL;
2286
2287 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2288 if (err)
2289 return err;
2290 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Nicolas Dichtel29c994e2016-08-30 10:09:22 +02002291 idev->dev->ifindex, &idev->cnf);
WANG Cong20e61da2014-07-25 15:25:08 -07002292 if (err)
2293 neigh_sysctl_unregister(idev->arp_parms);
2294 return err;
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002295}
2296
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002297static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002299 __devinet_sysctl_unregister(&idev->cnf);
2300 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002303static struct ctl_table ctl_forward_entry[] = {
2304 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002305 .procname = "ip_forward",
2306 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00002307 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002308 .maxlen = sizeof(int),
2309 .mode = 0644,
2310 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002311 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002312 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002313 },
2314 { },
2315};
Eric Dumazet2a75de02008-01-05 23:08:49 -08002316#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002317
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002318static __net_init int devinet_init_net(struct net *net)
2319{
2320 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002321 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002322#ifdef CONFIG_SYSCTL
2323 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002324 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002325#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002326
2327 err = -ENOMEM;
2328 all = &ipv4_devconf;
2329 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002330
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002331 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002332 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002333 if (!all)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002334 goto err_alloc_all;
2335
2336 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002337 if (!dflt)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002338 goto err_alloc_dflt;
2339
Eric Dumazet2a75de02008-01-05 23:08:49 -08002340#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002341 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002342 if (!tbl)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002343 goto err_alloc_ctl;
2344
Eric W. Biederman02291682010-02-14 03:25:51 +00002345 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002346 tbl[0].extra1 = all;
2347 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002348#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002349 }
2350
2351#ifdef CONFIG_SYSCTL
Nicolas Dichtel29c994e2016-08-30 10:09:22 +02002352 err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002353 if (err < 0)
2354 goto err_reg_all;
2355
Nicolas Dichtel29c994e2016-08-30 10:09:22 +02002356 err = __devinet_sysctl_register(net, "default",
2357 NETCONFA_IFINDEX_DEFAULT, dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002358 if (err < 0)
2359 goto err_reg_dflt;
2360
2361 err = -ENOMEM;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002362 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
Ian Morris51456b22015-04-03 09:17:26 +01002363 if (!forw_hdr)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002364 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002365 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002366#endif
2367
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002368 net->ipv4.devconf_all = all;
2369 net->ipv4.devconf_dflt = dflt;
2370 return 0;
2371
2372#ifdef CONFIG_SYSCTL
2373err_reg_ctl:
2374 __devinet_sysctl_unregister(dflt);
2375err_reg_dflt:
2376 __devinet_sysctl_unregister(all);
2377err_reg_all:
2378 if (tbl != ctl_forward_entry)
2379 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002380err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08002381#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002382 if (dflt != &ipv4_devconf_dflt)
2383 kfree(dflt);
2384err_alloc_dflt:
2385 if (all != &ipv4_devconf)
2386 kfree(all);
2387err_alloc_all:
2388 return err;
2389}
2390
2391static __net_exit void devinet_exit_net(struct net *net)
2392{
Eric Dumazet2a75de02008-01-05 23:08:49 -08002393#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002394 struct ctl_table *tbl;
2395
2396 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002397 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2398 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
2399 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002400 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08002401#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002402 kfree(net->ipv4.devconf_dflt);
2403 kfree(net->ipv4.devconf_all);
2404}
2405
2406static __net_initdata struct pernet_operations devinet_ops = {
2407 .init = devinet_init_net,
2408 .exit = devinet_exit_net,
2409};
2410
Daniel Borkmann207895f2015-01-29 12:15:03 +01002411static struct rtnl_af_ops inet_af_ops __read_mostly = {
Thomas Graf9f0f7272010-11-16 04:32:48 +00002412 .family = AF_INET,
2413 .fill_link_af = inet_fill_link_af,
2414 .get_link_af_size = inet_get_link_af_size,
Thomas Grafcf7afbf2010-11-22 01:31:54 +00002415 .validate_link_af = inet_validate_link_af,
2416 .set_link_af = inet_set_link_af,
Thomas Graf9f0f7272010-11-16 04:32:48 +00002417};
2418
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419void __init devinet_init(void)
2420{
David S. Millerfd23c3b2011-02-18 12:42:28 -08002421 int i;
2422
2423 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2424 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2425
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002426 register_pernet_subsys(&devinet_ops);
2427
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 register_gifconf(PF_INET, inet_gifconf);
2429 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07002430
viresh kumar906e0732014-01-22 12:23:32 +05302431 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
Jiri Pirko5c766d62013-01-24 09:41:41 +00002432
Thomas Graf9f0f7272010-11-16 04:32:48 +00002433 rtnl_af_register(&inet_af_ops);
2434
Greg Rosec7ac8672011-06-10 01:27:09 +00002435 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
2436 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
2437 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
Nicolas Dichtel9e551112012-10-25 22:28:53 +00002438 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
Nicolas Dichtel7a674202013-03-05 23:42:06 +00002439 inet_netconf_dump_devconf, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440}