devinet.c 62.1 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
 *				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.
 */


29
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
30
#include <linux/bitops.h>
31
#include <linux/capability.h>
L
Linus Torvalds 已提交
32 33 34
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
35
#include <linux/sched/signal.h>
L
Linus Torvalds 已提交
36 37 38 39 40 41 42
#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>
43
#include <linux/if_addr.h>
L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51 52
#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>
53
#include <linux/slab.h>
54
#include <linux/hash.h>
L
Linus Torvalds 已提交
55 56 57 58
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif
#include <linux/kmod.h>
59
#include <linux/netconf.h>
L
Linus Torvalds 已提交
60

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

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

static struct ipv4_devconf ipv4_devconf_dflt = {
81
	.data = {
82 83 84 85 86
		[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,
87 88
		[IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
		[IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] =  1000 /*ms*/,
89
	},
L
Linus Torvalds 已提交
90 91
};

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

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

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

107 108
static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];

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

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

static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
{
E
Eric Dumazet 已提交
118
	u32 hash = inet_addr_hash(net, ifa->ifa_local);
119

120
	ASSERT_RTNL();
121 122 123 124 125
	hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
}

static void inet_hash_remove(struct in_ifaddr *ifa)
{
126
	ASSERT_RTNL();
127 128 129
	hlist_del_init_rcu(&ifa->hash);
}

130 131 132 133 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)
{
	struct net_device *result = NULL;
	struct in_ifaddr *ifa;

	rcu_read_lock();
144 145
	ifa = inet_lookup_ifaddr_rcu(net, addr);
	if (!ifa) {
146 147 148 149 150 151 152 153 154 155 156 157
		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);
158 159
	} else {
		result = ifa->ifa_dev->dev;
160
	}
161 162 163 164 165 166 167
	if (result && devref)
		dev_hold(result);
	rcu_read_unlock();
	return result;
}
EXPORT_SYMBOL(__ip_dev_find);

168 169 170 171 172 173 174 175 176 177 178 179 180 181
/* called under RCU lock */
struct in_ifaddr *inet_lookup_ifaddr_rcu(struct net *net, __be32 addr)
{
	u32 hash = inet_addr_hash(net, addr);
	struct in_ifaddr *ifa;

	hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash)
		if (ifa->ifa_local == addr &&
		    net_eq(dev_net(ifa->ifa_dev->dev), net))
			return ifa;

	return NULL;
}

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

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

/* Locks all the inet devices. */

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

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 已提交
216
static void inet_free_ifa(struct in_ifaddr *ifa)
L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224
{
	call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
}

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

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

239
static struct in_device *inetdev_init(struct net_device *dev)
L
Linus Torvalds 已提交
240 241
{
	struct in_device *in_dev;
242
	int err = -ENOMEM;
L
Linus Torvalds 已提交
243 244 245

	ASSERT_RTNL();

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

263 264 265 266 267 268 269
	err = devinet_sysctl_register(in_dev);
	if (err) {
		in_dev->dead = 1;
		in_dev_put(in_dev);
		in_dev = NULL;
		goto out;
	}
L
Linus Torvalds 已提交
270 271 272
	ip_mc_init_dev(in_dev);
	if (dev->flags & IFF_UP)
		ip_mc_up(in_dev);
273

274
	/* we can receive as soon as ip_ptr is set -- do this last */
275
	rcu_assign_pointer(dev->ip_ptr, in_dev);
276
out:
277
	return in_dev ?: ERR_PTR(err);
L
Linus Torvalds 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
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);
	}

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

310
	devinet_sysctl_unregister(in_dev);
L
Linus Torvalds 已提交
311 312 313 314 315 316
	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 已提交
317
int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
L
Linus Torvalds 已提交
318 319 320 321 322 323 324 325 326 327 328 329 330 331
{
	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;
}

332
static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
333
			 int destroy, struct nlmsghdr *nlh, u32 portid)
L
Linus Torvalds 已提交
334
{
335
	struct in_ifaddr *promote = NULL;
336 337 338 339
	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 已提交
340 341 342

	ASSERT_RTNL();

343 344 345
	if (in_dev->dead)
		goto no_promotions;

346
	/* 1. Deleting primary ifaddr forces deletion all secondaries
347 348
	 * unless alias promotion is set
	 **/
L
Linus Torvalds 已提交
349 350 351 352 353

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

		while ((ifa = *ifap1) != NULL) {
354
			if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
355 356 357
			    ifa1->ifa_scope <= ifa->ifa_scope)
				last_prim = ifa;

L
Linus Torvalds 已提交
358 359 360 361
			if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
			    ifa1->ifa_mask != ifa->ifa_mask ||
			    !inet_ifa_match(ifa1->ifa_address, ifa)) {
				ifap1 = &ifa->ifa_next;
362
				prev_prom = ifa;
L
Linus Torvalds 已提交
363 364 365
				continue;
			}

366
			if (!do_promote) {
367
				inet_hash_remove(ifa);
368
				*ifap1 = ifa->ifa_next;
L
Linus Torvalds 已提交
369

370
				rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
371 372
				blocking_notifier_call_chain(&inetaddr_chain,
						NETDEV_DOWN, ifa);
373 374 375 376 377
				inet_free_ifa(ifa);
			} else {
				promote = ifa;
				break;
			}
L
Linus Torvalds 已提交
378 379 380
		}
	}

381 382 383 384 385 386 387 388 389 390 391
	/* 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);
	}

392
no_promotions:
L
Linus Torvalds 已提交
393 394 395
	/* 2. Unlink it */

	*ifap = ifa1->ifa_next;
396
	inet_hash_remove(ifa1);
L
Linus Torvalds 已提交
397 398 399 400 401 402 403 404 405 406 407

	/* 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.
	 */
408
	rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
409
	blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
L
Linus Torvalds 已提交
410

411
	if (promote) {
412
		struct in_ifaddr *next_sec = promote->ifa_next;
413 414 415 416 417 418

		if (prev_prom) {
			prev_prom->ifa_next = promote->ifa_next;
			promote->ifa_next = last_prim->ifa_next;
			last_prim->ifa_next = promote;
		}
419 420

		promote->ifa_flags &= ~IFA_F_SECONDARY;
421
		rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
422 423
		blocking_notifier_call_chain(&inetaddr_chain,
				NETDEV_UP, promote);
424
		for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
425 426 427 428 429 430 431
			if (ifa1->ifa_mask != ifa->ifa_mask ||
			    !inet_ifa_match(ifa1->ifa_address, ifa))
					continue;
			fib_add_ifaddr(ifa);
		}

	}
432
	if (destroy)
433
		inet_free_ifa(ifa1);
L
Linus Torvalds 已提交
434 435
}

436 437 438 439 440 441
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 已提交
442 443 444 445
static void check_lifetime(struct work_struct *work);

static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);

446
static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
447
			     u32 portid, struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
448 449 450
{
	struct in_device *in_dev = ifa->ifa_dev;
	struct in_ifaddr *ifa1, **ifap, **last_primary;
451 452
	struct in_validator_info ivi;
	int ret;
L
Linus Torvalds 已提交
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482

	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;
		}
	}

