rtnetlink.c 23.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		Routing netlink socket interface: protocol independent part.
 *
 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 *		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.
 *
 *	Fixes:
 *	Vitaly E. Lavrov		RTA_OK arithmetics was wrong.
 */

#include <linux/errno.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/capability.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/security.h>
36
#include <linux/mutex.h>
37
#include <linux/if_addr.h>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51

#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/string.h>

#include <linux/inet.h>
#include <linux/netdevice.h>
#include <net/ip.h>
#include <net/protocol.h>
#include <net/arp.h>
#include <net/route.h>
#include <net/udp.h>
#include <net/sock.h>
#include <net/pkt_sched.h>
52
#include <net/fib_rules.h>
53
#include <net/rtnetlink.h>
L
Linus Torvalds 已提交
54

55 56 57 58 59 60
struct rtnl_link
{
	rtnl_doit_func		doit;
	rtnl_dumpit_func	dumpit;
};

61
static DEFINE_MUTEX(rtnl_mutex);
T
Thomas Graf 已提交
62
static struct sock *rtnl;
L
Linus Torvalds 已提交
63 64 65

void rtnl_lock(void)
{
66
	mutex_lock(&rtnl_mutex);
L
Linus Torvalds 已提交
67 68
}

69
void __rtnl_unlock(void)
L
Linus Torvalds 已提交
70
{
71
	mutex_unlock(&rtnl_mutex);
L
Linus Torvalds 已提交
72
}
73

L
Linus Torvalds 已提交
74 75
void rtnl_unlock(void)
{
76 77 78
	mutex_unlock(&rtnl_mutex);
	if (rtnl && rtnl->sk_receive_queue.qlen)
		rtnl->sk_data_ready(rtnl, 0);
L
Linus Torvalds 已提交
79 80 81
	netdev_run_todo();
}

82 83 84 85 86
int rtnl_trylock(void)
{
	return mutex_trylock(&rtnl_mutex);
}

L
Linus Torvalds 已提交
87 88 89 90 91 92 93 94 95 96 97 98 99
int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len)
{
	memset(tb, 0, sizeof(struct rtattr*)*maxattr);

	while (RTA_OK(rta, len)) {
		unsigned flavor = rta->rta_type;
		if (flavor && flavor <= maxattr)
			tb[flavor-1] = rta;
		rta = RTA_NEXT(rta, len);
	}
	return 0;
}

A
Adrian Bunk 已提交
100
static struct rtnl_link *rtnl_msg_handlers[NPROTO];
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

static inline int rtm_msgindex(int msgtype)
{
	int msgindex = msgtype - RTM_BASE;

	/*
	 * msgindex < 0 implies someone tried to register a netlink
	 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
	 * the message type has not been added to linux/rtnetlink.h
	 */
	BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);

	return msgindex;
}

static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex)
{
	struct rtnl_link *tab;

	tab = rtnl_msg_handlers[protocol];
121
	if (tab == NULL || tab[msgindex].doit == NULL)
122 123
		tab = rtnl_msg_handlers[PF_UNSPEC];

124
	return tab ? tab[msgindex].doit : NULL;
125 126 127 128 129 130 131
}

static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex)
{
	struct rtnl_link *tab;

	tab = rtnl_msg_handlers[protocol];
132
	if (tab == NULL || tab[msgindex].dumpit == NULL)
133 134
		tab = rtnl_msg_handlers[PF_UNSPEC];

135
	return tab ? tab[msgindex].dumpit : NULL;
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
}

/**
 * __rtnl_register - Register a rtnetlink message type
 * @protocol: Protocol family or PF_UNSPEC
 * @msgtype: rtnetlink message type
 * @doit: Function pointer called for each request message
 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
 *
 * Registers the specified function pointers (at least one of them has
 * to be non-NULL) to be called whenever a request message for the
 * specified protocol family and message type is received.
 *
 * The special protocol family PF_UNSPEC may be used to define fallback
 * function pointers for the case when no entry for the specific protocol
 * family exists.
 *
 * Returns 0 on success or a negative error code.
 */
