devinet.c 66.0 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
	[IFA_RT_PRIORITY]	= { .type = NLA_U32 },
103
	[IFA_TARGET_NETNSID]	= { .type = NLA_S32 },
104 105
};

C
Christian Brauner 已提交
106 107 108 109 110 111
struct inet_fill_args {
	u32 portid;
	u32 seq;
	int event;
	unsigned int flags;
	int netnsid;
112
	int ifindex;
C
Christian Brauner 已提交
113 114
};

E
Eric Dumazet 已提交
115 116 117
#define IN4_ADDR_HSIZE_SHIFT	8
#define IN4_ADDR_HSIZE		(1U << IN4_ADDR_HSIZE_SHIFT)

118 119
static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];

120
static u32 inet_addr_hash(const struct net *net, __be32 addr)
121
{
E
Eric Dumazet 已提交
122
	u32 val = (__force u32) addr ^ net_hash_mix(net);
123

E
Eric Dumazet 已提交
124
	return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
125 126 127 128
}

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

131
	ASSERT_RTNL();
132 133 134 135 136
	hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
}

static void inet_hash_remove(struct in_ifaddr *ifa)
{
137
	ASSERT_RTNL();
138 139 140
	hlist_del_init_rcu(&ifa->hash);
}

141 142 143 144 145 146 147 148 149 150 151 152 153 154
/**
 * __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();
155 156
	ifa = inet_lookup_ifaddr_rcu(net, addr);
	if (!ifa) {
157 158 159 160 161 162 163 164 165 166 167 168
		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);
169 170
	} else {
		result = ifa->ifa_dev->dev;
171
	}
172 173 174 175 176 177 178
	if (result && devref)
		dev_hold(result);
	rcu_read_unlock();
	return result;
}
EXPORT_SYMBOL(__ip_dev_find);

179 180 181 182 183 184 185 186 187 188 189 190 191 192
/* 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;
}

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

195
static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
196
static BLOCKING_NOTIFIER_HEAD(inetaddr_validator_chain);
L
Linus Torvalds 已提交
197 198 199
static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
			 int destroy);
#ifdef CONFIG_SYSCTL
200
static int devinet_sysctl_register(struct in_device *idev);
201 202
static void devinet_sysctl_unregister(struct in_device *idev);
#else
203
static int devinet_sysctl_register(struct in_device *idev)
204
{
205
	return 0;
206
}
E
Eric Dumazet 已提交
207
static void devinet_sysctl_unregister(struct in_device *idev)
208 209
{
}
L
Linus Torvalds 已提交
210 211 212 213 214 215
#endif

/* Locks all the inet devices. */

static struct in_ifaddr *inet_alloc_ifa(void)
{
A
Alexey Dobriyan 已提交
216
	return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224 225 226
}

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 已提交
227
static void inet_free_ifa(struct in_ifaddr *ifa)
L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235
{
	call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
}

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

236 237
	WARN_ON(idev->ifa_list);
	WARN_ON(idev->mc_list);
238
	kfree(rcu_dereference_protected(idev->mc_hash, 1));
L
Linus Torvalds 已提交
239
#ifdef NET_REFCNT_DEBUG
240
	pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
L
Linus Torvalds 已提交
241 242 243
#endif
	dev_put(dev);
	if (!idev->dead)
E
Eric Dumazet 已提交
244 245
		pr_err("Freeing alive in_device %p\n", idev);
	else
L
Linus Torvalds 已提交
246 247
		kfree(idev);
}
E
Eric Dumazet 已提交
248
EXPORT_SYMBOL(in_dev_finish_destroy);
L
Linus Torvalds 已提交
249

250
static struct in_device *inetdev_init(struct net_device *dev)
L
Linus Torvalds 已提交
251 252
{
	struct in_device *in_dev;
253
	int err = -ENOMEM;
L
Linus Torvalds 已提交
254 255 256

	ASSERT_RTNL();

257
	in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
L
Linus Torvalds 已提交
258 259
	if (!in_dev)
		goto out;
260
	memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
261
			sizeof(in_dev->cnf));
L
Linus Torvalds 已提交
262 263
	in_dev->cnf.sysctl = NULL;
	in_dev->dev = dev;
E
Eric Dumazet 已提交
264 265
	in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
	if (!in_dev->arp_parms)
L
Linus Torvalds 已提交
266
		goto out_kfree;
267 268
	if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
		dev_disable_lro(dev);
L
Linus Torvalds 已提交
269 270
	/* Reference in_dev->dev */
	dev_hold(dev);
271
	/* Account for reference dev->ip_ptr (below) */
272
	refcount_set(&in_dev->refcnt, 1);
L
Linus Torvalds 已提交
273

274 275 276 277 278 279 280
	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 已提交
281 282 283
	ip_mc_init_dev(in_dev);
	if (dev->flags & IFF_UP)
		ip_mc_up(in_dev);
284

285
	/* we can receive as soon as ip_ptr is set -- do this last */
286
	rcu_assign_pointer(dev->ip_ptr, in_dev);
287
out:
288
	return in_dev ?: ERR_PTR(err);
L
Linus Torvalds 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
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);
	}

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

321
	devinet_sysctl_unregister(in_dev);
L
Linus Torvalds 已提交
322 323 324 325 326 327
	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 已提交
328
int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
L
Linus Torvalds 已提交
329 330 331 332 333 334 335 336 337 338 339 340 341 342
{
	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;
}

343
static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
344
			 int destroy, struct nlmsghdr *nlh, u32 portid)
L
Linus Torvalds 已提交
345
{
346
	struct in_ifaddr *promote = NULL;
347 348 349 350
	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 已提交
351 352 353

	ASSERT_RTNL();

354 355 356
	if (in_dev->dead)
		goto no_promotions;

357
	/* 1. Deleting primary ifaddr forces deletion all secondaries
358 359
	 * unless alias promotion is set
	 **/
L
Linus Torvalds 已提交
360 361 362 363 364

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

		while ((ifa = *ifap1) != NULL) {
365
			if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
366 367 368
			    ifa1->ifa_scope <= ifa->ifa_scope)
				last_prim = ifa;

L
Linus Torvalds 已提交
369 370 371 372
			if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
			    ifa1->ifa_mask != ifa->ifa_mask ||
			    !inet_ifa_match(ifa1->ifa_address, ifa)) {
				ifap1 = &ifa->ifa_next;
373
				prev_prom = ifa;
L
Linus Torvalds 已提交
374 375 376
				continue;
			}

377
			if (!do_promote) {
378
				inet_hash_remove(ifa);
379
				*ifap1 = ifa->ifa_next;
L
Linus Torvalds 已提交
380

381
				rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
382 383
				blocking_notifier_call_chain(&inetaddr_chain,
						NETDEV_DOWN, ifa);
384 385 386 387 388
				inet_free_ifa(ifa);
			} else {
				promote = ifa;
				break;
			}
L
Linus Torvalds 已提交
389 390 391
		}
	}

392 393 394 395 396 397 398 399 400 401 402
	/* 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);
	}

403
no_promotions:
L
Linus Torvalds 已提交
404 405 406
	/* 2. Unlink it */

	*ifap = ifa1->ifa_next;
407
	inet_hash_remove(ifa1);
L
Linus Torvalds 已提交
408 409 410 411 412 413 414 415 416 417 418

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

422
	if (promote) {
423
		struct in_ifaddr *next_sec = promote->ifa_next;
424 425 426 427 428 429

		if (prev_prom) {
			prev_prom->ifa_next = promote->ifa_next;
			promote->ifa_next = last_prim->ifa_next;
			last_prim->ifa_next = promote;
		}
430 431

		promote->ifa_flags &= ~IFA_F_SECONDARY;
432
		rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
433 434
		blocking_notifier_call_chain(&inetaddr_chain,
				NETDEV_UP, promote);
435
		for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
436 437 438 439 440 441 442
			if (ifa1->ifa_mask != ifa->ifa_mask ||
			    !inet_ifa_match(ifa1->ifa_address, ifa))
					continue;
			fib_add_ifaddr(ifa);
		}

	}
443
	if (destroy)
444
		inet_free_ifa(ifa1);
L
Linus Torvalds 已提交
445 446
}

447 448 449 450 451 452
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 已提交
453 454 455 456
static void check_lifetime(struct work_struct *work);

static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);

457
static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
458
			     u32 portid, struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
