devinet.c 56.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 *	NET3	IP device support routines.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 *	Derived from the IP parts of dev.c 1.0.19
10
 * 		Authors:	Ross Biro
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *				Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *				Mark Evans, <evansmp@uhura.aston.ac.uk>
 *
 *	Additional Authors:
 *		Alan Cox, <gw4pts@gw4pts.ampr.org>
 *		Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 *	Changes:
 *		Alexey Kuznetsov:	pa_* fields are replaced with ifaddr
 *					lists.
 *		Cyrus Durgin:		updated for kmod
 *		Matthias Andree:	in devinet_ioctl, compare label and
 *					address (4.4BSD alias style support),
 *					fall back to comparing just the label
 *					if no match found.
 */


#include <asm/uaccess.h>
#include <linux/bitops.h>
31
#include <linux/capability.h>
L
Linus Torvalds 已提交
32 33 34 35 36 37 38 39 40 41
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
42
#include <linux/if_addr.h>
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51
#include <linux/if_ether.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/notifier.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
52
#include <linux/slab.h>
53
#include <linux/hash.h>
L
Linus Torvalds 已提交
54 55 56 57
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif
#include <linux/kmod.h>
58
#include <linux/netconf.h>
L
Linus Torvalds 已提交
59

60
#include <net/arp.h>
L
Linus Torvalds 已提交
61 62 63
#include <net/ip.h>
#include <net/route.h>
#include <net/ip_fib.h>
64
#include <net/rtnetlink.h>
65
#include <net/net_namespace.h>
J
Jiri Pirko 已提交
66
#include <net/addrconf.h>
L
Linus Torvalds 已提交
67

68 69
#include "fib_lookup.h"

70
static struct ipv4_devconf ipv4_devconf = {
71
	.data = {
72 73 74 75
		[IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
		[IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
		[IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
		[IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
76 77
		[IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
		[IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] =  1000 /*ms*/,
78
	},
L
Linus Torvalds 已提交
79 80 81
};

static struct ipv4_devconf ipv4_devconf_dflt = {
82
	.data = {
83 84 85 86 87
		[IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
		[IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
		[IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
		[IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
		[IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
88 89
		[IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
		[IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] =  1000 /*ms*/,
90
	},
L
Linus Torvalds 已提交
91 92
};

93 94
#define IPV4_DEVCONF_DFLT(net, attr) \
	IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
95

96
static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
97 98 99
	[IFA_LOCAL]     	= { .type = NLA_U32 },
	[IFA_ADDRESS]   	= { .type = NLA_U32 },
	[IFA_BROADCAST] 	= { .type = NLA_U32 },
100
	[IFA_LABEL]     	= { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
J
Jiri Pirko 已提交
101
	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
102
	[IFA_FLAGS]		= { .type = NLA_U32 },
103 104
};

E
Eric Dumazet 已提交
105 106 107
#define IN4_ADDR_HSIZE_SHIFT	8
#define IN4_ADDR_HSIZE		(1U << IN4_ADDR_HSIZE_SHIFT)

108 109 110
static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
static DEFINE_SPINLOCK(inet_addr_hash_lock);

E
Eric Dumazet 已提交
111
static u32 inet_addr_hash(struct net *net, __be32 addr)
112
{
E
Eric Dumazet 已提交
113
	u32 val = (__force u32) addr ^ net_hash_mix(net);
114

E
Eric Dumazet 已提交
115
	return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
116 117 118 119
}

static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
{
E
Eric Dumazet 已提交
120
	u32 hash = inet_addr_hash(net, ifa->ifa_local);
121 122 123 124 125 126 127 128 129 130 131 132 133

	spin_lock(&inet_addr_hash_lock);
	hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
	spin_unlock(&inet_addr_hash_lock);
}

static void inet_hash_remove(struct in_ifaddr *ifa)
{
	spin_lock(&inet_addr_hash_lock);
	hlist_del_init_rcu(&ifa->hash);
	spin_unlock(&inet_addr_hash_lock);
}

134 135 136 137 138 139 140 141 142 143
/**
 * __ip_dev_find - find the first device with a given source address.
 * @net: the net namespace
 * @addr: the source address
 * @devref: if true, take a reference on the found device
 *
 * If a caller uses devref=false, it should be protected by RCU, or RTNL
 */
struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
{
E
Eric Dumazet 已提交
144
	u32 hash = inet_addr_hash(net, addr);
145 146 147 148
	struct net_device *result = NULL;
	struct in_ifaddr *ifa;

	rcu_read_lock();
149
	hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
150
		if (ifa->ifa_local == addr) {
E
Eric Dumazet 已提交
151 152 153 154
			struct net_device *dev = ifa->ifa_dev->dev;

			if (!net_eq(dev_net(dev), net))
				continue;
155 156 157 158
			result = dev;
			break;
		}
	}
159 160 161 162 163 164 165 166 167 168 169 170 171 172
	if (!result) {
		struct flowi4 fl4 = { .daddr = addr };
		struct fib_result res = { 0 };
		struct fib_table *local;

		/* Fallback to FIB local table so that communication
		 * over loopback subnets work.
		 */
		local = fib_get_table(net, RT_TABLE_LOCAL);
		if (local &&
		    !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
		    res.type == RTN_LOCAL)
			result = FIB_RES_DEV(res);
	}
173 174 175 176 177 178 179
	if (result && devref)
		dev_hold(result);
	rcu_read_unlock();
	return result;
}
EXPORT_SYMBOL(__ip_dev_find);

180
static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
L
Linus Torvalds 已提交
181

182
static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
L
Linus Torvalds 已提交
183 184 185
static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
			 int destroy);
#ifdef CONFIG_SYSCTL
186
static void devinet_sysctl_register(struct in_device *idev);
187 188
static void devinet_sysctl_unregister(struct in_device *idev);
#else
E
Eric Dumazet 已提交
189
static void devinet_sysctl_register(struct in_device *idev)
190 191
{
}
E
Eric Dumazet 已提交
192
static void devinet_sysctl_unregister(struct in_device *idev)
193 194
{
}
L
Linus Torvalds 已提交
195 196 197 198 199 200
#endif

/* Locks all the inet devices. */

static struct in_ifaddr *inet_alloc_ifa(void)
{
A
Alexey Dobriyan 已提交
201
	return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210 211
}

static void inet_rcu_free_ifa(struct rcu_head *head)
{
	struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
	if (ifa->ifa_dev)
		in_dev_put(ifa->ifa_dev);
	kfree(ifa);
}

E
Eric Dumazet 已提交
212
static void inet_free_ifa(struct in_ifaddr *ifa)
L
Linus Torvalds 已提交
213 214 215 216 217 218 219 220
{
	call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
}

void in_dev_finish_destroy(struct in_device *idev)
{
	struct net_device *dev = idev->dev;

221 222
	WARN_ON(idev->ifa_list);
	WARN_ON(idev->mc_list);
223
	kfree(rcu_dereference_protected(idev->mc_hash, 1));
L
Linus Torvalds 已提交
224
#ifdef NET_REFCNT_DEBUG
225
	pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
L
Linus Torvalds 已提交
226 227 228
#endif
	dev_put(dev);
	if (!idev->dead)
E
Eric Dumazet 已提交
229 230
		pr_err("Freeing alive in_device %p\n", idev);
	else
L
Linus Torvalds 已提交
231 232
		kfree(idev);
}
E
Eric Dumazet 已提交
233
EXPORT_SYMBOL(in_dev_finish_destroy);
L
Linus Torvalds 已提交
234

235
static struct in_device *inetdev_init(struct net_device *dev)
L
Linus Torvalds 已提交
236 237 238 239 240
{
	struct in_device *in_dev;

	ASSERT_RTNL();

241
	in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
L
Linus Torvalds 已提交
242 243
	if (!in_dev)
		goto out;
244
	memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
245
			sizeof(in_dev->cnf));
L
Linus Torvalds 已提交
246 247
	in_dev->cnf.sysctl = NULL;
	in_dev->dev = dev;
E
Eric Dumazet 已提交
248 249
	in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
	if (!in_dev->arp_parms)
L
Linus Torvalds 已提交
250
		goto out_kfree;
251 252
	if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
		dev_disable_lro(dev);
L
Linus Torvalds 已提交
253 254
	/* Reference in_dev->dev */
	dev_hold(dev);
255
	/* Account for reference dev->ip_ptr (below) */
L
Linus Torvalds 已提交
256 257
	in_dev_hold(in_dev);

258
	devinet_sysctl_register(in_dev);
L
Linus Torvalds 已提交
259 260 261
	ip_mc_init_dev(in_dev);
	if (dev->flags & IFF_UP)
		ip_mc_up(in_dev);
262

263
	/* we can receive as soon as ip_ptr is set -- do this last */
264
	rcu_assign_pointer(dev->ip_ptr, in_dev);
265
out:
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	return in_dev;
out_kfree:
	kfree(in_dev);
	in_dev = NULL;
	goto out;
}

static void in_dev_rcu_put(struct rcu_head *head)
{
	struct in_device *idev = container_of(head, struct in_device, rcu_head);
	in_dev_put(idev);
}

static void inetdev_destroy(struct in_device *in_dev)
{
	struct in_ifaddr *ifa;
	struct net_device *dev;

	ASSERT_RTNL();

	dev = in_dev->dev;

	in_dev->dead = 1;

	ip_mc_destroy_dev(in_dev);

	while ((ifa = in_dev->ifa_list) != NULL) {
		inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
		inet_free_ifa(ifa);
	}

297
	RCU_INIT_POINTER(dev->ip_ptr, NULL);
L
Linus Torvalds 已提交
298

299
	devinet_sysctl_unregister(in_dev);
L
Linus Torvalds 已提交
300 301 302 303 304 305
	neigh_parms_release(&arp_tbl, in_dev->arp_parms);
	arp_ifdown(dev);

	call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
}

A
Al Viro 已提交
306
int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
L
Linus Torvalds 已提交
307 308 309 310 311 312 313 314 315 316 317 318 319 320
{
	rcu_read_lock();
	for_primary_ifa(in_dev) {
		if (inet_ifa_match(a, ifa)) {
			if (!b || inet_ifa_match(b, ifa)) {
				rcu_read_unlock();
				return 1;
			}
		}
	} endfor_ifa(in_dev);
	rcu_read_unlock();
	return 0;
}

321
static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
322
			 int destroy, struct nlmsghdr *nlh, u32 portid)
L
Linus Torvalds 已提交
323
{
324
	struct in_ifaddr *promote = NULL;
325 326 327 328
	struct in_ifaddr *ifa, *ifa1 = *ifap;
	struct in_ifaddr *last_prim = in_dev->ifa_list;
	struct in_ifaddr *prev_prom = NULL;
	int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
L
Linus Torvalds 已提交
329 330 331

	ASSERT_RTNL();

332
	/* 1. Deleting primary ifaddr forces deletion all secondaries
333 334
	 * unless alias promotion is set
	 **/
L
Linus Torvalds 已提交
335 336 337 338 339

	if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
		struct in_ifaddr **ifap1 = &ifa1->ifa_next;

		while ((ifa = *ifap1) != NULL) {
340
			if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
341 342 343
			    ifa1->ifa_scope <= ifa->ifa_scope)
				last_prim = ifa;

L
Linus Torvalds 已提交
344 345 346 347
			if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
			    ifa1->ifa_mask != ifa->ifa_mask ||
			    !inet_ifa_match(ifa1->ifa_address, ifa)) {
				ifap1 = &ifa->ifa_next;
348
				prev_prom = ifa;
L
Linus Torvalds 已提交
349 350 351
				continue;
			}

352
			if (!do_promote) {
353
				inet_hash_remove(ifa);
354
				*ifap1 = ifa->ifa_next;
L
Linus Torvalds 已提交
355

356
				rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
357 358
				blocking_notifier_call_chain(&inetaddr_chain,
						NETDEV_DOWN, ifa);
359 360 361 362 363
				inet_free_ifa(ifa);
			} else {
				promote = ifa;
				break;
			}
L
Linus Torvalds 已提交
364 365 366
		}
	}

367 368 369 370 371 372 373 374 375 376 377
	/* On promotion all secondaries from subnet are changing
	 * the primary IP, we must remove all their routes silently
	 * and later to add them back with new prefsrc. Do this
	 * while all addresses are on the device list.
	 */
	for (ifa = promote; ifa; ifa = ifa->ifa_next) {
		if (ifa1->ifa_mask == ifa->ifa_mask &&
		    inet_ifa_match(ifa1->ifa_address, ifa))
			fib_del_ifaddr(ifa, ifa1);
	}

L
Linus Torvalds 已提交
378 379 380
	/* 2. Unlink it */

	*ifap = ifa1->ifa_next;
381
	inet_hash_remove(ifa1);
L
Linus Torvalds 已提交
382 383 384 385 386 387 388 389 390 391 392

	/* 3. Announce address deletion */

	/* Send message first, then call notifier.
	   At first sight, FIB update triggered by notifier
	   will refer to already deleted ifaddr, that could confuse
	   netlink listeners. It is not true: look, gated sees
	   that route deleted and if it still thinks that ifaddr
	   is valid, it will try to restore deleted routes... Grr.
	   So that, this order is correct.
	 */
393
	rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
394
	blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
L
Linus Torvalds 已提交
395

396
	if (promote) {
397
		struct in_ifaddr *next_sec = promote->ifa_next;
398 399 400 401 402 403

		if (prev_prom) {
			prev_prom->ifa_next = promote->ifa_next;
			promote->ifa_next = last_prim->ifa_next;
			last_prim->ifa_next = promote;
		}
404 405

		promote->ifa_flags &= ~IFA_F_SECONDARY;
406
		rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
407 408
		blocking_notifier_call_chain(&inetaddr_chain,
				NETDEV_UP, promote);
409
		for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
410 411 412 413 414 415 416
			if (ifa1->ifa_mask != ifa->ifa_mask ||
			    !inet_ifa_match(ifa1->ifa_address, ifa))
					continue;
			fib_add_ifaddr(ifa);
		}

	}
417
	if (destroy)
418
		inet_free_ifa(ifa1);
L
Linus Torvalds 已提交
419 420
}

421 422 423 424 425 426
static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
			 int destroy)
{
	__inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
}

J
Jiri Pirko 已提交
427 428 429 430
static void check_lifetime(struct work_struct *work);

static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);

431
static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
432
			     u32 portid)