int __rtnl_register(int protocol, int msgtype,
		    rtnl_doit_func doit, rtnl_dumpit_func dumpit)
{
	struct rtnl_link *tab;
	int msgindex;

	BUG_ON(protocol < 0 || protocol >= NPROTO);
	msgindex = rtm_msgindex(msgtype);

	tab = rtnl_msg_handlers[protocol];
	if (tab == NULL) {
		tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL);
		if (tab == NULL)
			return -ENOBUFS;

		rtnl_msg_handlers[protocol] = tab;
	}

	if (doit)
		tab[msgindex].doit = doit;

	if (dumpit)
		tab[msgindex].dumpit = dumpit;

	return 0;
}

EXPORT_SYMBOL_GPL(__rtnl_register);

/**
 * rtnl_register - Register a rtnetlink message type
 *
 * Identical to __rtnl_register() but panics on failure. This is useful
 * as failure of this function is very unlikely, it can only happen due
 * to lack of memory when allocating the chain to store all message
 * handlers for a protocol. Meant for use in init functions where lack
 * of memory implies no sense in continueing.
 */
void rtnl_register(int protocol, int msgtype,
		   rtnl_doit_func doit, rtnl_dumpit_func dumpit)
{
	if (__rtnl_register(protocol, msgtype, doit, dumpit) < 0)
		panic("Unable to register rtnetlink message handler, "
		      "protocol = %d, message type = %d\n",
		      protocol, msgtype);
}

EXPORT_SYMBOL_GPL(rtnl_register);

/**
 * rtnl_unregister - Unregister a rtnetlink message type
 * @protocol: Protocol family or PF_UNSPEC
 * @msgtype: rtnetlink message type
 *
 * Returns 0 on success or a negative error code.
 */
int rtnl_unregister(int protocol, int msgtype)
{
	int msgindex;

	BUG_ON(protocol < 0 || protocol >= NPROTO);
	msgindex = rtm_msgindex(msgtype);

	if (rtnl_msg_handlers[protocol] == NULL)
		return -ENOENT;

	rtnl_msg_handlers[protocol][msgindex].doit = NULL;
	rtnl_msg_handlers[protocol][msgindex].dumpit = NULL;

	return 0;
}

EXPORT_SYMBOL_GPL(rtnl_unregister);

/**
 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
 * @protocol : Protocol family or PF_UNSPEC
 *
 * Identical to calling rtnl_unregster() for all registered message types
 * of a certain protocol family.
 */
void rtnl_unregister_all(int protocol)
{
	BUG_ON(protocol < 0 || protocol >= NPROTO);

	kfree(rtnl_msg_handlers[protocol]);
	rtnl_msg_handlers[protocol] = NULL;
}

EXPORT_SYMBOL_GPL(rtnl_unregister_all);
L
Linus Torvalds 已提交
245

246
static const int rtm_min[RTM_NR_FAMILIES] =
L
Linus Torvalds 已提交
247
{
248 249 250
	[RTM_FAM(RTM_NEWLINK)]      = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
	[RTM_FAM(RTM_NEWADDR)]      = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
	[RTM_FAM(RTM_NEWROUTE)]     = NLMSG_LENGTH(sizeof(struct rtmsg)),
251
	[RTM_FAM(RTM_NEWRULE)]      = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)),
252 253 254 255 256 257
	[RTM_FAM(RTM_NEWQDISC)]     = NLMSG_LENGTH(sizeof(struct tcmsg)),
	[RTM_FAM(RTM_NEWTCLASS)]    = NLMSG_LENGTH(sizeof(struct tcmsg)),
	[RTM_FAM(RTM_NEWTFILTER)]   = NLMSG_LENGTH(sizeof(struct tcmsg)),
	[RTM_FAM(RTM_NEWACTION)]    = NLMSG_LENGTH(sizeof(struct tcamsg)),
	[RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
	[RTM_FAM(RTM_GETANYCAST)]   = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
L
Linus Torvalds 已提交
258 259
};