459 460 461
{
	struct in_device *in_dev = ifa->ifa_dev;
	struct in_ifaddr *ifa1, **ifap, **last_primary;
462 463
	struct in_validator_info ivi;
	int ret;
L
Linus Torvalds 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493

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

494 495 496 497 498 499 500 501 502
	/* 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;
503
	ivi.extack = extack;
504 505 506 507 508 509 510 511
	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 已提交
512
	if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
513
		prandom_seed((__force u32) ifa->ifa_local);
L
Linus Torvalds 已提交
514 515 516 517 518 519
		ifap = last_primary;
	}

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

520 521
	inet_hash_insert(dev_net(in_dev->dev), ifa);

J
Jiri Pirko 已提交
522
	cancel_delayed_work(&check_lifetime_work);
523
	queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
J
Jiri Pirko 已提交
524

L
Linus Torvalds 已提交
525 526 527
	/* Send message first, then call notifier.
	   Notifier will trigger FIB update, so that
	   listeners of netlink will know about new ifaddr */
528
	rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
529
	blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
L
Linus Torvalds 已提交
530 531 532 533

	return 0;
}

534 535
static int inet_insert_ifa(struct in_ifaddr *ifa)
{
536
	return __inet_insert_ifa(ifa, NULL, 0, NULL);
537 538
}

L
Linus Torvalds 已提交
539 540
static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
{
541
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
542 543 544 545

	ASSERT_RTNL();

	if (!in_dev) {
546 547
		inet_free_ifa(ifa);
		return -ENOBUFS;
L
Linus Torvalds 已提交
548
	}
549
	ipv4_devconf_setall(in_dev);
550
	neigh_parms_data_state_setall(in_dev->arp_parms);
L
Linus Torvalds 已提交
551
	if (ifa->ifa_dev != in_dev) {
552
		WARN_ON(ifa->ifa_dev);
L
Linus Torvalds 已提交
553 554 555
		in_dev_hold(in_dev);
		ifa->ifa_dev = in_dev;
	}
556
	if (ipv4_is_loopback(ifa->ifa_local))
L
Linus Torvalds 已提交
557 558 559 560
		ifa->ifa_scope = RT_SCOPE_HOST;
	return inet_insert_ifa(ifa);
}

561 562 563
/* Caller must hold RCU or RTNL :
 * We dont take a reference on found in_device
 */
564
struct in_device *inetdev_by_index(struct net *net, int ifindex)
L
Linus Torvalds 已提交
565 566 567
{
	struct net_device *dev;
	struct in_device *in_dev = NULL;
568 569 570

	rcu_read_lock();
	dev = dev_get_by_index_rcu(net, ifindex);
L
Linus Torvalds 已提交
571
	if (dev)
572
		in_dev = rcu_dereference_rtnl(dev->ip_ptr);
573
	rcu_read_unlock();
L
Linus Torvalds 已提交
574 575
	return in_dev;
}
E
Eric Dumazet 已提交
576
EXPORT_SYMBOL(inetdev_by_index);
L
Linus Torvalds 已提交
577 578 579

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

A
Al Viro 已提交
580 581
struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
				    __be32 mask)
L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591
{
	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;
}

592 593 594 595 596 597 598 599 600 601 602 603
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)
604
		ret = ip_mc_join_group(sk, &mreq);
605
	else
606
		ret = ip_mc_leave_group(sk, &mreq);
607 608 609 610 611
	release_sock(sk);

	return ret;
}

612 613
static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
			    struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
614
{
615
	struct net *net = sock_net(skb->sk);
616
	struct nlattr *tb[IFA_MAX+1];
L
Linus Torvalds 已提交
617
	struct in_device *in_dev;
618
	struct ifaddrmsg *ifm;
L
Linus Torvalds 已提交
619
	struct in_ifaddr *ifa, **ifap;
620
	int err = -EINVAL;
L
Linus Torvalds 已提交
621 622 623

	ASSERT_RTNL();

624
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy,
625
			  extack);
626 627 628 629
	if (err < 0)
		goto errout;

	ifm = nlmsg_data(nlh);
630
	in_dev = inetdev_by_index(net, ifm->ifa_index);
631
	if (!in_dev) {
632 633 634 635
		err = -ENODEV;
		goto errout;
	}

L
Linus Torvalds 已提交
636 637
	for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
	     ifap = &ifa->ifa_next) {
638
		if (tb[IFA_LOCAL] &&
639
		    ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
640 641 642
			continue;

		if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
L
Linus Torvalds 已提交
643
			continue;
644 645 646

		if (tb[IFA_ADDRESS] &&
		    (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
647
		    !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
648 649
			continue;

650 651
		if (ipv4_is_multicast(ifa->ifa_address))
			ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
652
		__inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
L
Linus Torvalds 已提交
653 654
		return 0;
	}
655 656 657 658

	err = -EADDRNOTAVAIL;
errout:
	return err;
L
Linus Torvalds 已提交
659 660
}

J
Jiri Pirko 已提交
661 662 663 664 665 666
#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;
667
	struct hlist_node *n;
J
Jiri Pirko 已提交
668 669 670 671 672 673
	int i;

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

	for (i = 0; i < IN4_ADDR_HSIZE; i++) {
674 675 676
		bool change_needed = false;

		rcu_read_lock();
677
		hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
J
Jiri Pirko 已提交
678 679 680 681 682 683 684 685 686 687 688
			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) {
689
				change_needed = true;
J
Jiri Pirko 已提交
690 691 692 693 694 695 696 697 698
			} 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;

699 700
				if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
					change_needed = true;
J
Jiri Pirko 已提交
701 702 703 704 705 706 707
			} else if (time_before(ifa->ifa_tstamp +
					       ifa->ifa_preferred_lft * HZ,
					       next)) {
				next = ifa->ifa_tstamp +
				       ifa->ifa_preferred_lft * HZ;
			}
		}
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
		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 已提交
743 744 745 746 747 748 749 750 751 752 753 754 755 756
	}

	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;

757 758
	queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
			next_sched - now);
J
Jiri Pirko 已提交
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
}

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,
D
David Ahern 已提交
786 787
				       __u32 *pvalid_lft, __u32 *pprefered_lft,
				       struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
788
{
789 790 791
	struct nlattr *tb[IFA_MAX+1];
	struct in_ifaddr *ifa;
	struct ifaddrmsg *ifm;
L
Linus Torvalds 已提交
792 793
	struct net_device *dev;
	struct in_device *in_dev;
794
	int err;
L
Linus Torvalds 已提交
795

796
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy,
D
David Ahern 已提交
797
			  extack);
798 799
	if (err < 0)
		goto errout;
L
Linus Torvalds 已提交
800

801
	ifm = nlmsg_data(nlh);
802
	err = -EINVAL;
803
	if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
804
		goto errout;
L
Linus Torvalds 已提交
805

806
	dev = __dev_get_by_index(net, ifm->ifa_index);
807
	err = -ENODEV;
808
	if (!dev)
809
		goto errout;
L
Linus Torvalds 已提交
810

811
	in_dev = __in_dev_get_rtnl(dev);
812
	err = -ENOBUFS;
813
	if (!in_dev)
814
		goto errout;
L
Linus Torvalds 已提交
815

816
	ifa = inet_alloc_ifa();
817
	if (!ifa)
818 819 820 821 822 823
		/*
		 * A potential indev allocation can be left alive, it stays
		 * assigned to its device and is destroy with it.
		 */
		goto errout;

824
	ipv4_devconf_setall(in_dev);
825
	neigh_parms_data_state_setall(in_dev->arp_parms);
826 827
	in_dev_hold(in_dev);

828
	if (!tb[IFA_ADDRESS])
829
		tb[IFA_ADDRESS] = tb[IFA_LOCAL];
L
Linus Torvalds 已提交
830

831
	INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
832 833
	ifa->ifa_prefixlen = ifm->ifa_prefixlen;
	ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
834 835
	ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
					 ifm->ifa_flags;
L
Linus Torvalds 已提交
836
	ifa->ifa_scope = ifm->ifa_scope;
837 838
	ifa->ifa_dev = in_dev;

839 840
	ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
	ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
841 842

	if (tb[IFA_BROADCAST])
843
		ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
844 845 846

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

850 851 852
	if (tb[IFA_RT_PRIORITY])
		ifa->ifa_rt_priority = nla_get_u32(tb[IFA_RT_PRIORITY]);

J
Jiri Pirko 已提交
853 854 855 856 857 858
	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;
859
			goto errout_free;
J
Jiri Pirko 已提交
860 861 862 863 864
		}
		*pvalid_lft = ci->ifa_valid;
		*pprefered_lft = ci->ifa_prefered;
	}