483 484 485 486 487 488 489 490 491
	/* Allow any devices that wish to register ifaddr validtors to weigh
	 * in now, before changes are committed.  The rntl lock is serializing
	 * access here, so the state should not change between a validator call
	 * and a final notify on commit.  This isn't invoked on promotion under
	 * the assumption that validators are checking the address itself, and
	 * not the flags.
	 */
	ivi.ivi_addr = ifa->ifa_address;
	ivi.ivi_dev = ifa->ifa_dev;
492
	ivi.extack = extack;
493 494 495 496 497 498 499 500
	ret = blocking_notifier_call_chain(&inetaddr_validator_chain,
					   NETDEV_UP, &ivi);
	ret = notifier_to_errno(ret);
	if (ret) {
		inet_free_ifa(ifa);
		return ret;
	}

L
Linus Torvalds 已提交
501
	if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
502
		prandom_seed((__force u32) ifa->ifa_local);
L
Linus Torvalds 已提交
503 504 505 506 507 508
		ifap = last_primary;
	}

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

509 510
	inet_hash_insert(dev_net(in_dev->dev), ifa);

J
Jiri Pirko 已提交
511
	cancel_delayed_work(&check_lifetime_work);
512
	queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
J
Jiri Pirko 已提交
513

L
Linus Torvalds 已提交
514 515 516
	/* Send message first, then call notifier.
	   Notifier will trigger FIB update, so that
	   listeners of netlink will know about new ifaddr */
517
	rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
518
	blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
L
Linus Torvalds 已提交
519 520 521 522

	return 0;
}

523 524
static int inet_insert_ifa(struct in_ifaddr *ifa)
{
525
	return __inet_insert_ifa(ifa, NULL, 0, NULL);
526 527
}

L
Linus Torvalds 已提交
528 529
static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
{
530
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
531 532 533 534

	ASSERT_RTNL();

	if (!in_dev) {
535 536
		inet_free_ifa(ifa);
		return -ENOBUFS;
L
Linus Torvalds 已提交
537
	}
538
	ipv4_devconf_setall(in_dev);
539
	neigh_parms_data_state_setall(in_dev->arp_parms);
L
Linus Torvalds 已提交
540
	if (ifa->ifa_dev != in_dev) {
541
		WARN_ON(ifa->ifa_dev);
L
Linus Torvalds 已提交
542 543 544
		in_dev_hold(in_dev);
		ifa->ifa_dev = in_dev;
	}
545
	if (ipv4_is_loopback(ifa->ifa_local))
L
Linus Torvalds 已提交
546 547 548 549
		ifa->ifa_scope = RT_SCOPE_HOST;
	return inet_insert_ifa(ifa);
}

550 551 552
/* Caller must hold RCU or RTNL :
 * We dont take a reference on found in_device
 */
553
struct in_device *inetdev_by_index(struct net *net, int ifindex)
L
Linus Torvalds 已提交
554 555 556
{
	struct net_device *dev;
	struct in_device *in_dev = NULL;
557 558 559

	rcu_read_lock();
	dev = dev_get_by_index_rcu(net, ifindex);
L
Linus Torvalds 已提交
560
	if (dev)
561
		in_dev = rcu_dereference_rtnl(dev->ip_ptr);
562
	rcu_read_unlock();
L
Linus Torvalds 已提交
563 564
	return in_dev;
}
E
Eric Dumazet 已提交
565
EXPORT_SYMBOL(inetdev_by_index);
L
Linus Torvalds 已提交
566 567 568

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

A
Al Viro 已提交
569 570
struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
				    __be32 mask)
L
Linus Torvalds 已提交
571 572 573 574 575 576 577 578 579 580
{
	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;
}

581 582 583 584 585 586 587 588 589 590 591 592
static int ip_mc_config(struct sock *sk, bool join, const struct in_ifaddr *ifa)
{
	struct ip_mreqn mreq = {
		.imr_multiaddr.s_addr = ifa->ifa_address,
		.imr_ifindex = ifa->ifa_dev->dev->ifindex,
	};
	int ret;

	ASSERT_RTNL();

	lock_sock(sk);
	if (join)
593
		ret = ip_mc_join_group(sk, &mreq);
594
	else
595
		ret = ip_mc_leave_group(sk, &mreq);
596 597 598 599 600
	release_sock(sk);

	return ret;
}

601 602
static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
			    struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
603
{
604
	struct net *net = sock_net(skb->sk);
605
	struct nlattr *tb[IFA_MAX+1];
L
Linus Torvalds 已提交
606
	struct in_device *in_dev;
607
	struct ifaddrmsg *ifm;
L
Linus Torvalds 已提交
608
	struct in_ifaddr *ifa, **ifap;
609
	int err = -EINVAL;
L
Linus Torvalds 已提交
610 611 612

	ASSERT_RTNL();

613
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy,
614
			  extack);
615 616 617 618
	if (err < 0)
		goto errout;

	ifm = nlmsg_data(nlh);
619
	in_dev = inetdev_by_index(net, ifm->ifa_index);
620
	if (!in_dev) {
621 622 623 624
		err = -ENODEV;
		goto errout;
	}

L
Linus Torvalds 已提交
625 626
	for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
	     ifap = &ifa->ifa_next) {
627
		if (tb[IFA_LOCAL] &&
628
		    ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
629 630 631
			continue;

		if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
L
Linus Torvalds 已提交
632
			continue;
633 634 635

		if (tb[IFA_ADDRESS] &&
		    (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
636
		    !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
637 638
			continue;

639 640
		if (ipv4_is_multicast(ifa->ifa_address))
			ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
641
		__inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
L
Linus Torvalds 已提交
642 643
		return 0;
	}
644 645 646 647

	err = -EADDRNOTAVAIL;
errout:
	return err;
L
Linus Torvalds 已提交
648 649
}

J
Jiri Pirko 已提交
650 651 652 653 654 655
#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;
656
	struct hlist_node *n;
J
Jiri Pirko 已提交
657 658 659 660 661 662
	int i;

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

	for (i = 0; i < IN4_ADDR_HSIZE; i++) {
663 664 665
		bool change_needed = false;

		rcu_read_lock();
666
		hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
J
Jiri Pirko 已提交
667 668 669 670 671 672 673 674 675 676 677
			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) {
678
				change_needed = true;
J
Jiri Pirko 已提交
679 680 681 682 683 684 685 686 687
			} 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;

688 689
				if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
					change_needed = true;
J
Jiri Pirko 已提交
690 691 692 693 694 695 696
			} else if (time_before(ifa->ifa_tstamp +
					       ifa->ifa_preferred_lft * HZ,
					       next)) {
				next = ifa->ifa_tstamp +
				       ifa->ifa_preferred_lft * HZ;
			}
		}
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
		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 已提交
732 733 734 735 736 737 738 739 740 741 742 743 744 745
	}

	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;

746 747
	queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
			next_sched - now);
J
Jiri Pirko 已提交
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
}

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 已提交
776
{
777 778 779
	struct nlattr *tb[IFA_MAX+1];
	struct in_ifaddr *ifa;
	struct ifaddrmsg *ifm;
L
Linus Torvalds 已提交
780 781
	struct net_device *dev;
	struct in_device *in_dev;
782
	int err;
L
Linus Torvalds 已提交
783

784 785
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy,
			  NULL);
786 787
	if (err < 0)
		goto errout;