L
Linus Torvalds 已提交
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
{
	struct in_device *in_dev = ifa->ifa_dev;
	struct in_ifaddr *ifa1, **ifap, **last_primary;

	ASSERT_RTNL();

	if (!ifa->ifa_local) {
		inet_free_ifa(ifa);
		return 0;
	}

	ifa->ifa_flags &= ~IFA_F_SECONDARY;
	last_primary = &in_dev->ifa_list;

	for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
	     ifap = &ifa1->ifa_next) {
		if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
		    ifa->ifa_scope <= ifa1->ifa_scope)
			last_primary = &ifa1->ifa_next;
		if (ifa1->ifa_mask == ifa->ifa_mask &&
		    inet_ifa_match(ifa1->ifa_address, ifa)) {
			if (ifa1->ifa_local == ifa->ifa_local) {
				inet_free_ifa(ifa);
				return -EEXIST;
			}
			if (ifa1->ifa_scope != ifa->ifa_scope) {
				inet_free_ifa(ifa);
				return -EINVAL;
			}
			ifa->ifa_flags |= IFA_F_SECONDARY;
		}
	}

	if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
		net_srandom(ifa->ifa_local);
		ifap = last_primary;
	}

	ifa->ifa_next = *ifap;
	*ifap = ifa;

474 475
	inet_hash_insert(dev_net(in_dev->dev), ifa);

J
Jiri Pirko 已提交
476 477 478
	cancel_delayed_work(&check_lifetime_work);
	schedule_delayed_work(&check_lifetime_work, 0);

L
Linus Torvalds 已提交
479 480 481
	/* Send message first, then call notifier.
	   Notifier will trigger FIB update, so that
	   listeners of netlink will know about new ifaddr */
482
	rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
483
	blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
L
Linus Torvalds 已提交
484 485 486 487

	return 0;
}

488 489 490 491 492
static int inet_insert_ifa(struct in_ifaddr *ifa)
{
	return __inet_insert_ifa(ifa, NULL, 0);
}

L
Linus Torvalds 已提交
493 494
static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
{
495
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
496 497 498 499

	ASSERT_RTNL();

	if (!in_dev) {
500 501
		inet_free_ifa(ifa);
		return -ENOBUFS;
L
Linus Torvalds 已提交
502
	}
503
	ipv4_devconf_setall(in_dev);
504
	neigh_parms_data_state_setall(in_dev->arp_parms);
L
Linus Torvalds 已提交
505
	if (ifa->ifa_dev != in_dev) {
506
		WARN_ON(ifa->ifa_dev);
L
Linus Torvalds 已提交
507 508 509
		in_dev_hold(in_dev);
		ifa->ifa_dev = in_dev;
	}
510
	if (ipv4_is_loopback(ifa->ifa_local))
L
Linus Torvalds 已提交
511 512 513 514
		ifa->ifa_scope = RT_SCOPE_HOST;
	return inet_insert_ifa(ifa);
}

515 516 517
/* Caller must hold RCU or RTNL :
 * We dont take a reference on found in_device
 */
518
struct in_device *inetdev_by_index(struct net *net, int ifindex)
L
Linus Torvalds 已提交
519 520 521
{
	struct net_device *dev;
	struct in_device *in_dev = NULL;
522 523 524

	rcu_read_lock();
	dev = dev_get_by_index_rcu(net, ifindex);
L
Linus Torvalds 已提交
525
	if (dev)
526
		in_dev = rcu_dereference_rtnl(dev->ip_ptr);
527
	rcu_read_unlock();
L
Linus Torvalds 已提交
528 529
	return in_dev;
}
E
Eric Dumazet 已提交
530
EXPORT_SYMBOL(inetdev_by_index);
L
Linus Torvalds 已提交
531 532 533

/* Called only from RTNL semaphored context. No locks. */

A
Al Viro 已提交
534 535
struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
				    __be32 mask)
L
Linus Torvalds 已提交
536 537 538 539 540 541 542 543 544 545
{
	ASSERT_RTNL();

	for_primary_ifa(in_dev) {
		if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
			return ifa;
	} endfor_ifa(in_dev);
	return NULL;
}