865 866
	return ifa;

867 868
errout_free:
	inet_free_ifa(ifa);
869 870 871 872
errout:
	return ERR_PTR(err);
}

J
Jiri Pirko 已提交
873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
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;
}

891 892
static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
			    struct netlink_ext_ack *extack)
893
{
894
	struct net *net = sock_net(skb->sk);
895
	struct in_ifaddr *ifa;
J
Jiri Pirko 已提交
896 897 898
	struct in_ifaddr *ifa_existing;
	__u32 valid_lft = INFINITY_LIFE_TIME;
	__u32 prefered_lft = INFINITY_LIFE_TIME;
899 900 901

	ASSERT_RTNL();

D
David Ahern 已提交
902
	ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft, extack);
903 904 905
	if (IS_ERR(ifa))
		return PTR_ERR(ifa);

J
Jiri Pirko 已提交
906 907 908
	ifa_existing = find_matching_ifa(ifa);
	if (!ifa_existing) {
		/* It would be best to check for !NLM_F_CREATE here but
S
stephen hemminger 已提交
909
		 * userspace already relies on not having to provide this.
J
Jiri Pirko 已提交
910 911
		 */
		set_ifa_lifetime(ifa, valid_lft, prefered_lft);
912 913 914 915 916 917 918 919 920
		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;
			}
		}
921 922
		return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid,
					 extack);
J
Jiri Pirko 已提交
923
	} else {
924 925
		u32 new_metric = ifa->ifa_rt_priority;

J
Jiri Pirko 已提交
926 927 928 929 930
		inet_free_ifa(ifa);

		if (nlh->nlmsg_flags & NLM_F_EXCL ||
		    !(nlh->nlmsg_flags & NLM_F_REPLACE))
			return -EEXIST;
931
		ifa = ifa_existing;
932 933 934 935 936 937

		if (ifa->ifa_rt_priority != new_metric) {
			fib_modify_prefix_metric(ifa, new_metric);
			ifa->ifa_rt_priority = new_metric;
		}

938
		set_ifa_lifetime(ifa, valid_lft, prefered_lft);
939
		cancel_delayed_work(&check_lifetime_work);
940 941
		queue_delayed_work(system_power_efficient_wq,
				&check_lifetime_work, 0);
942
		rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
J
Jiri Pirko 已提交
943 944
	}
	return 0;
L
Linus Torvalds 已提交
945 946 947 948 949 950
}

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

E
Eric Dumazet 已提交
951
static int inet_abc_len(__be32 addr)
L
Linus Torvalds 已提交
952 953 954
{
	int rc = -1;	/* Something else, probably a multicast. */

955
	if (ipv4_is_zeronet(addr))
956
		rc = 0;
L
Linus Torvalds 已提交
957
	else {
958
		__u32 haddr = ntohl(addr);
L
Linus Torvalds 已提交
959

960
		if (IN_CLASSA(haddr))
L
Linus Torvalds 已提交
961
			rc = 8;
962
		else if (IN_CLASSB(haddr))
L
Linus Torvalds 已提交
963
			rc = 16;
964
		else if (IN_CLASSC(haddr))
L
Linus Torvalds 已提交
965 966 967
			rc = 24;
	}

968
	return rc;
L
Linus Torvalds 已提交
969 970 971
}


972
int devinet_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr)
L
Linus Torvalds 已提交
973 974
{
	struct sockaddr_in sin_orig;
975
	struct sockaddr_in *sin = (struct sockaddr_in *)&ifr->ifr_addr;
L
Linus Torvalds 已提交
976 977 978 979 980 981 982 983
	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;

984
	ifr->ifr_name[IFNAMSIZ - 1] = 0;
L
Linus Torvalds 已提交
985 986 987 988

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

989
	colon = strchr(ifr->ifr_name, ':');
L
Linus Torvalds 已提交
990 991 992
	if (colon)
		*colon = 0;

993
	dev_load(net, ifr->ifr_name);
L
Linus Torvalds 已提交
994

S
Stephen Hemminger 已提交
995
	switch (cmd) {
L
Linus Torvalds 已提交
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	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:
1010
		ret = -EPERM;
1011
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016 1017
			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 */
1018
		ret = -EPERM;
1019
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
			goto out;
		ret = -EINVAL;
		if (sin->sin_family != AF_INET)
			goto out;
		break;
	default:
		ret = -EINVAL;
		goto out;
	}

	rtnl_lock();

	ret = -ENODEV;
1033
	dev = __dev_get_by_name(net, ifr->ifr_name);
E
Eric Dumazet 已提交
1034
	if (!dev)
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039
		goto done;

	if (colon)
		*colon = ':';

E
Eric Dumazet 已提交
1040 1041
	in_dev = __in_dev_get_rtnl(dev);
	if (in_dev) {
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046 1047 1048 1049
		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) {
1050
				if (!strcmp(ifr->ifr_name, ifa->ifa_label) &&
L
Linus Torvalds 已提交
1051
				    sin_orig.sin_addr.s_addr ==
1052
							ifa->ifa_local) {
L
Linus Torvalds 已提交
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
					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)
1063
				if (!strcmp(ifr->ifr_name, ifa->ifa_label))
L
Linus Torvalds 已提交
1064 1065 1066 1067 1068 1069 1070 1071
					break;
		}
	}

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

S
Stephen Hemminger 已提交
1072
	switch (cmd) {
L
Linus Torvalds 已提交
1073
	case SIOCGIFADDR:	/* Get interface address */
1074
		ret = 0;
L
Linus Torvalds 已提交
1075
		sin->sin_addr.s_addr = ifa->ifa_local;
1076
		break;
L
Linus Torvalds 已提交
1077 1078

	case SIOCGIFBRDADDR:	/* Get the broadcast address */
1079
		ret = 0;
L
Linus Torvalds 已提交
1080
		sin->sin_addr.s_addr = ifa->ifa_broadcast;
1081
		break;
L
Linus Torvalds 已提交
1082 1083

	case SIOCGIFDSTADDR:	/* Get the destination address */
1084
		ret = 0;
L
Linus Torvalds 已提交
1085
		sin->sin_addr.s_addr = ifa->ifa_address;
1086
		break;
L
Linus Torvalds 已提交
1087 1088

	case SIOCGIFNETMASK:	/* Get the netmask for the interface */
1089
		ret = 0;
L
Linus Torvalds 已提交
1090
		sin->sin_addr.s_addr = ifa->ifa_mask;
1091
		break;
L
Linus Torvalds 已提交
1092 1093 1094 1095 1096 1097 1098

	case SIOCSIFFLAGS:
		if (colon) {
			ret = -EADDRNOTAVAIL;
			if (!ifa)
				break;
			ret = 0;
1099
			if (!(ifr->ifr_flags & IFF_UP))
L
Linus Torvalds 已提交
1100 1101 1102
				inet_del_ifa(in_dev, ifap, 1);
			break;
		}
1103
		ret = dev_change_flags(dev, ifr->ifr_flags);
L
Linus Torvalds 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112
		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 已提交
1113 1114
			ifa = inet_alloc_ifa();
			if (!ifa)
L
Linus Torvalds 已提交
1115
				break;
1116
			INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
1117
			if (colon)
1118
				memcpy(ifa->ifa_label, ifr->ifr_name, IFNAMSIZ);
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124 1125 1126
			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;
1127
			ifa->ifa_scope = 0;
L
Linus Torvalds 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
		}

		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 已提交
1143
		set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
L
Linus Torvalds 已提交
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
		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 已提交
1179
			__be32 old_mask = ifa->ifa_mask;
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
			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 ==
1193
			     (ifa->ifa_local|~old_mask))) {
L
Linus Torvalds 已提交
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
				ifa->ifa_broadcast = (ifa->ifa_local |
						      ~sin->sin_addr.s_addr);
			}
			inet_insert_ifa(ifa);
		}
		break;
	}
done:
	rtnl_unlock();
out:
	return ret;
}