L
Linus Torvalds 已提交
788

789
	ifm = nlmsg_data(nlh);
790
	err = -EINVAL;
791
	if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
792
		goto errout;
L
Linus Torvalds 已提交
793

794
	dev = __dev_get_by_index(net, ifm->ifa_index);
795
	err = -ENODEV;
796
	if (!dev)
797
		goto errout;
L
Linus Torvalds 已提交
798

799
	in_dev = __in_dev_get_rtnl(dev);
800
	err = -ENOBUFS;
801
	if (!in_dev)
802
		goto errout;
L
Linus Torvalds 已提交
803

804
	ifa = inet_alloc_ifa();
805
	if (!ifa)
806 807 808 809 810 811
		/*
		 * A potential indev allocation can be left alive, it stays
		 * assigned to its device and is destroy with it.
		 */
		goto errout;

812
	ipv4_devconf_setall(in_dev);
813
	neigh_parms_data_state_setall(in_dev->arp_parms);
814 815
	in_dev_hold(in_dev);

816
	if (!tb[IFA_ADDRESS])
817
		tb[IFA_ADDRESS] = tb[IFA_LOCAL];
L
Linus Torvalds 已提交
818

819
	INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
820 821
	ifa->ifa_prefixlen = ifm->ifa_prefixlen;
	ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
822 823
	ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
					 ifm->ifa_flags;
L
Linus Torvalds 已提交
824
	ifa->ifa_scope = ifm->ifa_scope;
825 826
	ifa->ifa_dev = in_dev;

827 828
	ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
	ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
829 830

	if (tb[IFA_BROADCAST])
831
		ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
832 833 834

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

J
Jiri Pirko 已提交
838 839 840 841 842 843
	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;
844
			goto errout_free;
J
Jiri Pirko 已提交
845 846 847 848 849
		}
		*pvalid_lft = ci->ifa_valid;
		*pprefered_lft = ci->ifa_prefered;
	}

850 851
	return ifa;

852 853
errout_free:
	inet_free_ifa(ifa);
854 855 856 857
errout:
	return ERR_PTR(err);
}

J
Jiri Pirko 已提交
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
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;
}

876 877
static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
			    struct netlink_ext_ack *extack)
878
{
879
	struct net *net = sock_net(skb->sk);
880
	struct in_ifaddr *ifa;
J
Jiri Pirko 已提交
881 882 883
	struct in_ifaddr *ifa_existing;
	__u32 valid_lft = INFINITY_LIFE_TIME;
	__u32 prefered_lft = INFINITY_LIFE_TIME;
884 885 886

	ASSERT_RTNL();

J
Jiri Pirko 已提交
887
	ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft);
888 889 890
	if (IS_ERR(ifa))
		return PTR_ERR(ifa);

J
Jiri Pirko 已提交
891 892 893
	ifa_existing = find_matching_ifa(ifa);
	if (!ifa_existing) {
		/* It would be best to check for !NLM_F_CREATE here but
S
stephen hemminger 已提交
894
		 * userspace already relies on not having to provide this.
J
Jiri Pirko 已提交
895 896
		 */
		set_ifa_lifetime(ifa, valid_lft, prefered_lft);
897 898 899 900 901 902 903 904 905
		if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
			int ret = ip_mc_config(net->ipv4.mc_autojoin_sk,
					       true, ifa);

			if (ret < 0) {
				inet_free_ifa(ifa);
				return ret;
			}
		}
906 907
		return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid,
					 extack);
J
Jiri Pirko 已提交
908 909 910 911 912 913
	} else {
		inet_free_ifa(ifa);

		if (nlh->nlmsg_flags & NLM_F_EXCL ||
		    !(nlh->nlmsg_flags & NLM_F_REPLACE))
			return -EEXIST;
914 915
		ifa = ifa_existing;
		set_ifa_lifetime(ifa, valid_lft, prefered_lft);
916
		cancel_delayed_work(&check_lifetime_work);
917 918
		queue_delayed_work(system_power_efficient_wq,
				&check_lifetime_work, 0);
919
		rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
J
Jiri Pirko 已提交
920 921
	}
	return 0;
L
Linus Torvalds 已提交
922 923 924 925 926 927
}

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

E
Eric Dumazet 已提交
928
static int inet_abc_len(__be32 addr)
L
Linus Torvalds 已提交
929 930 931
{
	int rc = -1;	/* Something else, probably a multicast. */

932
	if (ipv4_is_zeronet(addr))
933
		rc = 0;
L
Linus Torvalds 已提交
934
	else {
935
		__u32 haddr = ntohl(addr);
L
Linus Torvalds 已提交
936

937
		if (IN_CLASSA(haddr))
L
Linus Torvalds 已提交
938
			rc = 8;
939
		else if (IN_CLASSB(haddr))
L
Linus Torvalds 已提交
940
			rc = 16;
941
		else if (IN_CLASSC(haddr))
L
Linus Torvalds 已提交
942 943 944
			rc = 24;
	}

945
	return rc;
L
Linus Torvalds 已提交
946 947 948
}