260
static const int rta_max[RTM_NR_FAMILIES] =
L
Linus Torvalds 已提交
261
{
262 263 264
	[RTM_FAM(RTM_NEWLINK)]      = IFLA_MAX,
	[RTM_FAM(RTM_NEWADDR)]      = IFA_MAX,
	[RTM_FAM(RTM_NEWROUTE)]     = RTA_MAX,
265
	[RTM_FAM(RTM_NEWRULE)]      = FRA_MAX,
266 267 268 269
	[RTM_FAM(RTM_NEWQDISC)]     = TCA_MAX,
	[RTM_FAM(RTM_NEWTCLASS)]    = TCA_MAX,
	[RTM_FAM(RTM_NEWTFILTER)]   = TCA_MAX,
	[RTM_FAM(RTM_NEWACTION)]    = TCAA_MAX,
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280
};

void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
{
	struct rtattr *rta;
	int size = RTA_LENGTH(attrlen);

	rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
	rta->rta_type = attrtype;
	rta->rta_len = size;
	memcpy(RTA_DATA(rta), data, attrlen);
281
	memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
}

size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size)
{
	size_t ret = RTA_PAYLOAD(rta);
	char *src = RTA_DATA(rta);

	if (ret > 0 && src[ret - 1] == '\0')
		ret--;
	if (size > 0) {
		size_t len = (ret >= size) ? size - 1 : ret;
		memset(dest, 0, size);
		memcpy(dest, src, len);
	}
	return ret;
}

int rtnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, int echo)
{
	int err = 0;

303
	NETLINK_CB(skb).dst_group = group;
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311
	if (echo)
		atomic_inc(&skb->users);
	netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
	if (echo)
		err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
	return err;
}

312 313 314 315 316
int rtnl_unicast(struct sk_buff *skb, u32 pid)
{
	return nlmsg_unicast(rtnl, skb, pid);
}

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group,
		struct nlmsghdr *nlh, gfp_t flags)
{
	int report = 0;

	if (nlh)
		report = nlmsg_report(nlh);

	return nlmsg_notify(rtnl, skb, pid, group, report, flags);
}

void rtnl_set_sk_err(u32 group, int error)
{
	netlink_set_err(rtnl, 0, group, error);
}

L
Linus Torvalds 已提交
333 334
int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
{
335 336 337 338 339 340 341 342 343 344 345 346
	struct nlattr *mx;
	int i, valid = 0;

	mx = nla_nest_start(skb, RTA_METRICS);
	if (mx == NULL)
		return -ENOBUFS;

	for (i = 0; i < RTAX_MAX; i++) {
		if (metrics[i]) {
			valid++;
			NLA_PUT_U32(skb, i+1, metrics[i]);
		}
L
Linus Torvalds 已提交
347 348
	}

349 350 351 352
	if (!valid) {
		nla_nest_cancel(skb, mx);
		return 0;
	}
353 354 355 356 357

	return nla_nest_end(skb, mx);

nla_put_failure:
	return nla_nest_cancel(skb, mx);
L
Linus Torvalds 已提交
358 359
}

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
		       u32 ts, u32 tsage, long expires, u32 error)
{
	struct rta_cacheinfo ci = {
		.rta_lastuse = jiffies_to_clock_t(jiffies - dst->lastuse),
		.rta_used = dst->__use,
		.rta_clntref = atomic_read(&(dst->__refcnt)),
		.rta_error = error,
		.rta_id =  id,
		.rta_ts = ts,
		.rta_tsage = tsage,
	};

	if (expires)
		ci.rta_expires = jiffies_to_clock_t(expires);

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

EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
L
Linus Torvalds 已提交
380

S
Stefan Rompf 已提交
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
static void set_operstate(struct net_device *dev, unsigned char transition)
{
	unsigned char operstate = dev->operstate;

	switch(transition) {
	case IF_OPER_UP:
		if ((operstate == IF_OPER_DORMANT ||
		     operstate == IF_OPER_UNKNOWN) &&
		    !netif_dormant(dev))
			operstate = IF_OPER_UP;
		break;

	case IF_OPER_DORMANT:
		if (operstate == IF_OPER_UP ||
		    operstate == IF_OPER_UNKNOWN)
			operstate = IF_OPER_DORMANT;
		break;
398
	}
S
Stefan Rompf 已提交
399 400 401 402 403 404 405 406 407

	if (dev->operstate != operstate) {
		write_lock_bh(&dev_base_lock);
		dev->operstate = operstate;
		write_unlock_bh(&dev_base_lock);
		netdev_state_change(dev);
	}
}

408 409
static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
				 struct net_device_stats *b)