546
static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
547
{
548
	struct net *net = sock_net(skb->sk);
549
	struct nlattr *tb[IFA_MAX+1];
L
Linus Torvalds 已提交
550
	struct in_device *in_dev;
551
	struct ifaddrmsg *ifm;
L
Linus Torvalds 已提交
552
	struct in_ifaddr *ifa, **ifap;
553
	int err = -EINVAL;
L
Linus Torvalds 已提交
554 555 556

	ASSERT_RTNL();

557 558 559 560 561
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
	if (err < 0)
		goto errout;

	ifm = nlmsg_data(nlh);
562
	in_dev = inetdev_by_index(net, ifm->ifa_index);
563 564 565 566 567
	if (in_dev == NULL) {
		err = -ENODEV;
		goto errout;
	}

L
Linus Torvalds 已提交
568 569
	for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
	     ifap = &ifa->ifa_next) {
570
		if (tb[IFA_LOCAL] &&
571
		    ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
572 573 574
			continue;

		if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
L
Linus Torvalds 已提交
575
			continue;
576 577 578

		if (tb[IFA_ADDRESS] &&
		    (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
579
		    !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
580 581
			continue;

582
		__inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
L
Linus Torvalds 已提交
583 584
		return 0;
	}
585 586 587 588

	err = -EADDRNOTAVAIL;
errout:
	return err;
L
Linus Torvalds 已提交
589 590
}

J
Jiri Pirko 已提交
591 592 593 594 595 596
#define INFINITY_LIFE_TIME	0xFFFFFFFF

static void check_lifetime(struct work_struct *work)
{
	unsigned long now, next, next_sec, next_sched;
	struct in_ifaddr *ifa;
597
	struct hlist_node *n;
J
Jiri Pirko 已提交
598 599 600 601 602 603
	int i;

	now = jiffies;
	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);

	for (i = 0; i < IN4_ADDR_HSIZE; i++) {
604 605 606
		bool change_needed = false;

		rcu_read_lock();
607
		hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
J
Jiri Pirko 已提交
608 609 610 611 612 613 614 615 616 617 618
			unsigned long age;

			if (ifa->ifa_flags & IFA_F_PERMANENT)
				continue;

			/* We try to batch several events at once. */
			age = (now - ifa->ifa_tstamp +
			       ADDRCONF_TIMER_FUZZ_MINUS) / HZ;

			if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
			    age >= ifa->ifa_valid_lft) {
619
				change_needed = true;
J
Jiri Pirko 已提交
620 621 622 623 624 625 626 627 628
			} else if (ifa->ifa_preferred_lft ==
				   INFINITY_LIFE_TIME) {
				continue;
			} else if (age >= ifa->ifa_preferred_lft) {
				if (time_before(ifa->ifa_tstamp +
						ifa->ifa_valid_lft * HZ, next))
					next = ifa->ifa_tstamp +
					       ifa->ifa_valid_lft * HZ;

629 630
				if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
					change_needed = true;
J
Jiri Pirko 已提交
631 632 633 634 635 636 637
			} else if (time_before(ifa->ifa_tstamp +
					       ifa->ifa_preferred_lft * HZ,
					       next)) {
				next = ifa->ifa_tstamp +
				       ifa->ifa_preferred_lft * HZ;
			}
		}
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
		rcu_read_unlock();
		if (!change_needed)
			continue;
		rtnl_lock();
		hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
			unsigned long age;

			if (ifa->ifa_flags & IFA_F_PERMANENT)
				continue;

			/* We try to batch several events at once. */
			age = (now - ifa->ifa_tstamp +
			       ADDRCONF_TIMER_FUZZ_MINUS) / HZ;

			if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
			    age >= ifa->ifa_valid_lft) {
				struct in_ifaddr **ifap;

				for (ifap = &ifa->ifa_dev->ifa_list;
				     *ifap != NULL; ifap = &(*ifap)->ifa_next) {
					if (*ifap == ifa) {
						inet_del_ifa(ifa->ifa_dev,
							     ifap, 1);
						break;
					}
				}
			} else if (ifa->ifa_preferred_lft !=
				   INFINITY_LIFE_TIME &&
				   age >= ifa->ifa_preferred_lft &&
				   !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
				ifa->ifa_flags |= IFA_F_DEPRECATED;
				rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
			}
		}
		rtnl_unlock();
J
Jiri Pirko 已提交
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
	}

	next_sec = round_jiffies_up(next);
	next_sched = next;

	/* If rounded timeout is accurate enough, accept it. */
	if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
		next_sched = next_sec;

	now = jiffies;
	/* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
	if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
		next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;

	schedule_delayed_work(&check_lifetime_work, next_sched - now);
}

static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
			     __u32 prefered_lft)
{
	unsigned long timeout;

	ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);

	timeout = addrconf_timeout_fixup(valid_lft, HZ);
	if (addrconf_finite_timeout(timeout))
		ifa->ifa_valid_lft = timeout;
	else
		ifa->ifa_flags |= IFA_F_PERMANENT;

	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
	if (addrconf_finite_timeout(timeout)) {
		if (timeout == 0)
			ifa->ifa_flags |= IFA_F_DEPRECATED;
		ifa->ifa_preferred_lft = timeout;
	}
	ifa->ifa_tstamp = jiffies;
	if (!ifa->ifa_cstamp)
		ifa->ifa_cstamp = ifa->ifa_tstamp;
}

static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
				       __u32 *pvalid_lft, __u32 *pprefered_lft)
L
Linus Torvalds 已提交
716
{
717 718 719
	struct nlattr *tb[IFA_MAX+1];
	struct in_ifaddr *ifa;
	struct ifaddrmsg *ifm;
L
Linus Torvalds 已提交
720 721
	struct net_device *dev;
	struct in_device *in_dev;
722
	int err;
L
Linus Torvalds 已提交
723

724 725 726
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
	if (err < 0)
		goto errout;
L
Linus Torvalds 已提交
727

728
	ifm = nlmsg_data(nlh);
729 730
	err = -EINVAL;
	if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
731
		goto errout;
L
Linus Torvalds 已提交
732

733
	dev = __dev_get_by_index(net, ifm->ifa_index);
734 735
	err = -ENODEV;
	if (dev == NULL)
736
		goto errout;
L
Linus Torvalds 已提交
737

738
	in_dev = __in_dev_get_rtnl(dev);
739 740
	err = -ENOBUFS;
	if (in_dev == NULL)
741
		goto errout;
L
Linus Torvalds 已提交
742

743
	ifa = inet_alloc_ifa();
744
	if (ifa == NULL)
745 746 747 748 749 750
		/*
		 * A potential indev allocation can be left alive, it stays
		 * assigned to its device and is destroy with it.
		 */
		goto errout;

751
	ipv4_devconf_setall(in_dev);
752
	neigh_parms_data_state_setall(in_dev->arp_parms);
753 754 755 756
	in_dev_hold(in_dev);

	if (tb[IFA_ADDRESS] == NULL)
		tb[IFA_ADDRESS] = tb[IFA_LOCAL];
L
Linus Torvalds 已提交
757

758
	INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
759 760
	ifa->ifa_prefixlen = ifm->ifa_prefixlen;
	ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
761 762
	ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
					 ifm->ifa_flags;
L
Linus Torvalds 已提交
763
	ifa->ifa_scope = ifm->ifa_scope;
764 765
	ifa->ifa_dev = in_dev;

766 767
	ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
	ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
768 769

	if (tb[IFA_BROADCAST])
770
		ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
771 772 773

	if (tb[IFA_LABEL])
		nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
L
Linus Torvalds 已提交
774 775 776
	else
		memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);

J
Jiri Pirko 已提交
777 778 779 780 781 782
	if (tb[IFA_CACHEINFO]) {
		struct ifa_cacheinfo *ci;

		ci = nla_data(tb[IFA_CACHEINFO]);
		if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
			err = -EINVAL;
783
			goto errout_free;
J
Jiri Pirko 已提交
784 785 786 787 788
		}
		*pvalid_lft = ci->ifa_valid;
		*pprefered_lft = ci->ifa_prefered;
	}

789 790
	return ifa;

791 792
errout_free:
	inet_free_ifa(ifa);
793 794 795 796
errout:
	return ERR_PTR(err);
}

J
Jiri Pirko 已提交
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
{
	struct in_device *in_dev = ifa->ifa_dev;
	struct in_ifaddr *ifa1, **ifap;

	if (!ifa->ifa_local)
		return NULL;

	for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
	     ifap = &ifa1->ifa_next) {
		if (ifa1->ifa_mask == ifa->ifa_mask &&
		    inet_ifa_match(ifa1->ifa_address, ifa) &&
		    ifa1->ifa_local == ifa->ifa_local)
			return ifa1;
	}
	return NULL;
}

815
static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
816
{
817
	struct net *net = sock_net(skb->sk);
818
	struct in_ifaddr *ifa;
J
Jiri Pirko 已提交
819 820 821
	struct in_ifaddr *ifa_existing;
	__u32 valid_lft = INFINITY_LIFE_TIME;
	__u32 prefered_lft = INFINITY_LIFE_TIME;
822 823 824

	ASSERT_RTNL();

J
Jiri Pirko 已提交
825
	ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
826 827 828
	if (IS_ERR(ifa))
		return PTR_ERR(ifa);

J
Jiri Pirko 已提交
829 830 831 832 833 834 835 836 837 838 839 840 841
	ifa_existing = find_matching_ifa(ifa);
	if (!ifa_existing) {
		/* It would be best to check for !NLM_F_CREATE here but
		 * userspace alreay relies on not having to provide this.
		 */
		set_ifa_lifetime(ifa, valid_lft, prefered_lft);
		return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid);
	} else {
		inet_free_ifa(ifa);

		if (nlh->nlmsg_flags & NLM_F_EXCL ||
		    !(nlh->nlmsg_flags & NLM_F_REPLACE))
			return -EEXIST;
842 843
		ifa = ifa_existing;
		set_ifa_lifetime(ifa, valid_lft, prefered_lft);
844 845
		cancel_delayed_work(&check_lifetime_work);
		schedule_delayed_work(&check_lifetime_work, 0);
846 847
		rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
		blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
J
Jiri Pirko 已提交
848 849
	}
	return 0;
L
Linus Torvalds 已提交
850 851 852 853 854 855
}

/*
 *	Determine a default network mask, based on the IP address.
 */