949
int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
L
Linus Torvalds 已提交
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
{
	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;

977
	dev_load(net, ifr.ifr_name);
L
Linus Torvalds 已提交
978

S
Stephen Hemminger 已提交
979
	switch (cmd) {
L
Linus Torvalds 已提交
980 981 982 983 984 985 986 987 988 989 990 991 992 993
	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:
994
		ret = -EPERM;
995
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
996 997 998 999 1000 1001
			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 */
1002
		ret = -EPERM;
1003
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
			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 已提交
1017 1018
	dev = __dev_get_by_name(net, ifr.ifr_name);
	if (!dev)
L
Linus Torvalds 已提交
1019 1020 1021 1022 1023
		goto done;

	if (colon)
		*colon = ':';

E
Eric Dumazet 已提交
1024 1025
	in_dev = __in_dev_get_rtnl(dev);
	if (in_dev) {
L
Linus Torvalds 已提交
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
		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 ==
1036
							ifa->ifa_local) {
L
Linus Torvalds 已提交
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
					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 已提交
1056
	switch (cmd) {
L
Linus Torvalds 已提交
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 1087 1088 1089 1090 1091 1092
	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 已提交
1093 1094
			ifa = inet_alloc_ifa();
			if (!ifa)
L
Linus Torvalds 已提交
1095
				break;
1096
			INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
			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;
1107
			ifa->ifa_scope = 0;
L
Linus Torvalds 已提交
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
		}

		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 已提交
1123
		set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
		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 已提交
1159
			__be32 old_mask = ifa->ifa_mask;
L
Linus Torvalds 已提交
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
			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 ==
1173
			     (ifa->ifa_local|~old_mask))) {
L
Linus Torvalds 已提交
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
				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)
{
1193
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
1194 1195 1196 1197
	struct in_ifaddr *ifa;
	struct ifreq ifr;
	int done = 0;

E
Eric Dumazet 已提交
1198
	if (!in_dev)
L
Linus Torvalds 已提交
1199 1200
		goto out;

E
Eric Dumazet 已提交
1201
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
L
Linus Torvalds 已提交
1202 1203 1204 1205 1206 1207 1208
		if (!buf) {
			done += sizeof(ifr);
			continue;
		}
		if (len < (int) sizeof(ifr))
			break;
		memset(&ifr, 0, sizeof(struct ifreq));
D
Dan Carpenter 已提交
1209
		strcpy(ifr.ifr_name, ifa->ifa_label);
L
Linus Torvalds 已提交
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226

		(*(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;
}

1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
static __be32 in_dev_select_addr(const struct in_device *in_dev,
				 int scope)
{
	for_primary_ifa(in_dev) {
		if (ifa->ifa_scope != RT_SCOPE_LINK &&
		    ifa->ifa_scope <= scope)
			return ifa->ifa_local;
	} endfor_ifa(in_dev);

	return 0;
}

A
Al Viro 已提交
1239
__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
L
Linus Torvalds 已提交
1240
{
A
Al Viro 已提交
1241
	__be32 addr = 0;
L
Linus Torvalds 已提交
1242
	struct in_device *in_dev;
1243
	struct net *net = dev_net(dev);
1244
	int master_idx;
L
Linus Torvalds 已提交
1245 1246

	rcu_read_lock();
1247
	in_dev = __in_dev_get_rcu(dev);
L
Linus Torvalds 已提交
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
	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)
1263
		goto out_unlock;
E
Eric Dumazet 已提交
1264
no_in_dev:
1265
	master_idx = l3mdev_master_ifindex_rcu(dev);
L
Linus Torvalds 已提交
1266

1267 1268 1269 1270 1271 1272 1273 1274
	/* For VRFs, the VRF device takes the place of the loopback device,
	 * with addresses on it being preferred.  Note in such cases the
	 * loopback device will be among the devices that fail the master_idx
	 * equality check in the loop below.
	 */
	if (master_idx &&
	    (dev = dev_get_by_index_rcu(net, master_idx)) &&
	    (in_dev = __in_dev_get_rcu(dev))) {
1275 1276 1277
		addr = in_dev_select_addr(in_dev, scope);
		if (addr)
			goto out_unlock;
1278 1279
	}

L
Linus Torvalds 已提交
1280
	/* Not loopback addresses on loopback should be preferred
S
Stephen Hemminger 已提交
1281
	   in this case. It is important that lo is the first interface
L
Linus Torvalds 已提交
1282 1283
	   in dev_base list.
	 */
1284
	for_each_netdev_rcu(net, dev) {
1285 1286 1287
		if (l3mdev_master_ifindex_rcu(dev) != master_idx)
			continue;

E
Eric Dumazet 已提交
1288 1289
		in_dev = __in_dev_get_rcu(dev);
		if (!in_dev)
L
Linus Torvalds 已提交
1290 1291
			continue;

1292 1293 1294
		addr = in_dev_select_addr(in_dev, scope);
		if (addr)
			goto out_unlock;
L
Linus Torvalds 已提交
1295
	}
1296
out_unlock:
L
Linus Torvalds 已提交
1297 1298 1299
	rcu_read_unlock();
	return addr;
}
E
Eric Dumazet 已提交
1300
EXPORT_SYMBOL(inet_select_addr);
L
Linus Torvalds 已提交
1301

A
Al Viro 已提交
1302 1303
static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
			      __be32 local, int scope)
L
Linus Torvalds 已提交
1304 1305
{
	int same = 0;
A
Al Viro 已提交
1306
	__be32 addr = 0;
L
Linus Torvalds 已提交
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335

	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 已提交
1336
	return same ? addr : 0;
L
Linus Torvalds 已提交
1337 1338 1339 1340
}

/*
 * Confirm that local IP address exists using wildcards:
1341 1342
 * - net: netns to check, cannot be NULL
 * - in_dev: only on this interface, NULL=any interface
L
Linus Torvalds 已提交
1343 1344 1345 1346
 * - 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
 */
1347
__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1348
			 __be32 dst, __be32 local, int scope)
L
Linus Torvalds 已提交
1349
{
A
Al Viro 已提交
1350
	__be32 addr = 0;
1351
	struct net_device *dev;
L
Linus Torvalds 已提交
1352

1353
	if (in_dev)
1354
		return confirm_addr_indev(in_dev, dst, local, scope);
L
Linus Torvalds 已提交
1355 1356

	rcu_read_lock();
1357
	for_each_netdev_rcu(net, dev) {
E
Eric Dumazet 已提交
1358 1359
		in_dev = __in_dev_get_rcu(dev);
		if (in_dev) {
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364 1365 1366 1367 1368
			addr = confirm_addr_indev(in_dev, dst, local, scope);
			if (addr)
				break;
		}
	}
	rcu_read_unlock();

	return addr;
}
1369
EXPORT_SYMBOL(inet_confirm_addr);
L
Linus Torvalds 已提交
1370 1371 1372 1373 1374 1375 1376

/*
 *	Device notifier
 */

int register_inetaddr_notifier(struct notifier_block *nb)
{
1377
	return blocking_notifier_chain_register(&inetaddr_chain, nb);
L
Linus Torvalds 已提交
1378
}
E
Eric Dumazet 已提交
1379
EXPORT_SYMBOL(register_inetaddr_notifier);
L
Linus Torvalds 已提交
1380 1381 1382

int unregister_inetaddr_notifier(struct notifier_block *nb)
{
1383
	return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
L
Linus Torvalds 已提交
1384
}
E
Eric Dumazet 已提交
1385
EXPORT_SYMBOL(unregister_inetaddr_notifier);
L
Linus Torvalds 已提交
1386

1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
int register_inetaddr_validator_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&inetaddr_validator_chain, nb);
}
EXPORT_SYMBOL(register_inetaddr_validator_notifier);

int unregister_inetaddr_validator_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&inetaddr_validator_chain,
	    nb);
}
EXPORT_SYMBOL(unregister_inetaddr_validator_notifier);

E
Eric Dumazet 已提交
1400 1401
/* 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 已提交
1402 1403
*/
static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1404
{
L
Linus Torvalds 已提交
1405 1406 1407
	struct in_ifaddr *ifa;
	int named = 0;

1408 1409
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
		char old[IFNAMSIZ], *dot;
L
Linus Torvalds 已提交
1410 1411

		memcpy(old, ifa->ifa_label, IFNAMSIZ);
1412
		memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
L
Linus Torvalds 已提交
1413
		if (named++ == 0)
1414
			goto skip;
1415
		dot = strchr(old, ':');
1416
		if (!dot) {
1417
			sprintf(old, ":%d", named);
L
Linus Torvalds 已提交
1418 1419
			dot = old;
		}
E
Eric Dumazet 已提交
1420
		if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1421
			strcat(ifa->ifa_label, dot);
E
Eric Dumazet 已提交
1422
		else
1423
			strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1424 1425
skip:
		rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1426 1427
	}
}
L
Linus Torvalds 已提交
1428

E
Eric Dumazet 已提交
1429
static bool inetdev_valid_mtu(unsigned int mtu)
B
Breno Leitao 已提交
1430
{
1431
	return mtu >= IPV4_MIN_MTU;
B
Breno Leitao 已提交
1432 1433
}

1434 1435 1436 1437
static void inetdev_send_gratuitous_arp(struct net_device *dev,
					struct in_device *in_dev)

{
1438
	struct in_ifaddr *ifa;
1439

1440 1441 1442 1443 1444 1445 1446
	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);
	}
1447 1448
}