L
Linus Torvalds 已提交
410
{
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
	a->rx_packets = b->rx_packets;
	a->tx_packets = b->tx_packets;
	a->rx_bytes = b->rx_bytes;
	a->tx_bytes = b->tx_bytes;
	a->rx_errors = b->rx_errors;
	a->tx_errors = b->tx_errors;
	a->rx_dropped = b->rx_dropped;
	a->tx_dropped = b->tx_dropped;

	a->multicast = b->multicast;
	a->collisions = b->collisions;

	a->rx_length_errors = b->rx_length_errors;
	a->rx_over_errors = b->rx_over_errors;
	a->rx_crc_errors = b->rx_crc_errors;
	a->rx_frame_errors = b->rx_frame_errors;
	a->rx_fifo_errors = b->rx_fifo_errors;
	a->rx_missed_errors = b->rx_missed_errors;

	a->tx_aborted_errors = b->tx_aborted_errors;
	a->tx_carrier_errors = b->tx_carrier_errors;
	a->tx_fifo_errors = b->tx_fifo_errors;
	a->tx_heartbeat_errors = b->tx_heartbeat_errors;
	a->tx_window_errors = b->tx_window_errors;

	a->rx_compressed = b->rx_compressed;
	a->tx_compressed = b->tx_compressed;
};
L
Linus Torvalds 已提交
439

440
static inline size_t if_nlmsg_size(void)
441 442 443 444 445 446 447 448 449 450 451 452 453 454
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
	       + nla_total_size(sizeof(struct rtnl_link_ifmap))
	       + nla_total_size(sizeof(struct rtnl_link_stats))
	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
	       + nla_total_size(4) /* IFLA_TXQLEN */
	       + nla_total_size(4) /* IFLA_WEIGHT */
	       + nla_total_size(4) /* IFLA_MTU */
	       + nla_total_size(4) /* IFLA_LINK */
	       + nla_total_size(4) /* IFLA_MASTER */
	       + nla_total_size(1) /* IFLA_OPERSTATE */
455
	       + nla_total_size(1); /* IFLA_LINKMODE */
456 457
}

458
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
459 460
			    int type, u32 pid, u32 seq, u32 change,
			    unsigned int flags)
461 462 463
{
	struct ifinfomsg *ifm;
	struct nlmsghdr *nlh;
L
Linus Torvalds 已提交
464

465 466
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
	if (nlh == NULL)
467
		return -EMSGSIZE;
L
Linus Torvalds 已提交
468

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
	ifm = nlmsg_data(nlh);
	ifm->ifi_family = AF_UNSPEC;
	ifm->__ifi_pad = 0;
	ifm->ifi_type = dev->type;
	ifm->ifi_index = dev->ifindex;
	ifm->ifi_flags = dev_get_flags(dev);
	ifm->ifi_change = change;

	NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
	NLA_PUT_U32(skb, IFLA_TXQLEN, dev->tx_queue_len);
	NLA_PUT_U32(skb, IFLA_WEIGHT, dev->weight);
	NLA_PUT_U8(skb, IFLA_OPERSTATE,
		   netif_running(dev) ? dev->operstate : IF_OPER_DOWN);
	NLA_PUT_U8(skb, IFLA_LINKMODE, dev->link_mode);
	NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);

	if (dev->ifindex != dev->iflink)
		NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);

	if (dev->master)
		NLA_PUT_U32(skb, IFLA_MASTER, dev->master->ifindex);
L
Linus Torvalds 已提交
490

491 492
	if (dev->qdisc_sleeping)
		NLA_PUT_STRING(skb, IFLA_QDISC, dev->qdisc_sleeping->ops->id);
S
Stefan Rompf 已提交
493