1207
static int inet_gifconf(struct net_device *dev, char __user *buf, int len, int size)
L
Linus Torvalds 已提交
1208
{
1209
	struct in_device *in_dev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
1210 1211 1212 1213
	struct in_ifaddr *ifa;
	struct ifreq ifr;
	int done = 0;

1214 1215 1216
	if (WARN_ON(size > sizeof(struct ifreq)))
		goto out;

E
Eric Dumazet 已提交
1217
	if (!in_dev)
L
Linus Torvalds 已提交
1218 1219
		goto out;

E
Eric Dumazet 已提交
1220
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
L
Linus Torvalds 已提交
1221
		if (!buf) {
1222
			done += size;
L
Linus Torvalds 已提交
1223 1224
			continue;
		}
1225
		if (len < size)
L
Linus Torvalds 已提交
1226 1227
			break;
		memset(&ifr, 0, sizeof(struct ifreq));
D
Dan Carpenter 已提交
1228
		strcpy(ifr.ifr_name, ifa->ifa_label);
L
Linus Torvalds 已提交
1229 1230 1231 1232 1233

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

1234
		if (copy_to_user(buf + done, &ifr, size)) {
L
Linus Torvalds 已提交
1235 1236 1237
			done = -EFAULT;
			break;
		}
1238 1239
		len  -= size;
		done += size;
L
Linus Torvalds 已提交
1240 1241 1242 1243 1244
	}
out:
	return done;
}

1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
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 已提交
1257
__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
L
Linus Torvalds 已提交
1258
{
A
Al Viro 已提交
1259
	__be32 addr = 0;
L
Linus Torvalds 已提交
1260
	struct in_device *in_dev;
1261
	struct net *net = dev_net(dev);
1262
	int master_idx;
L
Linus Torvalds 已提交
1263 1264

	rcu_read_lock();
1265
	in_dev = __in_dev_get_rcu(dev);
L
Linus Torvalds 已提交
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
	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)
1281
		goto out_unlock;
E
Eric Dumazet 已提交
1282
no_in_dev:
1283
	master_idx = l3mdev_master_ifindex_rcu(dev);
L
Linus Torvalds 已提交
1284

1285 1286 1287 1288 1289 1290 1291 1292
	/* 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))) {
1293 1294 1295
		addr = in_dev_select_addr(in_dev, scope);
		if (addr)
			goto out_unlock;
1296 1297
	}

L
Linus Torvalds 已提交
1298
	/* Not loopback addresses on loopback should be preferred
S
Stephen Hemminger 已提交
1299
	   in this case. It is important that lo is the first interface
L
Linus Torvalds 已提交
1300 1301
	   in dev_base list.
	 */
1302
	for_each_netdev_rcu(net, dev) {
1303 1304 1305
		if (l3mdev_master_ifindex_rcu(dev) != master_idx)
			continue;

E
Eric Dumazet 已提交
1306 1307
		in_dev = __in_dev_get_rcu(dev);
		if (!in_dev)
L
Linus Torvalds 已提交
1308 1309
			continue;

1310 1311 1312
		addr = in_dev_select_addr(in_dev, scope);
		if (addr)
			goto out_unlock;
L
Linus Torvalds 已提交
1313
	}
1314
out_unlock:
L
Linus Torvalds 已提交
1315 1316 1317
	rcu_read_unlock();
	return addr;
}
E
Eric Dumazet 已提交
1318
EXPORT_SYMBOL(inet_select_addr);
L
Linus Torvalds 已提交
1319

A
Al Viro 已提交
1320 1321
static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
			      __be32 local, int scope)
L
Linus Torvalds 已提交
1322 1323
{
	int same = 0;
A
Al Viro 已提交
1324
	__be32 addr = 0;
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353

	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 已提交
1354
	return same ? addr : 0;
L
Linus Torvalds 已提交
1355 1356 1357 1358
}

/*
 * Confirm that local IP address exists using wildcards:
1359 1360
 * - net: netns to check, cannot be NULL
 * - in_dev: only on this interface, NULL=any interface
L
Linus Torvalds 已提交
1361 1362 1363 1364
 * - 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
 */
1365
__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
1366
			 __be32 dst, __be32 local, int scope)
L
Linus Torvalds 已提交
1367
{
A
Al Viro 已提交
1368
	__be32 addr = 0;
1369
	struct net_device *dev;
L
Linus Torvalds 已提交
1370

1371
	if (in_dev)
1372
		return confirm_addr_indev(in_dev, dst, local, scope);
L
Linus Torvalds 已提交
1373 1374

	rcu_read_lock();
1375
	for_each_netdev_rcu(net, dev) {
E
Eric Dumazet 已提交
1376 1377
		in_dev = __in_dev_get_rcu(dev);
		if (in_dev) {
L
Linus Torvalds 已提交
1378 1379 1380 1381 1382 1383 1384 1385 1386
			addr = confirm_addr_indev(in_dev, dst, local, scope);
			if (addr)
				break;
		}
	}
	rcu_read_unlock();

	return addr;
}
1387
EXPORT_SYMBOL(inet_confirm_addr);
L
Linus Torvalds 已提交
1388 1389 1390 1391 1392 1393 1394

/*
 *	Device notifier
 */

int register_inetaddr_notifier(struct notifier_block *nb)
{
1395
	return blocking_notifier_chain_register(&inetaddr_chain, nb);
L
Linus Torvalds 已提交
1396
}
E
Eric Dumazet 已提交
1397
EXPORT_SYMBOL(register_inetaddr_notifier);
L
Linus Torvalds 已提交
1398 1399 1400

int unregister_inetaddr_notifier(struct notifier_block *nb)
{
1401
	return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
L
Linus Torvalds 已提交
1402
}
E
Eric Dumazet 已提交
1403
EXPORT_SYMBOL(unregister_inetaddr_notifier);
L
Linus Torvalds 已提交
1404

1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
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 已提交
1418 1419
/* 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 已提交
1420 1421
*/
static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1422
{
L
Linus Torvalds 已提交
1423 1424 1425
	struct in_ifaddr *ifa;
	int named = 0;

1426 1427
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
		char old[IFNAMSIZ], *dot;
L
Linus Torvalds 已提交
1428 1429

		memcpy(old, ifa->ifa_label, IFNAMSIZ);
1430
		memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
L
Linus Torvalds 已提交
1431
		if (named++ == 0)
1432
			goto skip;
1433
		dot = strchr(old, ':');
1434
		if (!dot) {
1435
			sprintf(old, ":%d", named);
L
Linus Torvalds 已提交
1436 1437
			dot = old;
		}
E
Eric Dumazet 已提交
1438
		if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
1439
			strcat(ifa->ifa_label, dot);
E
Eric Dumazet 已提交
1440
		else
1441
			strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1442 1443
skip:
		rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1444 1445
	}
}
L
Linus Torvalds 已提交
1446

E
Eric Dumazet 已提交
1447
static bool inetdev_valid_mtu(unsigned int mtu)
B
Breno Leitao 已提交
1448
{
1449
	return mtu >= IPV4_MIN_MTU;
B
Breno Leitao 已提交
1450 1451
}

1452 1453 1454 1455
static void inetdev_send_gratuitous_arp(struct net_device *dev,
					struct in_device *in_dev)

{
1456
	struct in_ifaddr *ifa;
1457

1458 1459 1460 1461 1462 1463 1464
	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);
	}
1465 1466
}

L
Linus Torvalds 已提交
1467 1468 1469 1470 1471
/* Called only under RTNL semaphore */

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

L
Linus Torvalds 已提交
1475 1476 1477
	ASSERT_RTNL();

	if (!in_dev) {
1478
		if (event == NETDEV_REGISTER) {
L
Linus Torvalds 已提交
1479
			in_dev = inetdev_init(dev);
1480 1481
			if (IS_ERR(in_dev))
				return notifier_from_errno(PTR_ERR(in_dev));
1482
			if (dev->flags & IFF_LOOPBACK) {
1483 1484
				IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
				IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1485
			}
B
Breno Leitao 已提交
1486 1487 1488 1489
		} else if (event == NETDEV_CHANGEMTU) {
			/* Re-enabling IP */
			if (inetdev_valid_mtu(dev->mtu))
				in_dev = inetdev_init(dev);
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494 1495
		}
		goto out;
	}

	switch (event) {
	case NETDEV_REGISTER:
1496
		pr_debug("%s: bug\n", __func__);
1497
		RCU_INIT_POINTER(dev->ip_ptr, NULL);
L
Linus Torvalds 已提交
1498 1499
		break;
	case NETDEV_UP:
B
Breno Leitao 已提交
1500
		if (!inetdev_valid_mtu(dev->mtu))
L
Linus Torvalds 已提交
1501
			break;
1502
		if (dev->flags & IFF_LOOPBACK) {
E
Eric Dumazet 已提交
1503 1504 1505
			struct in_ifaddr *ifa = inet_alloc_ifa();

			if (ifa) {
1506
				INIT_HLIST_NODE(&ifa->hash);
L
Linus Torvalds 已提交
1507 1508 1509 1510 1511 1512 1513 1514
				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 已提交
1515 1516
				set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
						 INFINITY_LIFE_TIME);
1517 1518
				ipv4_devconf_setall(in_dev);
				neigh_parms_data_state_setall(in_dev->arp_parms);
L
Linus Torvalds 已提交
1519 1520 1521 1522
				inet_insert_ifa(ifa);
			}
		}
		ip_mc_up(in_dev);