L
Linus Torvalds 已提交
1449 1450 1451 1452 1453
/* Called only under RTNL semaphore */

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

L
Linus Torvalds 已提交
1457 1458 1459
	ASSERT_RTNL();

	if (!in_dev) {
1460
		if (event == NETDEV_REGISTER) {
L
Linus Torvalds 已提交
1461
			in_dev = inetdev_init(dev);
1462 1463
			if (IS_ERR(in_dev))
				return notifier_from_errno(PTR_ERR(in_dev));
1464
			if (dev->flags & IFF_LOOPBACK) {
1465 1466
				IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
				IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1467
			}
B
Breno Leitao 已提交
1468 1469 1470 1471
		} else if (event == NETDEV_CHANGEMTU) {
			/* Re-enabling IP */
			if (inetdev_valid_mtu(dev->mtu))
				in_dev = inetdev_init(dev);
L
Linus Torvalds 已提交
1472 1473 1474 1475 1476 1477
		}
		goto out;
	}

	switch (event) {
	case NETDEV_REGISTER:
1478
		pr_debug("%s: bug\n", __func__);
1479
		RCU_INIT_POINTER(dev->ip_ptr, NULL);
L
Linus Torvalds 已提交
1480 1481
		break;
	case NETDEV_UP:
B
Breno Leitao 已提交
1482
		if (!inetdev_valid_mtu(dev->mtu))
L
Linus Torvalds 已提交
1483
			break;
1484
		if (dev->flags & IFF_LOOPBACK) {
E
Eric Dumazet 已提交
1485 1486 1487
			struct in_ifaddr *ifa = inet_alloc_ifa();

			if (ifa) {
1488
				INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
1489 1490 1491 1492 1493 1494 1495 1496
				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 已提交
1497 1498
				set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
						 INFINITY_LIFE_TIME);
1499 1500
				ipv4_devconf_setall(in_dev);
				neigh_parms_data_state_setall(in_dev->arp_parms);
L
Linus Torvalds 已提交
1501 1502 1503 1504
				inet_insert_ifa(ifa);
			}
		}
		ip_mc_up(in_dev);
1505 1506
		/* fall through */
	case NETDEV_CHANGEADDR:
1507 1508 1509 1510
		if (!IN_DEV_ARP_NOTIFY(in_dev))
			break;
		/* fall through */
	case NETDEV_NOTIFY_PEERS:
1511
		/* Send gratuitous ARP to notify of link change */
1512
		inetdev_send_gratuitous_arp(dev, in_dev);
L
Linus Torvalds 已提交
1513 1514 1515 1516
		break;
	case NETDEV_DOWN:
		ip_mc_down(in_dev);
		break;
1517
	case NETDEV_PRE_TYPE_CHANGE:
1518 1519
		ip_mc_unmap(in_dev);
		break;
1520
	case NETDEV_POST_TYPE_CHANGE:
1521 1522
		ip_mc_remap(in_dev);
		break;
L
Linus Torvalds 已提交
1523
	case NETDEV_CHANGEMTU:
B
Breno Leitao 已提交
1524
		if (inetdev_valid_mtu(dev->mtu))
L
Linus Torvalds 已提交
1525
			break;
B
Breno Leitao 已提交
1526
		/* disable IP when MTU is not enough */
1527
		/* fall through */
L
Linus Torvalds 已提交
1528 1529 1530 1531 1532 1533 1534 1535 1536
	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);

1537
		devinet_sysctl_unregister(in_dev);
1538
		devinet_sysctl_register(in_dev);
L
Linus Torvalds 已提交
1539 1540 1541 1542 1543 1544 1545
		break;
	}
out:
	return NOTIFY_DONE;
}

static struct notifier_block ip_netdev_notifier = {
J
Jianjun Kong 已提交
1546
	.notifier_call = inetdev_event,
L
Linus Torvalds 已提交
1547 1548
};

E
Eric Dumazet 已提交
1549
static size_t inet_nlmsg_size(void)
1550 1551 1552 1553 1554
{
	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
	       + nla_total_size(4) /* IFA_ADDRESS */
	       + nla_total_size(4) /* IFA_LOCAL */
	       + nla_total_size(4) /* IFA_BROADCAST */
1555
	       + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1556 1557
	       + nla_total_size(4)  /* IFA_FLAGS */
	       + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1558 1559
}

J
Jiri Pirko 已提交
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
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 已提交
1578
static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1579
			    u32 portid, u32 seq, int event, unsigned int flags)
L
Linus Torvalds 已提交
1580 1581 1582
{
	struct ifaddrmsg *ifm;
	struct nlmsghdr  *nlh;
J
Jiri Pirko 已提交
1583
	u32 preferred, valid;
L
Linus Torvalds 已提交
1584

1585
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
1586
	if (!nlh)
1587
		return -EMSGSIZE;
1588 1589

	ifm = nlmsg_data(nlh);
L
Linus Torvalds 已提交
1590 1591
	ifm->ifa_family = AF_INET;
	ifm->ifa_prefixlen = ifa->ifa_prefixlen;
J
Jiri Pirko 已提交
1592
	ifm->ifa_flags = ifa->ifa_flags;
L
Linus Torvalds 已提交
1593 1594
	ifm->ifa_scope = ifa->ifa_scope;
	ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1595

J
Jiri Pirko 已提交
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
	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 已提交
1617
	if ((ifa->ifa_address &&
1618
	     nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
D
David S. Miller 已提交
1619
	    (ifa->ifa_local &&
1620
	     nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
D
David S. Miller 已提交
1621
	    (ifa->ifa_broadcast &&
1622
	     nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
D
David S. Miller 已提交
1623
	    (ifa->ifa_label[0] &&
J
Jiri Pirko 已提交
1624
	     nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1625
	    nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
J
Jiri Pirko 已提交
1626 1627
	    put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
			  preferred, valid))
D
David S. Miller 已提交
1628
		goto nla_put_failure;
L
Linus Torvalds 已提交
1629

1630 1631
	nlmsg_end(skb, nlh);
	return 0;
1632 1633

nla_put_failure:
1634 1635
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
1636 1637 1638 1639
}

static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
1640
	struct net *net = sock_net(skb->sk);
E
Eric Dumazet 已提交
1641 1642 1643
	int h, s_h;
	int idx, s_idx;
	int ip_idx, s_ip_idx;
L
Linus Torvalds 已提交
1644 1645 1646
	struct net_device *dev;
	struct in_device *in_dev;
	struct in_ifaddr *ifa;
E
Eric Dumazet 已提交
1647
	struct hlist_head *head;
L
Linus Torvalds 已提交
1648

E
Eric Dumazet 已提交
1649 1650 1651 1652 1653 1654 1655 1656
	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();
1657 1658
		cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
			  net->dev_base_seq;
1659
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
1660 1661
			if (idx < s_idx)
				goto cont;
1662
			if (h > s_h || idx > s_idx)
E
Eric Dumazet 已提交
1663 1664 1665 1666
				s_ip_idx = 0;
			in_dev = __in_dev_get_rcu(dev);
			if (!in_dev)
				goto cont;
L
Linus Torvalds 已提交
1667

E
Eric Dumazet 已提交
1668 1669 1670 1671 1672
			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,
1673
					     NETLINK_CB(cb->skb).portid,
L
Linus Torvalds 已提交
1674
					     cb->nlh->nlmsg_seq,
1675
					     RTM_NEWADDR, NLM_F_MULTI) < 0) {
E
Eric Dumazet 已提交
1676 1677 1678
					rcu_read_unlock();
					goto done;
				}
1679
				nl_dump_check_consistent(cb, nlmsg_hdr(skb));
E
Eric Dumazet 已提交
1680
			}
