blob: bc19bd06dd006f548282e25f33c7d6ef056a54ac [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>
30#include <asm/system.h>
31#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080032#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/module.h>
34#include <linux/types.h>
35#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/string.h>
37#include <linux/mm.h>
38#include <linux/socket.h>
39#include <linux/sockios.h>
40#include <linux/in.h>
41#include <linux/errno.h>
42#include <linux/interrupt.h>
Thomas Graf18237302006-08-04 23:04:54 -070043#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/if_ether.h>
45#include <linux/inet.h>
46#include <linux/netdevice.h>
47#include <linux/etherdevice.h>
48#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/init.h>
50#include <linux/notifier.h>
51#include <linux/inetdevice.h>
52#include <linux/igmp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090053#include <linux/slab.h>
David S. Millerfd23c3b2011-02-18 12:42:28 -080054#include <linux/hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#ifdef CONFIG_SYSCTL
56#include <linux/sysctl.h>
57#endif
58#include <linux/kmod.h>
59
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
David S. Miller406b6f92011-03-22 21:56:23 -070067#include "fib_lookup.h"
68
Adrian Bunk0027ba82008-01-31 17:17:31 -080069static struct ipv4_devconf ipv4_devconf = {
Herbert Xu42f811b2007-06-04 23:34:44 -070070 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000071 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
72 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
73 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
74 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
Herbert Xu42f811b2007-06-04 23:34:44 -070075 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070076};
77
78static struct ipv4_devconf ipv4_devconf_dflt = {
Herbert Xu42f811b2007-06-04 23:34:44 -070079 .data = {
Eric W. Biederman02291682010-02-14 03:25:51 +000080 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
81 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
82 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
83 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
84 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
Herbert Xu42f811b2007-06-04 23:34:44 -070085 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070086};
87
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -080088#define IPV4_DEVCONF_DFLT(net, attr) \
89 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
Herbert Xu42f811b2007-06-04 23:34:44 -070090
Patrick McHardyef7c79e2007-06-05 12:38:30 -070091static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
Thomas Graf5c753972006-08-04 23:03:53 -070092 [IFA_LOCAL] = { .type = NLA_U32 },
93 [IFA_ADDRESS] = { .type = NLA_U32 },
94 [IFA_BROADCAST] = { .type = NLA_U32 },
Thomas Graf5176f912006-08-26 20:13:18 -070095 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
Thomas Graf5c753972006-08-04 23:03:53 -070096};
97
David S. Millerfd23c3b2011-02-18 12:42:28 -080098/* inet_addr_hash's shifting is dependent upon this IN4_ADDR_HSIZE
99 * value. So if you change this define, make appropriate changes to
100 * inet_addr_hash as well.
101 */
102#define IN4_ADDR_HSIZE 256
103static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
104static DEFINE_SPINLOCK(inet_addr_hash_lock);
105
106static inline unsigned int inet_addr_hash(struct net *net, __be32 addr)
107{
108 u32 val = (__force u32) addr ^ hash_ptr(net, 8);
109
110 return ((val ^ (val >> 8) ^ (val >> 16) ^ (val >> 24)) &
111 (IN4_ADDR_HSIZE - 1));
112}
113
114static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
115{
David S. Millere0660082011-03-03 11:24:19 -0800116 unsigned int hash = inet_addr_hash(net, ifa->ifa_local);
David S. Millerfd23c3b2011-02-18 12:42:28 -0800117
118 spin_lock(&inet_addr_hash_lock);
119 hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
120 spin_unlock(&inet_addr_hash_lock);
121}
122
123static void inet_hash_remove(struct in_ifaddr *ifa)
124{
125 spin_lock(&inet_addr_hash_lock);
126 hlist_del_init_rcu(&ifa->hash);
127 spin_unlock(&inet_addr_hash_lock);
128}
129
David S. Miller9435eb12011-02-18 12:43:09 -0800130/**
131 * __ip_dev_find - find the first device with a given source address.
132 * @net: the net namespace
133 * @addr: the source address
134 * @devref: if true, take a reference on the found device
135 *
136 * If a caller uses devref=false, it should be protected by RCU, or RTNL
137 */
138struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
139{
140 unsigned int hash = inet_addr_hash(net, addr);
141 struct net_device *result = NULL;
142 struct in_ifaddr *ifa;
143 struct hlist_node *node;
144
145 rcu_read_lock();
146 hlist_for_each_entry_rcu(ifa, node, &inet_addr_lst[hash], hash) {
147 struct net_device *dev = ifa->ifa_dev->dev;
148
149 if (!net_eq(dev_net(dev), net))
150 continue;
David S. Millere0660082011-03-03 11:24:19 -0800151 if (ifa->ifa_local == addr) {
David S. Miller9435eb12011-02-18 12:43:09 -0800152 result = dev;
153 break;
154 }
155 }
David S. Miller406b6f92011-03-22 21:56:23 -0700156 if (!result) {
157 struct flowi4 fl4 = { .daddr = addr };
158 struct fib_result res = { 0 };
159 struct fib_table *local;
160
161 /* Fallback to FIB local table so that communication
162 * over loopback subnets work.
163 */
164 local = fib_get_table(net, RT_TABLE_LOCAL);
165 if (local &&
166 !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
167 res.type == RTN_LOCAL)
168 result = FIB_RES_DEV(res);
169 }
David S. Miller9435eb12011-02-18 12:43:09 -0800170 if (result && devref)
171 dev_hold(result);
172 rcu_read_unlock();
173 return result;
174}
175EXPORT_SYMBOL(__ip_dev_find);
176
Thomas Grafd6062cb2006-08-15 00:33:59 -0700177static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Alan Sterne041c682006-03-27 01:16:30 -0800179static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
181 int destroy);
182#ifdef CONFIG_SYSCTL
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100183static void devinet_sysctl_register(struct in_device *idev);
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800184static void devinet_sysctl_unregister(struct in_device *idev);
185#else
186static inline void devinet_sysctl_register(struct in_device *idev)
187{
188}
189static inline void devinet_sysctl_unregister(struct in_device *idev)
190{
191}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192#endif
193
194/* Locks all the inet devices. */
195
196static struct in_ifaddr *inet_alloc_ifa(void)
197{
Alexey Dobriyan93adcc82008-10-28 13:25:09 -0700198 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199}
200
201static void inet_rcu_free_ifa(struct rcu_head *head)
202{
203 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
204 if (ifa->ifa_dev)
205 in_dev_put(ifa->ifa_dev);
206 kfree(ifa);
207}
208
209static inline void inet_free_ifa(struct in_ifaddr *ifa)
210{
211 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
212}
213
214void in_dev_finish_destroy(struct in_device *idev)
215{
216 struct net_device *dev = idev->dev;
217
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700218 WARN_ON(idev->ifa_list);
219 WARN_ON(idev->mc_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220#ifdef NET_REFCNT_DEBUG
221 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
222 idev, dev ? dev->name : "NIL");
223#endif
224 dev_put(dev);
225 if (!idev->dead)
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800226 pr_err("Freeing alive in_device %p\n", idev);
227 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 kfree(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800230EXPORT_SYMBOL(in_dev_finish_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Herbert Xu71e27da2007-06-04 23:36:06 -0700232static struct in_device *inetdev_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 struct in_device *in_dev;
235
236 ASSERT_RTNL();
237
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700238 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 if (!in_dev)
240 goto out;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900241 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -0800242 sizeof(in_dev->cnf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 in_dev->cnf.sysctl = NULL;
244 in_dev->dev = dev;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800245 in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
246 if (!in_dev->arp_parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 goto out_kfree;
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700248 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
249 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 /* Reference in_dev->dev */
251 dev_hold(dev);
David L Stevens30c4cf52007-01-04 12:31:14 -0800252 /* Account for reference dev->ip_ptr (below) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 in_dev_hold(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Pavel Emelyanov66f27a52007-12-02 00:55:54 +1100255 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 ip_mc_init_dev(in_dev);
257 if (dev->flags & IFF_UP)
258 ip_mc_up(in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800259
David L Stevens30c4cf52007-01-04 12:31:14 -0800260 /* we can receive as soon as ip_ptr is set -- do this last */
261 rcu_assign_pointer(dev->ip_ptr, in_dev);
Jarek Poplawski483479e2007-01-09 14:38:31 -0800262out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return in_dev;
264out_kfree:
265 kfree(in_dev);
266 in_dev = NULL;
267 goto out;
268}
269
270static void in_dev_rcu_put(struct rcu_head *head)
271{
272 struct in_device *idev = container_of(head, struct in_device, rcu_head);
273 in_dev_put(idev);
274}
275
276static void inetdev_destroy(struct in_device *in_dev)
277{
278 struct in_ifaddr *ifa;
279 struct net_device *dev;
280
281 ASSERT_RTNL();
282
283 dev = in_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 in_dev->dead = 1;
286
287 ip_mc_destroy_dev(in_dev);
288
289 while ((ifa = in_dev->ifa_list) != NULL) {
290 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
291 inet_free_ifa(ifa);
292 }
293
Eric Dumazet95ae6b22010-09-15 04:04:31 +0000294 rcu_assign_pointer(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Pavel Emelyanov51602b22007-12-11 02:17:40 -0800296 devinet_sysctl_unregister(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
298 arp_ifdown(dev);
299
300 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
301}
302
Al Viroff428d72006-09-26 22:13:35 -0700303int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
305 rcu_read_lock();
306 for_primary_ifa(in_dev) {
307 if (inet_ifa_match(a, ifa)) {
308 if (!b || inet_ifa_match(b, ifa)) {
309 rcu_read_unlock();
310 return 1;
311 }
312 }
313 } endfor_ifa(in_dev);
314 rcu_read_unlock();
315 return 0;
316}
317
Thomas Grafd6062cb2006-08-15 00:33:59 -0700318static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
319 int destroy, struct nlmsghdr *nlh, u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
Harald Welte8f937c62005-05-29 20:23:46 -0700321 struct in_ifaddr *promote = NULL;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800322 struct in_ifaddr *ifa, *ifa1 = *ifap;
323 struct in_ifaddr *last_prim = in_dev->ifa_list;
324 struct in_ifaddr *prev_prom = NULL;
325 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 ASSERT_RTNL();
328
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900329 /* 1. Deleting primary ifaddr forces deletion all secondaries
Harald Welte8f937c62005-05-29 20:23:46 -0700330 * unless alias promotion is set
331 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
335
336 while ((ifa = *ifap1) != NULL) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900337 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800338 ifa1->ifa_scope <= ifa->ifa_scope)
339 last_prim = ifa;
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
342 ifa1->ifa_mask != ifa->ifa_mask ||
343 !inet_ifa_match(ifa1->ifa_address, ifa)) {
344 ifap1 = &ifa->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800345 prev_prom = ifa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 continue;
347 }
348
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800349 if (!do_promote) {
David S. Millerfd23c3b2011-02-18 12:42:28 -0800350 inet_hash_remove(ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700351 *ifap1 = ifa->ifa_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Thomas Grafd6062cb2006-08-15 00:33:59 -0700353 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800354 blocking_notifier_call_chain(&inetaddr_chain,
355 NETDEV_DOWN, ifa);
Harald Welte8f937c62005-05-29 20:23:46 -0700356 inet_free_ifa(ifa);
357 } else {
358 promote = ifa;
359 break;
360 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 }
362 }
363
Julian Anastasov2d230e22011-03-19 12:13:52 +0000364 /* On promotion all secondaries from subnet are changing
365 * the primary IP, we must remove all their routes silently
366 * and later to add them back with new prefsrc. Do this
367 * while all addresses are on the device list.
368 */
369 for (ifa = promote; ifa; ifa = ifa->ifa_next) {
370 if (ifa1->ifa_mask == ifa->ifa_mask &&
371 inet_ifa_match(ifa1->ifa_address, ifa))
372 fib_del_ifaddr(ifa, ifa1);
373 }
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /* 2. Unlink it */
376
377 *ifap = ifa1->ifa_next;
David S. Millerfd23c3b2011-02-18 12:42:28 -0800378 inet_hash_remove(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 /* 3. Announce address deletion */
381
382 /* Send message first, then call notifier.
383 At first sight, FIB update triggered by notifier
384 will refer to already deleted ifaddr, that could confuse
385 netlink listeners. It is not true: look, gated sees
386 that route deleted and if it still thinks that ifaddr
387 is valid, it will try to restore deleted routes... Grr.
388 So that, this order is correct.
389 */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700390 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800391 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800392
393 if (promote) {
Julian Anastasov04024b92011-03-19 12:13:54 +0000394 struct in_ifaddr *next_sec = promote->ifa_next;
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800395
396 if (prev_prom) {
397 prev_prom->ifa_next = promote->ifa_next;
398 promote->ifa_next = last_prim->ifa_next;
399 last_prim->ifa_next = promote;
400 }
401
402 promote->ifa_flags &= ~IFA_F_SECONDARY;
Thomas Grafd6062cb2006-08-15 00:33:59 -0700403 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800404 blocking_notifier_call_chain(&inetaddr_chain,
405 NETDEV_UP, promote);
Julian Anastasov04024b92011-03-19 12:13:54 +0000406 for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800407 if (ifa1->ifa_mask != ifa->ifa_mask ||
408 !inet_ifa_match(ifa1->ifa_address, ifa))
409 continue;
410 fib_add_ifaddr(ifa);
411 }
412
413 }
Herbert Xu63630972007-06-07 18:35:38 -0700414 if (destroy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 inet_free_ifa(ifa1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
417
Thomas Grafd6062cb2006-08-15 00:33:59 -0700418static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
419 int destroy)
420{
421 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
422}
423
424static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
425 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 struct in_device *in_dev = ifa->ifa_dev;
428 struct in_ifaddr *ifa1, **ifap, **last_primary;
429
430 ASSERT_RTNL();
431
432 if (!ifa->ifa_local) {
433 inet_free_ifa(ifa);
434 return 0;
435 }
436
437 ifa->ifa_flags &= ~IFA_F_SECONDARY;
438 last_primary = &in_dev->ifa_list;
439
440 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
441 ifap = &ifa1->ifa_next) {
442 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
443 ifa->ifa_scope <= ifa1->ifa_scope)
444 last_primary = &ifa1->ifa_next;
445 if (ifa1->ifa_mask == ifa->ifa_mask &&
446 inet_ifa_match(ifa1->ifa_address, ifa)) {
447 if (ifa1->ifa_local == ifa->ifa_local) {
448 inet_free_ifa(ifa);
449 return -EEXIST;
450 }
451 if (ifa1->ifa_scope != ifa->ifa_scope) {
452 inet_free_ifa(ifa);
453 return -EINVAL;
454 }
455 ifa->ifa_flags |= IFA_F_SECONDARY;
456 }
457 }
458
459 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
460 net_srandom(ifa->ifa_local);
461 ifap = last_primary;
462 }
463
464 ifa->ifa_next = *ifap;
465 *ifap = ifa;
466
David S. Millerfd23c3b2011-02-18 12:42:28 -0800467 inet_hash_insert(dev_net(in_dev->dev), ifa);
468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 /* Send message first, then call notifier.
470 Notifier will trigger FIB update, so that
471 listeners of netlink will know about new ifaddr */
Thomas Grafd6062cb2006-08-15 00:33:59 -0700472 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
Alan Sterne041c682006-03-27 01:16:30 -0800473 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475 return 0;
476}
477
Thomas Grafd6062cb2006-08-15 00:33:59 -0700478static int inet_insert_ifa(struct in_ifaddr *ifa)
479{
480 return __inet_insert_ifa(ifa, NULL, 0);
481}
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
484{
Herbert Xue5ed6392005-10-03 14:35:55 -0700485 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487 ASSERT_RTNL();
488
489 if (!in_dev) {
Herbert Xu71e27da2007-06-04 23:36:06 -0700490 inet_free_ifa(ifa);
491 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 }
Herbert Xu71e27da2007-06-04 23:36:06 -0700493 ipv4_devconf_setall(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (ifa->ifa_dev != in_dev) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700495 WARN_ON(ifa->ifa_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 in_dev_hold(in_dev);
497 ifa->ifa_dev = in_dev;
498 }
Joe Perchesf97c1e02007-12-16 13:45:43 -0800499 if (ipv4_is_loopback(ifa->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 ifa->ifa_scope = RT_SCOPE_HOST;
501 return inet_insert_ifa(ifa);
502}
503
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000504/* Caller must hold RCU or RTNL :
505 * We dont take a reference on found in_device
506 */
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800507struct in_device *inetdev_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
509 struct net_device *dev;
510 struct in_device *in_dev = NULL;
Eric Dumazetc148fc22009-11-01 19:23:04 +0000511
512 rcu_read_lock();
513 dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if (dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000515 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Eric Dumazetc148fc22009-11-01 19:23:04 +0000516 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 return in_dev;
518}
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800519EXPORT_SYMBOL(inetdev_by_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
521/* Called only from RTNL semaphored context. No locks. */
522
Al Viro60cad5d2006-09-26 22:17:09 -0700523struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
524 __be32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
526 ASSERT_RTNL();
527
528 for_primary_ifa(in_dev) {
529 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
530 return ifa;
531 } endfor_ifa(in_dev);
532 return NULL;
533}
534
535static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
536{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900537 struct net *net = sock_net(skb->sk);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700538 struct nlattr *tb[IFA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 struct in_device *in_dev;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700540 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 struct in_ifaddr *ifa, **ifap;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700542 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
544 ASSERT_RTNL();
545
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700546 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
547 if (err < 0)
548 goto errout;
549
550 ifm = nlmsg_data(nlh);
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800551 in_dev = inetdev_by_index(net, ifm->ifa_index);
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700552 if (in_dev == NULL) {
553 err = -ENODEV;
554 goto errout;
555 }
556
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
558 ifap = &ifa->ifa_next) {
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700559 if (tb[IFA_LOCAL] &&
Al Viroa7a628c2006-09-26 22:16:43 -0700560 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 continue;
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700562
563 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
564 continue;
565
566 if (tb[IFA_ADDRESS] &&
567 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
Al Viroa7a628c2006-09-26 22:16:43 -0700568 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700569 continue;
570
Thomas Grafd6062cb2006-08-15 00:33:59 -0700571 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 return 0;
573 }
Thomas Grafdfdd5fd2006-08-04 23:04:17 -0700574
575 err = -EADDRNOTAVAIL;
576errout:
577 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800580static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
Thomas Graf5c753972006-08-04 23:03:53 -0700582 struct nlattr *tb[IFA_MAX+1];
583 struct in_ifaddr *ifa;
584 struct ifaddrmsg *ifm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 struct net_device *dev;
586 struct in_device *in_dev;
Denis V. Lunev7b218572008-01-31 18:47:00 -0800587 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Thomas Graf5c753972006-08-04 23:03:53 -0700589 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
590 if (err < 0)
591 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Thomas Graf5c753972006-08-04 23:03:53 -0700593 ifm = nlmsg_data(nlh);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800594 err = -EINVAL;
595 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700596 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800598 dev = __dev_get_by_index(net, ifm->ifa_index);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800599 err = -ENODEV;
600 if (dev == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700601 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Thomas Graf5c753972006-08-04 23:03:53 -0700603 in_dev = __in_dev_get_rtnl(dev);
Denis V. Lunev7b218572008-01-31 18:47:00 -0800604 err = -ENOBUFS;
605 if (in_dev == NULL)
Herbert Xu71e27da2007-06-04 23:36:06 -0700606 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Thomas Graf5c753972006-08-04 23:03:53 -0700608 ifa = inet_alloc_ifa();
Denis V. Lunev7b218572008-01-31 18:47:00 -0800609 if (ifa == NULL)
Thomas Graf5c753972006-08-04 23:03:53 -0700610 /*
611 * A potential indev allocation can be left alive, it stays
612 * assigned to its device and is destroy with it.
613 */
Thomas Graf5c753972006-08-04 23:03:53 -0700614 goto errout;
Thomas Graf5c753972006-08-04 23:03:53 -0700615
Pavel Emelyanova4e65d32007-12-07 23:55:43 -0800616 ipv4_devconf_setall(in_dev);
Thomas Graf5c753972006-08-04 23:03:53 -0700617 in_dev_hold(in_dev);
618
619 if (tb[IFA_ADDRESS] == NULL)
620 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
621
David S. Millerfd23c3b2011-02-18 12:42:28 -0800622 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
624 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 ifa->ifa_flags = ifm->ifa_flags;
626 ifa->ifa_scope = ifm->ifa_scope;
Thomas Graf5c753972006-08-04 23:03:53 -0700627 ifa->ifa_dev = in_dev;
628
Al Viroa7a628c2006-09-26 22:16:43 -0700629 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
630 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
Thomas Graf5c753972006-08-04 23:03:53 -0700631
632 if (tb[IFA_BROADCAST])
Al Viroa7a628c2006-09-26 22:16:43 -0700633 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
Thomas Graf5c753972006-08-04 23:03:53 -0700634
Thomas Graf5c753972006-08-04 23:03:53 -0700635 if (tb[IFA_LABEL])
636 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 else
638 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
639
Thomas Graf5c753972006-08-04 23:03:53 -0700640 return ifa;
641
642errout:
643 return ERR_PTR(err);
644}
645
646static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
647{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900648 struct net *net = sock_net(skb->sk);
Thomas Graf5c753972006-08-04 23:03:53 -0700649 struct in_ifaddr *ifa;
650
651 ASSERT_RTNL();
652
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -0800653 ifa = rtm_to_ifaddr(net, nlh);
Thomas Graf5c753972006-08-04 23:03:53 -0700654 if (IS_ERR(ifa))
655 return PTR_ERR(ifa);
656
Thomas Grafd6062cb2006-08-15 00:33:59 -0700657 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
659
660/*
661 * Determine a default network mask, based on the IP address.
662 */
663
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800664static inline int inet_abc_len(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 int rc = -1; /* Something else, probably a multicast. */
667
Joe Perchesf97c1e02007-12-16 13:45:43 -0800668 if (ipv4_is_zeronet(addr))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900669 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 else {
Al Viro714e85b2006-11-14 20:51:49 -0800671 __u32 haddr = ntohl(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
Al Viro714e85b2006-11-14 20:51:49 -0800673 if (IN_CLASSA(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 rc = 8;
Al Viro714e85b2006-11-14 20:51:49 -0800675 else if (IN_CLASSB(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 rc = 16;
Al Viro714e85b2006-11-14 20:51:49 -0800677 else if (IN_CLASSC(haddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 rc = 24;
679 }
680
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900681 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682}
683
684
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800685int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686{
687 struct ifreq ifr;
688 struct sockaddr_in sin_orig;
689 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
690 struct in_device *in_dev;
691 struct in_ifaddr **ifap = NULL;
692 struct in_ifaddr *ifa = NULL;
693 struct net_device *dev;
694 char *colon;
695 int ret = -EFAULT;
696 int tryaddrmatch = 0;
697
698 /*
699 * Fetch the caller's info block into kernel space
700 */
701
702 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
703 goto out;
704 ifr.ifr_name[IFNAMSIZ - 1] = 0;
705
706 /* save original address for comparison */
707 memcpy(&sin_orig, sin, sizeof(*sin));
708
709 colon = strchr(ifr.ifr_name, ':');
710 if (colon)
711 *colon = 0;
712
Denis V. Luneve5b13cb2008-02-28 20:51:43 -0800713 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Stephen Hemminger132adf52007-03-08 20:44:43 -0800715 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 case SIOCGIFADDR: /* Get interface address */
717 case SIOCGIFBRDADDR: /* Get the broadcast address */
718 case SIOCGIFDSTADDR: /* Get the destination address */
719 case SIOCGIFNETMASK: /* Get the netmask for the interface */
720 /* Note that these ioctls will not sleep,
721 so that we do not impose a lock.
722 One day we will be forced to put shlock here (I mean SMP)
723 */
724 tryaddrmatch = (sin_orig.sin_family == AF_INET);
725 memset(sin, 0, sizeof(*sin));
726 sin->sin_family = AF_INET;
727 break;
728
729 case SIOCSIFFLAGS:
730 ret = -EACCES;
731 if (!capable(CAP_NET_ADMIN))
732 goto out;
733 break;
734 case SIOCSIFADDR: /* Set interface address (and family) */
735 case SIOCSIFBRDADDR: /* Set the broadcast address */
736 case SIOCSIFDSTADDR: /* Set the destination address */
737 case SIOCSIFNETMASK: /* Set the netmask for the interface */
738 ret = -EACCES;
739 if (!capable(CAP_NET_ADMIN))
740 goto out;
741 ret = -EINVAL;
742 if (sin->sin_family != AF_INET)
743 goto out;
744 break;
745 default:
746 ret = -EINVAL;
747 goto out;
748 }
749
750 rtnl_lock();
751
752 ret = -ENODEV;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800753 dev = __dev_get_by_name(net, ifr.ifr_name);
754 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 goto done;
756
757 if (colon)
758 *colon = ':';
759
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800760 in_dev = __in_dev_get_rtnl(dev);
761 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 if (tryaddrmatch) {
763 /* Matthias Andree */
764 /* compare label and address (4.4BSD style) */
765 /* note: we only do this for a limited set of ioctls
766 and only if the original address family was AF_INET.
767 This is checked above. */
768 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
769 ifap = &ifa->ifa_next) {
770 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
771 sin_orig.sin_addr.s_addr ==
David S. Miller6c91afe2011-03-09 13:27:16 -0800772 ifa->ifa_local) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 break; /* found */
774 }
775 }
776 }
777 /* we didn't get a match, maybe the application is
778 4.3BSD-style and passed in junk so we fall back to
779 comparing just the label */
780 if (!ifa) {
781 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
782 ifap = &ifa->ifa_next)
783 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
784 break;
785 }
786 }
787
788 ret = -EADDRNOTAVAIL;
789 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
790 goto done;
791
Stephen Hemminger132adf52007-03-08 20:44:43 -0800792 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 case SIOCGIFADDR: /* Get interface address */
794 sin->sin_addr.s_addr = ifa->ifa_local;
795 goto rarok;
796
797 case SIOCGIFBRDADDR: /* Get the broadcast address */
798 sin->sin_addr.s_addr = ifa->ifa_broadcast;
799 goto rarok;
800
801 case SIOCGIFDSTADDR: /* Get the destination address */
802 sin->sin_addr.s_addr = ifa->ifa_address;
803 goto rarok;
804
805 case SIOCGIFNETMASK: /* Get the netmask for the interface */
806 sin->sin_addr.s_addr = ifa->ifa_mask;
807 goto rarok;
808
809 case SIOCSIFFLAGS:
810 if (colon) {
811 ret = -EADDRNOTAVAIL;
812 if (!ifa)
813 break;
814 ret = 0;
815 if (!(ifr.ifr_flags & IFF_UP))
816 inet_del_ifa(in_dev, ifap, 1);
817 break;
818 }
819 ret = dev_change_flags(dev, ifr.ifr_flags);
820 break;
821
822 case SIOCSIFADDR: /* Set interface address (and family) */
823 ret = -EINVAL;
824 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
825 break;
826
827 if (!ifa) {
828 ret = -ENOBUFS;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800829 ifa = inet_alloc_ifa();
David S. Millerfd23c3b2011-02-18 12:42:28 -0800830 INIT_HLIST_NODE(&ifa->hash);
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800831 if (!ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 break;
833 if (colon)
834 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
835 else
836 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
837 } else {
838 ret = 0;
839 if (ifa->ifa_local == sin->sin_addr.s_addr)
840 break;
841 inet_del_ifa(in_dev, ifap, 0);
842 ifa->ifa_broadcast = 0;
Bjorn Mork148f9722008-02-26 18:17:53 -0800843 ifa->ifa_scope = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 }
845
846 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
847
848 if (!(dev->flags & IFF_POINTOPOINT)) {
849 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
850 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
851 if ((dev->flags & IFF_BROADCAST) &&
852 ifa->ifa_prefixlen < 31)
853 ifa->ifa_broadcast = ifa->ifa_address |
854 ~ifa->ifa_mask;
855 } else {
856 ifa->ifa_prefixlen = 32;
857 ifa->ifa_mask = inet_make_mask(32);
858 }
859 ret = inet_set_ifa(dev, ifa);
860 break;
861
862 case SIOCSIFBRDADDR: /* Set the broadcast address */
863 ret = 0;
864 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
865 inet_del_ifa(in_dev, ifap, 0);
866 ifa->ifa_broadcast = sin->sin_addr.s_addr;
867 inet_insert_ifa(ifa);
868 }
869 break;
870
871 case SIOCSIFDSTADDR: /* Set the destination address */
872 ret = 0;
873 if (ifa->ifa_address == sin->sin_addr.s_addr)
874 break;
875 ret = -EINVAL;
876 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
877 break;
878 ret = 0;
879 inet_del_ifa(in_dev, ifap, 0);
880 ifa->ifa_address = sin->sin_addr.s_addr;
881 inet_insert_ifa(ifa);
882 break;
883
884 case SIOCSIFNETMASK: /* Set the netmask for the interface */
885
886 /*
887 * The mask we set must be legal.
888 */
889 ret = -EINVAL;
890 if (bad_mask(sin->sin_addr.s_addr, 0))
891 break;
892 ret = 0;
893 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
Al Viroa144ea42006-09-28 18:00:55 -0700894 __be32 old_mask = ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 inet_del_ifa(in_dev, ifap, 0);
896 ifa->ifa_mask = sin->sin_addr.s_addr;
897 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
898
899 /* See if current broadcast address matches
900 * with current netmask, then recalculate
901 * the broadcast address. Otherwise it's a
902 * funny address, so don't touch it since
903 * the user seems to know what (s)he's doing...
904 */
905 if ((dev->flags & IFF_BROADCAST) &&
906 (ifa->ifa_prefixlen < 31) &&
907 (ifa->ifa_broadcast ==
David Engeldcab5e12005-10-21 22:09:16 -0500908 (ifa->ifa_local|~old_mask))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 ifa->ifa_broadcast = (ifa->ifa_local |
910 ~sin->sin_addr.s_addr);
911 }
912 inet_insert_ifa(ifa);
913 }
914 break;
915 }
916done:
917 rtnl_unlock();
918out:
919 return ret;
920rarok:
921 rtnl_unlock();
922 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
923 goto out;
924}
925
926static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
927{
Herbert Xue5ed6392005-10-03 14:35:55 -0700928 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 struct in_ifaddr *ifa;
930 struct ifreq ifr;
931 int done = 0;
932
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800933 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 goto out;
935
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800936 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (!buf) {
938 done += sizeof(ifr);
939 continue;
940 }
941 if (len < (int) sizeof(ifr))
942 break;
943 memset(&ifr, 0, sizeof(struct ifreq));
944 if (ifa->ifa_label)
945 strcpy(ifr.ifr_name, ifa->ifa_label);
946 else
947 strcpy(ifr.ifr_name, dev->name);
948
949 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
950 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
951 ifa->ifa_local;
952
953 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
954 done = -EFAULT;
955 break;
956 }
957 buf += sizeof(struct ifreq);
958 len -= sizeof(struct ifreq);
959 done += sizeof(struct ifreq);
960 }
961out:
962 return done;
963}
964
Al Viroa61ced52006-09-26 21:27:54 -0700965__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966{
Al Viroa61ced52006-09-26 21:27:54 -0700967 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900969 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
971 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700972 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (!in_dev)
974 goto no_in_dev;
975
976 for_primary_ifa(in_dev) {
977 if (ifa->ifa_scope > scope)
978 continue;
979 if (!dst || inet_ifa_match(dst, ifa)) {
980 addr = ifa->ifa_local;
981 break;
982 }
983 if (!addr)
984 addr = ifa->ifa_local;
985 } endfor_ifa(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
987 if (addr)
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800988 goto out_unlock;
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800989no_in_dev:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991 /* Not loopback addresses on loopback should be preferred
992 in this case. It is importnat that lo is the first interface
993 in dev_base list.
994 */
Eric Dumazetc6d14c82009-11-04 05:43:23 -0800995 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -0800996 in_dev = __in_dev_get_rcu(dev);
997 if (!in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 continue;
999
1000 for_primary_ifa(in_dev) {
1001 if (ifa->ifa_scope != RT_SCOPE_LINK &&
1002 ifa->ifa_scope <= scope) {
1003 addr = ifa->ifa_local;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001004 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 }
1006 } endfor_ifa(in_dev);
1007 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001008out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 return addr;
1011}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001012EXPORT_SYMBOL(inet_select_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
Al Viro60cad5d2006-09-26 22:17:09 -07001014static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
1015 __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016{
1017 int same = 0;
Al Viroa144ea42006-09-28 18:00:55 -07001018 __be32 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 for_ifa(in_dev) {
1021 if (!addr &&
1022 (local == ifa->ifa_local || !local) &&
1023 ifa->ifa_scope <= scope) {
1024 addr = ifa->ifa_local;
1025 if (same)
1026 break;
1027 }
1028 if (!same) {
1029 same = (!local || inet_ifa_match(local, ifa)) &&
1030 (!dst || inet_ifa_match(dst, ifa));
1031 if (same && addr) {
1032 if (local || !dst)
1033 break;
1034 /* Is the selected addr into dst subnet? */
1035 if (inet_ifa_match(addr, ifa))
1036 break;
1037 /* No, then can we use new local src? */
1038 if (ifa->ifa_scope <= scope) {
1039 addr = ifa->ifa_local;
1040 break;
1041 }
1042 /* search for large dst subnet for addr */
1043 same = 0;
1044 }
1045 }
1046 } endfor_ifa(in_dev);
1047
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001048 return same ? addr : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
1051/*
1052 * Confirm that local IP address exists using wildcards:
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001053 * - in_dev: only on this interface, 0=any interface
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 * - dst: only in the same subnet as dst, 0=any dst
1055 * - local: address, 0=autoselect the local address
1056 * - scope: maximum allowed scope value for the local address
1057 */
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001058__be32 inet_confirm_addr(struct in_device *in_dev,
1059 __be32 dst, __be32 local, int scope)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060{
Al Viro60cad5d2006-09-26 22:17:09 -07001061 __be32 addr = 0;
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001062 struct net_device *dev;
Denis V. Lunev39a6d062008-01-14 23:06:19 -08001063 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Denis V. Lunev39a6d062008-01-14 23:06:19 -08001065 if (scope != RT_SCOPE_LINK)
Denis V. Lunev9bd85e32008-01-14 23:05:55 -08001066 return confirm_addr_indev(in_dev, dst, local, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001068 net = dev_net(in_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 rcu_read_lock();
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001070 for_each_netdev_rcu(net, dev) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001071 in_dev = __in_dev_get_rcu(dev);
1072 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 addr = confirm_addr_indev(in_dev, dst, local, scope);
1074 if (addr)
1075 break;
1076 }
1077 }
1078 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 return addr;
1081}
1082
1083/*
1084 * Device notifier
1085 */
1086
1087int register_inetaddr_notifier(struct notifier_block *nb)
1088{
Alan Sterne041c682006-03-27 01:16:30 -08001089 return blocking_notifier_chain_register(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001091EXPORT_SYMBOL(register_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
1093int unregister_inetaddr_notifier(struct notifier_block *nb)
1094{
Alan Sterne041c682006-03-27 01:16:30 -08001095 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096}
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001097EXPORT_SYMBOL(unregister_inetaddr_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001099/* Rename ifa_labels for a device name change. Make some effort to preserve
1100 * existing alias numbering and to create unique labels if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101*/
1102static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001103{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 struct in_ifaddr *ifa;
1105 int named = 0;
1106
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001107 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1108 char old[IFNAMSIZ], *dot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
1110 memcpy(old, ifa->ifa_label, IFNAMSIZ);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001111 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 if (named++ == 0)
Thomas Graf573bf472008-06-10 15:40:04 -07001113 goto skip;
Mark McLoughlin44344b22008-01-04 00:56:25 -08001114 dot = strchr(old, ':');
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001115 if (dot == NULL) {
1116 sprintf(old, ":%d", named);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 dot = old;
1118 }
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001119 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001120 strcat(ifa->ifa_label, dot);
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001121 else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001122 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
Thomas Graf573bf472008-06-10 15:40:04 -07001123skip:
1124 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001125 }
1126}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127
Breno Leitao06770842008-09-02 17:28:58 -07001128static inline bool inetdev_valid_mtu(unsigned mtu)
1129{
1130 return mtu >= 68;
1131}
1132
Ian Campbelld11327ad2011-02-11 07:44:16 +00001133static void inetdev_send_gratuitous_arp(struct net_device *dev,
1134 struct in_device *in_dev)
1135
1136{
Zoltan Kissb76d0782011-07-24 13:09:30 +00001137 struct in_ifaddr *ifa;
Ian Campbelld11327ad2011-02-11 07:44:16 +00001138
Zoltan Kissb76d0782011-07-24 13:09:30 +00001139 for (ifa = in_dev->ifa_list; ifa;
1140 ifa = ifa->ifa_next) {
1141 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1142 ifa->ifa_local, dev,
1143 ifa->ifa_local, NULL,
1144 dev->dev_addr, NULL);
1145 }
Ian Campbelld11327ad2011-02-11 07:44:16 +00001146}
1147
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148/* Called only under RTNL semaphore */
1149
1150static int inetdev_event(struct notifier_block *this, unsigned long event,
1151 void *ptr)
1152{
1153 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -07001154 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 ASSERT_RTNL();
1157
1158 if (!in_dev) {
Herbert Xu8030f542007-02-22 01:53:47 +09001159 if (event == NETDEV_REGISTER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 in_dev = inetdev_init(dev);
Herbert Xub217d612007-07-30 17:04:52 -07001161 if (!in_dev)
1162 return notifier_from_errno(-ENOMEM);
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001163 if (dev->flags & IFF_LOOPBACK) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001164 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1165 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
Herbert Xu8030f542007-02-22 01:53:47 +09001166 }
Breno Leitao06770842008-09-02 17:28:58 -07001167 } else if (event == NETDEV_CHANGEMTU) {
1168 /* Re-enabling IP */
1169 if (inetdev_valid_mtu(dev->mtu))
1170 in_dev = inetdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172 goto out;
1173 }
1174
1175 switch (event) {
1176 case NETDEV_REGISTER:
1177 printk(KERN_DEBUG "inetdev_event: bug\n");
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001178 rcu_assign_pointer(dev->ip_ptr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 break;
1180 case NETDEV_UP:
Breno Leitao06770842008-09-02 17:28:58 -07001181 if (!inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 break;
Eric W. Biederman0cc217e2007-09-26 22:10:06 -07001183 if (dev->flags & IFF_LOOPBACK) {
Eric Dumazet9f9354b2009-11-04 22:05:10 -08001184 struct in_ifaddr *ifa = inet_alloc_ifa();
1185
1186 if (ifa) {
David S. Millerfd23c3b2011-02-18 12:42:28 -08001187 INIT_HLIST_NODE(&ifa->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 ifa->ifa_local =
1189 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1190 ifa->ifa_prefixlen = 8;
1191 ifa->ifa_mask = inet_make_mask(8);
1192 in_dev_hold(in_dev);
1193 ifa->ifa_dev = in_dev;
1194 ifa->ifa_scope = RT_SCOPE_HOST;
1195 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1196 inet_insert_ifa(ifa);
1197 }
1198 }
1199 ip_mc_up(in_dev);
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001200 /* fall through */
1201 case NETDEV_CHANGEADDR:
Ian Campbelld11327ad2011-02-11 07:44:16 +00001202 if (!IN_DEV_ARP_NOTIFY(in_dev))
1203 break;
1204 /* fall through */
1205 case NETDEV_NOTIFY_PEERS:
Stephen Hemmingera21090c2009-10-07 03:18:17 -07001206 /* Send gratuitous ARP to notify of link change */
Ian Campbelld11327ad2011-02-11 07:44:16 +00001207 inetdev_send_gratuitous_arp(dev, in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 break;
1209 case NETDEV_DOWN:
1210 ip_mc_down(in_dev);
1211 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001212 case NETDEV_PRE_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001213 ip_mc_unmap(in_dev);
1214 break;
Jiri Pirko93d9b7d2010-03-10 10:28:56 +00001215 case NETDEV_POST_TYPE_CHANGE:
Moni Shoua75c78502009-09-15 02:37:40 -07001216 ip_mc_remap(in_dev);
1217 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 case NETDEV_CHANGEMTU:
Breno Leitao06770842008-09-02 17:28:58 -07001219 if (inetdev_valid_mtu(dev->mtu))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 break;
Breno Leitao06770842008-09-02 17:28:58 -07001221 /* disable IP when MTU is not enough */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 case NETDEV_UNREGISTER:
1223 inetdev_destroy(in_dev);
1224 break;
1225 case NETDEV_CHANGENAME:
1226 /* Do not notify about label change, this event is
1227 * not interesting to applications using netlink.
1228 */
1229 inetdev_changename(dev, in_dev);
1230
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001231 devinet_sysctl_unregister(in_dev);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001232 devinet_sysctl_register(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 break;
1234 }
1235out:
1236 return NOTIFY_DONE;
1237}
1238
1239static struct notifier_block ip_netdev_notifier = {
Jianjun Kong539afed2008-11-03 02:48:48 -08001240 .notifier_call = inetdev_event,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241};
1242
Thomas Graf339bf982006-11-10 14:10:15 -08001243static inline size_t inet_nlmsg_size(void)
1244{
1245 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1246 + nla_total_size(4) /* IFA_ADDRESS */
1247 + nla_total_size(4) /* IFA_LOCAL */
1248 + nla_total_size(4) /* IFA_BROADCAST */
Thomas Graf339bf982006-11-10 14:10:15 -08001249 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1250}
1251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07001253 u32 pid, u32 seq, int event, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254{
1255 struct ifaddrmsg *ifm;
1256 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Thomas Graf47f68512006-08-04 23:04:36 -07001258 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1259 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08001260 return -EMSGSIZE;
Thomas Graf47f68512006-08-04 23:04:36 -07001261
1262 ifm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 ifm->ifa_family = AF_INET;
1264 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1265 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1266 ifm->ifa_scope = ifa->ifa_scope;
1267 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
Thomas Graf47f68512006-08-04 23:04:36 -07001269 if (ifa->ifa_address)
Al Viroa7a628c2006-09-26 22:16:43 -07001270 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
Thomas Graf47f68512006-08-04 23:04:36 -07001271
1272 if (ifa->ifa_local)
Al Viroa7a628c2006-09-26 22:16:43 -07001273 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
Thomas Graf47f68512006-08-04 23:04:36 -07001274
1275 if (ifa->ifa_broadcast)
Al Viroa7a628c2006-09-26 22:16:43 -07001276 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
Thomas Graf47f68512006-08-04 23:04:36 -07001277
Thomas Graf47f68512006-08-04 23:04:36 -07001278 if (ifa->ifa_label[0])
1279 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1280
1281 return nlmsg_end(skb, nlh);
1282
1283nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001284 nlmsg_cancel(skb, nlh);
1285 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286}
1287
1288static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1289{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001290 struct net *net = sock_net(skb->sk);
Eric Dumazeteec4df92009-11-12 07:44:25 +00001291 int h, s_h;
1292 int idx, s_idx;
1293 int ip_idx, s_ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 struct net_device *dev;
1295 struct in_device *in_dev;
1296 struct in_ifaddr *ifa;
Eric Dumazeteec4df92009-11-12 07:44:25 +00001297 struct hlist_head *head;
1298 struct hlist_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Eric Dumazeteec4df92009-11-12 07:44:25 +00001300 s_h = cb->args[0];
1301 s_idx = idx = cb->args[1];
1302 s_ip_idx = ip_idx = cb->args[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
Eric Dumazeteec4df92009-11-12 07:44:25 +00001304 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1305 idx = 0;
1306 head = &net->dev_index_head[h];
1307 rcu_read_lock();
1308 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
1309 if (idx < s_idx)
1310 goto cont;
Patrick McHardy4b97efd2010-03-26 20:27:49 -07001311 if (h > s_h || idx > s_idx)
Eric Dumazeteec4df92009-11-12 07:44:25 +00001312 s_ip_idx = 0;
1313 in_dev = __in_dev_get_rcu(dev);
1314 if (!in_dev)
1315 goto cont;
1316
1317 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1318 ifa = ifa->ifa_next, ip_idx++) {
1319 if (ip_idx < s_ip_idx)
1320 continue;
1321 if (inet_fill_ifaddr(skb, ifa,
1322 NETLINK_CB(cb->skb).pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 cb->nlh->nlmsg_seq,
Eric Dumazeteec4df92009-11-12 07:44:25 +00001324 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1325 rcu_read_unlock();
1326 goto done;
1327 }
1328 }
Pavel Emelianov7562f872007-05-03 15:13:45 -07001329cont:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001330 idx++;
1331 }
1332 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
1334
1335done:
Eric Dumazeteec4df92009-11-12 07:44:25 +00001336 cb->args[0] = h;
1337 cb->args[1] = idx;
1338 cb->args[2] = ip_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
1340 return skb->len;
1341}
1342
Jianjun Kong539afed2008-11-03 02:48:48 -08001343static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
Thomas Grafd6062cb2006-08-15 00:33:59 -07001344 u32 pid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345{
Thomas Graf47f68512006-08-04 23:04:36 -07001346 struct sk_buff *skb;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001347 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1348 int err = -ENOBUFS;
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001349 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001351 net = dev_net(ifa->ifa_dev->dev);
Thomas Graf339bf982006-11-10 14:10:15 -08001352 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
Thomas Graf47f68512006-08-04 23:04:36 -07001353 if (skb == NULL)
Thomas Grafd6062cb2006-08-15 00:33:59 -07001354 goto errout;
1355
1356 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
Patrick McHardy26932562007-01-31 23:16:40 -08001357 if (err < 0) {
1358 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1359 WARN_ON(err == -EMSGSIZE);
1360 kfree_skb(skb);
1361 goto errout;
1362 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001363 rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1364 return;
Thomas Grafd6062cb2006-08-15 00:33:59 -07001365errout:
1366 if (err < 0)
Denis V. Lunev4b8aa9a2008-01-31 18:47:40 -08001367 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368}
1369
Thomas Graf9f0f7272010-11-16 04:32:48 +00001370static size_t inet_get_link_af_size(const struct net_device *dev)
1371{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001372 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001373
1374 if (!in_dev)
1375 return 0;
1376
1377 return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
1378}
1379
1380static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
1381{
Eric Dumazet1fc19af2011-05-09 20:55:03 -07001382 struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
Thomas Graf9f0f7272010-11-16 04:32:48 +00001383 struct nlattr *nla;
1384 int i;
1385
1386 if (!in_dev)
1387 return -ENODATA;
1388
1389 nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1390 if (nla == NULL)
1391 return -EMSGSIZE;
1392
1393 for (i = 0; i < IPV4_DEVCONF_MAX; i++)
1394 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
1395
1396 return 0;
1397}
1398
1399static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
1400 [IFLA_INET_CONF] = { .type = NLA_NESTED },
1401};
1402
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001403static int inet_validate_link_af(const struct net_device *dev,
1404 const struct nlattr *nla)
Thomas Graf9f0f7272010-11-16 04:32:48 +00001405{
Thomas Graf9f0f7272010-11-16 04:32:48 +00001406 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1407 int err, rem;
1408
Eric Dumazetf7fce742010-12-01 06:03:06 +00001409 if (dev && !__in_dev_get_rtnl(dev))
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001410 return -EAFNOSUPPORT;
Thomas Graf9f0f7272010-11-16 04:32:48 +00001411
1412 err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
1413 if (err < 0)
1414 return err;
1415
1416 if (tb[IFLA_INET_CONF]) {
1417 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
1418 int cfgid = nla_type(a);
1419
1420 if (nla_len(a) < 4)
1421 return -EINVAL;
1422
1423 if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
1424 return -EINVAL;
1425 }
1426 }
1427
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001428 return 0;
1429}
1430
1431static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
1432{
Eric Dumazetf7fce742010-12-01 06:03:06 +00001433 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001434 struct nlattr *a, *tb[IFLA_INET_MAX+1];
1435 int rem;
1436
1437 if (!in_dev)
1438 return -EAFNOSUPPORT;
1439
1440 if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
1441 BUG();
1442
Thomas Graf9f0f7272010-11-16 04:32:48 +00001443 if (tb[IFLA_INET_CONF]) {
1444 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
1445 ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
1446 }
1447
1448 return 0;
1449}
1450
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451#ifdef CONFIG_SYSCTL
1452
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001453static void devinet_copy_dflt_conf(struct net *net, int i)
Herbert Xu31be3082007-06-04 23:35:37 -07001454{
1455 struct net_device *dev;
1456
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001457 rcu_read_lock();
1458 for_each_netdev_rcu(net, dev) {
Herbert Xu31be3082007-06-04 23:35:37 -07001459 struct in_device *in_dev;
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001460
Herbert Xu31be3082007-06-04 23:35:37 -07001461 in_dev = __in_dev_get_rcu(dev);
1462 if (in_dev && !test_bit(i, in_dev->cnf.state))
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001463 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
Herbert Xu31be3082007-06-04 23:35:37 -07001464 }
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001465 rcu_read_unlock();
Herbert Xu31be3082007-06-04 23:35:37 -07001466}
1467
Eric Dumazetc6d14c82009-11-04 05:43:23 -08001468/* called with RTNL locked */
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001469static void inet_forward_change(struct net *net)
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001470{
1471 struct net_device *dev;
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001472 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001473
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001474 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001475 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001476
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001477 for_each_netdev(net, dev) {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001478 struct in_device *in_dev;
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001479 if (on)
1480 dev_disable_lro(dev);
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001481 rcu_read_lock();
1482 in_dev = __in_dev_get_rcu(dev);
1483 if (in_dev)
1484 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1485 rcu_read_unlock();
1486 }
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001487}
1488
Herbert Xu31be3082007-06-04 23:35:37 -07001489static int devinet_conf_proc(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001490 void __user *buffer,
Herbert Xu31be3082007-06-04 23:35:37 -07001491 size_t *lenp, loff_t *ppos)
1492{
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001493 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Herbert Xu31be3082007-06-04 23:35:37 -07001494
1495 if (write) {
1496 struct ipv4_devconf *cnf = ctl->extra1;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001497 struct net *net = ctl->extra2;
Herbert Xu31be3082007-06-04 23:35:37 -07001498 int i = (int *)ctl->data - cnf->data;
1499
1500 set_bit(i, cnf->state);
1501
Pavel Emelyanov9355bbd2007-12-16 13:32:16 -08001502 if (cnf == net->ipv4.devconf_dflt)
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001503 devinet_copy_dflt_conf(net, i);
Herbert Xu31be3082007-06-04 23:35:37 -07001504 }
1505
1506 return ret;
1507}
1508
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509static int devinet_sysctl_forward(ctl_table *ctl, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001510 void __user *buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 size_t *lenp, loff_t *ppos)
1512{
1513 int *valp = ctl->data;
1514 int val = *valp;
Eric W. Biederman88af1822010-02-19 13:22:59 +00001515 loff_t pos = *ppos;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001516 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
1518 if (write && *valp != val) {
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001519 struct net *net = ctl->extra2;
1520
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001521 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
Eric W. Biederman88af1822010-02-19 13:22:59 +00001522 if (!rtnl_trylock()) {
1523 /* Restore the original values before restarting */
1524 *valp = val;
1525 *ppos = pos;
Eric W. Biederman9b8adb52009-05-13 16:59:21 +00001526 return restart_syscall();
Eric W. Biederman88af1822010-02-19 13:22:59 +00001527 }
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001528 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1529 inet_forward_change(net);
1530 } else if (*valp) {
1531 struct ipv4_devconf *cnf = ctl->extra1;
1532 struct in_device *idev =
1533 container_of(cnf, struct in_device, cnf);
1534 dev_disable_lro(idev->dev);
1535 }
1536 rtnl_unlock();
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001537 rt_cache_flush(net, 0);
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001538 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 }
1540
1541 return ret;
1542}
1543
David S. Miller323e1262010-12-12 21:55:08 -08001544static int ipv4_doint_and_flush(ctl_table *ctl, int write,
1545 void __user *buffer,
1546 size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547{
1548 int *valp = ctl->data;
1549 int val = *valp;
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001550 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001551 struct net *net = ctl->extra2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
1553 if (write && *valp != val)
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001554 rt_cache_flush(net, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555
1556 return ret;
1557}
1558
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001559#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
Herbert Xu42f811b2007-06-04 23:34:44 -07001560 { \
Herbert Xu42f811b2007-06-04 23:34:44 -07001561 .procname = name, \
1562 .data = ipv4_devconf.data + \
Eric W. Biederman02291682010-02-14 03:25:51 +00001563 IPV4_DEVCONF_ ## attr - 1, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001564 .maxlen = sizeof(int), \
1565 .mode = mval, \
1566 .proc_handler = proc, \
Herbert Xu31be3082007-06-04 23:35:37 -07001567 .extra1 = &ipv4_devconf, \
Herbert Xu42f811b2007-06-04 23:34:44 -07001568 }
1569
1570#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001571 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001572
1573#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001574 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001575
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001576#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
1577 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
Herbert Xu42f811b2007-06-04 23:34:44 -07001578
1579#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001580 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
Herbert Xu42f811b2007-06-04 23:34:44 -07001581
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582static struct devinet_sysctl_table {
1583 struct ctl_table_header *sysctl_header;
Eric W. Biederman02291682010-02-14 03:25:51 +00001584 struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001585 char *dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586} devinet_sysctl = {
1587 .devinet_vars = {
Herbert Xu42f811b2007-06-04 23:34:44 -07001588 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001589 devinet_sysctl_forward),
Herbert Xu42f811b2007-06-04 23:34:44 -07001590 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1591
1592 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1593 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1594 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1595 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1596 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1597 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1598 "accept_source_route"),
Patrick McHardy8153a102009-12-03 01:25:58 +00001599 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
Jamal Hadi Salim28f6aee2009-12-25 17:30:22 -08001600 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
Herbert Xu42f811b2007-06-04 23:34:44 -07001601 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1602 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1603 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1604 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1605 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1606 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1607 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1608 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1609 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
Stephen Hemmingereefef1c2009-02-01 01:04:33 -08001610 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +00001611 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
Herbert Xu42f811b2007-06-04 23:34:44 -07001612
1613 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1614 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1615 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1616 "force_igmp_version"),
1617 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1618 "promote_secondaries"),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620};
1621
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001622static int __devinet_sysctl_register(struct net *net, char *dev_name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001623 struct ipv4_devconf *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624{
1625 int i;
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001626 struct devinet_sysctl_table *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001628#define DEVINET_CTL_PATH_DEV 3
1629
1630 struct ctl_path devinet_ctl_path[] = {
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001631 { .procname = "net", },
1632 { .procname = "ipv4", },
1633 { .procname = "conf", },
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001634 { /* to be set */ },
1635 { },
1636 };
1637
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001638 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 if (!t)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001640 goto out;
1641
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1643 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
Herbert Xu31be3082007-06-04 23:35:37 -07001644 t->devinet_vars[i].extra1 = p;
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001645 t->devinet_vars[i].extra2 = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 }
1647
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001648 /*
1649 * Make a copy of dev_name, because '.procname' is regarded as const
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 * by sysctl and we wouldn't want anyone to change it under our feet
1651 * (see SIOCSIFNAME).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001652 */
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001653 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1654 if (!t->dev_name)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001655 goto free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001657 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001659 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001660 t->devinet_vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 if (!t->sysctl_header)
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001662 goto free_procname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
1664 p->sysctl = t;
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001665 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001667free_procname:
Pavel Emelyanovbfada692007-12-02 00:57:08 +11001668 kfree(t->dev_name);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001669free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 kfree(t);
Pavel Emelyanov9fa89642007-12-02 00:17:46 +11001671out:
Pavel Emelyanovea40b322007-12-16 13:30:07 -08001672 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673}
1674
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001675static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1676{
1677 struct devinet_sysctl_table *t = cnf->sysctl;
1678
1679 if (t == NULL)
1680 return;
1681
1682 cnf->sysctl = NULL;
Lucian Adrian Grijincuff538812011-05-01 01:44:01 +00001683 unregister_net_sysctl_table(t->sysctl_header);
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001684 kfree(t->dev_name);
1685 kfree(t);
1686}
1687
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001688static void devinet_sysctl_register(struct in_device *idev)
1689{
Eric W. Biederman54716e32010-02-14 03:27:03 +00001690 neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001691 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001692 &idev->cnf);
Pavel Emelyanov66f27a52007-12-02 00:55:54 +11001693}
1694
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001695static void devinet_sysctl_unregister(struct in_device *idev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696{
Pavel Emelyanov51602b22007-12-11 02:17:40 -08001697 __devinet_sysctl_unregister(&idev->cnf);
1698 neigh_sysctl_unregister(idev->arp_parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001701static struct ctl_table ctl_forward_entry[] = {
1702 {
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001703 .procname = "ip_forward",
1704 .data = &ipv4_devconf.data[
Eric W. Biederman02291682010-02-14 03:25:51 +00001705 IPV4_DEVCONF_FORWARDING - 1],
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001706 .maxlen = sizeof(int),
1707 .mode = 0644,
1708 .proc_handler = devinet_sysctl_forward,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001709 .extra1 = &ipv4_devconf,
Pavel Emelyanovc0ce9fb2007-12-16 13:31:14 -08001710 .extra2 = &init_net,
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001711 },
1712 { },
1713};
1714
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001715static __net_initdata struct ctl_path net_ipv4_path[] = {
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001716 { .procname = "net", },
1717 { .procname = "ipv4", },
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001718 { },
1719};
Eric Dumazet2a75de02008-01-05 23:08:49 -08001720#endif
Pavel Emelyanov68dd2992007-12-05 01:44:58 -08001721
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001722static __net_init int devinet_init_net(struct net *net)
1723{
1724 int err;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001725 struct ipv4_devconf *all, *dflt;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001726#ifdef CONFIG_SYSCTL
1727 struct ctl_table *tbl = ctl_forward_entry;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001728 struct ctl_table_header *forw_hdr;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001729#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001730
1731 err = -ENOMEM;
1732 all = &ipv4_devconf;
1733 dflt = &ipv4_devconf_dflt;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001734
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08001735 if (!net_eq(net, &init_net)) {
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001736 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1737 if (all == NULL)
1738 goto err_alloc_all;
1739
1740 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1741 if (dflt == NULL)
1742 goto err_alloc_dflt;
1743
Eric Dumazet2a75de02008-01-05 23:08:49 -08001744#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001745 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1746 if (tbl == NULL)
1747 goto err_alloc_ctl;
1748
Eric W. Biederman02291682010-02-14 03:25:51 +00001749 tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001750 tbl[0].extra1 = all;
1751 tbl[0].extra2 = net;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001752#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001753 }
1754
1755#ifdef CONFIG_SYSCTL
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001756 err = __devinet_sysctl_register(net, "all", all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001757 if (err < 0)
1758 goto err_reg_all;
1759
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001760 err = __devinet_sysctl_register(net, "default", dflt);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001761 if (err < 0)
1762 goto err_reg_dflt;
1763
1764 err = -ENOMEM;
1765 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1766 if (forw_hdr == NULL)
1767 goto err_reg_ctl;
Eric Dumazet2a75de02008-01-05 23:08:49 -08001768 net->ipv4.forw_hdr = forw_hdr;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001769#endif
1770
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001771 net->ipv4.devconf_all = all;
1772 net->ipv4.devconf_dflt = dflt;
1773 return 0;
1774
1775#ifdef CONFIG_SYSCTL
1776err_reg_ctl:
1777 __devinet_sysctl_unregister(dflt);
1778err_reg_dflt:
1779 __devinet_sysctl_unregister(all);
1780err_reg_all:
1781 if (tbl != ctl_forward_entry)
1782 kfree(tbl);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001783err_alloc_ctl:
Eric Dumazet2a75de02008-01-05 23:08:49 -08001784#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001785 if (dflt != &ipv4_devconf_dflt)
1786 kfree(dflt);
1787err_alloc_dflt:
1788 if (all != &ipv4_devconf)
1789 kfree(all);
1790err_alloc_all:
1791 return err;
1792}
1793
1794static __net_exit void devinet_exit_net(struct net *net)
1795{
Eric Dumazet2a75de02008-01-05 23:08:49 -08001796#ifdef CONFIG_SYSCTL
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001797 struct ctl_table *tbl;
1798
1799 tbl = net->ipv4.forw_hdr->ctl_table_arg;
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001800 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1801 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1802 __devinet_sysctl_unregister(net->ipv4.devconf_all);
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001803 kfree(tbl);
Eric Dumazet2a75de02008-01-05 23:08:49 -08001804#endif
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001805 kfree(net->ipv4.devconf_dflt);
1806 kfree(net->ipv4.devconf_all);
1807}
1808
1809static __net_initdata struct pernet_operations devinet_ops = {
1810 .init = devinet_init_net,
1811 .exit = devinet_exit_net,
1812};
1813
Thomas Graf9f0f7272010-11-16 04:32:48 +00001814static struct rtnl_af_ops inet_af_ops = {
1815 .family = AF_INET,
1816 .fill_link_af = inet_fill_link_af,
1817 .get_link_af_size = inet_get_link_af_size,
Thomas Grafcf7afbf2010-11-22 01:31:54 +00001818 .validate_link_af = inet_validate_link_af,
1819 .set_link_af = inet_set_link_af,
Thomas Graf9f0f7272010-11-16 04:32:48 +00001820};
1821
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822void __init devinet_init(void)
1823{
David S. Millerfd23c3b2011-02-18 12:42:28 -08001824 int i;
1825
1826 for (i = 0; i < IN4_ADDR_HSIZE; i++)
1827 INIT_HLIST_HEAD(&inet_addr_lst[i]);
1828
Pavel Emelyanov752d14d2007-12-16 13:31:47 -08001829 register_pernet_subsys(&devinet_ops);
1830
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 register_gifconf(PF_INET, inet_gifconf);
1832 register_netdevice_notifier(&ip_netdev_notifier);
Thomas Graf63f34442007-03-22 11:55:17 -07001833
Thomas Graf9f0f7272010-11-16 04:32:48 +00001834 rtnl_af_register(&inet_af_ops);
1835
Greg Rosec7ac8672011-06-10 01:27:09 +00001836 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
1837 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
1838 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839}
1840