1523 1524
		/* fall through */
	case NETDEV_CHANGEADDR:
1525 1526 1527 1528
		if (!IN_DEV_ARP_NOTIFY(in_dev))
			break;
		/* fall through */
	case NETDEV_NOTIFY_PEERS:
1529
		/* Send gratuitous ARP to notify of link change */
1530
		inetdev_send_gratuitous_arp(dev, in_dev);
L
Linus Torvalds 已提交
1531 1532 1533 1534
		break;
	case NETDEV_DOWN:
		ip_mc_down(in_dev);
		break;
1535
	case NETDEV_PRE_TYPE_CHANGE:
1536 1537
		ip_mc_unmap(in_dev);
		break;
1538
	case NETDEV_POST_TYPE_CHANGE:
1539 1540
		ip_mc_remap(in_dev);
		break;
L
Linus Torvalds 已提交
1541
	case NETDEV_CHANGEMTU:
B
Breno Leitao 已提交
1542
		if (inetdev_valid_mtu(dev->mtu))
L
Linus Torvalds 已提交
1543
			break;
B
Breno Leitao 已提交
1544
		/* disable IP when MTU is not enough */
1545
		/* fall through */
L
Linus Torvalds 已提交
1546 1547 1548 1549 1550 1551 1552 1553 1554
	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);

1555
		devinet_sysctl_unregister(in_dev);
1556
		devinet_sysctl_register(in_dev);
L
Linus Torvalds 已提交
1557 1558 1559 1560 1561 1562 1563
		break;
	}
out:
	return NOTIFY_DONE;
}

static struct notifier_block ip_netdev_notifier = {
J
Jianjun Kong 已提交
1564
	.notifier_call = inetdev_event,
L
Linus Torvalds 已提交
1565 1566
};

E
Eric Dumazet 已提交
1567
static size_t inet_nlmsg_size(void)
1568 1569 1570 1571 1572
{
	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
	       + nla_total_size(4) /* IFA_ADDRESS */
	       + nla_total_size(4) /* IFA_LOCAL */
	       + nla_total_size(4) /* IFA_BROADCAST */
1573
	       + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
1574
	       + nla_total_size(4)  /* IFA_FLAGS */
1575
	       + nla_total_size(4)  /* IFA_RT_PRIORITY */
1576
	       + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
1577 1578
}

J
Jiri Pirko 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
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 已提交
1597
static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
C
Christian Brauner 已提交
1598
			    struct inet_fill_args *args)
L
Linus Torvalds 已提交
1599 1600 1601
{
	struct ifaddrmsg *ifm;
	struct nlmsghdr  *nlh;
J
Jiri Pirko 已提交
1602
	u32 preferred, valid;
L
Linus Torvalds 已提交
1603

C
Christian Brauner 已提交
1604 1605
	nlh = nlmsg_put(skb, args->portid, args->seq, args->event, sizeof(*ifm),
			args->flags);
1606
	if (!nlh)
1607
		return -EMSGSIZE;
1608 1609

	ifm = nlmsg_data(nlh);
L
Linus Torvalds 已提交
1610 1611
	ifm->ifa_family = AF_INET;
	ifm->ifa_prefixlen = ifa->ifa_prefixlen;
J
Jiri Pirko 已提交
1612
	ifm->ifa_flags = ifa->ifa_flags;
L
Linus Torvalds 已提交
1613 1614
	ifm->ifa_scope = ifa->ifa_scope;
	ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1615

C
Christian Brauner 已提交
1616 1617
	if (args->netnsid >= 0 &&
	    nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
1618 1619
		goto nla_put_failure;

J
Jiri Pirko 已提交
1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
	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 已提交
1641
	if ((ifa->ifa_address &&
1642
	     nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
D
David S. Miller 已提交
1643
	    (ifa->ifa_local &&
1644
	     nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
D
David S. Miller 已提交
1645
	    (ifa->ifa_broadcast &&
1646
	     nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
D
David S. Miller 已提交
1647
	    (ifa->ifa_label[0] &&
J
Jiri Pirko 已提交
1648
	     nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
1649
	    nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
1650 1651
	    (ifa->ifa_rt_priority &&
	     nla_put_u32(skb, IFA_RT_PRIORITY, ifa->ifa_rt_priority)) ||
J
Jiri Pirko 已提交
1652 1653
	    put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
			  preferred, valid))
D
David S. Miller 已提交
1654
		goto nla_put_failure;
L
Linus Torvalds 已提交
1655

1656 1657
	nlmsg_end(skb, nlh);
	return 0;
1658 1659

nla_put_failure:
1660 1661
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
1662 1663
}

1664 1665 1666
static int inet_valid_dump_ifaddr_req(const struct nlmsghdr *nlh,
				      struct inet_fill_args *fillargs,
				      struct net **tgt_net, struct sock *sk,
1667
				      struct netlink_callback *cb)
1668
{
1669
	struct netlink_ext_ack *extack = cb->extack;
1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
	struct nlattr *tb[IFA_MAX+1];
	struct ifaddrmsg *ifm;
	int err, i;

	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
		NL_SET_ERR_MSG(extack, "ipv4: Invalid header for address dump request");
		return -EINVAL;
	}

	ifm = nlmsg_data(nlh);
	if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
		NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for address dump request");
		return -EINVAL;
	}
1684 1685 1686 1687 1688

	fillargs->ifindex = ifm->ifa_index;
	if (fillargs->ifindex) {
		cb->answer_flags |= NLM_F_DUMP_FILTERED;
		fillargs->flags |= NLM_F_DUMP_FILTERED;
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
	}

	err = nlmsg_parse_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
				 ifa_ipv4_policy, extack);
	if (err < 0)
		return err;

	for (i = 0; i <= IFA_MAX; ++i) {
		if (!tb[i])
			continue;

		if (i == IFA_TARGET_NETNSID) {
			struct net *net;

			fillargs->netnsid = nla_get_s32(tb[i]);

			net = rtnl_get_net_ns_capable(sk, fillargs->netnsid);
			if (IS_ERR(net)) {
1707
				fillargs->netnsid = -1;
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
				NL_SET_ERR_MSG(extack, "ipv4: Invalid target network namespace id");
				return PTR_ERR(net);
			}
			*tgt_net = net;
		} else {
			NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in dump request");
			return -EINVAL;
		}
	}

	return 0;
}

1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
static int in_dev_dump_addr(struct in_device *in_dev, struct sk_buff *skb,
			    struct netlink_callback *cb, int s_ip_idx,
			    struct inet_fill_args *fillargs)
{
	struct in_ifaddr *ifa;
	int ip_idx = 0;
	int err;

	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next, ip_idx++) {
		if (ip_idx < s_ip_idx)
			continue;

		err = inet_fill_ifaddr(skb, ifa, fillargs);
		if (err < 0)
			goto done;

		nl_dump_check_consistent(cb, nlmsg_hdr(skb));
	}
	err = 0;

done:
	cb->args[2] = ip_idx;

	return err;
}

L
Linus Torvalds 已提交
1747 1748
static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
1749
	const struct nlmsghdr *nlh = cb->nlh;
C
Christian Brauner 已提交
1750 1751
	struct inet_fill_args fillargs = {
		.portid = NETLINK_CB(cb->skb).portid,
1752
		.seq = nlh->nlmsg_seq,
C
Christian Brauner 已提交
1753 1754 1755 1756
		.event = RTM_NEWADDR,
		.flags = NLM_F_MULTI,
		.netnsid = -1,
	};
1757
	struct net *net = sock_net(skb->sk);
1758
	struct net *tgt_net = net;
E
Eric Dumazet 已提交
1759 1760
	int h, s_h;
	int idx, s_idx;
1761
	int s_ip_idx;
L
Linus Torvalds 已提交
1762 1763
	struct net_device *dev;
	struct in_device *in_dev;
E
Eric Dumazet 已提交
1764
	struct hlist_head *head;
1765
	int err = 0;
L
Linus Torvalds 已提交
1766