1681
cont:
E
Eric Dumazet 已提交
1682 1683 1684
			idx++;
		}
		rcu_read_unlock();
L
Linus Torvalds 已提交
1685 1686 1687
	}

done:
E
Eric Dumazet 已提交
1688 1689 1690
	cb->args[0] = h;
	cb->args[1] = idx;
	cb->args[2] = ip_idx;
L
Linus Torvalds 已提交
1691 1692 1693 1694

	return skb->len;
}

J
Jianjun Kong 已提交
1695
static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1696
		      u32 portid)
L
Linus Torvalds 已提交
1697
{
1698
	struct sk_buff *skb;
1699 1700
	u32 seq = nlh ? nlh->nlmsg_seq : 0;
	int err = -ENOBUFS;
1701
	struct net *net;
L
Linus Torvalds 已提交
1702

1703
	net = dev_net(ifa->ifa_dev->dev);
1704
	skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1705
	if (!skb)
1706 1707
		goto errout;

1708
	err = inet_fill_ifaddr(skb, ifa, portid, seq, event, 0);
1709 1710 1711 1712 1713 1714
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
1715
	rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1716
	return;
1717 1718
errout:
	if (err < 0)
1719
		rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
L
Linus Torvalds 已提交
1720 1721
}

1722 1723
static size_t inet_get_link_af_size(const struct net_device *dev,
				    u32 ext_filter_mask)
T
Thomas Graf 已提交
1724
{
E
Eric Dumazet 已提交
1725
	struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
T
Thomas Graf 已提交
1726 1727 1728 1729 1730 1731 1732

	if (!in_dev)
		return 0;

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

1733 1734
static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
			     u32 ext_filter_mask)
T
Thomas Graf 已提交
1735
{
E
Eric Dumazet 已提交
1736
	struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
T
Thomas Graf 已提交
1737 1738 1739 1740 1741 1742 1743
	struct nlattr *nla;
	int i;

	if (!in_dev)
		return -ENODATA;

	nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1744
	if (!nla)
T
Thomas Graf 已提交
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
		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 },
};

1757 1758
static int inet_validate_link_af(const struct net_device *dev,
				 const struct nlattr *nla)
T
Thomas Graf 已提交
1759 1760 1761 1762
{
	struct nlattr *a, *tb[IFLA_INET_MAX+1];
	int err, rem;

F
Florian Westphal 已提交
1763
	if (dev && !__in_dev_get_rcu(dev))
1764
		return -EAFNOSUPPORT;
T
Thomas Graf 已提交
1765

1766
	err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL);
T
Thomas Graf 已提交
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
	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;
		}
	}

1782 1783 1784 1785 1786
	return 0;
}

static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
{
F
Florian Westphal 已提交
1787
	struct in_device *in_dev = __in_dev_get_rcu(dev);
1788 1789 1790 1791 1792 1793
	struct nlattr *a, *tb[IFLA_INET_MAX+1];
	int rem;

	if (!in_dev)
		return -EAFNOSUPPORT;

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

T
Thomas Graf 已提交
1797 1798 1799 1800 1801 1802 1803 1804
	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;
}

1805 1806 1807 1808
static int inet_netconf_msgsize_devconf(int type)
{
	int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
		   + nla_total_size(4);	/* NETCONFA_IFINDEX */
1809
	bool all = false;
1810

1811 1812 1813 1814
	if (type == NETCONFA_ALL)
		all = true;

	if (all || type == NETCONFA_FORWARDING)
1815
		size += nla_total_size(4);
1816
	if (all || type == NETCONFA_RP_FILTER)
1817
		size += nla_total_size(4);
1818
	if (all || type == NETCONFA_MC_FORWARDING)
1819
		size += nla_total_size(4);
1820
	if (all || type == NETCONFA_PROXY_NEIGH)
S
stephen hemminger 已提交
1821
		size += nla_total_size(4);
1822
	if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
1823
		size += nla_total_size(4);
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834

	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;
1835
	bool all = false;
1836 1837 1838

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
			flags);
1839
	if (!nlh)
1840 1841
		return -EMSGSIZE;

1842 1843 1844
	if (type == NETCONFA_ALL)
		all = true;

1845 1846 1847 1848 1849 1850
	ncm = nlmsg_data(nlh);
	ncm->ncm_family = AF_INET;

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

1851 1852 1853
	if (!devconf)
		goto out;

1854
	if ((all || type == NETCONFA_FORWARDING) &&
1855 1856 1857
	    nla_put_s32(skb, NETCONFA_FORWARDING,
			IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
		goto nla_put_failure;
1858
	if ((all || type == NETCONFA_RP_FILTER) &&
1859 1860 1861
	    nla_put_s32(skb, NETCONFA_RP_FILTER,
			IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
		goto nla_put_failure;
1862
	if ((all || type == NETCONFA_MC_FORWARDING) &&
1863 1864 1865
	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
			IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
		goto nla_put_failure;
1866
	if ((all || type == NETCONFA_PROXY_NEIGH) &&
1867
	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
S
stephen hemminger 已提交
1868 1869
			IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
		goto nla_put_failure;
1870
	if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
1871 1872 1873
	    nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
			IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
		goto nla_put_failure;
1874

1875
out:
1876 1877
	nlmsg_end(skb, nlh);
	return 0;
1878 1879 1880 1881 1882 1883

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

1884 1885
void inet_netconf_notify_devconf(struct net *net, int event, int type,
				 int ifindex, struct ipv4_devconf *devconf)
1886 1887 1888 1889
{
	struct sk_buff *skb;
	int err = -ENOBUFS;

1890
	skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
1891
	if (!skb)
1892 1893 1894
		goto errout;

	err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
1895
					event, 0, type);
1896 1897 1898 1899 1900 1901
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
1902
	rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
1903 1904 1905 1906 1907 1908
	return;
errout:
	if (err < 0)
		rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
}

1909 1910 1911
static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
1912
	[NETCONFA_RP_FILTER]	= { .len = sizeof(int) },
1913
	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
1914
	[NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]	= { .len = sizeof(int) },
1915 1916 1917
};

static int inet_netconf_get_devconf(struct sk_buff *in_skb,
1918 1919
				    struct nlmsghdr *nlh,
				    struct netlink_ext_ack *extack)
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931
{
	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,
1932
			  devconf_ipv4_policy, extack);
1933 1934 1935
	if (err < 0)
		goto errout;

1936
	err = -EINVAL;
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949
	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);
1950
		if (!dev)
1951 1952
			goto errout;
		in_dev = __in_dev_get_rtnl(dev);
1953
		if (!in_dev)
1954 1955 1956 1957 1958 1959
			goto errout;
		devconf = &in_dev->cnf;
		break;
	}

	err = -ENOBUFS;
1960
	skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
1961
	if (!skb)
1962 1963 1964 1965 1966
		goto errout;

	err = inet_netconf_fill_devconf(skb, ifindex, devconf,
					NETLINK_CB(in_skb).portid,
					nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
1967
					NETCONFA_ALL);
1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
	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;
}

1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995
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();
1996 1997
		cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
			  net->dev_base_seq;
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
		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,
2011
						      NETCONFA_ALL) < 0) {
2012 2013 2014
				rcu_read_unlock();
				goto done;
			}