L
Linus Torvalds 已提交
494 495 496 497 498 499 500 501 502
	if (1) {
		struct rtnl_link_ifmap map = {
			.mem_start   = dev->mem_start,
			.mem_end     = dev->mem_end,
			.base_addr   = dev->base_addr,
			.irq         = dev->irq,
			.dma         = dev->dma,
			.port        = dev->if_port,
		};
503
		NLA_PUT(skb, IFLA_MAP, sizeof(map), &map);
L
Linus Torvalds 已提交
504 505 506
	}

	if (dev->addr_len) {
507 508
		NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
		NLA_PUT(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast);
L
Linus Torvalds 已提交
509 510 511
	}

	if (dev->get_stats) {
512
		struct net_device_stats *stats = dev->get_stats(dev);
L
Linus Torvalds 已提交
513
		if (stats) {
514 515 516 517 518 519 520 521
			struct nlattr *attr;

			attr = nla_reserve(skb, IFLA_STATS,
					   sizeof(struct rtnl_link_stats));
			if (attr == NULL)
				goto nla_put_failure;

			copy_rtnl_link_stats(nla_data(attr), stats);
L
Linus Torvalds 已提交
522 523 524
		}
	}

525 526 527
	return nlmsg_end(skb, nlh);

nla_put_failure:
528 529
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
530 531
}

532
static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
L
Linus Torvalds 已提交
533 534 535 536 537
{
	int idx;
	int s_idx = cb->args[0];
	struct net_device *dev;

538 539
	idx = 0;
	for_each_netdev(dev) {
L
Linus Torvalds 已提交
540
		if (idx < s_idx)
541
			goto cont;
542
		if (rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
543 544
				     NETLINK_CB(cb->skb).pid,
				     cb->nlh->nlmsg_seq, 0, NLM_F_MULTI) <= 0)
L
Linus Torvalds 已提交
545
			break;
546 547
cont:
		idx++;
L
Linus Torvalds 已提交
548 549 550 551 552 553
	}
	cb->args[0] = idx;

	return skb->len;
}

554
static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
555 556
	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },
	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },
557 558 559 560 561 562 563 564
	[IFLA_MTU]		= { .type = NLA_U32 },
	[IFLA_TXQLEN]		= { .type = NLA_U32 },
	[IFLA_WEIGHT]		= { .type = NLA_U32 },
	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
	[IFLA_LINKMODE]		= { .type = NLA_U8 },
};