E
Eric Dumazet 已提交
856
static int inet_abc_len(__be32 addr)
L
Linus Torvalds 已提交
857 858 859
{
	int rc = -1;	/* Something else, probably a multicast. */

860
	if (ipv4_is_zeronet(addr))
861
		rc = 0;
L
Linus Torvalds 已提交
862
	else {
863
		__u32 haddr = ntohl(addr);
L
Linus Torvalds 已提交
864

865
		if (IN_CLASSA(haddr))
L
Linus Torvalds 已提交
866
			rc = 8;
867
		else if (IN_CLASSB(haddr))
L
Linus Torvalds 已提交
868
			rc = 16;
869
		else if (IN_CLASSC(haddr))
L
Linus Torvalds 已提交
870 871 872
			rc = 24;
	}

873
	return rc;
L
Linus Torvalds 已提交
874 875 876
}


877
int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
L
Linus Torvalds 已提交
878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
{
	struct ifreq ifr;
	struct sockaddr_in sin_orig;
	struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
	struct in_device *in_dev;
	struct in_ifaddr **ifap = NULL;
	struct in_ifaddr *ifa = NULL;
	struct net_device *dev;
	char *colon;
	int ret = -EFAULT;
	int tryaddrmatch = 0;

	/*
	 *	Fetch the caller's info block into kernel space
	 */

	if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
		goto out;
	ifr.ifr_name[IFNAMSIZ - 1] = 0;

	/* save original address for comparison */
	memcpy(&sin_orig, sin, sizeof(*sin));

	colon = strchr(ifr.ifr_name, ':');
	if (colon)
		*colon = 0;

905
	dev_load(net, ifr.ifr_name);
L
Linus Torvalds 已提交
906

S
Stephen Hemminger 已提交
907
	switch (cmd) {
L
Linus Torvalds 已提交
908 909 910 911 912 913 914 915 916 917 918 919 920 921
	case SIOCGIFADDR:	/* Get interface address */
	case SIOCGIFBRDADDR:	/* Get the broadcast address */
	case SIOCGIFDSTADDR:	/* Get the destination address */
	case SIOCGIFNETMASK:	/* Get the netmask for the interface */
		/* Note that these ioctls will not sleep,
		   so that we do not impose a lock.
		   One day we will be forced to put shlock here (I mean SMP)
		 */
		tryaddrmatch = (sin_orig.sin_family == AF_INET);
		memset(sin, 0, sizeof(*sin));
		sin->sin_family = AF_INET;
		break;

	case SIOCSIFFLAGS:
922
		ret = -EPERM;
923
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
924 925 926 927 928 929
			goto out;
		break;
	case SIOCSIFADDR:	/* Set interface address (and family) */
	case SIOCSIFBRDADDR:	/* Set the broadcast address */
	case SIOCSIFDSTADDR:	/* Set the destination address */
	case SIOCSIFNETMASK: 	/* Set the netmask for the interface */
930
		ret = -EPERM;
931
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
932 933 934 935 936 937 938 939 940 941 942 943 944
			goto out;
		ret = -EINVAL;
		if (sin->sin_family != AF_INET)
			goto out;
		break;
	default:
		ret = -EINVAL;
		goto out;
	}

	rtnl_lock();

	ret = -ENODEV;
E
Eric Dumazet 已提交
945 946
	dev = __dev_get_by_name(net, ifr.ifr_name);
	if (!dev)
L
Linus Torvalds 已提交
947 948 949 950 951
		goto done;

	if (colon)
		*colon = ':';

E
Eric Dumazet 已提交
952 953
	in_dev = __in_dev_get_rtnl(dev);
	if (in_dev) {
L
Linus Torvalds 已提交
954 955 956 957 958 959 960 961 962 963
		if (tryaddrmatch) {
			/* Matthias Andree */
			/* compare label and address (4.4BSD style) */
			/* note: we only do this for a limited set of ioctls
			   and only if the original address family was AF_INET.
			   This is checked above. */
			for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
			     ifap = &ifa->ifa_next) {
				if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
				    sin_orig.sin_addr.s_addr ==
964
							ifa->ifa_local) {
L
Linus Torvalds 已提交
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
					break; /* found */
				}
			}
		}
		/* we didn't get a match, maybe the application is
		   4.3BSD-style and passed in junk so we fall back to
		   comparing just the label */
		if (!ifa) {
			for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
			     ifap = &ifa->ifa_next)
				if (!strcmp(ifr.ifr_name, ifa->ifa_label))
					break;
		}
	}

	ret = -EADDRNOTAVAIL;
	if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
		goto done;

S
Stephen Hemminger 已提交
984
	switch (cmd) {
L
Linus Torvalds 已提交
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
	case SIOCGIFADDR:	/* Get interface address */
		sin->sin_addr.s_addr = ifa->ifa_local;
		goto rarok;

	case SIOCGIFBRDADDR:	/* Get the broadcast address */
		sin->sin_addr.s_addr = ifa->ifa_broadcast;
		goto rarok;

	case SIOCGIFDSTADDR:	/* Get the destination address */
		sin->sin_addr.s_addr = ifa->ifa_address;
		goto rarok;

	case SIOCGIFNETMASK:	/* Get the netmask for the interface */
		sin->sin_addr.s_addr = ifa->ifa_mask;
		goto rarok;

	case SIOCSIFFLAGS:
		if (colon) {
			ret = -EADDRNOTAVAIL;
			if (!ifa)
				break;
			ret = 0;
			if (!(ifr.ifr_flags & IFF_UP))
				inet_del_ifa(in_dev, ifap, 1);
			break;
		}
		ret = dev_change_flags(dev, ifr.ifr_flags);
		break;

	case SIOCSIFADDR:	/* Set interface address (and family) */
		ret = -EINVAL;
		if (inet_abc_len(sin->sin_addr.s_addr) < 0)
			break;

		if (!ifa) {
			ret = -ENOBUFS;
E
Eric Dumazet 已提交
1021 1022
			ifa = inet_alloc_ifa();
			if (!ifa)
L
Linus Torvalds 已提交
1023
				break;
1024
			INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
			if (colon)
				memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
			else
				memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
		} else {
			ret = 0;
			if (ifa->ifa_local == sin->sin_addr.s_addr)
				break;
			inet_del_ifa(in_dev, ifap, 0);
			ifa->ifa_broadcast = 0;
1035
			ifa->ifa_scope = 0;
L
Linus Torvalds 已提交
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
		}

		ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;

		if (!(dev->flags & IFF_POINTOPOINT)) {
			ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
			ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
			if ((dev->flags & IFF_BROADCAST) &&
			    ifa->ifa_prefixlen < 31)
				ifa->ifa_broadcast = ifa->ifa_address |
						     ~ifa->ifa_mask;
		} else {
			ifa->ifa_prefixlen = 32;
			ifa->ifa_mask = inet_make_mask(32);
		}
J
Jiri Pirko 已提交
1051
		set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
		ret = inet_set_ifa(dev, ifa);
		break;

	case SIOCSIFBRDADDR:	/* Set the broadcast address */
		ret = 0;
		if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
			inet_del_ifa(in_dev, ifap, 0);
			ifa->ifa_broadcast = sin->sin_addr.s_addr;
			inet_insert_ifa(ifa);
		}
		break;

	case SIOCSIFDSTADDR:	/* Set the destination address */
		ret = 0;
		if (ifa->ifa_address == sin->sin_addr.s_addr)
			break;
		ret = -EINVAL;
		if (inet_abc_len(sin->sin_addr.s_addr) < 0)
			break;
		ret = 0;
		inet_del_ifa(in_dev, ifap, 0);
		ifa->ifa_address = sin->sin_addr.s_addr;
		inet_insert_ifa(ifa);
		break;

	case SIOCSIFNETMASK: 	/* Set the netmask for the interface */

		/*
		 *	The mask we set must be legal.
		 */
		ret = -EINVAL;
		if (bad_mask(sin->sin_addr.s_addr, 0))
			break;
		ret = 0;
		if (ifa->ifa_mask != sin->sin_addr.s_addr) {
A
Al Viro 已提交
1087
			__be32 old_mask = ifa->ifa_mask;
L
Linus Torvalds 已提交
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
			inet_del_ifa(in_dev, ifap, 0);
			ifa->ifa_mask = sin->sin_addr.s_addr;
			ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);

			/* See if current broadcast address matches
			 * with current netmask, then recalculate
			 * the broadcast address. Otherwise it's a
			 * funny address, so don't touch it since
			 * the user seems to know what (s)he's doing...
			 */
			if ((dev->flags & IFF_BROADCAST) &&
			    (ifa->ifa_prefixlen < 31) &&
			    (ifa->ifa_broadcast ==
1101
			     (ifa->ifa_local|~old_mask))) {
L
Linus Torvalds 已提交
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
				ifa->ifa_broadcast = (ifa->ifa_local |
						      ~sin->sin_addr.s_addr);
			}
			inet_insert_ifa(ifa);
		}
		break;
	}
done:
	rtnl_unlock();
out:
	return ret;
rarok:
	rtnl_unlock();
	ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
	goto out;
}

static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
{
1121
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
1122 1123 1124 1125
	struct in_ifaddr *ifa;
	struct ifreq ifr;
	int done = 0;

E
Eric Dumazet 已提交
1126
	if (!in_dev)
L
Linus Torvalds 已提交
1127 1128
		goto out;

E
Eric Dumazet 已提交
1129
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
L
Linus Torvalds 已提交
1130 1131 1132 1133 1134 1135 1136
		if (!buf) {
			done += sizeof(ifr);
			continue;
		}
		if (len < (int) sizeof(ifr))
			break;
		memset(&ifr, 0, sizeof(struct ifreq));
D
Dan Carpenter 已提交
1137
		strcpy(ifr.ifr_name, ifa->ifa_label);
L
Linus Torvalds 已提交
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154

		(*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
		(*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
								ifa->ifa_local;

		if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
			done = -EFAULT;
			break;
		}
		buf  += sizeof(struct ifreq);
		len  -= sizeof(struct ifreq);
		done += sizeof(struct ifreq);
	}
out:
	return done;
}

