blob: 65e76a48382c6e212fe42135f59f3636eba5ea4a [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
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900337 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700338 * unless alias promotion is set
339 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
343
344 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900345 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800346 ifa1->ifa_scope <= ifa->ifa_scope)
347 last_prim = ifa;
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
350 ifa1->ifa_mask != ifa->ifa_mask ||
351 !inet_ifa_match(ifa1->ifa_address, ifa)) {
352 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800353 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 continue;
355 }
356
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800357 if (!do_promote) {
David S. Millerfd23c3b2011-02-18 12:42:28 -0800358 inet_hash_remove(ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700359 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Eric W. Biederman15e47302012-09-07 20:12:54 +0000361 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800362 blocking_notifier_call_chain(&inetaddr_chain,
363 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700364 inet_free_ifa(ifa);
365 } else {
366 promote = ifa;
367 break;
368 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 }
370 }
371
Julian Anastasov2d230e22011-03-19 12:13:52 +0000372 /* On promotion all secondaries from subnet are changing
373 * the primary IP, we must remove all their routes silently
374 * and later to add them back with new prefsrc. Do this
375 * while all addresses are on the device list.
376 */
377 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
378 if (ifa1->ifa_mask == ifa->ifa_mask &&
379 inet_ifa_match(ifa1->ifa_address, ifa))
380 fib_del_ifaddr(ifa, ifa1);
381 }
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 /* 2. Unlink it */
384
385 *ifap = ifa1->ifa_next;
David S. Millerfd23c3b2011-02-18 12:42:28 -0800386 inet_hash_remove(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 /* 3. Announce address deletion */
389
390 /* Send message first, then call notifier.
391 At first sight, FIB update triggered by notifier
392 will refer to already deleted ifaddr, that could confuse
393 netlink listeners. It is not true: look, gated sees
394 that route deleted and if it still thinks that ifaddr
395 is valid, it will try to restore deleted routes... Grr.
396 So that, this order is correct.
397 */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000398 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800399 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800400
401 if (promote) {
Julian Anastasov04024b92011-03-19 12:13:54 +0000402 struct in_ifaddr *next_sec = promote->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800403
404 if (prev_prom) {
405 prev_prom->ifa_next = promote->ifa_next;
406 promote->ifa_next = last_prim->ifa_next;
407 last_prim->ifa_next = promote;
408 }
409
410 promote->ifa_flags &= ~IFA_F_SECONDARY;
Eric W. Biederman15e47302012-09-07 20:12:54 +0000411 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800412 blocking_notifier_call_chain(&inetaddr_chain,
413 NETDEV_UP, promote);
Julian Anastasov04024b92011-03-19 12:13:54 +0000414 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800415 if (ifa1->ifa_mask != ifa->ifa_mask ||
416 !inet_ifa_match(ifa1->ifa_address, ifa))
417 continue;
418 fib_add_ifaddr(ifa);
419 }
420
421 }
Herbert Xu63630972007-06-07 18:35:38 -0700422 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424}
425
Thomas Grafd6062cb2006-08-15 00:33:59 -0700426static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
427 int destroy)
428{
429 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
430}
431
Jiri Pirko5c766d62013-01-24 09:41:41 +0000432static void check_lifetime(struct work_struct *work);
433
434static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
435
Thomas Grafd6062cb2006-08-15 00:33:59 -0700436static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000437 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 struct in_device *in_dev = ifa->ifa_dev;
440 struct in_ifaddr *ifa1, **ifap, **last_primary;
441
442 ASSERT_RTNL();
443
444 if (!ifa->ifa_local) {
445 inet_free_ifa(ifa);
446 return 0;
447 }
448
449 ifa->ifa_flags &= ~IFA_F_SECONDARY;
450 last_primary = &in_dev->ifa_list;
451
452 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
453 ifap = &ifa1->ifa_next) {
454 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
455 ifa->ifa_scope <= ifa1->ifa_scope)
456 last_primary = &ifa1->ifa_next;
457 if (ifa1->ifa_mask == ifa->ifa_mask &&
458 inet_ifa_match(ifa1->ifa_address, ifa)) {
459 if (ifa1->ifa_local == ifa->ifa_local) {
460 inet_free_ifa(ifa);
461 return -EEXIST;
462 }
463 if (ifa1->ifa_scope != ifa->ifa_scope) {
464 inet_free_ifa(ifa);
465 return -EINVAL;
466 }
467 ifa->ifa_flags |= IFA_F_SECONDARY;
468 }
469 }
470
471 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
Aruna-Hewapathirane63862b52014-01-11 07:15:59 -0500472 prandom_seed((__force u32) ifa->ifa_local);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 ifap = last_primary;
474 }
475
476 ifa->ifa_next = *ifap;
477 *ifap = ifa;
478
David S. Millerfd23c3b2011-02-18 12:42:28 -0800479 inet_hash_insert(dev_net(in_dev->dev), ifa);
480
Jiri Pirko5c766d62013-01-24 09:41:41 +0000481 cancel_delayed_work(&check_lifetime_work);
viresh kumar906e0732014-01-22 12:23:32 +0530482 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 /* Send message first, then call notifier.
485 Notifier will trigger FIB update, so that
486 listeners of netlink will know about new ifaddr */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000487 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800488 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490 return 0;
491}
492
Thomas Grafd6062cb2006-08-15 00:33:59 -0700493static int inet_insert_ifa(struct in_ifaddr *ifa)
494{
495 return __inet_insert_ifa(ifa, NULL, 0);
496}
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
499{
Herbert Xue5ed6392005-10-03 14:35:55 -0700500 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502 ASSERT_RTNL();
503
504 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700505 inet_free_ifa(ifa);
506 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700508 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100509 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700511 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 in_dev_hold(in_dev);
513 ifa->ifa_dev = in_dev;
514 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800515 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 ifa->ifa_scope = RT_SCOPE_HOST;
517 return inet_insert_ifa(ifa);
518}
519
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000520/* Caller must hold RCU or RTNL :
521 * We dont take a reference on found in_device
522 */
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800523struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 struct net_device *dev;
526 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000527
528 rcu_read_lock();
529 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 if (dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000531 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000532 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 return in_dev;
534}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800535EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537/* Called only from RTNL semaphored context. No locks. */
538
Al Viro60cad5d2006-09-26 22:17:09 -0700539struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
540 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
542 ASSERT_RTNL();
543
544 for_primary_ifa(in_dev) {
545 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
546 return ifa;
547 } endfor_ifa(in_dev);
548 return NULL;
549}
550
Madhu Challa93a714d2015-02-25 09:58:35 -0800551static int ip_mc_config(struct sock *sk, bool join, const struct in_ifaddr *ifa)
552{
553 struct ip_mreqn mreq = {
554 .imr_multiaddr.s_addr = ifa->ifa_address,
555 .imr_ifindex = ifa->ifa_dev->dev->ifindex,
556 };
557 int ret;
558
559 ASSERT_RTNL();
560
561 lock_sock(sk);
562 if (join)
Marcelo Ricardo Leitner54ff9ef2015-03-18 14:50:43 -0300563 ret = ip_mc_join_group(sk, &mreq);
Madhu Challa93a714d2015-02-25 09:58:35 -0800564 else
Marcelo Ricardo Leitner54ff9ef2015-03-18 14:50:43 -0300565 ret = ip_mc_leave_group(sk, &mreq);
Madhu Challa93a714d2015-02-25 09:58:35 -0800566 release_sock(sk);
567
568 return ret;
569}
570
Thomas Graf661d2962013-03-21 07:45:29 +0000571static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900573 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700574 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700576 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700578 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 ASSERT_RTNL();
581
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700582 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
583 if (err < 0)
584 goto errout;
585
586 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800587 in_dev = inetdev_by_index(net, ifm->ifa_index);
Ian Morris51456b22015-04-03 09:17:26 +0100588 if (!in_dev) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700589 err = -ENODEV;
590 goto errout;
591 }
592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
594 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700595 if (tb[IFA_LOCAL] &&
Jiri Benc67b61f62015-03-29 16:59:26 +0200596 ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700598
599 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
600 continue;
601
602 if (tb[IFA_ADDRESS] &&
603 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Jiri Benc67b61f62015-03-29 16:59:26 +0200604 !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700605 continue;
606
Madhu Challa93a714d2015-02-25 09:58:35 -0800607 if (ipv4_is_multicast(ifa->ifa_address))
608 ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
Eric W. Biederman15e47302012-09-07 20:12:54 +0000609 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 return 0;
611 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700612
613 err = -EADDRNOTAVAIL;
614errout:
615 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616}
617
Jiri Pirko5c766d62013-01-24 09:41:41 +0000618#define INFINITY_LIFE_TIME 0xFFFFFFFF
619
620static void check_lifetime(struct work_struct *work)
621{
622 unsigned long now, next, next_sec, next_sched;
623 struct in_ifaddr *ifa;
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000624 struct hlist_node *n;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000625 int i;
626
627 now = jiffies;
628 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
629
Jiri Pirko5c766d62013-01-24 09:41:41 +0000630 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000631 bool change_needed = false;
632
633 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800634 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
Jiri Pirko5c766d62013-01-24 09:41:41 +0000635 unsigned long age;
636
637 if (ifa->ifa_flags & IFA_F_PERMANENT)
638 continue;
639
640 /* We try to batch several events at once. */
641 age = (now - ifa->ifa_tstamp +
642 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
643
644 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
645 age >= ifa->ifa_valid_lft) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000646 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000647 } else if (ifa->ifa_preferred_lft ==
648 INFINITY_LIFE_TIME) {
649 continue;
650 } else if (age >= ifa->ifa_preferred_lft) {
651 if (time_before(ifa->ifa_tstamp +
652 ifa->ifa_valid_lft * HZ, next))
653 next = ifa->ifa_tstamp +
654 ifa->ifa_valid_lft * HZ;
655
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000656 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
657 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000658 } else if (time_before(ifa->ifa_tstamp +
659 ifa->ifa_preferred_lft * HZ,
660 next)) {
661 next = ifa->ifa_tstamp +
662 ifa->ifa_preferred_lft * HZ;
663 }
664 }
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000665 rcu_read_unlock();
666 if (!change_needed)
667 continue;
668 rtnl_lock();
669 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
670 unsigned long age;
671
672 if (ifa->ifa_flags & IFA_F_PERMANENT)
673 continue;
674
675 /* We try to batch several events at once. */
676 age = (now - ifa->ifa_tstamp +
677 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
678
679 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
680 age >= ifa->ifa_valid_lft) {
681 struct in_ifaddr **ifap;
682
683 for (ifap = &ifa->ifa_dev->ifa_list;
684 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
685 if (*ifap == ifa) {
686 inet_del_ifa(ifa->ifa_dev,
687 ifap, 1);
688 break;
689 }
690 }
691 } else if (ifa->ifa_preferred_lft !=
692 INFINITY_LIFE_TIME &&
693 age >= ifa->ifa_preferred_lft &&
694 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
695 ifa->ifa_flags |= IFA_F_DEPRECATED;
696 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
697 }
698 }
699 rtnl_unlock();
Jiri Pirko5c766d62013-01-24 09:41:41 +0000700 }
Jiri Pirko5c766d62013-01-24 09:41:41 +0000701
702 next_sec = round_jiffies_up(next);
703 next_sched = next;
704
705 /* If rounded timeout is accurate enough, accept it. */
706 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
707 next_sched = next_sec;
708
709 now = jiffies;
710 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
711 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
712 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
713
viresh kumar906e0732014-01-22 12:23:32 +0530714 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
715 next_sched - now);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000716}
717
718static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
719 __u32 prefered_lft)
720{
721 unsigned long timeout;
722
723 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
724
725 timeout = addrconf_timeout_fixup(valid_lft, HZ);
726 if (addrconf_finite_timeout(timeout))
727 ifa->ifa_valid_lft = timeout;
728 else
729 ifa->ifa_flags |= IFA_F_PERMANENT;
730
731 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
732 if (addrconf_finite_timeout(timeout)) {
733 if (timeout == 0)
734 ifa->ifa_flags |= IFA_F_DEPRECATED;
735 ifa->ifa_preferred_lft = timeout;
736 }
737 ifa->ifa_tstamp = jiffies;
738 if (!ifa->ifa_cstamp)
739 ifa->ifa_cstamp = ifa->ifa_tstamp;
740}
741
742static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
743 __u32 *pvalid_lft, __u32 *pprefered_lft)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
Thomas Graf5c753972006-08-04 23:03:53 -0700745 struct nlattr *tb[IFA_MAX+1];
746 struct in_ifaddr *ifa;
747 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 struct net_device *dev;
749 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800750 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Thomas Graf5c753972006-08-04 23:03:53 -0700752 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
753 if (err < 0)
754 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Thomas Graf5c753972006-08-04 23:03:53 -0700756 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800757 err = -EINVAL;
Ian Morris51456b22015-04-03 09:17:26 +0100758 if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
Thomas Graf5c753972006-08-04 23:03:53 -0700759 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800761 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800762 err = -ENODEV;
Ian Morris51456b22015-04-03 09:17:26 +0100763 if (!dev)
Thomas Graf5c753972006-08-04 23:03:53 -0700764 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Thomas Graf5c753972006-08-04 23:03:53 -0700766 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800767 err = -ENOBUFS;
Ian Morris51456b22015-04-03 09:17:26 +0100768 if (!in_dev)
Herbert Xu71e27da2007-06-04 23:36:06 -0700769 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
Thomas Graf5c753972006-08-04 23:03:53 -0700771 ifa = inet_alloc_ifa();
Ian Morris51456b22015-04-03 09:17:26 +0100772 if (!ifa)
Thomas Graf5c753972006-08-04 23:03:53 -0700773 /*
774 * A potential indev allocation can be left alive, it stays
775 * assigned to its device and is destroy with it.
776 */
Thomas Graf5c753972006-08-04 23:03:53 -0700777 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700778
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800779 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100780 neigh_parms_data_state_setall(in_dev->arp_parms);
Thomas Graf5c753972006-08-04 23:03:53 -0700781 in_dev_hold(in_dev);
782
Ian Morris51456b22015-04-03 09:17:26 +0100783 if (!tb[IFA_ADDRESS])
Thomas Graf5c753972006-08-04 23:03:53 -0700784 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
785
David S. Millerfd23c3b2011-02-18 12:42:28 -0800786 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
788 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Jiri Pirkoad6c8132013-12-08 12:16:10 +0100789 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
790 ifm->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700792 ifa->ifa_dev = in_dev;
793
Jiri Benc67b61f62015-03-29 16:59:26 +0200794 ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
795 ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700796
797 if (tb[IFA_BROADCAST])
Jiri Benc67b61f62015-03-29 16:59:26 +0200798 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700799
Thomas Graf5c753972006-08-04 23:03:53 -0700800 if (tb[IFA_LABEL])
801 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 else
803 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
804
Jiri Pirko5c766d62013-01-24 09:41:41 +0000805 if (tb[IFA_CACHEINFO]) {
806 struct ifa_cacheinfo *ci;
807
808 ci = nla_data(tb[IFA_CACHEINFO]);
809 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
810 err = -EINVAL;
Daniel Borkmann446266b2013-08-02 11:32:43 +0200811 goto errout_free;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000812 }
813 *pvalid_lft = ci->ifa_valid;
814 *pprefered_lft = ci->ifa_prefered;
815 }
816
Thomas Graf5c753972006-08-04 23:03:53 -0700817 return ifa;
818
Daniel Borkmann446266b2013-08-02 11:32:43 +0200819errout_free:
820 inet_free_ifa(ifa);
Thomas Graf5c753972006-08-04 23:03:53 -0700821errout:
822 return ERR_PTR(err);
823}
824
Jiri Pirko5c766d62013-01-24 09:41:41 +0000825static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
826{
827 struct in_device *in_dev = ifa->ifa_dev;
828 struct in_ifaddr *ifa1, **ifap;
829
830 if (!ifa->ifa_local)
831 return NULL;
832
833 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
834 ifap = &ifa1->ifa_next) {
835 if (ifa1->ifa_mask == ifa->ifa_mask &&
836 inet_ifa_match(ifa1->ifa_address, ifa) &&
837 ifa1->ifa_local == ifa->ifa_local)
838 return ifa1;
839 }
840 return NULL;
841}
842
Thomas Graf661d2962013-03-21 07:45:29 +0000843static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Graf5c753972006-08-04 23:03:53 -0700844{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900845 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700846 struct in_ifaddr *ifa;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000847 struct in_ifaddr *ifa_existing;
848 __u32 valid_lft = INFINITY_LIFE_TIME;
849 __u32 prefered_lft = INFINITY_LIFE_TIME;
Thomas Graf5c753972006-08-04 23:03:53 -0700850
851 ASSERT_RTNL();
852
Jiri Pirko5c766d62013-01-24 09:41:41 +0000853 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
Thomas Graf5c753972006-08-04 23:03:53 -0700854 if (IS_ERR(ifa))
855 return PTR_ERR(ifa);
856
Jiri Pirko5c766d62013-01-24 09:41:41 +0000857 ifa_existing = find_matching_ifa(ifa);
858 if (!ifa_existing) {
859 /* It would be best to check for !NLM_F_CREATE here but
stephen hemminger614d0562014-05-16 20:46:58 -0700860 * userspace already relies on not having to provide this.
Jiri Pirko5c766d62013-01-24 09:41:41 +0000861 */
862 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
Madhu Challa93a714d2015-02-25 09:58:35 -0800863 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
864 int ret = ip_mc_config(net->ipv4.mc_autojoin_sk,
865 true, ifa);
866
867 if (ret < 0) {
868 inet_free_ifa(ifa);
869 return ret;
870 }
871 }
Jiri Pirko5c766d62013-01-24 09:41:41 +0000872 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
873 } else {
874 inet_free_ifa(ifa);
875
876 if (nlh->nlmsg_flags & NLM_F_EXCL ||
877 !(nlh->nlmsg_flags & NLM_F_REPLACE))
878 return -EEXIST;
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000879 ifa = ifa_existing;
880 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
Jiri Pirko05a324b2013-04-04 23:39:38 +0000881 cancel_delayed_work(&check_lifetime_work);
viresh kumar906e0732014-01-22 12:23:32 +0530882 queue_delayed_work(system_power_efficient_wq,
883 &check_lifetime_work, 0);
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000884 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000885 }
886 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}
888
889/*
890 * Determine a default network mask, based on the IP address.
891 */
892
Eric Dumazet40384992012-08-03 21:06:50 +0000893static int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894{
895 int rc = -1; /* Something else, probably a multicast. */
896
Joe Perchesf97c1e02007-12-16 13:45:43 -0800897 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900898 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 else {
Al Viro714e85b2006-11-14 20:51:49 -0800900 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
Al Viro714e85b2006-11-14 20:51:49 -0800902 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800904 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800906 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 rc = 24;
908 }
909
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900910 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911}
912
913
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800914int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
916 struct ifreq ifr;
917 struct sockaddr_in sin_orig;
918 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
919 struct in_device *in_dev;
920 struct in_ifaddr **ifap = NULL;
921 struct in_ifaddr *ifa = NULL;
922 struct net_device *dev;
923 char *colon;
924 int ret = -EFAULT;
925 int tryaddrmatch = 0;
926
927 /*
928 * Fetch the caller's info block into kernel space
929 */
930
931 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
932 goto out;
933 ifr.ifr_name[IFNAMSIZ - 1] = 0;
934
935 /* save original address for comparison */
936 memcpy(&sin_orig, sin, sizeof(*sin));
937
938 colon = strchr(ifr.ifr_name, ':');
939 if (colon)
940 *colon = 0;
941
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800942 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Stephen Hemminger132adf52007-03-08 20:44:43 -0800944 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 case SIOCGIFADDR: /* Get interface address */
946 case SIOCGIFBRDADDR: /* Get the broadcast address */
947 case SIOCGIFDSTADDR: /* Get the destination address */
948 case SIOCGIFNETMASK: /* Get the netmask for the interface */
949 /* Note that these ioctls will not sleep,
950 so that we do not impose a lock.
951 One day we will be forced to put shlock here (I mean SMP)
952 */
953 tryaddrmatch = (sin_orig.sin_family == AF_INET);
954 memset(sin, 0, sizeof(*sin));
955 sin->sin_family = AF_INET;
956 break;
957
958 case SIOCSIFFLAGS:
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000959 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000960 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 goto out;
962 break;
963 case SIOCSIFADDR: /* Set interface address (and family) */
964 case SIOCSIFBRDADDR: /* Set the broadcast address */
965 case SIOCSIFDSTADDR: /* Set the destination address */
966 case SIOCSIFNETMASK: /* Set the netmask for the interface */
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000967 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000968 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 goto out;
970 ret = -EINVAL;
971 if (sin->sin_family != AF_INET)
972 goto out;
973 break;
974 default:
975 ret = -EINVAL;
976 goto out;
977 }
978
979 rtnl_lock();
980
981 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800982 dev = __dev_get_by_name(net, ifr.ifr_name);
983 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 goto done;
985
986 if (colon)
987 *colon = ':';
988
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800989 in_dev = __in_dev_get_rtnl(dev);
990 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 if (tryaddrmatch) {
992 /* Matthias Andree */
993 /* compare label and address (4.4BSD style) */
994 /* note: we only do this for a limited set of ioctls
995 and only if the original address family was AF_INET.
996 This is checked above. */
997 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
998 ifap = &ifa->ifa_next) {
999 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
1000 sin_orig.sin_addr.s_addr ==
David S. Miller6c91afe2011-03-09 13:27:16 -08001001 ifa->ifa_local) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 break; /* found */
1003 }
1004 }
1005 }
1006 /* we didn't get a match, maybe the application is
1007 4.3BSD-style and passed in junk so we fall back to
1008 comparing just the label */
1009 if (!ifa) {
1010 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
1011 ifap = &ifa->ifa_next)
1012 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
1013 break;
1014 }
1015 }
1016
1017 ret = -EADDRNOTAVAIL;
1018 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
1019 goto done;
1020
Stephen Hemminger132adf52007-03-08 20:44:43 -08001021 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 case SIOCGIFADDR: /* Get interface address */
1023 sin->sin_addr.s_addr = ifa->ifa_local;
1024 goto rarok;
1025
1026 case SIOCGIFBRDADDR: /* Get the broadcast address */
1027 sin->sin_addr.s_addr = ifa->ifa_broadcast;
1028 goto rarok;
1029
1030 case SIOCGIFDSTADDR: /* Get the destination address */
1031 sin->sin_addr.s_addr = ifa->ifa_address;
1032 goto rarok;
1033
1034 case SIOCGIFNETMASK: /* Get the netmask for the interface */
1035 sin->sin_addr.s_addr = ifa->ifa_mask;
1036 goto rarok;
1037
1038 case SIOCSIFFLAGS:
1039 if (colon) {
1040 ret = -EADDRNOTAVAIL;
1041 if (!ifa)
1042 break;
1043 ret = 0;
1044 if (!(ifr.ifr_flags & IFF_UP))
1045 inet_del_ifa(in_dev, ifap, 1);
1046 break;
1047 }
1048 ret = dev_change_flags(dev, ifr.ifr_flags);
1049 break;
1050
1051 case SIOCSIFADDR: /* Set interface address (and family) */
1052 ret = -EINVAL;
1053 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1054 break;
1055
1056 if (!ifa) {
1057 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001058 ifa = inet_alloc_ifa();
1059 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 break;
Xi Wangc7e2e1d2013-01-05 11:19:24 +00001061 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 if (colon)
1063 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1064 else
1065 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1066 } else {
1067 ret = 0;
1068 if (ifa->ifa_local == sin->sin_addr.s_addr)
1069 break;
1070 inet_del_ifa(in_dev, ifap, 0);
1071 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -08001072 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 }
1074
1075 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1076
1077 if (!(dev->flags & IFF_POINTOPOINT)) {
1078 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1079 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1080 if ((dev->flags & IFF_BROADCAST) &&
1081 ifa->ifa_prefixlen < 31)
1082 ifa->ifa_broadcast = ifa->ifa_address |
1083 ~ifa->ifa_mask;
1084 } else {
1085 ifa->ifa_prefixlen = 32;
1086 ifa->ifa_mask = inet_make_mask(32);
1087 }
Jiri Pirko5c766d62013-01-24 09:41:41 +00001088 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 ret = inet_set_ifa(dev, ifa);
1090 break;
1091
1092 case SIOCSIFBRDADDR: /* Set the broadcast address */
1093 ret = 0;
1094 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1095 inet_del_ifa(in_dev, ifap, 0);
1096 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1097 inet_insert_ifa(ifa);
1098 }
1099 break;
1100
1101 case SIOCSIFDSTADDR: /* Set the destination address */
1102 ret = 0;
1103 if (ifa->ifa_address == sin->sin_addr.s_addr)
1104 break;
1105 ret = -EINVAL;
1106 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1107 break;
1108 ret = 0;
1109 inet_del_ifa(in_dev, ifap, 0);
1110 ifa->ifa_address = sin->sin_addr.s_addr;
1111 inet_insert_ifa(ifa);
1112 break;
1113
1114 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1115
1116 /*
1117 * The mask we set must be legal.
1118 */
1119 ret = -EINVAL;
1120 if (bad_mask(sin->sin_addr.s_addr, 0))
1121 break;
1122 ret = 0;
1123 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -07001124 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 inet_del_ifa(in_dev, ifap, 0);
1126 ifa->ifa_mask = sin->sin_addr.s_addr;
1127 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1128
1129 /* See if current broadcast address matches
1130 * with current netmask, then recalculate
1131 * the broadcast address. Otherwise it's a
1132 * funny address, so don't touch it since
1133 * the user seems to know what (s)he's doing...
1134 */
1135 if ((dev->flags & IFF_BROADCAST) &&
1136 (ifa->ifa_prefixlen < 31) &&
1137 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -05001138 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 ifa->ifa_broadcast = (ifa->ifa_local |
1140 ~sin->sin_addr.s_addr);
1141 }
1142 inet_insert_ifa(ifa);
1143 }
1144 break;
1145 }
1146done:
1147 rtnl_unlock();
1148out:
1149 return ret;
1150rarok:
1151 rtnl_unlock();
1152 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1153 goto out;
1154}
1155
1156static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1157{
Herbert Xue5ed6392005-10-03 14:35:55 -07001158 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 struct in_ifaddr *ifa;
1160 struct ifreq ifr;
1161 int done = 0;
1162
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001163 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 goto out;
1165
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001166 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 if (!buf) {
1168 done += sizeof(ifr);
1169 continue;
1170 }
1171 if (len < (int) sizeof(ifr))
1172 break;
1173 memset(&ifr, 0, sizeof(struct ifreq));
Dan Carpenter4299c8a2013-07-29 22:15:19 +03001174 strcpy(ifr.ifr_name, ifa->ifa_label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
1176 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1177 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1178 ifa->ifa_local;
1179
1180 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1181 done = -EFAULT;
1182 break;
1183 }
1184 buf += sizeof(struct ifreq);
1185 len -= sizeof(struct ifreq);
1186 done += sizeof(struct ifreq);
1187 }
1188out:
1189 return done;
1190}
1191
Al Viroa61ced52006-09-26 21:27:54 -07001192__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
Al Viroa61ced52006-09-26 21:27:54 -07001194 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001196 struct net *net = dev_net(dev);
David Ahern3f2fb9a2016-02-24 11:47:02 -08001197 int master_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
1199 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -07001200 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 if (!in_dev)
1202 goto no_in_dev;
1203
1204 for_primary_ifa(in_dev) {
1205 if (ifa->ifa_scope > scope)
1206 continue;
1207 if (!dst || inet_ifa_match(dst, ifa)) {
1208 addr = ifa->ifa_local;
1209 break;
1210 }
1211 if (!addr)
1212 addr = ifa->ifa_local;
1213 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001216 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001217no_in_dev:
David Ahern3f2fb9a2016-02-24 11:47:02 -08001218 master_idx = l3mdev_master_ifindex_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
David Lamparter17b693c2016-02-24 11:47:03 -08001220 /* For VRFs, the VRF device takes the place of the loopback device,
1221 * with addresses on it being preferred. Note in such cases the
1222 * loopback device will be among the devices that fail the master_idx
1223 * equality check in the loop below.
1224 */
1225 if (master_idx &&
1226 (dev = dev_get_by_index_rcu(net, master_idx)) &&
1227 (in_dev = __in_dev_get_rcu(dev))) {
1228 for_primary_ifa(in_dev) {
1229 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1230 ifa->ifa_scope <= scope) {
1231 addr = ifa->ifa_local;
1232 goto out_unlock;
1233 }
1234 } endfor_ifa(in_dev);
1235 }
1236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 /* Not loopback addresses on loopback should be preferred
Stephen Hemmingerca9f1fd2015-02-14 13:47:54 -05001238 in this case. It is important that lo is the first interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 in dev_base list.
1240 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001241 for_each_netdev_rcu(net, dev) {
David Ahern3f2fb9a2016-02-24 11:47:02 -08001242 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1243 continue;
1244
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001245 in_dev = __in_dev_get_rcu(dev);
1246 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 continue;
1248
1249 for_primary_ifa(in_dev) {
1250 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1251 ifa->ifa_scope <= scope) {
1252 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001253 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 }
1255 } endfor_ifa(in_dev);
1256 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001257out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 return addr;
1260}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001261EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Al Viro60cad5d2006-09-26 22:17:09 -07001263static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1264 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265{
1266 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -07001267 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 for_ifa(in_dev) {
1270 if (!addr &&
1271 (local == ifa->ifa_local || !local) &&
1272 ifa->ifa_scope <= scope) {
1273 addr = ifa->ifa_local;
1274 if (same)
1275 break;
1276 }
1277 if (!same) {
1278 same = (!local || inet_ifa_match(local, ifa)) &&
1279 (!dst || inet_ifa_match(dst, ifa));
1280 if (same && addr) {
1281 if (local || !dst)
1282 break;
1283 /* Is the selected addr into dst subnet? */
1284 if (inet_ifa_match(addr, ifa))
1285 break;
1286 /* No, then can we use new local src? */
1287 if (ifa->ifa_scope <= scope) {
1288 addr = ifa->ifa_local;
1289 break;
1290 }
1291 /* search for large dst subnet for addr */
1292 same = 0;
1293 }
1294 }
1295 } endfor_ifa(in_dev);
1296
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001297 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298}
1299
1300/*
1301 * Confirm that local IP address exists using wildcards:
Nicolas Dichtelb601fa192013-12-10 15:02:40 +01001302 * - net: netns to check, cannot be NULL
1303 * - in_dev: only on this interface, NULL=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 * - dst: only in the same subnet as dst, 0=any dst
1305 * - local: address, 0=autoselect the local address
1306 * - scope: maximum allowed scope value for the local address
1307 */
Nicolas Dichtelb601fa192013-12-10 15:02:40 +01001308__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001309 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310{
Al Viro60cad5d2006-09-26 22:17:09 -07001311 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001312 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
Ian Morris00db4122015-04-03 09:17:27 +01001314 if (in_dev)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001315 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001318 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001319 in_dev = __in_dev_get_rcu(dev);
1320 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 addr = confirm_addr_indev(in_dev, dst, local, scope);
1322 if (addr)
1323 break;
1324 }
1325 }
1326 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
1328 return addr;
1329}
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00001330EXPORT_SYMBOL(inet_confirm_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
1332/*
1333 * Device notifier
1334 */
1335
1336int register_inetaddr_notifier(struct notifier_block *nb)
1337{
Alan Sterne041c682006-03-27 01:16:30 -08001338 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001340EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342int unregister_inetaddr_notifier(struct notifier_block *nb)
1343{
Alan Sterne041c682006-03-27 01:16:30 -08001344 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001346EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001348/* Rename ifa_labels for a device name change. Make some effort to preserve
1349 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350*/
1351static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001352{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 struct in_ifaddr *ifa;
1354 int named = 0;
1355
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001356 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1357 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001360 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001362 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001363 dot = strchr(old, ':');
Ian Morris51456b22015-04-03 09:17:26 +01001364 if (!dot) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001365 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 dot = old;
1367 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001368 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001369 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001370 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001371 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001372skip:
1373 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001374 }
1375}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
Eric Dumazet40384992012-08-03 21:06:50 +00001377static bool inetdev_valid_mtu(unsigned int mtu)
Breno Leitao06770842008-09-02 17:28:58 -07001378{
1379 return mtu >= 68;
1380}
1381
Ian Campbelld11327ad2011-02-11 07:44:16 +00001382static void inetdev_send_gratuitous_arp(struct net_device *dev,
1383 struct in_device *in_dev)
1384
1385{
Zoltan Kissb76d0782011-07-24 13:09:30 +00001386 struct in_ifaddr *ifa;
Ian Campbelld11327ad2011-02-11 07:44:16 +00001387
Zoltan Kissb76d0782011-07-24 13:09:30 +00001388 for (ifa = in_dev->ifa_list; ifa;
1389 ifa = ifa->ifa_next) {
1390 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1391 ifa->ifa_local, dev,
1392 ifa->ifa_local, NULL,
1393 dev->dev_addr, NULL);
1394 }
Ian Campbelld11327ad2011-02-11 07:44:16 +00001395}
1396
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397/* Called only under RTNL semaphore */
1398
1399static int inetdev_event(struct notifier_block *this, unsigned long event,
1400 void *ptr)
1401{
Jiri Pirko351638e2013-05-28 01:30:21 +00001402 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Eric Dumazet748e2d92012-08-22 21:50:59 +00001403 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
1405 ASSERT_RTNL();
1406
1407 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001408 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 in_dev = inetdev_init(dev);
WANG Cong20e61da2014-07-25 15:25:08 -07001410 if (IS_ERR(in_dev))
1411 return notifier_from_errno(PTR_ERR(in_dev));
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001412 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001413 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1414 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001415 }
Breno Leitao06770842008-09-02 17:28:58 -07001416 } else if (event == NETDEV_CHANGEMTU) {
1417 /* Re-enabling IP */
1418 if (inetdev_valid_mtu(dev->mtu))
1419 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 }
1421 goto out;
1422 }
1423
1424 switch (event) {
1425 case NETDEV_REGISTER:
Joe Perches91df42b2012-05-15 14:11:54 +00001426 pr_debug("%s: bug\n", __func__);
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +00001427 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 break;
1429 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001430 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001432 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001433 struct in_ifaddr *ifa = inet_alloc_ifa();
1434
1435 if (ifa) {
David S. Millerfd23c3b2011-02-18 12:42:28 -08001436 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 ifa->ifa_local =
1438 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1439 ifa->ifa_prefixlen = 8;
1440 ifa->ifa_mask = inet_make_mask(8);
1441 in_dev_hold(in_dev);
1442 ifa->ifa_dev = in_dev;
1443 ifa->ifa_scope = RT_SCOPE_HOST;
1444 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Jiri Pirko5c766d62013-01-24 09:41:41 +00001445 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1446 INFINITY_LIFE_TIME);
Jiri Pirkodfd15822014-01-07 15:55:45 +01001447 ipv4_devconf_setall(in_dev);
1448 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 inet_insert_ifa(ifa);
1450 }
1451 }
1452 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001453 /* fall through */
1454 case NETDEV_CHANGEADDR:
Ian Campbelld11327ad2011-02-11 07:44:16 +00001455 if (!IN_DEV_ARP_NOTIFY(in_dev))
1456 break;
1457 /* fall through */
1458 case NETDEV_NOTIFY_PEERS:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001459 /* Send gratuitous ARP to notify of link change */
Ian Campbelld11327ad2011-02-11 07:44:16 +00001460 inetdev_send_gratuitous_arp(dev, in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 break;
1462 case NETDEV_DOWN:
1463 ip_mc_down(in_dev);
1464 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001465 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001466 ip_mc_unmap(in_dev);
1467 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001468 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001469 ip_mc_remap(in_dev);
1470 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001472 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 break;
Breno Leitao06770842008-09-02 17:28:58 -07001474 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 case NETDEV_UNREGISTER:
1476 inetdev_destroy(in_dev);
1477 break;
1478 case NETDEV_CHANGENAME:
1479 /* Do not notify about label change, this event is
1480 * not interesting to applications using netlink.
1481 */
1482 inetdev_changename(dev, in_dev);
1483
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001484 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001485 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 break;
1487 }
1488out:
1489 return NOTIFY_DONE;
1490}
1491
1492static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001493 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494};
1495
Eric Dumazet40384992012-08-03 21:06:50 +00001496static size_t inet_nlmsg_size(void)
Thomas Graf339bf982006-11-10 14:10:15 -08001497{
1498 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1499 + nla_total_size(4) /* IFA_ADDRESS */
1500 + nla_total_size(4) /* IFA_LOCAL */
1501 + nla_total_size(4) /* IFA_BROADCAST */
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001502 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
Geert Uytterhoeven63b5f152014-02-05 08:38:25 +01001503 + nla_total_size(4) /* IFA_FLAGS */
1504 + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
Thomas Graf339bf982006-11-10 14:10:15 -08001505}
1506
Jiri Pirko5c766d62013-01-24 09:41:41 +00001507static inline u32 cstamp_delta(unsigned long cstamp)
1508{
1509 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1510}
1511
1512static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1513 unsigned long tstamp, u32 preferred, u32 valid)
1514{
1515 struct ifa_cacheinfo ci;
1516
1517 ci.cstamp = cstamp_delta(cstamp);
1518 ci.tstamp = cstamp_delta(tstamp);
1519 ci.ifa_prefered = preferred;
1520 ci.ifa_valid = valid;
1521
1522 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1523}
1524
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001526 u32 portid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527{
1528 struct ifaddrmsg *ifm;
1529 struct nlmsghdr *nlh;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001530 u32 preferred, valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
Eric W. Biederman15e47302012-09-07 20:12:54 +00001532 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
Ian Morris51456b22015-04-03 09:17:26 +01001533 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08001534 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001535
1536 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 ifm->ifa_family = AF_INET;
1538 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001539 ifm->ifa_flags = ifa->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 ifm->ifa_scope = ifa->ifa_scope;
1541 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
Jiri Pirko5c766d62013-01-24 09:41:41 +00001543 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1544 preferred = ifa->ifa_preferred_lft;
1545 valid = ifa->ifa_valid_lft;
1546 if (preferred != INFINITY_LIFE_TIME) {
1547 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1548
1549 if (preferred > tval)
1550 preferred -= tval;
1551 else
1552 preferred = 0;
1553 if (valid != INFINITY_LIFE_TIME) {
1554 if (valid > tval)
1555 valid -= tval;
1556 else
1557 valid = 0;
1558 }
1559 }
1560 } else {
1561 preferred = INFINITY_LIFE_TIME;
1562 valid = INFINITY_LIFE_TIME;
1563 }
David S. Millerf3756b72012-04-01 20:39:02 -04001564 if ((ifa->ifa_address &&
Jiri Benc930345e2015-03-29 16:59:25 +02001565 nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
David S. Millerf3756b72012-04-01 20:39:02 -04001566 (ifa->ifa_local &&
Jiri Benc930345e2015-03-29 16:59:25 +02001567 nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
David S. Millerf3756b72012-04-01 20:39:02 -04001568 (ifa->ifa_broadcast &&
Jiri Benc930345e2015-03-29 16:59:25 +02001569 nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
David S. Millerf3756b72012-04-01 20:39:02 -04001570 (ifa->ifa_label[0] &&
Jiri Pirko5c766d62013-01-24 09:41:41 +00001571 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001572 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
Jiri Pirko5c766d62013-01-24 09:41:41 +00001573 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1574 preferred, valid))
David S. Millerf3756b72012-04-01 20:39:02 -04001575 goto nla_put_failure;
Thomas Graf47f68512006-08-04 23:04:36 -07001576
Johannes Berg053c0952015-01-16 22:09:00 +01001577 nlmsg_end(skb, nlh);
1578 return 0;
Thomas Graf47f68512006-08-04 23:04:36 -07001579
1580nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001581 nlmsg_cancel(skb, nlh);
1582 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583}
1584
1585static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1586{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001587 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001588 int h, s_h;
1589 int idx, s_idx;
1590 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 struct net_device *dev;
1592 struct in_device *in_dev;
1593 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001594 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
Eric Dumazeteec4df92009-11-12 07:44:25 +00001596 s_h = cb->args[0];
1597 s_idx = idx = cb->args[1];
1598 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Eric Dumazeteec4df92009-11-12 07:44:25 +00001600 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1601 idx = 0;
1602 head = &net->dev_index_head[h];
1603 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001604 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1605 net->dev_base_seq;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001606 hlist_for_each_entry_rcu(dev, head, index_hlist) {
Eric Dumazeteec4df92009-11-12 07:44:25 +00001607 if (idx < s_idx)
1608 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001609 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001610 s_ip_idx = 0;
1611 in_dev = __in_dev_get_rcu(dev);
1612 if (!in_dev)
1613 goto cont;
1614
1615 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1616 ifa = ifa->ifa_next, ip_idx++) {
1617 if (ip_idx < s_ip_idx)
1618 continue;
1619 if (inet_fill_ifaddr(skb, ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001620 NETLINK_CB(cb->skb).portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 cb->nlh->nlmsg_seq,
Johannes Berg053c0952015-01-16 22:09:00 +01001622 RTM_NEWADDR, NLM_F_MULTI) < 0) {
Eric Dumazeteec4df92009-11-12 07:44:25 +00001623 rcu_read_unlock();
1624 goto done;
1625 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001626 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Eric Dumazeteec4df92009-11-12 07:44:25 +00001627 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001628cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001629 idx++;
1630 }
1631 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 }
1633
1634done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001635 cb->args[0] = h;
1636 cb->args[1] = idx;
1637 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
1639 return skb->len;
1640}
1641
Jianjun Kong539afed2008-11-03 02:48:48 -08001642static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001643 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644{
Thomas Graf47f68512006-08-04 23:04:36 -07001645 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001646 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1647 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001648 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001650 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001651 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01001652 if (!skb)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001653 goto errout;
1654
Eric W. Biederman15e47302012-09-07 20:12:54 +00001655 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001656 if (err < 0) {
1657 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1658 WARN_ON(err == -EMSGSIZE);
1659 kfree_skb(skb);
1660 goto errout;
1661 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00001662 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001663 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001664errout:
1665 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001666 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667}
1668
Arad, Ronenb1974ed2015-10-19 09:23:28 -07001669static size_t inet_get_link_af_size(const struct net_device *dev,
1670 u32 ext_filter_mask)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001671{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001672 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001673
1674 if (!in_dev)
1675 return 0;
1676
1677 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1678}
1679
Sowmini Varadhand5566fd2015-09-11 16:48:48 -04001680static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
1681 u32 ext_filter_mask)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001682{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001683 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001684 struct nlattr *nla;
1685 int i;
1686
1687 if (!in_dev)
1688 return -ENODATA;
1689
1690 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
Ian Morris51456b22015-04-03 09:17:26 +01001691 if (!nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001692 return -EMSGSIZE;
1693
1694 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1695 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1696
1697 return 0;
1698}
1699
1700static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1701 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1702};
1703
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001704static int inet_validate_link_af(const struct net_device *dev,
1705 const struct nlattr *nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001706{
Thomas Graf9f0f7272010-11-16 04:32:48 +00001707 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1708 int err, rem;
1709
Eric Dumazetf7fce742010-12-01 06:03:06 +00001710 if (dev && !__in_dev_get_rtnl(dev))
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001711 return -EAFNOSUPPORT;
Thomas Graf9f0f7272010-11-16 04:32:48 +00001712
1713 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1714 if (err < 0)
1715 return err;
1716
1717 if (tb[IFLA_INET_CONF]) {
1718 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1719 int cfgid = nla_type(a);
1720
1721 if (nla_len(a) < 4)
1722 return -EINVAL;
1723
1724 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1725 return -EINVAL;
1726 }
1727 }
1728
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001729 return 0;
1730}
1731
1732static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1733{
Eric Dumazetf7fce742010-12-01 06:03:06 +00001734 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001735 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1736 int rem;
1737
1738 if (!in_dev)
1739 return -EAFNOSUPPORT;
1740
1741 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1742 BUG();
1743
Thomas Graf9f0f7272010-11-16 04:32:48 +00001744 if (tb[IFLA_INET_CONF]) {
1745 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1746 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1747 }
1748
1749 return 0;
1750}
1751
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001752static int inet_netconf_msgsize_devconf(int type)
1753{
1754 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1755 + nla_total_size(4); /* NETCONFA_IFINDEX */
Zhang Shengju136ba622016-03-10 08:55:50 +00001756 bool all = false;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001757
Zhang Shengju136ba622016-03-10 08:55:50 +00001758 if (type == NETCONFA_ALL)
1759 all = true;
1760
1761 if (all || type == NETCONFA_FORWARDING)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001762 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001763 if (all || type == NETCONFA_RP_FILTER)
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001764 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001765 if (all || type == NETCONFA_MC_FORWARDING)
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001766 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001767 if (all || type == NETCONFA_PROXY_NEIGH)
stephen hemmingerf085ff12013-12-12 13:06:50 -08001768 size += nla_total_size(4);
Zhang Shengju136ba622016-03-10 08:55:50 +00001769 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
Andy Gospodarek974d7af2015-07-07 13:56:57 -04001770 size += nla_total_size(4);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001771
1772 return size;
1773}
1774
1775static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1776 struct ipv4_devconf *devconf, u32 portid,
1777 u32 seq, int event, unsigned int flags,
1778 int type)
1779{
1780 struct nlmsghdr *nlh;
1781 struct netconfmsg *ncm;
Zhang Shengju136ba622016-03-10 08:55:50 +00001782 bool all = false;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001783
1784 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1785 flags);
Ian Morris51456b22015-04-03 09:17:26 +01001786 if (!nlh)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001787 return -EMSGSIZE;
1788
Zhang Shengju136ba622016-03-10 08:55:50 +00001789 if (type == NETCONFA_ALL)
1790 all = true;
1791
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001792 ncm = nlmsg_data(nlh);
1793 ncm->ncm_family = AF_INET;
1794
1795 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1796 goto nla_put_failure;
1797
Zhang Shengju136ba622016-03-10 08:55:50 +00001798 if ((all || type == NETCONFA_FORWARDING) &&
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001799 nla_put_s32(skb, NETCONFA_FORWARDING,
1800 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1801 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001802 if ((all || type == NETCONFA_RP_FILTER) &&
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001803 nla_put_s32(skb, NETCONFA_RP_FILTER,
1804 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1805 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001806 if ((all || type == NETCONFA_MC_FORWARDING) &&
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001807 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1808 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1809 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001810 if ((all || type == NETCONFA_PROXY_NEIGH) &&
stephen hemminger09aea5d2013-12-17 22:35:52 -08001811 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08001812 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1813 goto nla_put_failure;
Zhang Shengju136ba622016-03-10 08:55:50 +00001814 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
Andy Gospodarek974d7af2015-07-07 13:56:57 -04001815 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
1816 IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
1817 goto nla_put_failure;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001818
Johannes Berg053c0952015-01-16 22:09:00 +01001819 nlmsg_end(skb, nlh);
1820 return 0;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001821
1822nla_put_failure:
1823 nlmsg_cancel(skb, nlh);
1824 return -EMSGSIZE;
1825}
1826
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001827void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
1828 struct ipv4_devconf *devconf)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001829{
1830 struct sk_buff *skb;
1831 int err = -ENOBUFS;
1832
1833 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_ATOMIC);
Ian Morris51456b22015-04-03 09:17:26 +01001834 if (!skb)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001835 goto errout;
1836
1837 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1838 RTM_NEWNETCONF, 0, type);
1839 if (err < 0) {
1840 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1841 WARN_ON(err == -EMSGSIZE);
1842 kfree_skb(skb);
1843 goto errout;
1844 }
1845 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_ATOMIC);
1846 return;
1847errout:
1848 if (err < 0)
1849 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1850}
1851
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001852static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1853 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1854 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001855 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
stephen hemminger09aea5d2013-12-17 22:35:52 -08001856 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
Andy Gospodarek974d7af2015-07-07 13:56:57 -04001857 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001858};
1859
1860static int inet_netconf_get_devconf(struct sk_buff *in_skb,
Thomas Graf661d2962013-03-21 07:45:29 +00001861 struct nlmsghdr *nlh)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001862{
1863 struct net *net = sock_net(in_skb->sk);
1864 struct nlattr *tb[NETCONFA_MAX+1];
1865 struct netconfmsg *ncm;
1866 struct sk_buff *skb;
1867 struct ipv4_devconf *devconf;
1868 struct in_device *in_dev;
1869 struct net_device *dev;
1870 int ifindex;
1871 int err;
1872
1873 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1874 devconf_ipv4_policy);
1875 if (err < 0)
1876 goto errout;
1877
Anton Protopopova97eb332016-02-16 21:43:16 -05001878 err = -EINVAL;
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001879 if (!tb[NETCONFA_IFINDEX])
1880 goto errout;
1881
1882 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1883 switch (ifindex) {
1884 case NETCONFA_IFINDEX_ALL:
1885 devconf = net->ipv4.devconf_all;
1886 break;
1887 case NETCONFA_IFINDEX_DEFAULT:
1888 devconf = net->ipv4.devconf_dflt;
1889 break;
1890 default:
1891 dev = __dev_get_by_index(net, ifindex);
Ian Morris51456b22015-04-03 09:17:26 +01001892 if (!dev)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001893 goto errout;
1894 in_dev = __in_dev_get_rtnl(dev);
Ian Morris51456b22015-04-03 09:17:26 +01001895 if (!in_dev)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001896 goto errout;
1897 devconf = &in_dev->cnf;
1898 break;
1899 }
1900
1901 err = -ENOBUFS;
Zhang Shengju136ba622016-03-10 08:55:50 +00001902 skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_ATOMIC);
Ian Morris51456b22015-04-03 09:17:26 +01001903 if (!skb)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001904 goto errout;
1905
1906 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1907 NETLINK_CB(in_skb).portid,
1908 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
Zhang Shengju136ba622016-03-10 08:55:50 +00001909 NETCONFA_ALL);
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001910 if (err < 0) {
1911 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1912 WARN_ON(err == -EMSGSIZE);
1913 kfree_skb(skb);
1914 goto errout;
1915 }
1916 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1917errout:
1918 return err;
1919}
1920
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001921static int inet_netconf_dump_devconf(struct sk_buff *skb,
1922 struct netlink_callback *cb)
1923{
1924 struct net *net = sock_net(skb->sk);
1925 int h, s_h;
1926 int idx, s_idx;
1927 struct net_device *dev;
1928 struct in_device *in_dev;
1929 struct hlist_head *head;
1930
1931 s_h = cb->args[0];
1932 s_idx = idx = cb->args[1];
1933
1934 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1935 idx = 0;
1936 head = &net->dev_index_head[h];
1937 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001938 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1939 net->dev_base_seq;
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001940 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1941 if (idx < s_idx)
1942 goto cont;
1943 in_dev = __in_dev_get_rcu(dev);
1944 if (!in_dev)
1945 goto cont;
1946
1947 if (inet_netconf_fill_devconf(skb, dev->ifindex,
1948 &in_dev->cnf,
1949 NETLINK_CB(cb->skb).portid,
1950 cb->nlh->nlmsg_seq,
1951 RTM_NEWNETCONF,
1952 NLM_F_MULTI,
Zhang Shengju136ba622016-03-10 08:55:50 +00001953 NETCONFA_ALL) < 0) {
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001954 rcu_read_unlock();
1955 goto done;
1956 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001957 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001958cont:
1959 idx++;
1960 }
1961 rcu_read_unlock();
1962 }
1963 if (h == NETDEV_HASHENTRIES) {
1964 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
1965 net->ipv4.devconf_all,
1966 NETLINK_CB(cb->skb).portid,
1967 cb->nlh->nlmsg_seq,
1968 RTM_NEWNETCONF, NLM_F_MULTI,
Zhang Shengju136ba622016-03-10 08:55:50 +00001969 NETCONFA_ALL) < 0)
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001970 goto done;
1971 else
1972 h++;
1973 }
1974 if (h == NETDEV_HASHENTRIES + 1) {
1975 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
1976 net->ipv4.devconf_dflt,
1977 NETLINK_CB(cb->skb).portid,
1978 cb->nlh->nlmsg_seq,
1979 RTM_NEWNETCONF, NLM_F_MULTI,
Zhang Shengju136ba622016-03-10 08:55:50 +00001980 NETCONFA_ALL) < 0)
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001981 goto done;
1982 else
1983 h++;
1984 }
1985done:
1986 cb->args[0] = h;
1987 cb->args[1] = idx;
1988
1989 return skb->len;
1990}
1991
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992#ifdef CONFIG_SYSCTL
1993
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001994static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001995{
1996 struct net_device *dev;
1997
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001998 rcu_read_lock();
1999 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07002000 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002001
Herbert Xu31be3082007-06-04 23:35:37 -07002002 in_dev = __in_dev_get_rcu(dev);
2003 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08002004 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07002005 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002006 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07002007}
2008
Eric Dumazetc6d14c82009-11-04 05:43:23 -08002009/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002010static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002011{
2012 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08002013 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002014
Pavel Emelyanov586f1212007-12-16 13:32:48 -08002015 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08002016 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002017 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2018 NETCONFA_IFINDEX_ALL,
2019 net->ipv4.devconf_all);
2020 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2021 NETCONFA_IFINDEX_DEFAULT,
2022 net->ipv4.devconf_dflt);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002023
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002024 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002025 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002026 if (on)
2027 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002028 rcu_read_lock();
2029 in_dev = __in_dev_get_rcu(dev);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002030 if (in_dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002031 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002032 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2033 dev->ifindex, &in_dev->cnf);
2034 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002035 rcu_read_unlock();
2036 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002037}
2038
stephen hemmingerf085ff12013-12-12 13:06:50 -08002039static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
2040{
2041 if (cnf == net->ipv4.devconf_dflt)
2042 return NETCONFA_IFINDEX_DEFAULT;
2043 else if (cnf == net->ipv4.devconf_all)
2044 return NETCONFA_IFINDEX_ALL;
2045 else {
2046 struct in_device *idev
2047 = container_of(cnf, struct in_device, cnf);
2048 return idev->dev->ifindex;
2049 }
2050}
2051
Joe Perchesfe2c6332013-06-11 23:04:25 -07002052static int devinet_conf_proc(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002053 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07002054 size_t *lenp, loff_t *ppos)
2055{
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00002056 int old_value = *(int *)ctl->data;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002057 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00002058 int new_value = *(int *)ctl->data;
Herbert Xu31be3082007-06-04 23:35:37 -07002059
2060 if (write) {
2061 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002062 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07002063 int i = (int *)ctl->data - cnf->data;
stephen hemmingerf085ff12013-12-12 13:06:50 -08002064 int ifindex;
Herbert Xu31be3082007-06-04 23:35:37 -07002065
2066 set_bit(i, cnf->state);
2067
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08002068 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002069 devinet_copy_dflt_conf(net, i);
Thomas Grafd0daebc32012-06-12 00:44:01 +00002070 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
2071 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00002072 if ((new_value == 0) && (old_value != 0))
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002073 rt_cache_flush(net);
stephen hemmingerf085ff12013-12-12 13:06:50 -08002074
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002075 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
2076 new_value != old_value) {
stephen hemmingerf085ff12013-12-12 13:06:50 -08002077 ifindex = devinet_conf_ifindex(net, cnf);
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002078 inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
2079 ifindex, cnf);
2080 }
stephen hemmingerf085ff12013-12-12 13:06:50 -08002081 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2082 new_value != old_value) {
2083 ifindex = devinet_conf_ifindex(net, cnf);
stephen hemminger09aea5d2013-12-17 22:35:52 -08002084 inet_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08002085 ifindex, cnf);
2086 }
Andy Gospodarek974d7af2015-07-07 13:56:57 -04002087 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
2088 new_value != old_value) {
2089 ifindex = devinet_conf_ifindex(net, cnf);
2090 inet_netconf_notify_devconf(net, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2091 ifindex, cnf);
2092 }
Herbert Xu31be3082007-06-04 23:35:37 -07002093 }
2094
2095 return ret;
2096}
2097
Joe Perchesfe2c6332013-06-11 23:04:25 -07002098static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002099 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 size_t *lenp, loff_t *ppos)
2101{
2102 int *valp = ctl->data;
2103 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00002104 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002105 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106
2107 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002108 struct net *net = ctl->extra2;
2109
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002110 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00002111 if (!rtnl_trylock()) {
2112 /* Restore the original values before restarting */
2113 *valp = val;
2114 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00002115 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00002116 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002117 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2118 inet_forward_change(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002119 } else {
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002120 struct ipv4_devconf *cnf = ctl->extra1;
2121 struct in_device *idev =
2122 container_of(cnf, struct in_device, cnf);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002123 if (*valp)
2124 dev_disable_lro(idev->dev);
2125 inet_netconf_notify_devconf(net,
2126 NETCONFA_FORWARDING,
2127 idev->dev->ifindex,
2128 cnf);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002129 }
2130 rtnl_unlock();
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002131 rt_cache_flush(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002132 } else
2133 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2134 NETCONFA_IFINDEX_DEFAULT,
2135 net->ipv4.devconf_dflt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 }
2137
2138 return ret;
2139}
2140
Joe Perchesfe2c6332013-06-11 23:04:25 -07002141static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
David S. Miller323e1262010-12-12 21:55:08 -08002142 void __user *buffer,
2143 size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144{
2145 int *valp = ctl->data;
2146 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002147 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07002148 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149
2150 if (write && *valp != val)
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002151 rt_cache_flush(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152
2153 return ret;
2154}
2155
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002156#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07002157 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07002158 .procname = name, \
2159 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00002160 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002161 .maxlen = sizeof(int), \
2162 .mode = mval, \
2163 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07002164 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002165 }
2166
2167#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002168 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002169
2170#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002171 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002172
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002173#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2174 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002175
2176#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002177 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07002178
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179static struct devinet_sysctl_table {
2180 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00002181 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182} devinet_sysctl = {
2183 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07002184 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002185 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07002186 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2187
2188 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2189 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2190 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2191 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2192 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2193 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2194 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00002195 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08002196 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002197 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2198 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2199 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2200 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2201 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2202 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2203 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2204 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2205 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08002206 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00002207 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
William Manley5c6fe012013-08-06 19:03:14 +01002208 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2209 "force_igmp_version"),
William Manley26900482013-08-06 19:03:15 +01002210 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2211 "igmpv2_unsolicited_report_interval"),
2212 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2213 "igmpv3_unsolicited_report_interval"),
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04002214 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
2215 "ignore_routes_with_linkdown"),
Johannes Berg97daf332016-02-04 13:31:18 +01002216 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
2217 "drop_gratuitous_arp"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002218
2219 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2220 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002221 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2222 "promote_secondaries"),
Thomas Grafd0daebc32012-06-12 00:44:01 +00002223 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2224 "route_localnet"),
Johannes Berg12b74df2016-02-04 13:31:17 +01002225 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
2226 "drop_unicast_in_l2_multicast"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228};
2229
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002230static int __devinet_sysctl_register(struct net *net, char *dev_name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002231 struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232{
2233 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002234 struct devinet_sysctl_table *t;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002235 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11002236
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002237 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002239 goto out;
2240
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2242 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07002243 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002244 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 }
2246
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002247 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002249 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 if (!t->sysctl_header)
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002251 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
2253 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002254 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002256free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002258out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002259 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260}
2261
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002262static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
2263{
2264 struct devinet_sysctl_table *t = cnf->sysctl;
2265
Ian Morris51456b22015-04-03 09:17:26 +01002266 if (!t)
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002267 return;
2268
2269 cnf->sysctl = NULL;
Lucian Adrian Grijincuff538812011-05-01 01:44:01 +00002270 unregister_net_sysctl_table(t->sysctl_header);
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002271 kfree(t);
2272}
2273
WANG Cong20e61da2014-07-25 15:25:08 -07002274static int devinet_sysctl_register(struct in_device *idev)
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002275{
WANG Cong20e61da2014-07-25 15:25:08 -07002276 int err;
2277
2278 if (!sysctl_dev_name_is_allowed(idev->dev->name))
2279 return -EINVAL;
2280
2281 err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2282 if (err)
2283 return err;
2284 err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002285 &idev->cnf);
WANG Cong20e61da2014-07-25 15:25:08 -07002286 if (err)
2287 neigh_sysctl_unregister(idev->arp_parms);
2288 return err;
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002289}
2290
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002291static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002293 __devinet_sysctl_unregister(&idev->cnf);
2294 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002297static struct ctl_table ctl_forward_entry[] = {
2298 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002299 .procname = "ip_forward",
2300 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00002301 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002302 .maxlen = sizeof(int),
2303 .mode = 0644,
2304 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002305 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002306 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002307 },
2308 { },
2309};
Eric Dumazet2a75de02008-01-05 23:08:49 -08002310#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002311
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002312static __net_init int devinet_init_net(struct net *net)
2313{
2314 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002315 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002316#ifdef CONFIG_SYSCTL
2317 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002318 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002319#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002320
2321 err = -ENOMEM;
2322 all = &ipv4_devconf;
2323 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002324
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002325 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002326 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002327 if (!all)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002328 goto err_alloc_all;
2329
2330 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002331 if (!dflt)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002332 goto err_alloc_dflt;
2333
Eric Dumazet2a75de02008-01-05 23:08:49 -08002334#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002335 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01002336 if (!tbl)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002337 goto err_alloc_ctl;
2338
Eric W. Biederman02291682010-02-14 03:25:51 +00002339 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002340 tbl[0].extra1 = all;
2341 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002342#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002343 }
2344
2345#ifdef CONFIG_SYSCTL
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002346 err = __devinet_sysctl_register(net, "all", all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002347 if (err < 0)
2348 goto err_reg_all;
2349
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002350 err = __devinet_sysctl_register(net, "default", dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002351 if (err < 0)
2352 goto err_reg_dflt;
2353
2354 err = -ENOMEM;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002355 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
Ian Morris51456b22015-04-03 09:17:26 +01002356 if (!forw_hdr)
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002357 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002358 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002359#endif
2360
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002361 net->ipv4.devconf_all = all;
2362 net->ipv4.devconf_dflt = dflt;
2363 return 0;
2364
2365#ifdef CONFIG_SYSCTL
2366err_reg_ctl:
2367 __devinet_sysctl_unregister(dflt);
2368err_reg_dflt:
2369 __devinet_sysctl_unregister(all);
2370err_reg_all:
2371 if (tbl != ctl_forward_entry)
2372 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002373err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08002374#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002375 if (dflt != &ipv4_devconf_dflt)
2376 kfree(dflt);
2377err_alloc_dflt:
2378 if (all != &ipv4_devconf)
2379 kfree(all);
2380err_alloc_all:
2381 return err;
2382}
2383
2384static __net_exit void devinet_exit_net(struct net *net)
2385{
Eric Dumazet2a75de02008-01-05 23:08:49 -08002386#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002387 struct ctl_table *tbl;
2388
2389 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002390 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2391 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
2392 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002393 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08002394#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002395 kfree(net->ipv4.devconf_dflt);
2396 kfree(net->ipv4.devconf_all);
2397}
2398
2399static __net_initdata struct pernet_operations devinet_ops = {
2400 .init = devinet_init_net,
2401 .exit = devinet_exit_net,
2402};
2403
Daniel Borkmann207895f2015-01-29 12:15:03 +01002404static struct rtnl_af_ops inet_af_ops __read_mostly = {
Thomas Graf9f0f7272010-11-16 04:32:48 +00002405 .family = AF_INET,
2406 .fill_link_af = inet_fill_link_af,
2407 .get_link_af_size = inet_get_link_af_size,
Thomas Grafcf7afbf2010-11-22 01:31:54 +00002408 .validate_link_af = inet_validate_link_af,
2409 .set_link_af = inet_set_link_af,
Thomas Graf9f0f7272010-11-16 04:32:48 +00002410};
2411
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412void __init devinet_init(void)
2413{
David S. Millerfd23c3b2011-02-18 12:42:28 -08002414 int i;
2415
2416 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2417 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2418
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002419 register_pernet_subsys(&devinet_ops);
2420
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 register_gifconf(PF_INET, inet_gifconf);
2422 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07002423
viresh kumar906e0732014-01-22 12:23:32 +05302424 queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
Jiri Pirko5c766d62013-01-24 09:41:41 +00002425
Thomas Graf9f0f7272010-11-16 04:32:48 +00002426 rtnl_af_register(&inet_af_ops);
2427
Greg Rosec7ac8672011-06-10 01:27:09 +00002428 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
2429 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
2430 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
Nicolas Dichtel9e551112012-10-25 22:28:53 +00002431 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
Nicolas Dichtel7a674202013-03-05 23:42:06 +00002432 inet_netconf_dump_devconf, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433}