2015
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
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,
2027
					      NETCONFA_ALL) < 0)
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
			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,
2038
					      NETCONFA_ALL) < 0)
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
			goto done;
		else
			h++;
	}
done:
	cb->args[0] = h;
	cb->args[1] = idx;

	return skb->len;
}

L
Linus Torvalds 已提交
2050 2051
#ifdef CONFIG_SYSCTL

2052
static void devinet_copy_dflt_conf(struct net *net, int i)
2053 2054 2055
{
	struct net_device *dev;

2056 2057
	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
2058
		struct in_device *in_dev;
2059

2060 2061
		in_dev = __in_dev_get_rcu(dev);
		if (in_dev && !test_bit(i, in_dev->cnf.state))
2062
			in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2063
	}
2064
	rcu_read_unlock();
2065 2066
}

2067
/* called with RTNL locked */
2068
static void inet_forward_change(struct net *net)
2069 2070
{
	struct net_device *dev;
2071
	int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2072

2073
	IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2074
	IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2075 2076
	inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
				    NETCONFA_FORWARDING,
2077 2078
				    NETCONFA_IFINDEX_ALL,
				    net->ipv4.devconf_all);
2079 2080
	inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
				    NETCONFA_FORWARDING,
2081 2082
				    NETCONFA_IFINDEX_DEFAULT,
				    net->ipv4.devconf_dflt);
2083

2084
	for_each_netdev(net, dev) {
2085
		struct in_device *in_dev;
2086

2087 2088
		if (on)
			dev_disable_lro(dev);
2089 2090

		in_dev = __in_dev_get_rtnl(dev);
2091
		if (in_dev) {
2092
			IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2093 2094
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_FORWARDING,
2095 2096
						    dev->ifindex, &in_dev->cnf);
		}
2097 2098 2099
	}
}

S
stephen hemminger 已提交
2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
{
	if (cnf == net->ipv4.devconf_dflt)
		return NETCONFA_IFINDEX_DEFAULT;
	else if (cnf == net->ipv4.devconf_all)
		return NETCONFA_IFINDEX_ALL;
	else {
		struct in_device *idev
			= container_of(cnf, struct in_device, cnf);
		return idev->dev->ifindex;
	}
}

2113
static int devinet_conf_proc(struct ctl_table *ctl, int write,
2114
			     void __user *buffer,
2115 2116
			     size_t *lenp, loff_t *ppos)
{
2117
	int old_value = *(int *)ctl->data;
2118
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2119
	int new_value = *(int *)ctl->data;
2120 2121 2122

	if (write) {
		struct ipv4_devconf *cnf = ctl->extra1;
2123
		struct net *net = ctl->extra2;
2124
		int i = (int *)ctl->data - cnf->data;
S
stephen hemminger 已提交
2125
		int ifindex;
2126 2127 2128

		set_bit(i, cnf->state);

2129
		if (cnf == net->ipv4.devconf_dflt)
2130
			devinet_copy_dflt_conf(net, i);
2131 2132
		if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
		    i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2133
			if ((new_value == 0) && (old_value != 0))
2134
				rt_cache_flush(net);
S
stephen hemminger 已提交
2135

2136 2137
		if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
		    new_value != old_value) {
S
stephen hemminger 已提交
2138
			ifindex = devinet_conf_ifindex(net, cnf);
2139 2140
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_RP_FILTER,
2141 2142
						    ifindex, cnf);
		}
S
stephen hemminger 已提交
2143 2144 2145
		if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
		    new_value != old_value) {
			ifindex = devinet_conf_ifindex(net, cnf);
2146 2147
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_PROXY_NEIGH,
S
stephen hemminger 已提交
2148 2149
						    ifindex, cnf);
		}
2150 2151 2152
		if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
		    new_value != old_value) {
			ifindex = devinet_conf_ifindex(net, cnf);
2153 2154
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2155 2156
						    ifindex, cnf);
		}
2157 2158 2159 2160 2161
	}

	return ret;
}

2162
static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2163
				  void __user *buffer,
L
Linus Torvalds 已提交
2164 2165 2166 2167
				  size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
2168
	loff_t pos = *ppos;
2169
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
L
Linus Torvalds 已提交
2170 2171

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

2174
		if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
E
Eric W. Biederman 已提交
2175 2176 2177 2178
			if (!rtnl_trylock()) {
				/* Restore the original values before restarting */
				*valp = val;
				*ppos = pos;
2179
				return restart_syscall();
E
Eric W. Biederman 已提交
2180
			}
2181 2182
			if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
				inet_forward_change(net);
2183
			} else {
2184 2185 2186
				struct ipv4_devconf *cnf = ctl->extra1;
				struct in_device *idev =
					container_of(cnf, struct in_device, cnf);
2187 2188
				if (*valp)
					dev_disable_lro(idev->dev);
2189
				inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2190 2191 2192
							    NETCONFA_FORWARDING,
							    idev->dev->ifindex,
							    cnf);
2193 2194
			}
			rtnl_unlock();
2195
			rt_cache_flush(net);
2196
		} else
2197 2198
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_FORWARDING,
2199 2200
						    NETCONFA_IFINDEX_DEFAULT,
						    net->ipv4.devconf_dflt);
L
Linus Torvalds 已提交
2201 2202 2203 2204 2205
	}

	return ret;
}

2206
static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2207 2208
				void __user *buffer,
				size_t *lenp, loff_t *ppos)
L
Linus Torvalds 已提交
2209 2210 2211
{
	int *valp = ctl->data;
	int val = *valp;
2212
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2213
	struct net *net = ctl->extra2;
L
Linus Torvalds 已提交
2214 2215

	if (write && *valp != val)
2216
		rt_cache_flush(net);
L
Linus Torvalds 已提交
2217 2218 2219 2220

	return ret;
}

2221
#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2222 2223 2224
	{ \
		.procname	= name, \
		.data		= ipv4_devconf.data + \
2225
				  IPV4_DEVCONF_ ## attr - 1, \
2226 2227 2228
		.maxlen		= sizeof(int), \
		.mode		= mval, \
		.proc_handler	= proc, \
2229
		.extra1		= &ipv4_devconf, \
2230 2231 2232
	}

#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2233
	DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2234 2235

#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2236
	DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2237

2238 2239
#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
	DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2240 2241

#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2242
	DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2243

L
Linus Torvalds 已提交
2244 2245
static struct devinet_sysctl_table {
	struct ctl_table_header *sysctl_header;
2246
	struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
L
Linus Torvalds 已提交
2247 2248
} devinet_sysctl = {
	.devinet_vars = {
2249
		DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2250
					     devinet_sysctl_forward),
2251 2252 2253 2254 2255 2256 2257 2258 2259
		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"),
2260
		DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2261
		DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2262 2263 2264 2265 2266 2267 2268 2269 2270
		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"),
2271
		DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2272
		DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2273 2274
		DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
					"force_igmp_version"),