static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
L
Linus Torvalds 已提交
565
{
566
	struct ifinfomsg *ifm;
L
Linus Torvalds 已提交
567
	struct net_device *dev;
568 569 570
	int err, send_addr_notify = 0, modified = 0;
	struct nlattr *tb[IFLA_MAX+1];
	char ifname[IFNAMSIZ];
L
Linus Torvalds 已提交
571

572 573 574 575
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
	if (err < 0)
		goto errout;

576 577
	if (tb[IFLA_IFNAME])
		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
578 579
	else
		ifname[0] = '\0';
580 581 582

	err = -EINVAL;
	ifm = nlmsg_data(nlh);
583
	if (ifm->ifi_index > 0)
L
Linus Torvalds 已提交
584
		dev = dev_get_by_index(ifm->ifi_index);
585
	else if (tb[IFLA_IFNAME])
L
Linus Torvalds 已提交
586
		dev = dev_get_by_name(ifname);
587 588
	else
		goto errout;
L
Linus Torvalds 已提交
589

590 591 592 593
	if (dev == NULL) {
		err = -ENODEV;
		goto errout;
	}
L
Linus Torvalds 已提交
594

595 596 597
	if (tb[IFLA_ADDRESS] &&
	    nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
		goto errout_dev;
L
Linus Torvalds 已提交
598

599 600 601
	if (tb[IFLA_BROADCAST] &&
	    nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
		goto errout_dev;
L
Linus Torvalds 已提交
602

603
	if (tb[IFLA_MAP]) {
L
Linus Torvalds 已提交
604 605 606 607 608
		struct rtnl_link_ifmap *u_map;
		struct ifmap k_map;

		if (!dev->set_config) {
			err = -EOPNOTSUPP;
609
			goto errout_dev;
L
Linus Torvalds 已提交
610 611 612 613
		}

		if (!netif_device_present(dev)) {
			err = -ENODEV;
614
			goto errout_dev;
L
Linus Torvalds 已提交
615 616
		}

617
		u_map = nla_data(tb[IFLA_MAP]);
L
Linus Torvalds 已提交
618 619 620 621 622 623 624 625
		k_map.mem_start = (unsigned long) u_map->mem_start;
		k_map.mem_end = (unsigned long) u_map->mem_end;
		k_map.base_addr = (unsigned short) u_map->base_addr;
		k_map.irq = (unsigned char) u_map->irq;
		k_map.dma = (unsigned char) u_map->dma;
		k_map.port = (unsigned char) u_map->port;

		err = dev->set_config(dev, &k_map);
626 627
		if (err < 0)
			goto errout_dev;
L
Linus Torvalds 已提交
628

629
		modified = 1;
L
Linus Torvalds 已提交
630 631
	}

632
	if (tb[IFLA_ADDRESS]) {
633 634 635
		struct sockaddr *sa;
		int len;

L
Linus Torvalds 已提交
636 637
		if (!dev->set_mac_address) {
			err = -EOPNOTSUPP;
638
			goto errout_dev;
L
Linus Torvalds 已提交
639
		}
640

L
Linus Torvalds 已提交
641 642
		if (!netif_device_present(dev)) {
			err = -ENODEV;
643
			goto errout_dev;
L
Linus Torvalds 已提交
644 645
		}

646 647 648 649
		len = sizeof(sa_family_t) + dev->addr_len;
		sa = kmalloc(len, GFP_KERNEL);
		if (!sa) {
			err = -ENOMEM;
650
			goto errout_dev;
651 652
		}
		sa->sa_family = dev->type;
653
		memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
654 655 656
		       dev->addr_len);
		err = dev->set_mac_address(dev, sa);
		kfree(sa);
L
Linus Torvalds 已提交
657
		if (err)
658
			goto errout_dev;
L
Linus Torvalds 已提交
659
		send_addr_notify = 1;
660
		modified = 1;
L
Linus Torvalds 已提交
661 662
	}

663 664 665 666 667
	if (tb[IFLA_MTU]) {
		err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
		if (err < 0)
			goto errout_dev;
		modified = 1;
L
Linus Torvalds 已提交
668 669
	}

670 671 672 673 674
	/*
	 * Interface selected by interface index but interface
	 * name provided implies that a name change has been
	 * requested.
	 */
675
	if (ifm->ifi_index > 0 && ifname[0]) {
676 677 678 679
		err = dev_change_name(dev, ifname);
		if (err < 0)
			goto errout_dev;
		modified = 1;
L
Linus Torvalds 已提交
680 681
	}

682 683 684
	if (tb[IFLA_BROADCAST]) {
		nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
		send_addr_notify = 1;
L
Linus Torvalds 已提交
685 686 687
	}


688 689 690 691 692 693 694 695 696
	if (ifm->ifi_flags || ifm->ifi_change) {
		unsigned int flags = ifm->ifi_flags;

		/* bugwards compatibility: ifi_change == 0 is treated as ~0 */
		if (ifm->ifi_change)
			flags = (flags & ifm->ifi_change) |
				(dev->flags & ~ifm->ifi_change);
		dev_change_flags(dev, flags);
	}
L
Linus Torvalds 已提交
697

698 699
	if (tb[IFLA_TXQLEN])
		dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
S
Stefan Rompf 已提交
700

701 702
	if (tb[IFLA_WEIGHT])
		dev->weight = nla_get_u32(tb[IFLA_WEIGHT]);
S
Stefan Rompf 已提交
703

704 705
	if (tb[IFLA_OPERSTATE])
		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
S
Stefan Rompf 已提交
706

707
	if (tb[IFLA_LINKMODE]) {
S
Stefan Rompf 已提交
708
		write_lock_bh(&dev_base_lock);
709
		dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
S
Stefan Rompf 已提交
710 711 712
		write_unlock_bh(&dev_base_lock);
	}

L
Linus Torvalds 已提交
713 714
	err = 0;

715 716 717 718 719 720 721
errout_dev:
	if (err < 0 && modified && net_ratelimit())
		printk(KERN_WARNING "A link change request failed with "
		       "some changes comitted already. Interface %s may "
		       "have been left with an inconsistent configuration, "
		       "please check.\n", dev->name);

L
Linus Torvalds 已提交
722 723 724 725
	if (send_addr_notify)
		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);

	dev_put(dev);
726
errout:
L
Linus Torvalds 已提交
727 728 729
	return err;
}