E
Eric Dumazet 已提交
1767 1768
	s_h = cb->args[0];
	s_idx = idx = cb->args[1];
1769
	s_ip_idx = cb->args[2];
E
Eric Dumazet 已提交
1770

1771 1772
	if (cb->strict_check) {
		err = inet_valid_dump_ifaddr_req(nlh, &fillargs, &tgt_net,
1773
						 skb->sk, cb);
1774
		if (err < 0)
1775
			goto put_tgt_net;
1776

1777
		err = 0;
1778 1779
		if (fillargs.ifindex) {
			dev = __dev_get_by_index(tgt_net, fillargs.ifindex);
1780 1781 1782 1783
			if (!dev) {
				err = -ENODEV;
				goto put_tgt_net;
			}
1784 1785 1786 1787 1788 1789 1790 1791

			in_dev = __in_dev_get_rtnl(dev);
			if (in_dev) {
				err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
						       &fillargs);
			}
			goto put_tgt_net;
		}
1792 1793
	}

E
Eric Dumazet 已提交
1794 1795
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
1796
		head = &tgt_net->dev_index_head[h];
E
Eric Dumazet 已提交
1797
		rcu_read_lock();
1798 1799
		cb->seq = atomic_read(&tgt_net->ipv4.dev_addr_genid) ^
			  tgt_net->dev_base_seq;
1800
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
E
Eric Dumazet 已提交
1801 1802
			if (idx < s_idx)
				goto cont;
1803
			if (h > s_h || idx > s_idx)
E
Eric Dumazet 已提交
1804 1805 1806 1807
				s_ip_idx = 0;
			in_dev = __in_dev_get_rcu(dev);
			if (!in_dev)
				goto cont;
L
Linus Torvalds 已提交
1808

1809 1810 1811 1812 1813
			err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
					       &fillargs);
			if (err < 0) {
				rcu_read_unlock();
				goto done;
E
Eric Dumazet 已提交
1814
			}
1815
cont:
E
Eric Dumazet 已提交
1816 1817 1818
			idx++;
		}
		rcu_read_unlock();
L
Linus Torvalds 已提交
1819 1820 1821
	}

done:
E
Eric Dumazet 已提交
1822 1823
	cb->args[0] = h;
	cb->args[1] = idx;
1824
put_tgt_net:
C
Christian Brauner 已提交
1825
	if (fillargs.netnsid >= 0)
1826
		put_net(tgt_net);
L
Linus Torvalds 已提交
1827

1828
	return err < 0 ? err : skb->len;
L
Linus Torvalds 已提交
1829 1830
}

J
Jianjun Kong 已提交
1831
static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1832
		      u32 portid)
L
Linus Torvalds 已提交
1833
{
C
Christian Brauner 已提交
1834 1835 1836 1837 1838 1839 1840
	struct inet_fill_args fillargs = {
		.portid = portid,
		.seq = nlh ? nlh->nlmsg_seq : 0,
		.event = event,
		.flags = 0,
		.netnsid = -1,
	};
1841
	struct sk_buff *skb;
1842
	int err = -ENOBUFS;
1843
	struct net *net;
L
Linus Torvalds 已提交
1844

1845
	net = dev_net(ifa->ifa_dev->dev);
1846
	skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1847
	if (!skb)
1848 1849
		goto errout;

C
Christian Brauner 已提交
1850
	err = inet_fill_ifaddr(skb, ifa, &fillargs);
1851 1852 1853 1854 1855 1856
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
1857
	rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1858
	return;
1859 1860
errout:
	if (err < 0)
1861
		rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
L
Linus Torvalds 已提交
1862 1863
}

1864 1865
static size_t inet_get_link_af_size(const struct net_device *dev,
				    u32 ext_filter_mask)
T
Thomas Graf 已提交
1866
{
E
Eric Dumazet 已提交
1867
	struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
T
Thomas Graf 已提交
1868 1869 1870 1871 1872 1873 1874

	if (!in_dev)
		return 0;

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

1875 1876
static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
			     u32 ext_filter_mask)
T
Thomas Graf 已提交
1877
{
E
Eric Dumazet 已提交
1878
	struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
T
Thomas Graf 已提交
1879 1880 1881 1882 1883 1884 1885
	struct nlattr *nla;
	int i;

	if (!in_dev)
		return -ENODATA;

	nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
1886
	if (!nla)
T
Thomas Graf 已提交
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
		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 },
};

1899 1900
static int inet_validate_link_af(const struct net_device *dev,
				 const struct nlattr *nla)
T
Thomas Graf 已提交
1901 1902 1903 1904
{
	struct nlattr *a, *tb[IFLA_INET_MAX+1];
	int err, rem;

F
Florian Westphal 已提交
1905
	if (dev && !__in_dev_get_rcu(dev))
1906
		return -EAFNOSUPPORT;
T
Thomas Graf 已提交
1907

1908
	err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy, NULL);
T
Thomas Graf 已提交
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
	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;
		}
	}

1924 1925 1926 1927 1928
	return 0;
}

static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
{
F
Florian Westphal 已提交
1929
	struct in_device *in_dev = __in_dev_get_rcu(dev);
1930 1931 1932 1933 1934 1935
	struct nlattr *a, *tb[IFLA_INET_MAX+1];
	int rem;

	if (!in_dev)
		return -EAFNOSUPPORT;

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

T
Thomas Graf 已提交
1939 1940 1941 1942 1943 1944 1945 1946
	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;
}

1947 1948 1949 1950
static int inet_netconf_msgsize_devconf(int type)
{
	int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
		   + nla_total_size(4);	/* NETCONFA_IFINDEX */
1951
	bool all = false;
1952

1953 1954 1955 1956
	if (type == NETCONFA_ALL)
		all = true;

	if (all || type == NETCONFA_FORWARDING)
1957
		size += nla_total_size(4);
1958
	if (all || type == NETCONFA_RP_FILTER)
1959
		size += nla_total_size(4);
1960
	if (all || type == NETCONFA_MC_FORWARDING)
1961
		size += nla_total_size(4);
1962 1963
	if (all || type == NETCONFA_BC_FORWARDING)
		size += nla_total_size(4);
1964
	if (all || type == NETCONFA_PROXY_NEIGH)
S
stephen hemminger 已提交
1965
		size += nla_total_size(4);
1966
	if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
1967
		size += nla_total_size(4);
1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978

	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;
1979
	bool all = false;
1980 1981 1982

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
			flags);
1983
	if (!nlh)
1984 1985
		return -EMSGSIZE;

1986 1987 1988
	if (type == NETCONFA_ALL)
		all = true;

1989 1990 1991 1992 1993 1994
	ncm = nlmsg_data(nlh);
	ncm->ncm_family = AF_INET;

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

1995 1996 1997
	if (!devconf)
		goto out;