2275 2276 2277 2278
		DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
					"igmpv2_unsolicited_report_interval"),
		DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
					"igmpv3_unsolicited_report_interval"),
2279 2280
		DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
					"ignore_routes_with_linkdown"),
2281 2282
		DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
					"drop_gratuitous_arp"),
2283 2284 2285 2286 2287

		DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
		DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
		DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
					      "promote_secondaries"),
2288 2289
		DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
					      "route_localnet"),
2290 2291
		DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
					      "drop_unicast_in_l2_multicast"),
L
Linus Torvalds 已提交
2292 2293 2294
	},
};

2295
static int __devinet_sysctl_register(struct net *net, char *dev_name,
2296
				     int ifindex, struct ipv4_devconf *p)
L
Linus Torvalds 已提交
2297 2298
{
	int i;
2299
	struct devinet_sysctl_table *t;
2300
	char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2301

2302
	t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
L
Linus Torvalds 已提交
2303
	if (!t)
2304 2305
		goto out;

L
Linus Torvalds 已提交
2306 2307
	for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
		t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2308
		t->devinet_vars[i].extra1 = p;
2309
		t->devinet_vars[i].extra2 = net;
L
Linus Torvalds 已提交
2310 2311
	}

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

2314
	t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
L
Linus Torvalds 已提交
2315
	if (!t->sysctl_header)
2316
		goto free;
L
Linus Torvalds 已提交
2317 2318

	p->sysctl = t;
2319

2320 2321
	inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
				    ifindex, p);
2322
	return 0;
L
Linus Torvalds 已提交
2323

2324
free:
L
Linus Torvalds 已提交
2325
	kfree(t);
2326
out:
2327
	return -ENOBUFS;
L
Linus Torvalds 已提交
2328 2329
}

2330 2331
static void __devinet_sysctl_unregister(struct net *net,
					struct ipv4_devconf *cnf, int ifindex)
2332 2333 2334
{
	struct devinet_sysctl_table *t = cnf->sysctl;

2335 2336 2337 2338 2339
	if (t) {
		cnf->sysctl = NULL;
		unregister_net_sysctl_table(t->sysctl_header);
		kfree(t);
	}
2340

2341
	inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2342 2343
}

2344
static int devinet_sysctl_register(struct in_device *idev)
2345
{
2346 2347 2348 2349 2350 2351 2352 2353 2354
	int err;

	if (!sysctl_dev_name_is_allowed(idev->dev->name))
		return -EINVAL;

	err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
	if (err)
		return err;
	err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
2355
					idev->dev->ifindex, &idev->cnf);
2356 2357 2358
	if (err)
		neigh_sysctl_unregister(idev->arp_parms);
	return err;
2359 2360
}

2361
static void devinet_sysctl_unregister(struct in_device *idev)
L
Linus Torvalds 已提交
2362
{
2363 2364 2365
	struct net *net = dev_net(idev->dev);

	__devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2366
	neigh_sysctl_unregister(idev->arp_parms);
L
Linus Torvalds 已提交
2367 2368
}

2369 2370 2371 2372
static struct ctl_table ctl_forward_entry[] = {
	{
		.procname	= "ip_forward",
		.data		= &ipv4_devconf.data[
2373
					IPV4_DEVCONF_FORWARDING - 1],
2374 2375 2376 2377
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= devinet_sysctl_forward,
		.extra1		= &ipv4_devconf,
2378
		.extra2		= &init_net,
2379 2380 2381
	},
	{ },
};
2382
#endif
2383

2384 2385 2386 2387
static __net_init int devinet_init_net(struct net *net)
{
	int err;
	struct ipv4_devconf *all, *dflt;
2388 2389
#ifdef CONFIG_SYSCTL
	struct ctl_table *tbl = ctl_forward_entry;
2390
	struct ctl_table_header *forw_hdr;
2391
#endif
2392 2393 2394 2395 2396

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

O
Octavian Purdila 已提交
2397
	if (!net_eq(net, &init_net)) {
2398
		all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2399
		if (!all)
2400 2401 2402
			goto err_alloc_all;

		dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2403
		if (!dflt)
2404 2405
			goto err_alloc_dflt;

2406
#ifdef CONFIG_SYSCTL
2407
		tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2408
		if (!tbl)
2409 2410
			goto err_alloc_ctl;

2411
		tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2412 2413
		tbl[0].extra1 = all;
		tbl[0].extra2 = net;
2414
#endif
2415 2416 2417
	}

#ifdef CONFIG_SYSCTL
2418
	err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2419 2420 2421
	if (err < 0)
		goto err_reg_all;

2422 2423
	err = __devinet_sysctl_register(net, "default",
					NETCONFA_IFINDEX_DEFAULT, dflt);
2424 2425 2426 2427
	if (err < 0)
		goto err_reg_dflt;

	err = -ENOMEM;
2428
	forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2429
	if (!forw_hdr)
2430
		goto err_reg_ctl;
2431
	net->ipv4.forw_hdr = forw_hdr;
2432 2433 2434 2435 2436 2437 2438 2439
#endif

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

#ifdef CONFIG_SYSCTL
err_reg_ctl:
2440
	__devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2441
err_reg_dflt:
2442
	__devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2443 2444 2445 2446
err_reg_all:
	if (tbl != ctl_forward_entry)
		kfree(tbl);
err_alloc_ctl:
2447
#endif
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
	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)
{
2459
#ifdef CONFIG_SYSCTL
2460 2461 2462 2463
	struct ctl_table *tbl;

	tbl = net->ipv4.forw_hdr->ctl_table_arg;
	unregister_net_sysctl_table(net->ipv4.forw_hdr);
2464 2465 2466 2467
	__devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
				    NETCONFA_IFINDEX_DEFAULT);
	__devinet_sysctl_unregister(net, net->ipv4.devconf_all,
				    NETCONFA_IFINDEX_ALL);
2468
	kfree(tbl);
2469
#endif
2470 2471 2472 2473 2474 2475 2476 2477 2478
	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,
};

2479
static struct rtnl_af_ops inet_af_ops __read_mostly = {
T
Thomas Graf 已提交
2480 2481 2482
	.family		  = AF_INET,
	.fill_link_af	  = inet_fill_link_af,
	.get_link_af_size = inet_get_link_af_size,
2483 2484
	.validate_link_af = inet_validate_link_af,
	.set_link_af	  = inet_set_link_af,
T
Thomas Graf 已提交
2485 2486
};

L
Linus Torvalds 已提交
2487 2488
void __init devinet_init(void)
{
2489 2490 2491 2492 2493
	int i;

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

2494 2495
	register_pernet_subsys(&devinet_ops);

L
Linus Torvalds 已提交
2496 2497
	register_gifconf(PF_INET, inet_gifconf);
	register_netdevice_notifier(&ip_netdev_notifier);
2498

2499
	queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
J
Jiri Pirko 已提交
2500

T
Thomas Graf 已提交
2501 2502
	rtnl_af_register(&inet_af_ops);

2503 2504 2505
	rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0);
	rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0);
	rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0);
2506
	rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2507
		      inet_netconf_dump_devconf, 0);
L
Linus Torvalds 已提交
2508
}