A
Al Viro 已提交
1155
__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
L
Linus Torvalds 已提交
1156
{
A
Al Viro 已提交
1157
	__be32 addr = 0;
L
Linus Torvalds 已提交
1158
	struct in_device *in_dev;
1159
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
1160 1161

	rcu_read_lock();
1162
	in_dev = __in_dev_get_rcu(dev);
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
	if (!in_dev)
		goto no_in_dev;

	for_primary_ifa(in_dev) {
		if (ifa->ifa_scope > scope)
			continue;
		if (!dst || inet_ifa_match(dst, ifa)) {
			addr = ifa->ifa_local;
			break;
		}
		if (!addr)
			addr = ifa->ifa_local;
	} endfor_ifa(in_dev);

	if (addr)
1178
		goto out_unlock;
E
Eric Dumazet 已提交
1179
no_in_dev:
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184

	/* Not loopback addresses on loopback should be preferred
	   in this case. It is importnat that lo is the first interface
	   in dev_base list.
	 */
1185
	for_each_netdev_rcu(net, dev) {
E
Eric Dumazet 已提交
1186 1187
		in_dev = __in_dev_get_rcu(dev);
		if (!in_dev)
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193
			continue;

		for_primary_ifa(in_dev) {
			if (ifa->ifa_scope != RT_SCOPE_LINK &&
			    ifa->ifa_scope <= scope) {
				addr = ifa->ifa_local;
1194
				goto out_unlock;
L
Linus Torvalds 已提交
1195 1196 1197
			}
		} endfor_ifa(in_dev);
	}
1198
out_unlock:
L
Linus Torvalds 已提交
1199 1200 1201
	rcu_read_unlock();
	return addr;
}
E
Eric Dumazet 已提交
1202
EXPORT_SYMBOL(inet_select_addr);
L
Linus Torvalds 已提交
1203

A
Al Viro 已提交
1204 1205
static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
			      __be32 local, int scope)
L
Linus Torvalds 已提交
1206 1207
{
	int same = 0;
A
Al Viro 已提交
1208
	__be32 addr = 0;
L
Linus Torvalds 已提交
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237

	for_ifa(in_dev) {
		if (!addr &&
		    (local == ifa->ifa_local || !local) &&
		    ifa->ifa_scope <= scope) {
			addr = ifa->ifa_local;
			if (same)
				break;
		}
		if (!same) {
			same = (!local || inet_ifa_match(local, ifa)) &&
				(!dst || inet_ifa_match(dst, ifa));
			if (same && addr) {
				if (local || !dst)
					break;
				/* Is the selected addr into dst subnet? */
				if (inet_ifa_match(addr, ifa))
					break;
				/* No, then can we use new local src? */
				if (ifa->ifa_scope <= scope) {
					addr = ifa->ifa_local;
					break;
				}
				/* search for large dst subnet for addr */
				same = 0;
			}
		}
	} endfor_ifa(in_dev);

E
Eric Dumazet 已提交
1238
	return same ? addr : 0;
L
Linus Torvalds 已提交
1239 1240 1241 1242
}

/*
 * Confirm that local IP address exists using wildcards:
1243 1244
 * - net: netns to check, cannot be NULL
 * - in_dev: only on this interface, NULL=any interface
L
Linus Torvalds 已提交
1245 1246 1247 1248
 * - dst: only in the same subnet as dst, 0=any dst
 * - local: address, 0=autoselect the local address
 * - scope: maximum allowed scope value for the local address
 */
1249
__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1250
			 __be32 dst, __be32 local, int scope)
L
Linus Torvalds 已提交
1251
{
A
Al Viro 已提交
1252
	__be32 addr = 0;
1253
	struct net_device *dev;
L
Linus Torvalds 已提交
1254

1255
	if (in_dev != NULL)
1256
		return confirm_addr_indev(in_dev, dst, local, scope);
L
Linus Torvalds 已提交
1257 1258

	rcu_read_lock();
1259
	for_each_netdev_rcu(net, dev) {
E
Eric Dumazet 已提交
1260 1261
		in_dev = __in_dev_get_rcu(dev);
		if (in_dev) {
L
Linus Torvalds 已提交
1262 1263 1264 1265 1266 1267 1268 1269 1270
			addr = confirm_addr_indev(in_dev, dst, local, scope);
			if (addr)
				break;
		}
	}
	rcu_read_unlock();

	return addr;
}
1271
EXPORT_SYMBOL(inet_confirm_addr);
L
Linus Torvalds 已提交
1272 1273 1274 1275 1276 1277 1278

/*
 *	Device notifier
 */

int register_inetaddr_notifier(struct notifier_block *nb)
{
1279
	return blocking_notifier_chain_register(&inetaddr_chain, nb);
L
Linus Torvalds 已提交
1280
}
E
Eric Dumazet 已提交
1281
EXPORT_SYMBOL(register_inetaddr_notifier);
L
Linus Torvalds 已提交
1282 1283 1284

int unregister_inetaddr_notifier(struct notifier_block *nb)
{
1285
	return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
L
Linus Torvalds 已提交
1286
}
E
Eric Dumazet 已提交
1287
EXPORT_SYMBOL(unregister_inetaddr_notifier);
L
Linus Torvalds 已提交
1288

E
Eric Dumazet 已提交
1289 1290
/* Rename ifa_labels for a device name change. Make some effort to preserve
 * existing alias numbering and to create unique labels if possible.
L
Linus Torvalds 已提交
1291 1292
*/
static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1293
{
L
Linus Torvalds 已提交
1294 1295 1296
	struct in_ifaddr *ifa;
	int named = 0;

1297 1298
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
		char old[IFNAMSIZ], *dot;
L
Linus Torvalds 已提交
1299 1300

		memcpy(old, ifa->ifa_label, IFNAMSIZ);
1301
		memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
L
Linus Torvalds 已提交
1302
		if (named++ == 0)
1303
			goto skip;
1304
		dot = strchr(old, ':');
1305 1306
		if (dot == NULL) {
			sprintf(old, ":%d", named);
L
Linus Torvalds 已提交
1307 1308
			dot = old;
		}
E
Eric Dumazet 已提交
1309
		if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1310
			strcat(ifa->ifa_label, dot);
E
Eric Dumazet 已提交
1311
		else
1312
			strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1313 1314
skip:
		rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1315 1316
	}
}
L
Linus Torvalds 已提交
1317

E
Eric Dumazet 已提交
1318
static bool inetdev_valid_mtu(unsigned int mtu)
B
Breno Leitao 已提交
1319 1320 1321 1322
{
	return mtu >= 68;
}

1323 1324 1325 1326
static void inetdev_send_gratuitous_arp(struct net_device *dev,
					struct in_device *in_dev)

{
1327
	struct in_ifaddr *ifa;
1328

1329 1330 1331 1332 1333 1334 1335
	for (ifa = in_dev->ifa_list; ifa;
	     ifa = ifa->ifa_next) {
		arp_send(ARPOP_REQUEST, ETH_P_ARP,
			 ifa->ifa_local, dev,
			 ifa->ifa_local, NULL,
			 dev->dev_addr, NULL);
	}
1336 1337
}

L
Linus Torvalds 已提交
1338 1339 1340 1341 1342
/* Called only under RTNL semaphore */

static int inetdev_event(struct notifier_block *this, unsigned long event,
			 void *ptr)
{
1343
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1344
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
1345

L
Linus Torvalds 已提交
1346 1347 1348
	ASSERT_RTNL();

	if (!in_dev) {
1349
		if (event == NETDEV_REGISTER) {
L
Linus Torvalds 已提交
1350
			in_dev = inetdev_init(dev);
1351 1352
			if (!in_dev)
				return notifier_from_errno(-ENOMEM);
1353
			if (dev->flags & IFF_LOOPBACK) {
1354 1355
				IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
				IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1356
			}
B
Breno Leitao 已提交
1357 1358 1359 1360
		} else if (event == NETDEV_CHANGEMTU) {
			/* Re-enabling IP */
			if (inetdev_valid_mtu(dev->mtu))
				in_dev = inetdev_init(dev);
L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366
		}
		goto out;
	}

	switch (event) {
	case NETDEV_REGISTER:
1367
		pr_debug("%s: bug\n", __func__);
1368
		RCU_INIT_POINTER(dev->ip_ptr, NULL);
L
Linus Torvalds 已提交
1369 1370
		break;
	case NETDEV_UP:
B
Breno Leitao 已提交
1371
		if (!inetdev_valid_mtu(dev->mtu))
L
Linus Torvalds 已提交
1372
			break;
1373
		if (dev->flags & IFF_LOOPBACK) {
E
Eric Dumazet 已提交
1374 1375 1376
			struct in_ifaddr *ifa = inet_alloc_ifa();

			if (ifa) {
1377
				INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
1378 1379 1380 1381 1382 1383 1384 1385
				ifa->ifa_local =
				  ifa->ifa_address = htonl(INADDR_LOOPBACK);
				ifa->ifa_prefixlen = 8;
				ifa->ifa_mask = inet_make_mask(8);
				in_dev_hold(in_dev);
				ifa->ifa_dev = in_dev;
				ifa->ifa_scope = RT_SCOPE_HOST;
				memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
J
Jiri Pirko 已提交
1386 1387
				set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
						 INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
1388 1389 1390 1391
				inet_insert_ifa(ifa);
			}
		}
		ip_mc_up(in_dev);
1392 1393
		/* fall through */
	case NETDEV_CHANGEADDR:
1394 1395 1396 1397
		if (!IN_DEV_ARP_NOTIFY(in_dev))
			break;
		/* fall through */
	case NETDEV_NOTIFY_PEERS:
1398
		/* Send gratuitous ARP to notify of link change */
1399
		inetdev_send_gratuitous_arp(dev, in_dev);
L
Linus Torvalds 已提交
1400 1401 1402 1403
		break;
	case NETDEV_DOWN:
		ip_mc_down(in_dev);
		break;
1404
	case NETDEV_PRE_TYPE_CHANGE:
1405 1406
		ip_mc_unmap(in_dev);
		break;
1407
	case NETDEV_POST_TYPE_CHANGE:
1408 1409
		ip_mc_remap(in_dev);
		break;
L
Linus Torvalds 已提交
1410
	case NETDEV_CHANGEMTU:
B
Breno Leitao 已提交
1411
		if (inetdev_valid_mtu(dev->mtu))
L
Linus Torvalds 已提交
1412
			break;
B
Breno Leitao 已提交
1413
		/* disable IP when MTU is not enough */
L
Linus Torvalds 已提交
1414 1415 1416 1417 1418 1419 1420 1421 1422
	case NETDEV_UNREGISTER:
		inetdev_destroy(in_dev);
		break;
	case NETDEV_CHANGENAME:
		/* Do not notify about label change, this event is
		 * not interesting to applications using netlink.
		 */
		inetdev_changename(dev, in_dev);

1423
		devinet_sysctl_unregister(in_dev);
1424
		devinet_sysctl_register(in_dev);
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430 1431
		break;
	}
out:
	return NOTIFY_DONE;
}