1998
	if ((all || type == NETCONFA_FORWARDING) &&
1999 2000 2001
	    nla_put_s32(skb, NETCONFA_FORWARDING,
			IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
		goto nla_put_failure;
2002
	if ((all || type == NETCONFA_RP_FILTER) &&
2003 2004 2005
	    nla_put_s32(skb, NETCONFA_RP_FILTER,
			IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
		goto nla_put_failure;
2006
	if ((all || type == NETCONFA_MC_FORWARDING) &&
2007 2008 2009
	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
			IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
		goto nla_put_failure;
2010 2011 2012 2013
	if ((all || type == NETCONFA_BC_FORWARDING) &&
	    nla_put_s32(skb, NETCONFA_BC_FORWARDING,
			IPV4_DEVCONF(*devconf, BC_FORWARDING)) < 0)
		goto nla_put_failure;
2014
	if ((all || type == NETCONFA_PROXY_NEIGH) &&
2015
	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
S
stephen hemminger 已提交
2016 2017
			IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
		goto nla_put_failure;
2018
	if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
2019 2020 2021
	    nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
			IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
		goto nla_put_failure;
2022

2023
out:
2024 2025
	nlmsg_end(skb, nlh);
	return 0;
2026 2027 2028 2029 2030 2031

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

2032 2033
void inet_netconf_notify_devconf(struct net *net, int event, int type,
				 int ifindex, struct ipv4_devconf *devconf)
2034 2035 2036 2037
{
	struct sk_buff *skb;
	int err = -ENOBUFS;

2038
	skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
2039
	if (!skb)
2040 2041 2042
		goto errout;

	err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
2043
					event, 0, type);
2044 2045 2046 2047 2048 2049
	if (err < 0) {
		/* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
2050
	rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
2051 2052 2053 2054 2055 2056
	return;
errout:
	if (err < 0)
		rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
}

2057 2058 2059
static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
2060
	[NETCONFA_RP_FILTER]	= { .len = sizeof(int) },
2061
	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
2062
	[NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]	= { .len = sizeof(int) },
2063 2064 2065
};

static int inet_netconf_get_devconf(struct sk_buff *in_skb,
2066 2067
				    struct nlmsghdr *nlh,
				    struct netlink_ext_ack *extack)
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
{
	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,
2080
			  devconf_ipv4_policy, extack);
2081 2082 2083
	if (err < 0)
		goto errout;

2084
	err = -EINVAL;
2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
	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);
2098
		if (!dev)
2099 2100
			goto errout;
		in_dev = __in_dev_get_rtnl(dev);
2101
		if (!in_dev)
2102 2103 2104 2105 2106 2107
			goto errout;
		devconf = &in_dev->cnf;
		break;
	}

	err = -ENOBUFS;
2108
	skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
2109
	if (!skb)
2110 2111 2112 2113 2114
		goto errout;

	err = inet_netconf_fill_devconf(skb, ifindex, devconf,
					NETLINK_CB(in_skb).portid,
					nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
2115
					NETCONFA_ALL);
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
	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;
}

2127 2128 2129
static int inet_netconf_dump_devconf(struct sk_buff *skb,
				     struct netlink_callback *cb)
{
2130
	const struct nlmsghdr *nlh = cb->nlh;
2131 2132 2133 2134 2135 2136 2137
	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;

2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152
	if (cb->strict_check) {
		struct netlink_ext_ack *extack = cb->extack;
		struct netconfmsg *ncm;

		if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ncm))) {
			NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf dump request");
			return -EINVAL;
		}

		if (nlmsg_attrlen(nlh, sizeof(*ncm))) {
			NL_SET_ERR_MSG(extack, "ipv4: Invalid data after header in netconf dump request");
			return -EINVAL;
		}
	}

2153 2154 2155 2156 2157 2158 2159
	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();
2160 2161
		cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
			  net->dev_base_seq;
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
		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,
2172
						      nlh->nlmsg_seq,
2173 2174
						      RTM_NEWNETCONF,
						      NLM_F_MULTI,
2175
						      NETCONFA_ALL) < 0) {
2176 2177 2178
				rcu_read_unlock();
				goto done;
			}
2179
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2180 2181 2182 2183 2184 2185 2186 2187 2188
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,
2189
					      nlh->nlmsg_seq,
2190
					      RTM_NEWNETCONF, NLM_F_MULTI,
2191
					      NETCONFA_ALL) < 0)
2192 2193 2194 2195 2196 2197 2198 2199
			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,
2200
					      nlh->nlmsg_seq,
2201
					      RTM_NEWNETCONF, NLM_F_MULTI,
2202
					      NETCONFA_ALL) < 0)
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
			goto done;
		else
			h++;
	}
done:
	cb->args[0] = h;
	cb->args[1] = idx;

	return skb->len;
}

L
Linus Torvalds 已提交
2214 2215
#ifdef CONFIG_SYSCTL

2216
static void devinet_copy_dflt_conf(struct net *net, int i)
2217 2218 2219
{
	struct net_device *dev;

2220 2221
	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
2222
		struct in_device *in_dev;
2223

2224 2225
		in_dev = __in_dev_get_rcu(dev);
		if (in_dev && !test_bit(i, in_dev->cnf.state))
2226
			in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
2227
	}
2228
	rcu_read_unlock();
2229 2230
}

2231
/* called with RTNL locked */
2232
static void inet_forward_change(struct net *net)
2233 2234
{
	struct net_device *dev;
2235
	int on = IPV4_DEVCONF_ALL(net, FORWARDING);
2236

2237
	IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
2238
	IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
2239 2240
	inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
				    NETCONFA_FORWARDING,
2241 2242
				    NETCONFA_IFINDEX_ALL,
				    net->ipv4.devconf_all);
2243 2244
	inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
				    NETCONFA_FORWARDING,
2245 2246
				    NETCONFA_IFINDEX_DEFAULT,
				    net->ipv4.devconf_dflt);
2247

2248
	for_each_netdev(net, dev) {
2249
		struct in_device *in_dev;
2250

2251 2252
		if (on)
			dev_disable_lro(dev);
2253 2254

		in_dev = __in_dev_get_rtnl(dev);
2255
		if (in_dev) {
2256
			IN_DEV_CONF_SET(in_dev, FORWARDING, on);
2257 2258
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_FORWARDING,
2259 2260
						    dev->ifindex, &in_dev->cnf);
		}
2261 2262 2263
	}
}

S
stephen hemminger 已提交
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
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;
	}
}

2277
static int devinet_conf_proc(struct ctl_table *ctl, int write,
2278
			     void __user *buffer,
2279 2280
			     size_t *lenp, loff_t *ppos)
{
2281
	int old_value = *(int *)ctl->data;
2282
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2283
	int new_value = *(int *)ctl->data;
2284 2285 2286

	if (write) {
		struct ipv4_devconf *cnf = ctl->extra1;
2287
		struct net *net = ctl->extra2;
2288
		int i = (int *)ctl->data - cnf->data;
S
stephen hemminger 已提交
2289
		int ifindex;
2290 2291 2292

		set_bit(i, cnf->state);

2293
		if (cnf == net->ipv4.devconf_dflt)
2294
			devinet_copy_dflt_conf(net, i);
2295 2296
		if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
		    i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
2297
			if ((new_value == 0) && (old_value != 0))
2298
				rt_cache_flush(net);
S
stephen hemminger 已提交
2299

2300 2301 2302 2303
		if (i == IPV4_DEVCONF_BC_FORWARDING - 1 &&
		    new_value != old_value)
			rt_cache_flush(net);

2304 2305
		if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
		    new_value != old_value) {
S
stephen hemminger 已提交
2306
			ifindex = devinet_conf_ifindex(net, cnf);
2307 2308
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_RP_FILTER,
2309 2310
						    ifindex, cnf);
		}
S
stephen hemminger 已提交
2311 2312 2313
		if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
		    new_value != old_value) {
			ifindex = devinet_conf_ifindex(net, cnf);
2314 2315
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_PROXY_NEIGH,
S
stephen hemminger 已提交
2316 2317
						    ifindex, cnf);
		}
2318 2319 2320
		if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
		    new_value != old_value) {
			ifindex = devinet_conf_ifindex(net, cnf);
2321 2322
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
2323 2324
						    ifindex, cnf);
		}
2325 2326 2327 2328 2329
	}

	return ret;
}

2330
static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
2331
				  void __user *buffer,
L
Linus Torvalds 已提交
2332 2333 2334 2335
				  size_t *lenp, loff_t *ppos)
{
	int *valp = ctl->data;
	int val = *valp;
E
Eric W. Biederman 已提交
2336
	loff_t pos = *ppos;
2337
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
L
Linus Torvalds 已提交
2338 2339

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

2342
		if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
E
Eric W. Biederman 已提交
2343 2344 2345 2346
			if (!rtnl_trylock()) {
				/* Restore the original values before restarting */
				*valp = val;
				*ppos = pos;
2347
				return restart_syscall();
E
Eric W. Biederman 已提交
2348
			}
2349 2350
			if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
				inet_forward_change(net);
2351
			} else {
2352 2353 2354
				struct ipv4_devconf *cnf = ctl->extra1;
				struct in_device *idev =
					container_of(cnf, struct in_device, cnf);
2355 2356
				if (*valp)
					dev_disable_lro(idev->dev);
2357
				inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
2358 2359 2360
							    NETCONFA_FORWARDING,
							    idev->dev->ifindex,
							    cnf);
2361 2362
			}
			rtnl_unlock();
2363
			rt_cache_flush(net);
2364
		} else
2365 2366
			inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
						    NETCONFA_FORWARDING,
2367 2368
						    NETCONFA_IFINDEX_DEFAULT,
						    net->ipv4.devconf_dflt);
L
Linus Torvalds 已提交
2369 2370 2371 2372 2373
	}

	return ret;
}

2374
static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
2375 2376
				void __user *buffer,
				size_t *lenp, loff_t *ppos)
L
Linus Torvalds 已提交
2377 2378 2379
{
	int *valp = ctl->data;
	int val = *valp;
2380
	int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2381
	struct net *net = ctl->extra2;
L
Linus Torvalds 已提交
2382 2383

	if (write && *valp != val)
2384
		rt_cache_flush(net);
L
Linus Torvalds 已提交
2385 2386 2387 2388

	return ret;
}