730
static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
731
{
732 733 734 735
	struct ifinfomsg *ifm;
	struct nlattr *tb[IFLA_MAX+1];
	struct net_device *dev = NULL;
	struct sk_buff *nskb;
736
	int err;
737

738 739
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
	if (err < 0)
740
		return err;
741 742

	ifm = nlmsg_data(nlh);
743
	if (ifm->ifi_index > 0) {
744
		dev = dev_get_by_index(ifm->ifi_index);
745 746 747
		if (dev == NULL)
			return -ENODEV;
	} else
748 749
		return -EINVAL;

750
	nskb = nlmsg_new(if_nlmsg_size(), GFP_KERNEL);
751 752 753 754 755
	if (nskb == NULL) {
		err = -ENOBUFS;
		goto errout;
	}

756 757
	err = rtnl_fill_ifinfo(nskb, dev, RTM_NEWLINK, NETLINK_CB(skb).pid,
			       nlh->nlmsg_seq, 0, 0);
758 759 760 761 762 763
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_size */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(nskb);
		goto errout;
	}
764
	err = rtnl_unicast(nskb, NETLINK_CB(skb).pid);
765
errout:
766 767
	dev_put(dev);

768
	return err;
769 770
}

A
Adrian Bunk 已提交
771
static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
L
Linus Torvalds 已提交
772 773 774 775 776 777 778 779 780 781
{
	int idx;
	int s_idx = cb->family;

	if (s_idx == 0)
		s_idx = 1;
	for (idx=1; idx<NPROTO; idx++) {
		int type = cb->nlh->nlmsg_type-RTM_BASE;
		if (idx < s_idx || idx == PF_PACKET)
			continue;
782 783
		if (rtnl_msg_handlers[idx] == NULL ||
		    rtnl_msg_handlers[idx][type].dumpit == NULL)
L
Linus Torvalds 已提交
784 785 786
			continue;
		if (idx > s_idx)
			memset(&cb->args[0], 0, sizeof(cb->args));
787
		if (rtnl_msg_handlers[idx][type].dumpit(skb, cb))
L
Linus Torvalds 已提交
788 789 790 791 792 793 794 795 796 797
			break;
	}
	cb->family = idx;

	return skb->len;
}

void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change)
{
	struct sk_buff *skb;
798
	int err = -ENOBUFS;
L
Linus Torvalds 已提交
799

800
	skb = nlmsg_new(if_nlmsg_size(), GFP_KERNEL);
801 802
	if (skb == NULL)
		goto errout;
L
Linus Torvalds 已提交
803

804
	err = rtnl_fill_ifinfo(skb, dev, type, 0, 0, change, 0);
805 806 807 808 809 810
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
811 812 813 814
	err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
errout:
	if (err < 0)
		rtnl_set_sk_err(RTNLGRP_LINK, err);
L
Linus Torvalds 已提交
815 816 817 818 819 820 821 822
}

/* Protected by RTNL sempahore.  */
static struct rtattr **rta_buf;
static int rtattr_max;

/* Process one rtnetlink message. */

823
static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
824
{
825
	rtnl_doit_func doit;
L
Linus Torvalds 已提交
826 827 828 829
	int sz_idx, kind;
	int min_len;
	int family;
	int type;
830
	int err;
L
Linus Torvalds 已提交
831 832 833

	type = nlh->nlmsg_type;
	if (type > RTM_MAX)
834
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
835 836 837 838 839 840 841 842

	type -= RTM_BASE;

	/* All the messages must have at least 1 byte length */
	if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg)))
		return 0;

	family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family;
843 844
	if (family >= NPROTO)
		return -EAFNOSUPPORT;
L
Linus Torvalds 已提交
845 846 847 848

	sz_idx = type>>2;
	kind = type&3;