static struct notifier_block ip_netdev_notifier = {
J
Jianjun Kong 已提交
1432
	.notifier_call = inetdev_event,
L
Linus Torvalds 已提交
1433 1434
};

E
Eric Dumazet 已提交
1435
static size_t inet_nlmsg_size(void)
1436 1437 1438 1439 1440
{
	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
	       + nla_total_size(4) /* IFA_ADDRESS */
	       + nla_total_size(4) /* IFA_LOCAL */
	       + nla_total_size(4) /* IFA_BROADCAST */
1441 1442
	       + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
	       + nla_total_size(4);  /* IFA_FLAGS */
1443 1444
}

J
Jiri Pirko 已提交
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
static inline u32 cstamp_delta(unsigned long cstamp)
{
	return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
}

static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
			 unsigned long tstamp, u32 preferred, u32 valid)
{
	struct ifa_cacheinfo ci;

	ci.cstamp = cstamp_delta(cstamp);
	ci.tstamp = cstamp_delta(tstamp);
	ci.ifa_prefered = preferred;
	ci.ifa_valid = valid;

	return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
}

L
Linus Torvalds 已提交
1463
static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1464
			    u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
1465 1466 1467
{
	struct ifaddrmsg *ifm;
	struct nlmsghdr  *nlh;
J
Jiri Pirko 已提交
1468
	u32 preferred, valid;
L
Linus Torvalds 已提交
1469

1470
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1471
	if (nlh == NULL)
1472
		return -EMSGSIZE;
1473 1474

	ifm = nlmsg_data(nlh);
L
Linus Torvalds 已提交
1475 1476
	ifm->ifa_family = AF_INET;
	ifm->ifa_prefixlen = ifa->ifa_prefixlen;
J
Jiri Pirko 已提交
1477
	ifm->ifa_flags = ifa->ifa_flags;
L
Linus Torvalds 已提交
1478 1479
	ifm->ifa_scope = ifa->ifa_scope;
	ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1480

J
Jiri Pirko 已提交
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
	if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
		preferred = ifa->ifa_preferred_lft;
		valid = ifa->ifa_valid_lft;
		if (preferred != INFINITY_LIFE_TIME) {
			long tval = (jiffies - ifa->ifa_tstamp) / HZ;

			if (preferred > tval)
				preferred -= tval;
			else
				preferred = 0;
			if (valid != INFINITY_LIFE_TIME) {
				if (valid > tval)
					valid -= tval;
				else
					valid = 0;
			}
		}
	} else {
		preferred = INFINITY_LIFE_TIME;
		valid = INFINITY_LIFE_TIME;
	}
D
David S. Miller 已提交
1502 1503 1504 1505 1506 1507 1508
	if ((ifa->ifa_address &&
	     nla_put_be32(skb, IFA_ADDRESS, ifa->ifa_address)) ||
	    (ifa->ifa_local &&
	     nla_put_be32(skb, IFA_LOCAL, ifa->ifa_local)) ||
	    (ifa->ifa_broadcast &&
	     nla_put_be32(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
	    (ifa->ifa_label[0] &&
J
Jiri Pirko 已提交
1509
	     nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1510
	    nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
J
Jiri Pirko 已提交
1511 1512
	    put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
			  preferred, valid))
D
David S. Miller 已提交
1513
		goto nla_put_failure;
L
Linus Torvalds 已提交
1514

1515 1516 1517
	return nlmsg_end(skb, nlh);

nla_put_failure:
1518 1519
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
1520 1521 1522 1523
}

static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
1524
	struct net *net = sock_net(skb->sk);
E
Eric Dumazet 已提交
1525 1526 1527
	int h, s_h;
	int idx, s_idx;
	int ip_idx, s_ip_idx;
L
Linus Torvalds 已提交
1528 1529 1530
	struct net_device *dev;
	struct in_device *in_dev;
	struct in_ifaddr *ifa;
E
Eric Dumazet 已提交
1531
	struct hlist_head *head;
L
Linus Torvalds 已提交
1532

E
Eric Dumazet 已提交
1533 1534 1535 1536 1537 1538 1539 1540
	s_h = cb->args[0];
	s_idx = idx = cb->args[1];
	s_ip_idx = ip_idx = cb->args[2];

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
		rcu_read_lock();
1541 1542
		cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
			  net->dev_base_seq;
1543
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
1544 1545
			if (idx < s_idx)
				goto cont;
1546
			if (h > s_h || idx > s_idx)
E
Eric Dumazet 已提交
1547 1548 1549 1550
				s_ip_idx = 0;
			in_dev = __in_dev_get_rcu(dev);
			if (!in_dev)
				goto cont;
L
Linus Torvalds 已提交
1551

E
Eric Dumazet 已提交
1552 1553 1554 1555 1556
			for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
			     ifa = ifa->ifa_next, ip_idx++) {
				if (ip_idx < s_ip_idx)
					continue;
				if (inet_fill_ifaddr(skb, ifa,
1557
					     NETLINK_CB(cb->skb).portid,
L
Linus Torvalds 已提交
1558
					     cb->nlh->nlmsg_seq,
E
Eric Dumazet 已提交
1559 1560 1561 1562
					     RTM_NEWADDR, NLM_F_MULTI) <= 0) {
					rcu_read_unlock();
					goto done;
				}
1563
				nl_dump_check_consistent(cb, nlmsg_hdr(skb));
E
Eric Dumazet 已提交
1564
			}
1565
cont:
E
Eric Dumazet 已提交
1566 1567 1568
			idx++;
		}
		rcu_read_unlock();
L
Linus Torvalds 已提交
1569 1570 1571
	}

done:
E
Eric Dumazet 已提交
1572 1573 1574
	cb->args[0] = h;
	cb->args[1] = idx;
	cb->args[2] = ip_idx;
L
Linus Torvalds 已提交
1575 1576 1577 1578

	return skb->len;
}

J
Jianjun Kong 已提交
1579
static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1580
		      u32 portid)
L
Linus Torvalds 已提交
1581
{
1582
	struct sk_buff *skb;
1583 1584
	u32 seq = nlh ? nlh->nlmsg_seq : 0;
	int err = -ENOBUFS;
1585
	struct net *net;
L
Linus Torvalds 已提交
1586

1587
	net = dev_net(ifa->ifa_dev->dev);
1588
	skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1589
	if (skb == NULL)
1590 1591
		goto errout;

1592
	err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1593 1594 1595 1596 1597 1598
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
1599
	rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1600
	return;
1601 1602
errout:
	if (err < 0)
1603
		rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
L
Linus Torvalds 已提交
1604 1605
}

T
Thomas Graf 已提交
1606 1607
static size_t inet_get_link_af_size(const struct net_device *dev)
{
E
Eric Dumazet 已提交
1608
	struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
T
Thomas Graf 已提交
1609 1610 1611 1612 1613 1614 1615 1616 1617

	if (!in_dev)
		return 0;

	return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
}

static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
{
E
Eric Dumazet 已提交
1618
	struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
T
Thomas Graf 已提交
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
	struct nlattr *nla;
	int i;

	if (!in_dev)
		return -ENODATA;

	nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
	if (nla == NULL)
		return -EMSGSIZE;

	for (i = 0; i < IPV4_DEVCONF_MAX; i++)
		((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];

	return 0;
}

static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
	[IFLA_INET_CONF]	= { .type = NLA_NESTED },
};

1639 1640
static int inet_validate_link_af(const struct net_device *dev,
				 const struct nlattr *nla)
T
Thomas Graf 已提交
1641 1642 1643 1644
{
	struct nlattr *a, *tb[IFLA_INET_MAX+1];
	int err, rem;

1645
	if (dev && !__in_dev_get_rtnl(dev))
1646
		return -EAFNOSUPPORT;
T
Thomas Graf 已提交
1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663

	err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
	if (err < 0)
		return err;

	if (tb[IFLA_INET_CONF]) {
		nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
			int cfgid = nla_type(a);

			if (nla_len(a) < 4)
				return -EINVAL;

			if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
				return -EINVAL;
		}
	}