2389
#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
2390 2391 2392
	{ \
		.procname	= name, \
		.data		= ipv4_devconf.data + \
2393
				  IPV4_DEVCONF_ ## attr - 1, \
2394 2395 2396
		.maxlen		= sizeof(int), \
		.mode		= mval, \
		.proc_handler	= proc, \
2397
		.extra1		= &ipv4_devconf, \
2398 2399 2400
	}

#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
2401
	DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
2402 2403

#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
2404
	DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
2405

2406 2407
#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
	DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
2408 2409

#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
2410
	DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
2411

L
Linus Torvalds 已提交
2412 2413
static struct devinet_sysctl_table {
	struct ctl_table_header *sysctl_header;
2414
	struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
L
Linus Torvalds 已提交
2415 2416
} devinet_sysctl = {
	.devinet_vars = {
2417
		DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
2418
					     devinet_sysctl_forward),
2419
		DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
2420
		DEVINET_SYSCTL_RW_ENTRY(BC_FORWARDING, "bc_forwarding"),
2421 2422 2423 2424 2425 2426 2427 2428

		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"),
2429
		DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
2430
		DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
2431 2432 2433 2434 2435 2436 2437 2438 2439
		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"),
2440
		DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
2441
		DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
2442 2443
		DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
					"force_igmp_version"),
2444 2445 2446 2447
		DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
					"igmpv2_unsolicited_report_interval"),
		DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
					"igmpv3_unsolicited_report_interval"),
2448 2449
		DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
					"ignore_routes_with_linkdown"),
2450 2451
		DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
					"drop_gratuitous_arp"),
2452 2453 2454 2455 2456

		DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
		DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
		DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
					      "promote_secondaries"),
2457 2458
		DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
					      "route_localnet"),
2459 2460
		DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
					      "drop_unicast_in_l2_multicast"),
L
Linus Torvalds 已提交
2461 2462 2463
	},
};

2464
static int __devinet_sysctl_register(struct net *net, char *dev_name,
2465
				     int ifindex, struct ipv4_devconf *p)
L
Linus Torvalds 已提交
2466 2467
{
	int i;
2468
	struct devinet_sysctl_table *t;
2469
	char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
2470

2471
	t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
L
Linus Torvalds 已提交
2472
	if (!t)
2473 2474
		goto out;

L
Linus Torvalds 已提交
2475 2476
	for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
		t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
2477
		t->devinet_vars[i].extra1 = p;
2478
		t->devinet_vars[i].extra2 = net;
L
Linus Torvalds 已提交
2479 2480
	}

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

2483
	t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
L
Linus Torvalds 已提交
2484
	if (!t->sysctl_header)
2485
		goto free;
L
Linus Torvalds 已提交
2486 2487

	p->sysctl = t;
2488

2489 2490
	inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
				    ifindex, p);
2491
	return 0;
L
Linus Torvalds 已提交
2492

2493
free:
L
Linus Torvalds 已提交
2494
	kfree(t);
2495
out:
2496
	return -ENOBUFS;
L
Linus Torvalds 已提交
2497 2498
}

2499 2500
static void __devinet_sysctl_unregister(struct net *net,
					struct ipv4_devconf *cnf, int ifindex)
2501 2502 2503
{
	struct devinet_sysctl_table *t = cnf->sysctl;

2504 2505 2506 2507 2508
	if (t) {
		cnf->sysctl = NULL;
		unregister_net_sysctl_table(t->sysctl_header);
		kfree(t);
	}
2509

2510
	inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
2511 2512
}

2513
static int devinet_sysctl_register(struct in_device *idev)
2514
{
2515 2516 2517 2518 2519 2520 2521 2522 2523
	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,
2524
					idev->dev->ifindex, &idev->cnf);
2525 2526 2527
	if (err)
		neigh_sysctl_unregister(idev->arp_parms);
	return err;
2528 2529
}

2530
static void devinet_sysctl_unregister(struct in_device *idev)
L
Linus Torvalds 已提交
2531
{
2532 2533 2534
	struct net *net = dev_net(idev->dev);

	__devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
2535
	neigh_sysctl_unregister(idev->arp_parms);
L
Linus Torvalds 已提交
2536 2537
}

2538 2539 2540 2541
static struct ctl_table ctl_forward_entry[] = {
	{
		.procname	= "ip_forward",
		.data		= &ipv4_devconf.data[
2542
					IPV4_DEVCONF_FORWARDING - 1],
2543 2544 2545 2546
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= devinet_sysctl_forward,
		.extra1		= &ipv4_devconf,
2547
		.extra2		= &init_net,
2548 2549 2550
	},
	{ },
};
2551
#endif
2552

2553 2554 2555 2556
static __net_init int devinet_init_net(struct net *net)
{
	int err;
	struct ipv4_devconf *all, *dflt;
2557 2558
#ifdef CONFIG_SYSCTL
	struct ctl_table *tbl = ctl_forward_entry;
2559
	struct ctl_table_header *forw_hdr;
2560
#endif
2561 2562 2563 2564 2565

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

O
Octavian Purdila 已提交
2566
	if (!net_eq(net, &init_net)) {
2567
		all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
2568
		if (!all)
2569 2570 2571
			goto err_alloc_all;

		dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
2572
		if (!dflt)
2573 2574
			goto err_alloc_dflt;

2575
#ifdef CONFIG_SYSCTL
2576
		tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
2577
		if (!tbl)
2578 2579
			goto err_alloc_ctl;

2580
		tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
2581 2582
		tbl[0].extra1 = all;
		tbl[0].extra2 = net;
2583
#endif
2584 2585 2586
	}

#ifdef CONFIG_SYSCTL
2587
	err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
2588 2589 2590
	if (err < 0)
		goto err_reg_all;

2591 2592
	err = __devinet_sysctl_register(net, "default",
					NETCONFA_IFINDEX_DEFAULT, dflt);
2593 2594 2595 2596
	if (err < 0)
		goto err_reg_dflt;

	err = -ENOMEM;
2597
	forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
2598
	if (!forw_hdr)
2599
		goto err_reg_ctl;
2600
	net->ipv4.forw_hdr = forw_hdr;
2601 2602 2603 2604 2605 2606 2607 2608
#endif

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

#ifdef CONFIG_SYSCTL
err_reg_ctl:
2609
	__devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
2610
err_reg_dflt:
2611
	__devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
2612 2613 2614 2615
err_reg_all:
	if (tbl != ctl_forward_entry)
		kfree(tbl);
err_alloc_ctl:
2616
#endif
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
	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)
{
2628
#ifdef CONFIG_SYSCTL
2629 2630 2631 2632
	struct ctl_table *tbl;

	tbl = net->ipv4.forw_hdr->ctl_table_arg;
	unregister_net_sysctl_table(net->ipv4.forw_hdr);
2633 2634 2635 2636
	__devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
				    NETCONFA_IFINDEX_DEFAULT);
	__devinet_sysctl_unregister(net, net->ipv4.devconf_all,
				    NETCONFA_IFINDEX_ALL);
2637
	kfree(tbl);
2638
#endif
2639 2640 2641 2642 2643 2644 2645 2646 2647
	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,
};

2648
static struct rtnl_af_ops inet_af_ops __read_mostly = {
T
Thomas Graf 已提交
2649 2650 2651
	.family		  = AF_INET,
	.fill_link_af	  = inet_fill_link_af,
	.get_link_af_size = inet_get_link_af_size,
2652 2653
	.validate_link_af = inet_validate_link_af,
	.set_link_af	  = inet_set_link_af,
T
Thomas Graf 已提交
2654 2655
};

L
Linus Torvalds 已提交
2656 2657
void __init devinet_init(void)
{
2658 2659 2660 2661 2662
	int i;

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

2663 2664
	register_pernet_subsys(&devinet_ops);

L
Linus Torvalds 已提交
2665 2666
	register_gifconf(PF_INET, inet_gifconf);
	register_netdevice_notifier(&ip_netdev_notifier);
2667

2668
	queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
J
Jiri Pirko 已提交
2669

T
Thomas Graf 已提交
2670 2671
	rtnl_af_register(&inet_af_ops);

2672 2673 2674
	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);
2675
	rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
2676
		      inet_netconf_dump_devconf, 0);
L
Linus Torvalds 已提交
2677
}