blob: 9809f7b69728cb335e0963c92ea4c9522842849f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NET3 IP device support routines.
3 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Derived from the IP parts of dev.c 1.0.19
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
13 *
14 * Additional Authors:
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
17 *
18 * Changes:
19 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
20 * lists.
21 * Cyrus Durgin: updated for kmod
22 * Matthias Andree: in devinet_ioctl, compare label and
23 * address (4.4BSD alias style support),
24 * fall back to comparing just the label
25 * if no match found.
26 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080031#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/module.h>
33#include <linux/types.h>
34#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/string.h>
36#include <linux/mm.h>
37#include <linux/socket.h>
38#include <linux/sockios.h>
39#include <linux/in.h>
40#include <linux/errno.h>
41#include <linux/interrupt.h>
Thomas Graf18237302006-08-04 23:04:54 -070042#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/if_ether.h>
44#include <linux/inet.h>
45#include <linux/netdevice.h>
46#include <linux/etherdevice.h>
47#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/init.h>
49#include <linux/notifier.h>
50#include <linux/inetdevice.h>
51#include <linux/igmp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090052#include <linux/slab.h>
David S. Millerfd23c3b2011-02-18 12:42:28 -080053#include <linux/hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#ifdef CONFIG_SYSCTL
55#include <linux/sysctl.h>
56#endif
57#include <linux/kmod.h>
Nicolas Dichteledc9e742012-10-25 22:28:52 +000058#include <linux/netconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020060#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <net/ip.h>
62#include <net/route.h>
63#include <net/ip_fib.h>
Thomas Graf63f34442007-03-22 11:55:17 -070064#include <net/rtnetlink.h>
Pavel Emelyanov752d14d2007-12-16 13:31:47 -080065#include <net/net_namespace.h>
Jiri Pirko5c766d62013-01-24 09:41:41 +000066#include <net/addrconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
David S. Miller406b6f92011-03-22 21:56:23 -070068#include "fib_lookup.h"
69
Adrian Bunk0027ba82008-01-31 17:17:31 -080070static struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070071 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000072 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
73 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
74 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
75 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
William Manley26900482013-08-06 19:03:15 +010076 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
77 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
Herbert Xu42f811b2007-06-04 23:34:44 -070078 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070079};
80
81static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070082 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000083 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
84 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
85 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
86 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
87 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
William Manley26900482013-08-06 19:03:15 +010088 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
89 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] = 1000 /*ms*/,
Herbert Xu42f811b2007-06-04 23:34:44 -070090 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070091};
92
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -080093#define IPV4_DEVCONF_DFLT(net, attr) \
94 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
Herbert Xu42f811b2007-06-04 23:34:44 -070095
Patrick McHardyef7c79e2007-06-05 12:38:30 -070096static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
Thomas Graf5c753972006-08-04 23:03:53 -070097 [IFA_LOCAL] = { .type = NLA_U32 },
98 [IFA_ADDRESS] = { .type = NLA_U32 },
99 [IFA_BROADCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -0700100 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Jiri Pirko5c766d62013-01-24 09:41:41 +0000101 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
Jiri Pirkoad6c8132013-12-08 12:16:10 +0100102 [IFA_FLAGS] = { .type = NLA_U32 },
Thomas Graf5c753972006-08-04 23:03:53 -0700103};
104
Eric Dumazet40384992012-08-03 21:06:50 +0000105#define IN4_ADDR_HSIZE_SHIFT 8
106#define IN4_ADDR_HSIZE (1U << IN4_ADDR_HSIZE_SHIFT)
107
David S. Millerfd23c3b2011-02-18 12:42:28 -0800108static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
109static DEFINE_SPINLOCK(inet_addr_hash_lock);
110
Eric Dumazet40384992012-08-03 21:06:50 +0000111static u32 inet_addr_hash(struct net *net, __be32 addr)
David S. Millerfd23c3b2011-02-18 12:42:28 -0800112{
Eric Dumazet40384992012-08-03 21:06:50 +0000113 u32 val = (__force u32) addr ^ net_hash_mix(net);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800114
Eric Dumazet40384992012-08-03 21:06:50 +0000115 return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800116}
117
118static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
119{
Eric Dumazet40384992012-08-03 21:06:50 +0000120 u32 hash = inet_addr_hash(net, ifa->ifa_local);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800121
122 spin_lock(&inet_addr_hash_lock);
123 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
124 spin_unlock(&inet_addr_hash_lock);
125}
126
127static void inet_hash_remove(struct in_ifaddr *ifa)
128{
129 spin_lock(&inet_addr_hash_lock);
130 hlist_del_init_rcu(&ifa->hash);
131 spin_unlock(&inet_addr_hash_lock);
132}
133
David S. Miller9435eb12011-02-18 12:43:09 -0800134/**
135 * __ip_dev_find - find the first device with a given source address.
136 * @net: the net namespace
137 * @addr: the source address
138 * @devref: if true, take a reference on the found device
139 *
140 * If a caller uses devref=false, it should be protected by RCU, or RTNL
141 */
142struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
143{
Eric Dumazet40384992012-08-03 21:06:50 +0000144 u32 hash = inet_addr_hash(net, addr);
David S. Miller9435eb12011-02-18 12:43:09 -0800145 struct net_device *result = NULL;
146 struct in_ifaddr *ifa;
David S. Miller9435eb12011-02-18 12:43:09 -0800147
148 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800149 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
David S. Millere0660082011-03-03 11:24:19 -0800150 if (ifa->ifa_local == addr) {
Eric Dumazet40384992012-08-03 21:06:50 +0000151 struct net_device *dev = ifa->ifa_dev->dev;
152
153 if (!net_eq(dev_net(dev), net))
154 continue;
David S. Miller9435eb12011-02-18 12:43:09 -0800155 result = dev;
156 break;
157 }
158 }
David S. Miller406b6f92011-03-22 21:56:23 -0700159 if (!result) {
160 struct flowi4 fl4 = { .daddr = addr };
161 struct fib_result res = { 0 };
162 struct fib_table *local;
163
164 /* Fallback to FIB local table so that communication
165 * over loopback subnets work.
166 */
167 local = fib_get_table(net, RT_TABLE_LOCAL);
168 if (local &&
169 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
170 res.type == RTN_LOCAL)
171 result = FIB_RES_DEV(res);
172 }
David S. Miller9435eb12011-02-18 12:43:09 -0800173 if (result && devref)
174 dev_hold(result);
175 rcu_read_unlock();
176 return result;
177}
178EXPORT_SYMBOL(__ip_dev_find);
179
Thomas Grafd6062cb2006-08-15 00:33:59 -0700180static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Alan Sterne041c682006-03-27 01:16:30 -0800182static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
184 int destroy);
185#ifdef CONFIG_SYSCTL
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100186static void devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800187static void devinet_sysctl_unregister(struct in_device *idev);
188#else
Eric Dumazet40384992012-08-03 21:06:50 +0000189static void devinet_sysctl_register(struct in_device *idev)
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800190{
191}
Eric Dumazet40384992012-08-03 21:06:50 +0000192static void devinet_sysctl_unregister(struct in_device *idev)
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800193{
194}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195#endif
196
197/* Locks all the inet devices. */
198
199static struct in_ifaddr *inet_alloc_ifa(void)
200{
Alexey Dobriyan93adcc82008-10-28 13:25:09 -0700201 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
204static void inet_rcu_free_ifa(struct rcu_head *head)
205{
206 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
207 if (ifa->ifa_dev)
208 in_dev_put(ifa->ifa_dev);
209 kfree(ifa);
210}
211
Eric Dumazet40384992012-08-03 21:06:50 +0000212static void inet_free_ifa(struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
215}
216
217void in_dev_finish_destroy(struct in_device *idev)
218{
219 struct net_device *dev = idev->dev;
220
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700221 WARN_ON(idev->ifa_list);
222 WARN_ON(idev->mc_list);
Eric Dumazete9897072013-06-07 08:48:57 -0700223 kfree(rcu_dereference_protected(idev->mc_hash, 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224#ifdef NET_REFCNT_DEBUG
Joe Perches91df42b2012-05-15 14:11:54 +0000225 pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226#endif
227 dev_put(dev);
228 if (!idev->dead)
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800229 pr_err("Freeing alive in_device %p\n", idev);
230 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 kfree(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800233EXPORT_SYMBOL(in_dev_finish_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Herbert Xu71e27da2007-06-04 23:36:06 -0700235static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 struct in_device *in_dev;
238
239 ASSERT_RTNL();
240
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700241 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (!in_dev)
243 goto out;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900244 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800245 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 in_dev->cnf.sysctl = NULL;
247 in_dev->dev = dev;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800248 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
249 if (!in_dev->arp_parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 goto out_kfree;
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700251 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
252 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 /* Reference in_dev->dev */
254 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800255 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100258 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 ip_mc_init_dev(in_dev);
260 if (dev->flags & IFF_UP)
261 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800262
David L Stevens30c4cf52007-01-04 12:31:14 -0800263 /* we can receive as soon as ip_ptr is set -- do this last */
Eric Dumazetcf778b02012-01-12 04:41:32 +0000264 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800265out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return in_dev;
267out_kfree:
268 kfree(in_dev);
269 in_dev = NULL;
270 goto out;
271}
272
273static void in_dev_rcu_put(struct rcu_head *head)
274{
275 struct in_device *idev = container_of(head, struct in_device, rcu_head);
276 in_dev_put(idev);
277}
278
279static void inetdev_destroy(struct in_device *in_dev)
280{
281 struct in_ifaddr *ifa;
282 struct net_device *dev;
283
284 ASSERT_RTNL();
285
286 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 in_dev->dead = 1;
289
290 ip_mc_destroy_dev(in_dev);
291
292 while ((ifa = in_dev->ifa_list) != NULL) {
293 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
294 inet_free_ifa(ifa);
295 }
296
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000297 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800299 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
301 arp_ifdown(dev);
302
303 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
304}
305
Al Viroff428d72006-09-26 22:13:35 -0700306int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
308 rcu_read_lock();
309 for_primary_ifa(in_dev) {
310 if (inet_ifa_match(a, ifa)) {
311 if (!b || inet_ifa_match(b, ifa)) {
312 rcu_read_unlock();
313 return 1;
314 }
315 }
316 } endfor_ifa(in_dev);
317 rcu_read_unlock();
318 return 0;
319}
320
Thomas Grafd6062cb2006-08-15 00:33:59 -0700321static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000322 int destroy, struct nlmsghdr *nlh, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Harald Welte8f937c62005-05-29 20:23:46 -0700324 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800325 struct in_ifaddr *ifa, *ifa1 = *ifap;
326 struct in_ifaddr *last_prim = in_dev->ifa_list;
327 struct in_ifaddr *prev_prom = NULL;
328 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 ASSERT_RTNL();
331
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900332 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700333 * unless alias promotion is set
334 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
336 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
338
339 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900340 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800341 ifa1->ifa_scope <= ifa->ifa_scope)
342 last_prim = ifa;
343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
345 ifa1->ifa_mask != ifa->ifa_mask ||
346 !inet_ifa_match(ifa1->ifa_address, ifa)) {
347 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800348 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 continue;
350 }
351
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800352 if (!do_promote) {
David S. Millerfd23c3b2011-02-18 12:42:28 -0800353 inet_hash_remove(ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700354 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Eric W. Biederman15e47302012-09-07 20:12:54 +0000356 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800357 blocking_notifier_call_chain(&inetaddr_chain,
358 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700359 inet_free_ifa(ifa);
360 } else {
361 promote = ifa;
362 break;
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
365 }
366
Julian Anastasov2d230e22011-03-19 12:13:52 +0000367 /* On promotion all secondaries from subnet are changing
368 * the primary IP, we must remove all their routes silently
369 * and later to add them back with new prefsrc. Do this
370 * while all addresses are on the device list.
371 */
372 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
373 if (ifa1->ifa_mask == ifa->ifa_mask &&
374 inet_ifa_match(ifa1->ifa_address, ifa))
375 fib_del_ifaddr(ifa, ifa1);
376 }
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 /* 2. Unlink it */
379
380 *ifap = ifa1->ifa_next;
David S. Millerfd23c3b2011-02-18 12:42:28 -0800381 inet_hash_remove(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 /* 3. Announce address deletion */
384
385 /* Send message first, then call notifier.
386 At first sight, FIB update triggered by notifier
387 will refer to already deleted ifaddr, that could confuse
388 netlink listeners. It is not true: look, gated sees
389 that route deleted and if it still thinks that ifaddr
390 is valid, it will try to restore deleted routes... Grr.
391 So that, this order is correct.
392 */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000393 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800394 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800395
396 if (promote) {
Julian Anastasov04024b92011-03-19 12:13:54 +0000397 struct in_ifaddr *next_sec = promote->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800398
399 if (prev_prom) {
400 prev_prom->ifa_next = promote->ifa_next;
401 promote->ifa_next = last_prim->ifa_next;
402 last_prim->ifa_next = promote;
403 }
404
405 promote->ifa_flags &= ~IFA_F_SECONDARY;
Eric W. Biederman15e47302012-09-07 20:12:54 +0000406 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800407 blocking_notifier_call_chain(&inetaddr_chain,
408 NETDEV_UP, promote);
Julian Anastasov04024b92011-03-19 12:13:54 +0000409 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800410 if (ifa1->ifa_mask != ifa->ifa_mask ||
411 !inet_ifa_match(ifa1->ifa_address, ifa))
412 continue;
413 fib_add_ifaddr(ifa);
414 }
415
416 }
Herbert Xu63630972007-06-07 18:35:38 -0700417 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
Thomas Grafd6062cb2006-08-15 00:33:59 -0700421static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
422 int destroy)
423{
424 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
425}
426
Jiri Pirko5c766d62013-01-24 09:41:41 +0000427static void check_lifetime(struct work_struct *work);
428
429static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
430
Thomas Grafd6062cb2006-08-15 00:33:59 -0700431static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000432 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
434 struct in_device *in_dev = ifa->ifa_dev;
435 struct in_ifaddr *ifa1, **ifap, **last_primary;
436
437 ASSERT_RTNL();
438
439 if (!ifa->ifa_local) {
440 inet_free_ifa(ifa);
441 return 0;
442 }
443
444 ifa->ifa_flags &= ~IFA_F_SECONDARY;
445 last_primary = &in_dev->ifa_list;
446
447 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
448 ifap = &ifa1->ifa_next) {
449 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
450 ifa->ifa_scope <= ifa1->ifa_scope)
451 last_primary = &ifa1->ifa_next;
452 if (ifa1->ifa_mask == ifa->ifa_mask &&
453 inet_ifa_match(ifa1->ifa_address, ifa)) {
454 if (ifa1->ifa_local == ifa->ifa_local) {
455 inet_free_ifa(ifa);
456 return -EEXIST;
457 }
458 if (ifa1->ifa_scope != ifa->ifa_scope) {
459 inet_free_ifa(ifa);
460 return -EINVAL;
461 }
462 ifa->ifa_flags |= IFA_F_SECONDARY;
463 }
464 }
465
466 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
467 net_srandom(ifa->ifa_local);
468 ifap = last_primary;
469 }
470
471 ifa->ifa_next = *ifap;
472 *ifap = ifa;
473
David S. Millerfd23c3b2011-02-18 12:42:28 -0800474 inet_hash_insert(dev_net(in_dev->dev), ifa);
475
Jiri Pirko5c766d62013-01-24 09:41:41 +0000476 cancel_delayed_work(&check_lifetime_work);
477 schedule_delayed_work(&check_lifetime_work, 0);
478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 /* Send message first, then call notifier.
480 Notifier will trigger FIB update, so that
481 listeners of netlink will know about new ifaddr */
Eric W. Biederman15e47302012-09-07 20:12:54 +0000482 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
Alan Sterne041c682006-03-27 01:16:30 -0800483 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 return 0;
486}
487
Thomas Grafd6062cb2006-08-15 00:33:59 -0700488static int inet_insert_ifa(struct in_ifaddr *ifa)
489{
490 return __inet_insert_ifa(ifa, NULL, 0);
491}
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
494{
Herbert Xue5ed6392005-10-03 14:35:55 -0700495 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 ASSERT_RTNL();
498
499 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700500 inet_free_ifa(ifa);
501 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700503 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100504 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700506 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 in_dev_hold(in_dev);
508 ifa->ifa_dev = in_dev;
509 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800510 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 ifa->ifa_scope = RT_SCOPE_HOST;
512 return inet_insert_ifa(ifa);
513}
514
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000515/* Caller must hold RCU or RTNL :
516 * We dont take a reference on found in_device
517 */
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800518struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
520 struct net_device *dev;
521 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000522
523 rcu_read_lock();
524 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000526 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000527 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 return in_dev;
529}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800530EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532/* Called only from RTNL semaphored context. No locks. */
533
Al Viro60cad5d2006-09-26 22:17:09 -0700534struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
535 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
537 ASSERT_RTNL();
538
539 for_primary_ifa(in_dev) {
540 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
541 return ifa;
542 } endfor_ifa(in_dev);
543 return NULL;
544}
545
Thomas Graf661d2962013-03-21 07:45:29 +0000546static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900548 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700549 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700551 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700553 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 ASSERT_RTNL();
556
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700557 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
558 if (err < 0)
559 goto errout;
560
561 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800562 in_dev = inetdev_by_index(net, ifm->ifa_index);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700563 if (in_dev == NULL) {
564 err = -ENODEV;
565 goto errout;
566 }
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
569 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700570 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700571 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700573
574 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
575 continue;
576
577 if (tb[IFA_ADDRESS] &&
578 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700579 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700580 continue;
581
Eric W. Biederman15e47302012-09-07 20:12:54 +0000582 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 return 0;
584 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700585
586 err = -EADDRNOTAVAIL;
587errout:
588 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589}
590
Jiri Pirko5c766d62013-01-24 09:41:41 +0000591#define INFINITY_LIFE_TIME 0xFFFFFFFF
592
593static void check_lifetime(struct work_struct *work)
594{
595 unsigned long now, next, next_sec, next_sched;
596 struct in_ifaddr *ifa;
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000597 struct hlist_node *n;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000598 int i;
599
600 now = jiffies;
601 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
602
Jiri Pirko5c766d62013-01-24 09:41:41 +0000603 for (i = 0; i < IN4_ADDR_HSIZE; i++) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000604 bool change_needed = false;
605
606 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800607 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
Jiri Pirko5c766d62013-01-24 09:41:41 +0000608 unsigned long age;
609
610 if (ifa->ifa_flags & IFA_F_PERMANENT)
611 continue;
612
613 /* We try to batch several events at once. */
614 age = (now - ifa->ifa_tstamp +
615 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
616
617 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
618 age >= ifa->ifa_valid_lft) {
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000619 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000620 } else if (ifa->ifa_preferred_lft ==
621 INFINITY_LIFE_TIME) {
622 continue;
623 } else if (age >= ifa->ifa_preferred_lft) {
624 if (time_before(ifa->ifa_tstamp +
625 ifa->ifa_valid_lft * HZ, next))
626 next = ifa->ifa_tstamp +
627 ifa->ifa_valid_lft * HZ;
628
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000629 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
630 change_needed = true;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000631 } else if (time_before(ifa->ifa_tstamp +
632 ifa->ifa_preferred_lft * HZ,
633 next)) {
634 next = ifa->ifa_tstamp +
635 ifa->ifa_preferred_lft * HZ;
636 }
637 }
Jiri Pirkoc988d1e2013-04-04 23:39:39 +0000638 rcu_read_unlock();
639 if (!change_needed)
640 continue;
641 rtnl_lock();
642 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
643 unsigned long age;
644
645 if (ifa->ifa_flags & IFA_F_PERMANENT)
646 continue;
647
648 /* We try to batch several events at once. */
649 age = (now - ifa->ifa_tstamp +
650 ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
651
652 if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
653 age >= ifa->ifa_valid_lft) {
654 struct in_ifaddr **ifap;
655
656 for (ifap = &ifa->ifa_dev->ifa_list;
657 *ifap != NULL; ifap = &(*ifap)->ifa_next) {
658 if (*ifap == ifa) {
659 inet_del_ifa(ifa->ifa_dev,
660 ifap, 1);
661 break;
662 }
663 }
664 } else if (ifa->ifa_preferred_lft !=
665 INFINITY_LIFE_TIME &&
666 age >= ifa->ifa_preferred_lft &&
667 !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
668 ifa->ifa_flags |= IFA_F_DEPRECATED;
669 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
670 }
671 }
672 rtnl_unlock();
Jiri Pirko5c766d62013-01-24 09:41:41 +0000673 }
Jiri Pirko5c766d62013-01-24 09:41:41 +0000674
675 next_sec = round_jiffies_up(next);
676 next_sched = next;
677
678 /* If rounded timeout is accurate enough, accept it. */
679 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
680 next_sched = next_sec;
681
682 now = jiffies;
683 /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
684 if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
685 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
686
687 schedule_delayed_work(&check_lifetime_work, next_sched - now);
688}
689
690static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
691 __u32 prefered_lft)
692{
693 unsigned long timeout;
694
695 ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
696
697 timeout = addrconf_timeout_fixup(valid_lft, HZ);
698 if (addrconf_finite_timeout(timeout))
699 ifa->ifa_valid_lft = timeout;
700 else
701 ifa->ifa_flags |= IFA_F_PERMANENT;
702
703 timeout = addrconf_timeout_fixup(prefered_lft, HZ);
704 if (addrconf_finite_timeout(timeout)) {
705 if (timeout == 0)
706 ifa->ifa_flags |= IFA_F_DEPRECATED;
707 ifa->ifa_preferred_lft = timeout;
708 }
709 ifa->ifa_tstamp = jiffies;
710 if (!ifa->ifa_cstamp)
711 ifa->ifa_cstamp = ifa->ifa_tstamp;
712}
713
714static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
715 __u32 *pvalid_lft, __u32 *pprefered_lft)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
Thomas Graf5c753972006-08-04 23:03:53 -0700717 struct nlattr *tb[IFA_MAX+1];
718 struct in_ifaddr *ifa;
719 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 struct net_device *dev;
721 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800722 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
Thomas Graf5c753972006-08-04 23:03:53 -0700724 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
725 if (err < 0)
726 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Thomas Graf5c753972006-08-04 23:03:53 -0700728 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800729 err = -EINVAL;
730 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700731 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800733 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800734 err = -ENODEV;
735 if (dev == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700736 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Thomas Graf5c753972006-08-04 23:03:53 -0700738 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800739 err = -ENOBUFS;
740 if (in_dev == NULL)
Herbert Xu71e27da2007-06-04 23:36:06 -0700741 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Thomas Graf5c753972006-08-04 23:03:53 -0700743 ifa = inet_alloc_ifa();
Denis V. Lunev7b218572008-01-31 18:47:00 -0800744 if (ifa == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700745 /*
746 * A potential indev allocation can be left alive, it stays
747 * assigned to its device and is destroy with it.
748 */
Thomas Graf5c753972006-08-04 23:03:53 -0700749 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700750
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800751 ipv4_devconf_setall(in_dev);
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100752 neigh_parms_data_state_setall(in_dev->arp_parms);
Thomas Graf5c753972006-08-04 23:03:53 -0700753 in_dev_hold(in_dev);
754
755 if (tb[IFA_ADDRESS] == NULL)
756 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
757
David S. Millerfd23c3b2011-02-18 12:42:28 -0800758 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
760 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Jiri Pirkoad6c8132013-12-08 12:16:10 +0100761 ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
762 ifm->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700764 ifa->ifa_dev = in_dev;
765
Al Viroa7a628c2006-09-26 22:16:43 -0700766 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
767 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700768
769 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700770 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700771
Thomas Graf5c753972006-08-04 23:03:53 -0700772 if (tb[IFA_LABEL])
773 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 else
775 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
776
Jiri Pirko5c766d62013-01-24 09:41:41 +0000777 if (tb[IFA_CACHEINFO]) {
778 struct ifa_cacheinfo *ci;
779
780 ci = nla_data(tb[IFA_CACHEINFO]);
781 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
782 err = -EINVAL;
Daniel Borkmann446266b2013-08-02 11:32:43 +0200783 goto errout_free;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000784 }
785 *pvalid_lft = ci->ifa_valid;
786 *pprefered_lft = ci->ifa_prefered;
787 }
788
Thomas Graf5c753972006-08-04 23:03:53 -0700789 return ifa;
790
Daniel Borkmann446266b2013-08-02 11:32:43 +0200791errout_free:
792 inet_free_ifa(ifa);
Thomas Graf5c753972006-08-04 23:03:53 -0700793errout:
794 return ERR_PTR(err);
795}
796
Jiri Pirko5c766d62013-01-24 09:41:41 +0000797static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
798{
799 struct in_device *in_dev = ifa->ifa_dev;
800 struct in_ifaddr *ifa1, **ifap;
801
802 if (!ifa->ifa_local)
803 return NULL;
804
805 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
806 ifap = &ifa1->ifa_next) {
807 if (ifa1->ifa_mask == ifa->ifa_mask &&
808 inet_ifa_match(ifa1->ifa_address, ifa) &&
809 ifa1->ifa_local == ifa->ifa_local)
810 return ifa1;
811 }
812 return NULL;
813}
814
Thomas Graf661d2962013-03-21 07:45:29 +0000815static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Graf5c753972006-08-04 23:03:53 -0700816{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900817 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700818 struct in_ifaddr *ifa;
Jiri Pirko5c766d62013-01-24 09:41:41 +0000819 struct in_ifaddr *ifa_existing;
820 __u32 valid_lft = INFINITY_LIFE_TIME;
821 __u32 prefered_lft = INFINITY_LIFE_TIME;
Thomas Graf5c753972006-08-04 23:03:53 -0700822
823 ASSERT_RTNL();
824
Jiri Pirko5c766d62013-01-24 09:41:41 +0000825 ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
Thomas Graf5c753972006-08-04 23:03:53 -0700826 if (IS_ERR(ifa))
827 return PTR_ERR(ifa);
828
Jiri Pirko5c766d62013-01-24 09:41:41 +0000829 ifa_existing = find_matching_ifa(ifa);
830 if (!ifa_existing) {
831 /* It would be best to check for !NLM_F_CREATE here but
832 * userspace alreay relies on not having to provide this.
833 */
834 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
835 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
836 } else {
837 inet_free_ifa(ifa);
838
839 if (nlh->nlmsg_flags & NLM_F_EXCL ||
840 !(nlh->nlmsg_flags & NLM_F_REPLACE))
841 return -EEXIST;
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000842 ifa = ifa_existing;
843 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
Jiri Pirko05a324b2013-04-04 23:39:38 +0000844 cancel_delayed_work(&check_lifetime_work);
845 schedule_delayed_work(&check_lifetime_work, 0);
Jiri Pirko34e2ed32013-04-04 08:33:00 +0000846 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
847 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Jiri Pirko5c766d62013-01-24 09:41:41 +0000848 }
849 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
851
852/*
853 * Determine a default network mask, based on the IP address.
854 */
855
Eric Dumazet40384992012-08-03 21:06:50 +0000856static int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
858 int rc = -1; /* Something else, probably a multicast. */
859
Joe Perchesf97c1e02007-12-16 13:45:43 -0800860 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900861 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 else {
Al Viro714e85b2006-11-14 20:51:49 -0800863 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Al Viro714e85b2006-11-14 20:51:49 -0800865 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800867 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800869 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 rc = 24;
871 }
872
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900873 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874}
875
876
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800877int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
879 struct ifreq ifr;
880 struct sockaddr_in sin_orig;
881 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
882 struct in_device *in_dev;
883 struct in_ifaddr **ifap = NULL;
884 struct in_ifaddr *ifa = NULL;
885 struct net_device *dev;
886 char *colon;
887 int ret = -EFAULT;
888 int tryaddrmatch = 0;
889
890 /*
891 * Fetch the caller's info block into kernel space
892 */
893
894 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
895 goto out;
896 ifr.ifr_name[IFNAMSIZ - 1] = 0;
897
898 /* save original address for comparison */
899 memcpy(&sin_orig, sin, sizeof(*sin));
900
901 colon = strchr(ifr.ifr_name, ':');
902 if (colon)
903 *colon = 0;
904
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800905 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906
Stephen Hemminger132adf52007-03-08 20:44:43 -0800907 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 case SIOCGIFADDR: /* Get interface address */
909 case SIOCGIFBRDADDR: /* Get the broadcast address */
910 case SIOCGIFDSTADDR: /* Get the destination address */
911 case SIOCGIFNETMASK: /* Get the netmask for the interface */
912 /* Note that these ioctls will not sleep,
913 so that we do not impose a lock.
914 One day we will be forced to put shlock here (I mean SMP)
915 */
916 tryaddrmatch = (sin_orig.sin_family == AF_INET);
917 memset(sin, 0, sizeof(*sin));
918 sin->sin_family = AF_INET;
919 break;
920
921 case SIOCSIFFLAGS:
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000922 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000923 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 goto out;
925 break;
926 case SIOCSIFADDR: /* Set interface address (and family) */
927 case SIOCSIFBRDADDR: /* Set the broadcast address */
928 case SIOCSIFDSTADDR: /* Set the destination address */
929 case SIOCSIFNETMASK: /* Set the netmask for the interface */
Zhao Hongjiangbf5b30b2012-09-20 22:37:25 +0000930 ret = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000931 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 goto out;
933 ret = -EINVAL;
934 if (sin->sin_family != AF_INET)
935 goto out;
936 break;
937 default:
938 ret = -EINVAL;
939 goto out;
940 }
941
942 rtnl_lock();
943
944 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800945 dev = __dev_get_by_name(net, ifr.ifr_name);
946 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 goto done;
948
949 if (colon)
950 *colon = ':';
951
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800952 in_dev = __in_dev_get_rtnl(dev);
953 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 if (tryaddrmatch) {
955 /* Matthias Andree */
956 /* compare label and address (4.4BSD style) */
957 /* note: we only do this for a limited set of ioctls
958 and only if the original address family was AF_INET.
959 This is checked above. */
960 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
961 ifap = &ifa->ifa_next) {
962 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
963 sin_orig.sin_addr.s_addr ==
David S. Miller6c91afe2011-03-09 13:27:16 -0800964 ifa->ifa_local) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 break; /* found */
966 }
967 }
968 }
969 /* we didn't get a match, maybe the application is
970 4.3BSD-style and passed in junk so we fall back to
971 comparing just the label */
972 if (!ifa) {
973 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
974 ifap = &ifa->ifa_next)
975 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
976 break;
977 }
978 }
979
980 ret = -EADDRNOTAVAIL;
981 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
982 goto done;
983
Stephen Hemminger132adf52007-03-08 20:44:43 -0800984 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 case SIOCGIFADDR: /* Get interface address */
986 sin->sin_addr.s_addr = ifa->ifa_local;
987 goto rarok;
988
989 case SIOCGIFBRDADDR: /* Get the broadcast address */
990 sin->sin_addr.s_addr = ifa->ifa_broadcast;
991 goto rarok;
992
993 case SIOCGIFDSTADDR: /* Get the destination address */
994 sin->sin_addr.s_addr = ifa->ifa_address;
995 goto rarok;
996
997 case SIOCGIFNETMASK: /* Get the netmask for the interface */
998 sin->sin_addr.s_addr = ifa->ifa_mask;
999 goto rarok;
1000
1001 case SIOCSIFFLAGS:
1002 if (colon) {
1003 ret = -EADDRNOTAVAIL;
1004 if (!ifa)
1005 break;
1006 ret = 0;
1007 if (!(ifr.ifr_flags & IFF_UP))
1008 inet_del_ifa(in_dev, ifap, 1);
1009 break;
1010 }
1011 ret = dev_change_flags(dev, ifr.ifr_flags);
1012 break;
1013
1014 case SIOCSIFADDR: /* Set interface address (and family) */
1015 ret = -EINVAL;
1016 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1017 break;
1018
1019 if (!ifa) {
1020 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001021 ifa = inet_alloc_ifa();
1022 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 break;
Xi Wangc7e2e1d2013-01-05 11:19:24 +00001024 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 if (colon)
1026 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
1027 else
1028 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1029 } else {
1030 ret = 0;
1031 if (ifa->ifa_local == sin->sin_addr.s_addr)
1032 break;
1033 inet_del_ifa(in_dev, ifap, 0);
1034 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -08001035 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 }
1037
1038 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
1039
1040 if (!(dev->flags & IFF_POINTOPOINT)) {
1041 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
1042 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
1043 if ((dev->flags & IFF_BROADCAST) &&
1044 ifa->ifa_prefixlen < 31)
1045 ifa->ifa_broadcast = ifa->ifa_address |
1046 ~ifa->ifa_mask;
1047 } else {
1048 ifa->ifa_prefixlen = 32;
1049 ifa->ifa_mask = inet_make_mask(32);
1050 }
Jiri Pirko5c766d62013-01-24 09:41:41 +00001051 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 ret = inet_set_ifa(dev, ifa);
1053 break;
1054
1055 case SIOCSIFBRDADDR: /* Set the broadcast address */
1056 ret = 0;
1057 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
1058 inet_del_ifa(in_dev, ifap, 0);
1059 ifa->ifa_broadcast = sin->sin_addr.s_addr;
1060 inet_insert_ifa(ifa);
1061 }
1062 break;
1063
1064 case SIOCSIFDSTADDR: /* Set the destination address */
1065 ret = 0;
1066 if (ifa->ifa_address == sin->sin_addr.s_addr)
1067 break;
1068 ret = -EINVAL;
1069 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
1070 break;
1071 ret = 0;
1072 inet_del_ifa(in_dev, ifap, 0);
1073 ifa->ifa_address = sin->sin_addr.s_addr;
1074 inet_insert_ifa(ifa);
1075 break;
1076
1077 case SIOCSIFNETMASK: /* Set the netmask for the interface */
1078
1079 /*
1080 * The mask we set must be legal.
1081 */
1082 ret = -EINVAL;
1083 if (bad_mask(sin->sin_addr.s_addr, 0))
1084 break;
1085 ret = 0;
1086 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -07001087 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 inet_del_ifa(in_dev, ifap, 0);
1089 ifa->ifa_mask = sin->sin_addr.s_addr;
1090 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
1091
1092 /* See if current broadcast address matches
1093 * with current netmask, then recalculate
1094 * the broadcast address. Otherwise it's a
1095 * funny address, so don't touch it since
1096 * the user seems to know what (s)he's doing...
1097 */
1098 if ((dev->flags & IFF_BROADCAST) &&
1099 (ifa->ifa_prefixlen < 31) &&
1100 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -05001101 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 ifa->ifa_broadcast = (ifa->ifa_local |
1103 ~sin->sin_addr.s_addr);
1104 }
1105 inet_insert_ifa(ifa);
1106 }
1107 break;
1108 }
1109done:
1110 rtnl_unlock();
1111out:
1112 return ret;
1113rarok:
1114 rtnl_unlock();
1115 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
1116 goto out;
1117}
1118
1119static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
1120{
Herbert Xue5ed6392005-10-03 14:35:55 -07001121 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 struct in_ifaddr *ifa;
1123 struct ifreq ifr;
1124 int done = 0;
1125
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001126 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 goto out;
1128
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001129 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 if (!buf) {
1131 done += sizeof(ifr);
1132 continue;
1133 }
1134 if (len < (int) sizeof(ifr))
1135 break;
1136 memset(&ifr, 0, sizeof(struct ifreq));
Dan Carpenter4299c8a2013-07-29 22:15:19 +03001137 strcpy(ifr.ifr_name, ifa->ifa_label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
1139 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
1140 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
1141 ifa->ifa_local;
1142
1143 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
1144 done = -EFAULT;
1145 break;
1146 }
1147 buf += sizeof(struct ifreq);
1148 len -= sizeof(struct ifreq);
1149 done += sizeof(struct ifreq);
1150 }
1151out:
1152 return done;
1153}
1154
Al Viroa61ced52006-09-26 21:27:54 -07001155__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156{
Al Viroa61ced52006-09-26 21:27:54 -07001157 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001159 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
1161 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -07001162 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 if (!in_dev)
1164 goto no_in_dev;
1165
1166 for_primary_ifa(in_dev) {
1167 if (ifa->ifa_scope > scope)
1168 continue;
1169 if (!dst || inet_ifa_match(dst, ifa)) {
1170 addr = ifa->ifa_local;
1171 break;
1172 }
1173 if (!addr)
1174 addr = ifa->ifa_local;
1175 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
1177 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001178 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001179no_in_dev:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
1181 /* Not loopback addresses on loopback should be preferred
1182 in this case. It is importnat that lo is the first interface
1183 in dev_base list.
1184 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001185 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001186 in_dev = __in_dev_get_rcu(dev);
1187 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 continue;
1189
1190 for_primary_ifa(in_dev) {
1191 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1192 ifa->ifa_scope <= scope) {
1193 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001194 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 }
1196 } endfor_ifa(in_dev);
1197 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001198out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 return addr;
1201}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001202EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
Al Viro60cad5d2006-09-26 22:17:09 -07001204static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1205 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206{
1207 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -07001208 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
1210 for_ifa(in_dev) {
1211 if (!addr &&
1212 (local == ifa->ifa_local || !local) &&
1213 ifa->ifa_scope <= scope) {
1214 addr = ifa->ifa_local;
1215 if (same)
1216 break;
1217 }
1218 if (!same) {
1219 same = (!local || inet_ifa_match(local, ifa)) &&
1220 (!dst || inet_ifa_match(dst, ifa));
1221 if (same && addr) {
1222 if (local || !dst)
1223 break;
1224 /* Is the selected addr into dst subnet? */
1225 if (inet_ifa_match(addr, ifa))
1226 break;
1227 /* No, then can we use new local src? */
1228 if (ifa->ifa_scope <= scope) {
1229 addr = ifa->ifa_local;
1230 break;
1231 }
1232 /* search for large dst subnet for addr */
1233 same = 0;
1234 }
1235 }
1236 } endfor_ifa(in_dev);
1237
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001238 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239}
1240
1241/*
1242 * Confirm that local IP address exists using wildcards:
Nicolas Dichtelb601fa192013-12-10 15:02:40 +01001243 * - net: netns to check, cannot be NULL
1244 * - in_dev: only on this interface, NULL=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 * - dst: only in the same subnet as dst, 0=any dst
1246 * - local: address, 0=autoselect the local address
1247 * - scope: maximum allowed scope value for the local address
1248 */
Nicolas Dichtelb601fa192013-12-10 15:02:40 +01001249__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001250 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251{
Al Viro60cad5d2006-09-26 22:17:09 -07001252 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001253 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Nicolas Dichtelb601fa192013-12-10 15:02:40 +01001255 if (in_dev != NULL)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001256 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001259 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001260 in_dev = __in_dev_get_rcu(dev);
1261 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 addr = confirm_addr_indev(in_dev, dst, local, scope);
1263 if (addr)
1264 break;
1265 }
1266 }
1267 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 return addr;
1270}
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00001271EXPORT_SYMBOL(inet_confirm_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
1273/*
1274 * Device notifier
1275 */
1276
1277int register_inetaddr_notifier(struct notifier_block *nb)
1278{
Alan Sterne041c682006-03-27 01:16:30 -08001279 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001281EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
1283int unregister_inetaddr_notifier(struct notifier_block *nb)
1284{
Alan Sterne041c682006-03-27 01:16:30 -08001285 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001287EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001289/* Rename ifa_labels for a device name change. Make some effort to preserve
1290 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291*/
1292static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001293{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 struct in_ifaddr *ifa;
1295 int named = 0;
1296
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001297 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1298 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
1300 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001301 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001303 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001304 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001305 if (dot == NULL) {
1306 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 dot = old;
1308 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001309 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001310 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001311 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001312 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001313skip:
1314 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001315 }
1316}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
Eric Dumazet40384992012-08-03 21:06:50 +00001318static bool inetdev_valid_mtu(unsigned int mtu)
Breno Leitao06770842008-09-02 17:28:58 -07001319{
1320 return mtu >= 68;
1321}
1322
Ian Campbelld11327ad2011-02-11 07:44:16 +00001323static void inetdev_send_gratuitous_arp(struct net_device *dev,
1324 struct in_device *in_dev)
1325
1326{
Zoltan Kissb76d0782011-07-24 13:09:30 +00001327 struct in_ifaddr *ifa;
Ian Campbelld11327ad2011-02-11 07:44:16 +00001328
Zoltan Kissb76d0782011-07-24 13:09:30 +00001329 for (ifa = in_dev->ifa_list; ifa;
1330 ifa = ifa->ifa_next) {
1331 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1332 ifa->ifa_local, dev,
1333 ifa->ifa_local, NULL,
1334 dev->dev_addr, NULL);
1335 }
Ian Campbelld11327ad2011-02-11 07:44:16 +00001336}
1337
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338/* Called only under RTNL semaphore */
1339
1340static int inetdev_event(struct notifier_block *this, unsigned long event,
1341 void *ptr)
1342{
Jiri Pirko351638e2013-05-28 01:30:21 +00001343 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Eric Dumazet748e2d92012-08-22 21:50:59 +00001344 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
1346 ASSERT_RTNL();
1347
1348 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001349 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001351 if (!in_dev)
1352 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001353 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001354 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1355 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001356 }
Breno Leitao06770842008-09-02 17:28:58 -07001357 } else if (event == NETDEV_CHANGEMTU) {
1358 /* Re-enabling IP */
1359 if (inetdev_valid_mtu(dev->mtu))
1360 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 }
1362 goto out;
1363 }
1364
1365 switch (event) {
1366 case NETDEV_REGISTER:
Joe Perches91df42b2012-05-15 14:11:54 +00001367 pr_debug("%s: bug\n", __func__);
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +00001368 RCU_INIT_POINTER(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 break;
1370 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001371 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001373 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001374 struct in_ifaddr *ifa = inet_alloc_ifa();
1375
1376 if (ifa) {
David S. Millerfd23c3b2011-02-18 12:42:28 -08001377 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 ifa->ifa_local =
1379 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1380 ifa->ifa_prefixlen = 8;
1381 ifa->ifa_mask = inet_make_mask(8);
1382 in_dev_hold(in_dev);
1383 ifa->ifa_dev = in_dev;
1384 ifa->ifa_scope = RT_SCOPE_HOST;
1385 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Jiri Pirko5c766d62013-01-24 09:41:41 +00001386 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
1387 INFINITY_LIFE_TIME);
Jiri Pirkodfd15822014-01-07 15:55:45 +01001388 ipv4_devconf_setall(in_dev);
1389 neigh_parms_data_state_setall(in_dev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 inet_insert_ifa(ifa);
1391 }
1392 }
1393 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001394 /* fall through */
1395 case NETDEV_CHANGEADDR:
Ian Campbelld11327ad2011-02-11 07:44:16 +00001396 if (!IN_DEV_ARP_NOTIFY(in_dev))
1397 break;
1398 /* fall through */
1399 case NETDEV_NOTIFY_PEERS:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001400 /* Send gratuitous ARP to notify of link change */
Ian Campbelld11327ad2011-02-11 07:44:16 +00001401 inetdev_send_gratuitous_arp(dev, in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 break;
1403 case NETDEV_DOWN:
1404 ip_mc_down(in_dev);
1405 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001406 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001407 ip_mc_unmap(in_dev);
1408 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001409 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001410 ip_mc_remap(in_dev);
1411 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001413 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 break;
Breno Leitao06770842008-09-02 17:28:58 -07001415 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 case NETDEV_UNREGISTER:
1417 inetdev_destroy(in_dev);
1418 break;
1419 case NETDEV_CHANGENAME:
1420 /* Do not notify about label change, this event is
1421 * not interesting to applications using netlink.
1422 */
1423 inetdev_changename(dev, in_dev);
1424
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001425 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001426 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 break;
1428 }
1429out:
1430 return NOTIFY_DONE;
1431}
1432
1433static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001434 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435};
1436
Eric Dumazet40384992012-08-03 21:06:50 +00001437static size_t inet_nlmsg_size(void)
Thomas Graf339bf982006-11-10 14:10:15 -08001438{
1439 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1440 + nla_total_size(4) /* IFA_ADDRESS */
1441 + nla_total_size(4) /* IFA_LOCAL */
1442 + nla_total_size(4) /* IFA_BROADCAST */
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001443 + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1444 + nla_total_size(4); /* IFA_FLAGS */
Thomas Graf339bf982006-11-10 14:10:15 -08001445}
1446
Jiri Pirko5c766d62013-01-24 09:41:41 +00001447static inline u32 cstamp_delta(unsigned long cstamp)
1448{
1449 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
1450}
1451
1452static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
1453 unsigned long tstamp, u32 preferred, u32 valid)
1454{
1455 struct ifa_cacheinfo ci;
1456
1457 ci.cstamp = cstamp_delta(cstamp);
1458 ci.tstamp = cstamp_delta(tstamp);
1459 ci.ifa_prefered = preferred;
1460 ci.ifa_valid = valid;
1461
1462 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
1463}
1464
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001466 u32 portid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467{
1468 struct ifaddrmsg *ifm;
1469 struct nlmsghdr *nlh;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001470 u32 preferred, valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
Eric W. Biederman15e47302012-09-07 20:12:54 +00001472 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
Thomas Graf47f68512006-08-04 23:04:36 -07001473 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001474 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001475
1476 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 ifm->ifa_family = AF_INET;
1478 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
Jiri Pirko5c766d62013-01-24 09:41:41 +00001479 ifm->ifa_flags = ifa->ifa_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 ifm->ifa_scope = ifa->ifa_scope;
1481 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Jiri Pirko5c766d62013-01-24 09:41:41 +00001483 if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
1484 preferred = ifa->ifa_preferred_lft;
1485 valid = ifa->ifa_valid_lft;
1486 if (preferred != INFINITY_LIFE_TIME) {
1487 long tval = (jiffies - ifa->ifa_tstamp) / HZ;
1488
1489 if (preferred > tval)
1490 preferred -= tval;
1491 else
1492 preferred = 0;
1493 if (valid != INFINITY_LIFE_TIME) {
1494 if (valid > tval)
1495 valid -= tval;
1496 else
1497 valid = 0;
1498 }
1499 }
1500 } else {
1501 preferred = INFINITY_LIFE_TIME;
1502 valid = INFINITY_LIFE_TIME;
1503 }
David S. Millerf3756b72012-04-01 20:39:02 -04001504 if ((ifa->ifa_address &&
1505 nla_put_be32(skb, IFA_ADDRESS, ifa->ifa_address)) ||
1506 (ifa->ifa_local &&
1507 nla_put_be32(skb, IFA_LOCAL, ifa->ifa_local)) ||
1508 (ifa->ifa_broadcast &&
1509 nla_put_be32(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
1510 (ifa->ifa_label[0] &&
Jiri Pirko5c766d62013-01-24 09:41:41 +00001511 nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
Jiri Pirkoad6c8132013-12-08 12:16:10 +01001512 nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
Jiri Pirko5c766d62013-01-24 09:41:41 +00001513 put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
1514 preferred, valid))
David S. Millerf3756b72012-04-01 20:39:02 -04001515 goto nla_put_failure;
Thomas Graf47f68512006-08-04 23:04:36 -07001516
1517 return nlmsg_end(skb, nlh);
1518
1519nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001520 nlmsg_cancel(skb, nlh);
1521 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522}
1523
1524static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1525{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001526 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001527 int h, s_h;
1528 int idx, s_idx;
1529 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 struct net_device *dev;
1531 struct in_device *in_dev;
1532 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001533 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
Eric Dumazeteec4df92009-11-12 07:44:25 +00001535 s_h = cb->args[0];
1536 s_idx = idx = cb->args[1];
1537 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538
Eric Dumazeteec4df92009-11-12 07:44:25 +00001539 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1540 idx = 0;
1541 head = &net->dev_index_head[h];
1542 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001543 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1544 net->dev_base_seq;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001545 hlist_for_each_entry_rcu(dev, head, index_hlist) {
Eric Dumazeteec4df92009-11-12 07:44:25 +00001546 if (idx < s_idx)
1547 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001548 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001549 s_ip_idx = 0;
1550 in_dev = __in_dev_get_rcu(dev);
1551 if (!in_dev)
1552 goto cont;
1553
1554 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1555 ifa = ifa->ifa_next, ip_idx++) {
1556 if (ip_idx < s_ip_idx)
1557 continue;
1558 if (inet_fill_ifaddr(skb, ifa,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001559 NETLINK_CB(cb->skb).portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 cb->nlh->nlmsg_seq,
Eric Dumazeteec4df92009-11-12 07:44:25 +00001561 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1562 rcu_read_unlock();
1563 goto done;
1564 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001565 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Eric Dumazeteec4df92009-11-12 07:44:25 +00001566 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001567cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001568 idx++;
1569 }
1570 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 }
1572
1573done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001574 cb->args[0] = h;
1575 cb->args[1] = idx;
1576 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 return skb->len;
1579}
1580
Jianjun Kong539afed2008-11-03 02:48:48 -08001581static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001582 u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583{
Thomas Graf47f68512006-08-04 23:04:36 -07001584 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001585 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1586 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001587 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001589 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001590 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001591 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001592 goto errout;
1593
Eric W. Biederman15e47302012-09-07 20:12:54 +00001594 err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001595 if (err < 0) {
1596 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1597 WARN_ON(err == -EMSGSIZE);
1598 kfree_skb(skb);
1599 goto errout;
1600 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00001601 rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001602 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001603errout:
1604 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001605 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606}
1607
Thomas Graf9f0f7272010-11-16 04:32:48 +00001608static size_t inet_get_link_af_size(const struct net_device *dev)
1609{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001610 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001611
1612 if (!in_dev)
1613 return 0;
1614
1615 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1616}
1617
1618static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
1619{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001620 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001621 struct nlattr *nla;
1622 int i;
1623
1624 if (!in_dev)
1625 return -ENODATA;
1626
1627 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1628 if (nla == NULL)
1629 return -EMSGSIZE;
1630
1631 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1632 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1633
1634 return 0;
1635}
1636
1637static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1638 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1639};
1640
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001641static int inet_validate_link_af(const struct net_device *dev,
1642 const struct nlattr *nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001643{
Thomas Graf9f0f7272010-11-16 04:32:48 +00001644 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1645 int err, rem;
1646
Eric Dumazetf7fce742010-12-01 06:03:06 +00001647 if (dev && !__in_dev_get_rtnl(dev))
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001648 return -EAFNOSUPPORT;
Thomas Graf9f0f7272010-11-16 04:32:48 +00001649
1650 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1651 if (err < 0)
1652 return err;
1653
1654 if (tb[IFLA_INET_CONF]) {
1655 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1656 int cfgid = nla_type(a);
1657
1658 if (nla_len(a) < 4)
1659 return -EINVAL;
1660
1661 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1662 return -EINVAL;
1663 }
1664 }
1665
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001666 return 0;
1667}
1668
1669static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1670{
Eric Dumazetf7fce742010-12-01 06:03:06 +00001671 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001672 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1673 int rem;
1674
1675 if (!in_dev)
1676 return -EAFNOSUPPORT;
1677
1678 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1679 BUG();
1680
Thomas Graf9f0f7272010-11-16 04:32:48 +00001681 if (tb[IFLA_INET_CONF]) {
1682 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1683 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1684 }
1685
1686 return 0;
1687}
1688
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001689static int inet_netconf_msgsize_devconf(int type)
1690{
1691 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
1692 + nla_total_size(4); /* NETCONFA_IFINDEX */
1693
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001694 /* type -1 is used for ALL */
1695 if (type == -1 || type == NETCONFA_FORWARDING)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001696 size += nla_total_size(4);
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001697 if (type == -1 || type == NETCONFA_RP_FILTER)
1698 size += nla_total_size(4);
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001699 if (type == -1 || type == NETCONFA_MC_FORWARDING)
1700 size += nla_total_size(4);
stephen hemminger09aea5d2013-12-17 22:35:52 -08001701 if (type == -1 || type == NETCONFA_PROXY_NEIGH)
stephen hemmingerf085ff12013-12-12 13:06:50 -08001702 size += nla_total_size(4);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001703
1704 return size;
1705}
1706
1707static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
1708 struct ipv4_devconf *devconf, u32 portid,
1709 u32 seq, int event, unsigned int flags,
1710 int type)
1711{
1712 struct nlmsghdr *nlh;
1713 struct netconfmsg *ncm;
1714
1715 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
1716 flags);
1717 if (nlh == NULL)
1718 return -EMSGSIZE;
1719
1720 ncm = nlmsg_data(nlh);
1721 ncm->ncm_family = AF_INET;
1722
1723 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
1724 goto nla_put_failure;
1725
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001726 /* type -1 is used for ALL */
1727 if ((type == -1 || type == NETCONFA_FORWARDING) &&
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001728 nla_put_s32(skb, NETCONFA_FORWARDING,
1729 IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
1730 goto nla_put_failure;
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001731 if ((type == -1 || type == NETCONFA_RP_FILTER) &&
1732 nla_put_s32(skb, NETCONFA_RP_FILTER,
1733 IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
1734 goto nla_put_failure;
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001735 if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
1736 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
1737 IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
1738 goto nla_put_failure;
stephen hemminger09aea5d2013-12-17 22:35:52 -08001739 if ((type == -1 || type == NETCONFA_PROXY_NEIGH) &&
1740 nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08001741 IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
1742 goto nla_put_failure;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001743
1744 return nlmsg_end(skb, nlh);
1745
1746nla_put_failure:
1747 nlmsg_cancel(skb, nlh);
1748 return -EMSGSIZE;
1749}
1750
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001751void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
1752 struct ipv4_devconf *devconf)
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001753{
1754 struct sk_buff *skb;
1755 int err = -ENOBUFS;
1756
1757 skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_ATOMIC);
1758 if (skb == NULL)
1759 goto errout;
1760
1761 err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1762 RTM_NEWNETCONF, 0, type);
1763 if (err < 0) {
1764 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1765 WARN_ON(err == -EMSGSIZE);
1766 kfree_skb(skb);
1767 goto errout;
1768 }
1769 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_ATOMIC);
1770 return;
1771errout:
1772 if (err < 0)
1773 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
1774}
1775
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001776static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
1777 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
1778 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001779 [NETCONFA_RP_FILTER] = { .len = sizeof(int) },
stephen hemminger09aea5d2013-12-17 22:35:52 -08001780 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001781};
1782
1783static int inet_netconf_get_devconf(struct sk_buff *in_skb,
Thomas Graf661d2962013-03-21 07:45:29 +00001784 struct nlmsghdr *nlh)
Nicolas Dichtel9e551112012-10-25 22:28:53 +00001785{
1786 struct net *net = sock_net(in_skb->sk);
1787 struct nlattr *tb[NETCONFA_MAX+1];
1788 struct netconfmsg *ncm;
1789 struct sk_buff *skb;
1790 struct ipv4_devconf *devconf;
1791 struct in_device *in_dev;
1792 struct net_device *dev;
1793 int ifindex;
1794 int err;
1795
1796 err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
1797 devconf_ipv4_policy);
1798 if (err < 0)
1799 goto errout;
1800
1801 err = EINVAL;
1802 if (!tb[NETCONFA_IFINDEX])
1803 goto errout;
1804
1805 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
1806 switch (ifindex) {
1807 case NETCONFA_IFINDEX_ALL:
1808 devconf = net->ipv4.devconf_all;
1809 break;
1810 case NETCONFA_IFINDEX_DEFAULT:
1811 devconf = net->ipv4.devconf_dflt;
1812 break;
1813 default:
1814 dev = __dev_get_by_index(net, ifindex);
1815 if (dev == NULL)
1816 goto errout;
1817 in_dev = __in_dev_get_rtnl(dev);
1818 if (in_dev == NULL)
1819 goto errout;
1820 devconf = &in_dev->cnf;
1821 break;
1822 }
1823
1824 err = -ENOBUFS;
1825 skb = nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC);
1826 if (skb == NULL)
1827 goto errout;
1828
1829 err = inet_netconf_fill_devconf(skb, ifindex, devconf,
1830 NETLINK_CB(in_skb).portid,
1831 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1832 -1);
1833 if (err < 0) {
1834 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
1835 WARN_ON(err == -EMSGSIZE);
1836 kfree_skb(skb);
1837 goto errout;
1838 }
1839 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
1840errout:
1841 return err;
1842}
1843
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001844static int inet_netconf_dump_devconf(struct sk_buff *skb,
1845 struct netlink_callback *cb)
1846{
1847 struct net *net = sock_net(skb->sk);
1848 int h, s_h;
1849 int idx, s_idx;
1850 struct net_device *dev;
1851 struct in_device *in_dev;
1852 struct hlist_head *head;
1853
1854 s_h = cb->args[0];
1855 s_idx = idx = cb->args[1];
1856
1857 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1858 idx = 0;
1859 head = &net->dev_index_head[h];
1860 rcu_read_lock();
Nicolas Dichtel04652772013-03-22 06:28:42 +00001861 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
1862 net->dev_base_seq;
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001863 hlist_for_each_entry_rcu(dev, head, index_hlist) {
1864 if (idx < s_idx)
1865 goto cont;
1866 in_dev = __in_dev_get_rcu(dev);
1867 if (!in_dev)
1868 goto cont;
1869
1870 if (inet_netconf_fill_devconf(skb, dev->ifindex,
1871 &in_dev->cnf,
1872 NETLINK_CB(cb->skb).portid,
1873 cb->nlh->nlmsg_seq,
1874 RTM_NEWNETCONF,
1875 NLM_F_MULTI,
1876 -1) <= 0) {
1877 rcu_read_unlock();
1878 goto done;
1879 }
Nicolas Dichtel04652772013-03-22 06:28:42 +00001880 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
Nicolas Dichtel7a674202013-03-05 23:42:06 +00001881cont:
1882 idx++;
1883 }
1884 rcu_read_unlock();
1885 }
1886 if (h == NETDEV_HASHENTRIES) {
1887 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
1888 net->ipv4.devconf_all,
1889 NETLINK_CB(cb->skb).portid,
1890 cb->nlh->nlmsg_seq,
1891 RTM_NEWNETCONF, NLM_F_MULTI,
1892 -1) <= 0)
1893 goto done;
1894 else
1895 h++;
1896 }
1897 if (h == NETDEV_HASHENTRIES + 1) {
1898 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
1899 net->ipv4.devconf_dflt,
1900 NETLINK_CB(cb->skb).portid,
1901 cb->nlh->nlmsg_seq,
1902 RTM_NEWNETCONF, NLM_F_MULTI,
1903 -1) <= 0)
1904 goto done;
1905 else
1906 h++;
1907 }
1908done:
1909 cb->args[0] = h;
1910 cb->args[1] = idx;
1911
1912 return skb->len;
1913}
1914
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915#ifdef CONFIG_SYSCTL
1916
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001917static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001918{
1919 struct net_device *dev;
1920
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001921 rcu_read_lock();
1922 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001923 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001924
Herbert Xu31be3082007-06-04 23:35:37 -07001925 in_dev = __in_dev_get_rcu(dev);
1926 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001927 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001928 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001929 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07001930}
1931
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001932/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001933static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001934{
1935 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001936 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001937
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001938 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001939 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001940 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1941 NETCONFA_IFINDEX_ALL,
1942 net->ipv4.devconf_all);
1943 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1944 NETCONFA_IFINDEX_DEFAULT,
1945 net->ipv4.devconf_dflt);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001946
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001947 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001948 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001949 if (on)
1950 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001951 rcu_read_lock();
1952 in_dev = __in_dev_get_rcu(dev);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001953 if (in_dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001954 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00001955 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
1956 dev->ifindex, &in_dev->cnf);
1957 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001958 rcu_read_unlock();
1959 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001960}
1961
stephen hemmingerf085ff12013-12-12 13:06:50 -08001962static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
1963{
1964 if (cnf == net->ipv4.devconf_dflt)
1965 return NETCONFA_IFINDEX_DEFAULT;
1966 else if (cnf == net->ipv4.devconf_all)
1967 return NETCONFA_IFINDEX_ALL;
1968 else {
1969 struct in_device *idev
1970 = container_of(cnf, struct in_device, cnf);
1971 return idev->dev->ifindex;
1972 }
1973}
1974
Joe Perchesfe2c6332013-06-11 23:04:25 -07001975static int devinet_conf_proc(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001976 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07001977 size_t *lenp, loff_t *ppos)
1978{
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00001979 int old_value = *(int *)ctl->data;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001980 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00001981 int new_value = *(int *)ctl->data;
Herbert Xu31be3082007-06-04 23:35:37 -07001982
1983 if (write) {
1984 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001985 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001986 int i = (int *)ctl->data - cnf->data;
stephen hemmingerf085ff12013-12-12 13:06:50 -08001987 int ifindex;
Herbert Xu31be3082007-06-04 23:35:37 -07001988
1989 set_bit(i, cnf->state);
1990
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001991 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001992 devinet_copy_dflt_conf(net, i);
Thomas Grafd0daebc32012-06-12 00:44:01 +00001993 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
1994 i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
Peter Pan(潘卫平)d01ff0a2011-12-01 15:47:06 +00001995 if ((new_value == 0) && (old_value != 0))
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00001996 rt_cache_flush(net);
stephen hemmingerf085ff12013-12-12 13:06:50 -08001997
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00001998 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
1999 new_value != old_value) {
stephen hemmingerf085ff12013-12-12 13:06:50 -08002000 ifindex = devinet_conf_ifindex(net, cnf);
Nicolas Dichtelcc535df2012-10-29 04:53:27 +00002001 inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
2002 ifindex, cnf);
2003 }
stephen hemmingerf085ff12013-12-12 13:06:50 -08002004 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
2005 new_value != old_value) {
2006 ifindex = devinet_conf_ifindex(net, cnf);
stephen hemminger09aea5d2013-12-17 22:35:52 -08002007 inet_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
stephen hemmingerf085ff12013-12-12 13:06:50 -08002008 ifindex, cnf);
2009 }
Herbert Xu31be3082007-06-04 23:35:37 -07002010 }
2011
2012 return ret;
2013}
2014
Joe Perchesfe2c6332013-06-11 23:04:25 -07002015static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002016 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 size_t *lenp, loff_t *ppos)
2018{
2019 int *valp = ctl->data;
2020 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00002021 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002022 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
2024 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002025 struct net *net = ctl->extra2;
2026
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002027 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00002028 if (!rtnl_trylock()) {
2029 /* Restore the original values before restarting */
2030 *valp = val;
2031 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00002032 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00002033 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002034 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
2035 inet_forward_change(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002036 } else {
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002037 struct ipv4_devconf *cnf = ctl->extra1;
2038 struct in_device *idev =
2039 container_of(cnf, struct in_device, cnf);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002040 if (*valp)
2041 dev_disable_lro(idev->dev);
2042 inet_netconf_notify_devconf(net,
2043 NETCONFA_FORWARDING,
2044 idev->dev->ifindex,
2045 cnf);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07002046 }
2047 rtnl_unlock();
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002048 rt_cache_flush(net);
Nicolas Dichteledc9e742012-10-25 22:28:52 +00002049 } else
2050 inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
2051 NETCONFA_IFINDEX_DEFAULT,
2052 net->ipv4.devconf_dflt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 }
2054
2055 return ret;
2056}
2057
Joe Perchesfe2c6332013-06-11 23:04:25 -07002058static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
David S. Miller323e1262010-12-12 21:55:08 -08002059 void __user *buffer,
2060 size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061{
2062 int *valp = ctl->data;
2063 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002064 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07002065 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
2067 if (write && *valp != val)
Nicolas Dichtel4ccfe6d2012-09-07 00:45:29 +00002068 rt_cache_flush(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069
2070 return ret;
2071}
2072
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002073#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07002074 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07002075 .procname = name, \
2076 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00002077 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002078 .maxlen = sizeof(int), \
2079 .mode = mval, \
2080 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07002081 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07002082 }
2083
2084#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002085 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002086
2087#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002088 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002089
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002090#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
2091 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07002092
2093#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002094 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07002095
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096static struct devinet_sysctl_table {
2097 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00002098 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099} devinet_sysctl = {
2100 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07002101 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002102 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07002103 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2104
2105 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
2106 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
2107 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
2108 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
2109 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
2110 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
2111 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00002112 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08002113 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002114 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
2115 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
2116 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
2117 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
2118 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
2119 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
2120 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
2121 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
2122 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08002123 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00002124 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
William Manley5c6fe012013-08-06 19:03:14 +01002125 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
2126 "force_igmp_version"),
William Manley26900482013-08-06 19:03:15 +01002127 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
2128 "igmpv2_unsolicited_report_interval"),
2129 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
2130 "igmpv3_unsolicited_report_interval"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002131
2132 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
2133 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
Herbert Xu42f811b2007-06-04 23:34:44 -07002134 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
2135 "promote_secondaries"),
Thomas Grafd0daebc32012-06-12 00:44:01 +00002136 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
2137 "route_localnet"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139};
2140
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002141static int __devinet_sysctl_register(struct net *net, char *dev_name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002142 struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143{
2144 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002145 struct devinet_sysctl_table *t;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002146 char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11002147
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002148 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002150 goto out;
2151
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
2153 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07002154 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002155 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 }
2157
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002158 snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002160 t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 if (!t->sysctl_header)
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002162 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
2164 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002165 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002167free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11002169out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08002170 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171}
2172
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002173static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
2174{
2175 struct devinet_sysctl_table *t = cnf->sysctl;
2176
2177 if (t == NULL)
2178 return;
2179
2180 cnf->sysctl = NULL;
Lucian Adrian Grijincuff538812011-05-01 01:44:01 +00002181 unregister_net_sysctl_table(t->sysctl_header);
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002182 kfree(t);
2183}
2184
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002185static void devinet_sysctl_register(struct in_device *idev)
2186{
Jiri Pirko73af6142013-12-07 19:26:55 +01002187 neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002188 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002189 &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11002190}
2191
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002192static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08002194 __devinet_sysctl_unregister(&idev->cnf);
2195 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002198static struct ctl_table ctl_forward_entry[] = {
2199 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002200 .procname = "ip_forward",
2201 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00002202 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002203 .maxlen = sizeof(int),
2204 .mode = 0644,
2205 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002206 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08002207 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002208 },
2209 { },
2210};
Eric Dumazet2a75de02008-01-05 23:08:49 -08002211#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08002212
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002213static __net_init int devinet_init_net(struct net *net)
2214{
2215 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002216 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002217#ifdef CONFIG_SYSCTL
2218 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002219 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002220#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002221
2222 err = -ENOMEM;
2223 all = &ipv4_devconf;
2224 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002225
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08002226 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002227 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2228 if (all == NULL)
2229 goto err_alloc_all;
2230
2231 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2232 if (dflt == NULL)
2233 goto err_alloc_dflt;
2234
Eric Dumazet2a75de02008-01-05 23:08:49 -08002235#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002236 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2237 if (tbl == NULL)
2238 goto err_alloc_ctl;
2239
Eric W. Biederman02291682010-02-14 03:25:51 +00002240 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002241 tbl[0].extra1 = all;
2242 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002243#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002244 }
2245
2246#ifdef CONFIG_SYSCTL
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002247 err = __devinet_sysctl_register(net, "all", all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002248 if (err < 0)
2249 goto err_reg_all;
2250
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08002251 err = __devinet_sysctl_register(net, "default", dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002252 if (err < 0)
2253 goto err_reg_dflt;
2254
2255 err = -ENOMEM;
Eric W. Biederman8607ddb2012-04-19 13:42:09 +00002256 forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002257 if (forw_hdr == NULL)
2258 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08002259 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002260#endif
2261
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002262 net->ipv4.devconf_all = all;
2263 net->ipv4.devconf_dflt = dflt;
2264 return 0;
2265
2266#ifdef CONFIG_SYSCTL
2267err_reg_ctl:
2268 __devinet_sysctl_unregister(dflt);
2269err_reg_dflt:
2270 __devinet_sysctl_unregister(all);
2271err_reg_all:
2272 if (tbl != ctl_forward_entry)
2273 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002274err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08002275#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002276 if (dflt != &ipv4_devconf_dflt)
2277 kfree(dflt);
2278err_alloc_dflt:
2279 if (all != &ipv4_devconf)
2280 kfree(all);
2281err_alloc_all:
2282 return err;
2283}
2284
2285static __net_exit void devinet_exit_net(struct net *net)
2286{
Eric Dumazet2a75de02008-01-05 23:08:49 -08002287#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002288 struct ctl_table *tbl;
2289
2290 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002291 unregister_net_sysctl_table(net->ipv4.forw_hdr);
2292 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
2293 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002294 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08002295#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002296 kfree(net->ipv4.devconf_dflt);
2297 kfree(net->ipv4.devconf_all);
2298}
2299
2300static __net_initdata struct pernet_operations devinet_ops = {
2301 .init = devinet_init_net,
2302 .exit = devinet_exit_net,
2303};
2304
Thomas Graf9f0f7272010-11-16 04:32:48 +00002305static struct rtnl_af_ops inet_af_ops = {
2306 .family = AF_INET,
2307 .fill_link_af = inet_fill_link_af,
2308 .get_link_af_size = inet_get_link_af_size,
Thomas Grafcf7afbf2010-11-22 01:31:54 +00002309 .validate_link_af = inet_validate_link_af,
2310 .set_link_af = inet_set_link_af,
Thomas Graf9f0f7272010-11-16 04:32:48 +00002311};
2312
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313void __init devinet_init(void)
2314{
David S. Millerfd23c3b2011-02-18 12:42:28 -08002315 int i;
2316
2317 for (i = 0; i < IN4_ADDR_HSIZE; i++)
2318 INIT_HLIST_HEAD(&inet_addr_lst[i]);
2319
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08002320 register_pernet_subsys(&devinet_ops);
2321
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 register_gifconf(PF_INET, inet_gifconf);
2323 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07002324
Jiri Pirko5c766d62013-01-24 09:41:41 +00002325 schedule_delayed_work(&check_lifetime_work, 0);
2326
Thomas Graf9f0f7272010-11-16 04:32:48 +00002327 rtnl_af_register(&inet_af_ops);
2328
Greg Rosec7ac8672011-06-10 01:27:09 +00002329 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
2330 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
2331 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
Nicolas Dichtel9e551112012-10-25 22:28:53 +00002332 rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
Nicolas Dichtel7a674202013-03-05 23:42:06 +00002333 inet_netconf_dump_devconf, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334}
2335