1664 1665 1666 1667 1668
	return 0;
}

static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
{
1669
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
1670 1671 1672 1673 1674 1675 1676 1677 1678
	struct nlattr *a, *tb[IFLA_INET_MAX+1];
	int rem;

	if (!in_dev)
		return -EAFNOSUPPORT;

	if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
		BUG();

T
Thomas Graf 已提交
1679 1680 1681 1682 1683 1684 1685 1686
	if (tb[IFLA_INET_CONF]) {
		nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
			ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
	}

	return 0;
}

1687 1688 1689 1690 1691
static int inet_netconf_msgsize_devconf(int type)
{
	int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
		   + nla_total_size(4);	/* NETCONFA_IFINDEX */

1692 1693
	/* type -1 is used for ALL */
	if (type == -1 || type == NETCONFA_FORWARDING)
1694
		size += nla_total_size(4);
1695 1696
	if (type == -1 || type == NETCONFA_RP_FILTER)
		size += nla_total_size(4);
1697 1698
	if (type == -1 || type == NETCONFA_MC_FORWARDING)
		size += nla_total_size(4);
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721

	return size;
}

static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
				     struct ipv4_devconf *devconf, u32 portid,
				     u32 seq, int event, unsigned int flags,
				     int type)
{
	struct nlmsghdr  *nlh;
	struct netconfmsg *ncm;

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
			flags);
	if (nlh == NULL)
		return -EMSGSIZE;

	ncm = nlmsg_data(nlh);
	ncm->ncm_family = AF_INET;

	if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
		goto nla_put_failure;

1722 1723
	/* type -1 is used for ALL */
	if ((type == -1 || type == NETCONFA_FORWARDING) &&
1724 1725 1726
	    nla_put_s32(skb, NETCONFA_FORWARDING,
			IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
		goto nla_put_failure;
1727 1728 1729 1730
	if ((type == -1 || type == NETCONFA_RP_FILTER) &&
	    nla_put_s32(skb, NETCONFA_RP_FILTER,
			IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
		goto nla_put_failure;
1731 1732 1733 1734
	if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
			IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
		goto nla_put_failure;
1735 1736 1737 1738 1739 1740 1741 1742

	return nlmsg_end(skb, nlh);

nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
}

1743 1744
void inet_netconf_notify_devconf(struct net *net, int type, int ifindex,
				 struct ipv4_devconf *devconf)
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
{
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_ATOMIC);
	if (skb == NULL)
		goto errout;

	err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
					RTM_NEWNETCONF, 0, type);
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_ATOMIC);
	return;
errout:
	if (err < 0)
		rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
}

1768 1769 1770
static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
1771
	[NETCONFA_RP_FILTER]	= { .len = sizeof(int) },
1772 1773 1774
};

static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1775
				    struct nlmsghdr *nlh)
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
{
	struct net *net = sock_net(in_skb->sk);
	struct nlattr *tb[NETCONFA_MAX+1];
	struct netconfmsg *ncm;
	struct sk_buff *skb;
	struct ipv4_devconf *devconf;
	struct in_device *in_dev;
	struct net_device *dev;
	int ifindex;
	int err;

	err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
			  devconf_ipv4_policy);
	if (err < 0)
		goto errout;

	err = EINVAL;
	if (!tb[NETCONFA_IFINDEX])
		goto errout;

	ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
	switch (ifindex) {
	case NETCONFA_IFINDEX_ALL:
		devconf = net->ipv4.devconf_all;
		break;
	case NETCONFA_IFINDEX_DEFAULT:
		devconf = net->ipv4.devconf_dflt;
		break;
	default:
		dev = __dev_get_by_index(net, ifindex);
		if (dev == NULL)
			goto errout;
		in_dev = __in_dev_get_rtnl(dev);
		if (in_dev == NULL)
			goto errout;
		devconf = &in_dev->cnf;
		break;
	}

	err = -ENOBUFS;
	skb = nlmsg_new(inet_netconf_msgsize_devconf(-1), GFP_ATOMIC);
	if (skb == NULL)
		goto errout;

	err = inet_netconf_fill_devconf(skb, ifindex, devconf,
					NETLINK_CB(in_skb).portid,
					nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
					-1);
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
errout:
	return err;
}

1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
static int inet_netconf_dump_devconf(struct sk_buff *skb,
				     struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	int h, s_h;
	int idx, s_idx;
	struct net_device *dev;
	struct in_device *in_dev;
	struct hlist_head *head;

	s_h = cb->args[0];
	s_idx = idx = cb->args[1];

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
		rcu_read_lock();
1852 1853
		cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
			  net->dev_base_seq;
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
			if (idx < s_idx)
				goto cont;
			in_dev = __in_dev_get_rcu(dev);
			if (!in_dev)
				goto cont;

			if (inet_netconf_fill_devconf(skb, dev->ifindex,
						      &in_dev->cnf,
						      NETLINK_CB(cb->skb).portid,
						      cb->nlh->nlmsg_seq,
						      RTM_NEWNETCONF,
						      NLM_F_MULTI,
						      -1) <= 0) {
				rcu_read_unlock();
				goto done;
			}
1871
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
cont:
			idx++;
		}
		rcu_read_unlock();
	}
	if (h == NETDEV_HASHENTRIES) {
		if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
					      net->ipv4.devconf_all,
					      NETLINK_CB(cb->skb).portid,
					      cb->nlh->nlmsg_seq,
					      RTM_NEWNETCONF, NLM_F_MULTI,
					      -1) <= 0)
			goto done;
		else
			h++;
	}
	if (h == NETDEV_HASHENTRIES + 1) {
		if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
					      net->ipv4.devconf_dflt,
					      NETLINK_CB(cb->skb).portid,
					      cb->nlh->nlmsg_seq,
					      RTM_NEWNETCONF, NLM_F_MULTI,
					      -1) <= 0)
			goto done;
		else
			h++;
	}
done:
	cb->args[0] = h;
	cb->args[1] = idx;

	return skb->len;
}

L
Linus Torvalds 已提交
1906 1907
#ifdef CONFIG_SYSCTL

1908
static void devinet_copy_dflt_conf(struct net *net, int i)
1909 1910 1911
{
	struct net_device *dev;

1912 1913
	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
1914
		struct in_device *in_dev;
1915

1916 1917
		in_dev = __in_dev_get_rcu(dev);
		if (in_dev && !test_bit(i, in_dev->cnf.state))
1918
			in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1919
	}
1920
	rcu_read_unlock();
1921 1922
}

1923
/* called with RTNL locked */
1924
static void inet_forward_change(struct net *net)
1925 1926
{
	struct net_device *dev;
1927
	int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1928

1929
	IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1930
	IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1931 1932 1933 1934 1935 1936
	inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
				    NETCONFA_IFINDEX_ALL,
				    net->ipv4.devconf_all);
	inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
				    NETCONFA_IFINDEX_DEFAULT,
				    net->ipv4.devconf_dflt);
1937

1938
	for_each_netdev(net, dev) {
1939
		struct in_device *in_dev;
1940 1941
		if (on)
			dev_disable_lro(dev);
1942 1943
		rcu_read_lock();
		in_dev = __in_dev_get_rcu(dev);
1944
		if (in_dev) {
1945
			IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1946 1947 1948
			inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
						    dev->ifindex, &in_dev->cnf);
		}
1949 1950 1951 1952
		rcu_read_unlock();
	}
}

1953
static int devinet_conf_proc(struct ctl_table *ctl, int write,
1954
			     void __user *buffer,
1955 1956
			     size_t *lenp, loff_t *ppos)
{
1957
	int old_value = *(int *)ctl->data;
1958
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1959
	int new_value = *(int *)ctl->data;
1960 1961 1962

	if (write) {
		struct ipv4_devconf *cnf = ctl->extra1;
1963
		struct net *net = ctl->extra2;
1964 1965 1966 1967
		int i = (int *)ctl->data - cnf->data;

		set_bit(i, cnf->state);

1968
		if (cnf == net->ipv4.devconf_dflt)
1969
			devinet_copy_dflt_conf(net, i);
1970 1971
		if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
		    i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
1972
			if ((new_value == 0) && (old_value != 0))
1973
				rt_cache_flush(net);
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
		if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
		    new_value != old_value) {
			int ifindex;

			if (cnf == net->ipv4.devconf_dflt)
				ifindex = NETCONFA_IFINDEX_DEFAULT;
			else if (cnf == net->ipv4.devconf_all)
				ifindex = NETCONFA_IFINDEX_ALL;
			else {
				struct in_device *idev =
					container_of(cnf, struct in_device,
						     cnf);
				ifindex = idev->dev->ifindex;
			}
			inet_netconf_notify_devconf(net, NETCONFA_RP_FILTER,
						    ifindex, cnf);
		}
1991 1992 1993 1994 1995
	}

	return ret;
}

1996
static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
1997
				  void __user *buffer,
L
Linus Torvalds 已提交
1998 1999 2000 2001
				  size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
2002
	loff_t pos = *ppos;
2003
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
L
Linus Torvalds 已提交
2004 2005

	if (write && *valp != val) {
2006 2007
		struct net *net = ctl->extra2;

2008
		if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
E
Eric W. Biederman 已提交
2009 2010 2011 2012
			if (!rtnl_trylock()) {
				/* Restore the original values before restarting */
				*valp = val;
				*ppos = pos;
2013
				return restart_syscall();
E
Eric W. Biederman 已提交
2014
			}
2015 2016
			if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
				inet_forward_change(net);
2017
			} else {
2018 2019 2020
				struct ipv4_devconf *cnf = ctl->extra1;
				struct in_device *idev =
					container_of(cnf, struct in_device, cnf);
2021 2022 2023 2024 2025 2026
				if (*valp)
					dev_disable_lro(idev->dev);
				inet_netconf_notify_devconf(net,
							    NETCONFA_FORWARDING,
							    idev->dev->ifindex,
							    cnf);
2027 2028
			}
			rtnl_unlock();