849 850
	if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN))
		return -EPERM;
L
Linus Torvalds 已提交
851 852

	if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
853
		rtnl_dumpit_func dumpit;
L
Linus Torvalds 已提交
854

855 856
		dumpit = rtnl_get_dumpit(family, type);
		if (dumpit == NULL)
857
			return -EOPNOTSUPP;
858

859 860 861 862
		__rtnl_unlock();
		err = netlink_dump_start(rtnl, skb, nlh, dumpit, NULL);
		rtnl_lock();
		return err;
L
Linus Torvalds 已提交
863 864 865 866 867 868
	}

	memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *)));

	min_len = rtm_min[sz_idx];
	if (nlh->nlmsg_len < min_len)
869
		return -EINVAL;
L
Linus Torvalds 已提交
870 871 872 873 874 875 876 877 878

	if (nlh->nlmsg_len > min_len) {
		int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len);
		struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len);

		while (RTA_OK(attr, attrlen)) {
			unsigned flavor = attr->rta_type;
			if (flavor) {
				if (flavor > rta_max[sz_idx])
879
					return -EINVAL;
L
Linus Torvalds 已提交
880 881 882 883 884 885
				rta_buf[flavor-1] = attr;
			}
			attr = RTA_NEXT(attr, attrlen);
		}
	}

886 887
	doit = rtnl_get_doit(family, type);
	if (doit == NULL)
888
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
889

890
	return doit(skb, nlh, (void *)&rta_buf[0]);
L
Linus Torvalds 已提交
891 892 893 894
}

static void rtnetlink_rcv(struct sock *sk, int len)
{
895
	unsigned int qlen = 0;
896

L
Linus Torvalds 已提交
897
	do {
898
		mutex_lock(&rtnl_mutex);
899
		netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg);
900
		mutex_unlock(&rtnl_mutex);
L
Linus Torvalds 已提交
901 902

		netdev_run_todo();
903
	} while (qlen);
L
Linus Torvalds 已提交
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
}

static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	struct net_device *dev = ptr;
	switch (event) {
	case NETDEV_UNREGISTER:
		rtmsg_ifinfo(RTM_DELLINK, dev, ~0U);
		break;
	case NETDEV_REGISTER:
		rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
		break;
	case NETDEV_UP:
	case NETDEV_DOWN:
		rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
		break;
	case NETDEV_CHANGE:
	case NETDEV_GOING_DOWN:
		break;
	default:
		rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
		break;
	}
	return NOTIFY_DONE;
}

static struct notifier_block rtnetlink_dev_notifier = {
	.notifier_call	= rtnetlink_event,
};

void __init rtnetlink_init(void)
{
	int i;

	rtattr_max = 0;
	for (i = 0; i < ARRAY_SIZE(rta_max); i++)
		if (rta_max[i] > rtattr_max)
			rtattr_max = rta_max[i];
	rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL);
	if (!rta_buf)
		panic("rtnetlink_init: cannot allocate rta_buf\n");

946
	rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv,
947
				     &rtnl_mutex, THIS_MODULE);
L
Linus Torvalds 已提交
948 949 950 951
	if (rtnl == NULL)
		panic("rtnetlink_init: cannot initialize rtnetlink\n");
	netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV);
	register_netdevice_notifier(&rtnetlink_dev_notifier);
952 953 954

	rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink, rtnl_dump_ifinfo);
	rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL);
955 956 957

	rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all);
	rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all);
L
Linus Torvalds 已提交
958 959 960 961 962 963 964
}

EXPORT_SYMBOL(__rta_fill);
EXPORT_SYMBOL(rtattr_strlcpy);
EXPORT_SYMBOL(rtattr_parse);
EXPORT_SYMBOL(rtnetlink_put_metrics);
EXPORT_SYMBOL(rtnl_lock);
965
EXPORT_SYMBOL(rtnl_trylock);
L
Linus Torvalds 已提交
966
EXPORT_SYMBOL(rtnl_unlock);
967
EXPORT_SYMBOL(rtnl_unicast);
968 969
EXPORT_SYMBOL(rtnl_notify);
EXPORT_SYMBOL(rtnl_set_sk_err);