2029
			rt_cache_flush(net);
2030 2031 2032 2033
		} else
			inet_netconf_notify_devconf(net, NETCONFA_FORWARDING,
						    NETCONFA_IFINDEX_DEFAULT,
						    net->ipv4.devconf_dflt);
L
Linus Torvalds 已提交
2034 2035 2036 2037 2038
	}

	return ret;
}

2039
static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2040 2041
				void __user *buffer,
				size_t *lenp, loff_t *ppos)
L
Linus Torvalds 已提交
2042 2043 2044
{
	int *valp = ctl->data;
	int val = *valp;
2045
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2046
	struct net *net = ctl->extra2;
L
Linus Torvalds 已提交
2047 2048

	if (write && *valp != val)
2049
		rt_cache_flush(net);
L
Linus Torvalds 已提交
2050 2051 2052 2053

	return ret;
}

2054
#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2055 2056 2057
	{ \
		.procname	= name, \
		.data		= ipv4_devconf.data + \
2058
				  IPV4_DEVCONF_ ## attr - 1, \
2059 2060 2061
		.maxlen		= sizeof(int), \
		.mode		= mval, \
		.proc_handler	= proc, \
2062
		.extra1		= &ipv4_devconf, \
2063 2064 2065
	}

#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2066
	DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2067 2068

#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2069
	DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2070

2071 2072
#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
	DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2073 2074

#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2075
	DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2076

L
Linus Torvalds 已提交
2077 2078
static struct devinet_sysctl_table {
	struct ctl_table_header *sysctl_header;
2079
	struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
L
Linus Torvalds 已提交
2080 2081
} devinet_sysctl = {
	.devinet_vars = {
2082
		DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2083
					     devinet_sysctl_forward),
2084 2085 2086 2087 2088 2089 2090 2091 2092
		DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),

		DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
		DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
		DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
		DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
		DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
		DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
					"accept_source_route"),
2093
		DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2094
		DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2095 2096 2097 2098 2099 2100 2101 2102 2103
		DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
		DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
		DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
		DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
		DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
		DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
		DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
		DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
		DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
2104
		DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2105
		DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2106 2107
		DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
					"force_igmp_version"),
2108 2109 2110 2111
		DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
					"igmpv2_unsolicited_report_interval"),
		DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
					"igmpv3_unsolicited_report_interval"),
2112 2113 2114 2115 2116

		DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
		DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
		DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
					      "promote_secondaries"),
2117 2118
		DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
					      "route_localnet"),
L
Linus Torvalds 已提交
2119 2120 2121
	},
};

2122
static int __devinet_sysctl_register(struct net *net, char *dev_name,
2123
					struct ipv4_devconf *p)
L
Linus Torvalds 已提交
2124 2125
{
	int i;
2126
	struct devinet_sysctl_table *t;
2127
	char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2128

2129
	t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
L
Linus Torvalds 已提交
2130
	if (!t)
2131 2132
		goto out;

L
Linus Torvalds 已提交
2133 2134
	for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
		t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2135
		t->devinet_vars[i].extra1 = p;
2136
		t->devinet_vars[i].extra2 = net;
L
Linus Torvalds 已提交
2137 2138
	}

2139
	snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
L
Linus Torvalds 已提交
2140

2141
	t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
L
Linus Torvalds 已提交
2142
	if (!t->sysctl_header)
2143
		goto free;
L
Linus Torvalds 已提交
2144 2145

	p->sysctl = t;
2146
	return 0;
L
Linus Torvalds 已提交
2147

2148
free:
L
Linus Torvalds 已提交
2149
	kfree(t);
2150
out:
2151
	return -ENOBUFS;
L
Linus Torvalds 已提交
2152 2153
}

2154 2155 2156 2157 2158 2159 2160 2161
static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
{
	struct devinet_sysctl_table *t = cnf->sysctl;

	if (t == NULL)
		return;

	cnf->sysctl = NULL;
2162
	unregister_net_sysctl_table(t->sysctl_header);
2163 2164 2165
	kfree(t);
}

2166 2167
static void devinet_sysctl_register(struct in_device *idev)
{
2168
	neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
2169
	__devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2170
					&idev->cnf);
2171 2172
}

2173
static void devinet_sysctl_unregister(struct in_device *idev)
L
Linus Torvalds 已提交
2174
{
2175 2176
	__devinet_sysctl_unregister(&idev->cnf);
	neigh_sysctl_unregister(idev->arp_parms);
L
Linus Torvalds 已提交
2177 2178
}

2179 2180 2181 2182
static struct ctl_table ctl_forward_entry[] = {
	{
		.procname	= "ip_forward",
		.data		= &ipv4_devconf.data[
2183
					IPV4_DEVCONF_FORWARDING - 1],
2184 2185 2186 2187
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= devinet_sysctl_forward,
		.extra1		= &ipv4_devconf,
2188
		.extra2		= &init_net,
2189 2190 2191
	},
	{ },
};
2192
#endif
2193

2194 2195 2196 2197
static __net_init int devinet_init_net(struct net *net)
{
	int err;
	struct ipv4_devconf *all, *dflt;
2198 2199
#ifdef CONFIG_SYSCTL
	struct ctl_table *tbl = ctl_forward_entry;
2200
	struct ctl_table_header *forw_hdr;
2201
#endif
2202 2203 2204 2205 2206

	err = -ENOMEM;
	all = &ipv4_devconf;
	dflt = &ipv4_devconf_dflt;

O
Octavian Purdila 已提交
2207
	if (!net_eq(net, &init_net)) {
2208 2209 2210 2211 2212 2213 2214 2215
		all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
		if (all == NULL)
			goto err_alloc_all;

		dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
		if (dflt == NULL)
			goto err_alloc_dflt;

2216
#ifdef CONFIG_SYSCTL
2217 2218 2219 2220
		tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
		if (tbl == NULL)
			goto err_alloc_ctl;

2221
		tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2222 2223
		tbl[0].extra1 = all;
		tbl[0].extra2 = net;
2224
#endif
2225 2226 2227
	}

#ifdef CONFIG_SYSCTL
2228
	err = __devinet_sysctl_register(net, "all", all);
2229 2230 2231
	if (err < 0)
		goto err_reg_all;

2232
	err = __devinet_sysctl_register(net, "default", dflt);
2233 2234 2235 2236
	if (err < 0)
		goto err_reg_dflt;

	err = -ENOMEM;
2237
	forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2238 2239
	if (forw_hdr == NULL)
		goto err_reg_ctl;
2240
	net->ipv4.forw_hdr = forw_hdr;
2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255
#endif

	net->ipv4.devconf_all = all;
	net->ipv4.devconf_dflt = dflt;
	return 0;

#ifdef CONFIG_SYSCTL
err_reg_ctl:
	__devinet_sysctl_unregister(dflt);
err_reg_dflt:
	__devinet_sysctl_unregister(all);
err_reg_all:
	if (tbl != ctl_forward_entry)
		kfree(tbl);
err_alloc_ctl:
2256
#endif
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
	if (dflt != &ipv4_devconf_dflt)
		kfree(dflt);
err_alloc_dflt:
	if (all != &ipv4_devconf)
		kfree(all);
err_alloc_all:
	return err;
}

static __net_exit void devinet_exit_net(struct net *net)
{
2268
#ifdef CONFIG_SYSCTL
2269 2270 2271 2272 2273 2274 2275
	struct ctl_table *tbl;

	tbl = net->ipv4.forw_hdr->ctl_table_arg;
	unregister_net_sysctl_table(net->ipv4.forw_hdr);
	__devinet_sysctl_unregister(net->ipv4.devconf_dflt);
	__devinet_sysctl_unregister(net->ipv4.devconf_all);
	kfree(tbl);
2276
#endif
2277 2278 2279 2280 2281 2282 2283 2284 2285
	kfree(net->ipv4.devconf_dflt);
	kfree(net->ipv4.devconf_all);
}

static __net_initdata struct pernet_operations devinet_ops = {
	.init = devinet_init_net,
	.exit = devinet_exit_net,
};

T
Thomas Graf 已提交
2286 2287 2288 2289
static struct rtnl_af_ops inet_af_ops = {
	.family		  = AF_INET,
	.fill_link_af	  = inet_fill_link_af,
	.get_link_af_size = inet_get_link_af_size,
2290 2291
	.validate_link_af = inet_validate_link_af,
	.set_link_af	  = inet_set_link_af,
T
Thomas Graf 已提交
2292 2293
};

L
Linus Torvalds 已提交
2294 2295
void __init devinet_init(void)
{
2296 2297 2298 2299 2300
	int i;

	for (i = 0; i < IN4_ADDR_HSIZE; i++)
		INIT_HLIST_HEAD(&inet_addr_lst[i]);

2301 2302
	register_pernet_subsys(&devinet_ops);

L
Linus Torvalds 已提交
2303 2304
	register_gifconf(PF_INET, inet_gifconf);
	register_netdevice_notifier(&ip_netdev_notifier);
2305

J
Jiri Pirko 已提交
2306 2307
	schedule_delayed_work(&check_lifetime_work, 0);

T
Thomas Graf 已提交
2308 2309
	rtnl_af_register(&inet_af_ops);

2310 2311 2312
	rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
	rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
	rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
2313
	rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2314
		      inet_netconf_dump_devconf, NULL);
L
Linus Torvalds 已提交
2315 2316
}