ipmr.c 57.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 *	IP multicast routing support for mrouted 3.6/3.8
 *
4
 *		(c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *	  Linux Consultancy and Custom Driver Development
 *
 *	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:
 *	Michael Chastain	:	Incorrect size of copying.
 *	Alan Cox		:	Added the cache manager code
 *	Alan Cox		:	Fixed the clone/copy bug and device race.
 *	Mike McLagan		:	Routing by source
 *	Malcolm Beattie		:	Buffer handling fixes.
 *	Alexey Kuznetsov	:	Double buffer free and other fixes.
 *	SVR Anand		:	Fixed several multicast bugs and problems.
 *	Alexey Kuznetsov	:	Status, optimisations and more.
 *	Brad Parker		:	Better behaviour on mrouted upcall
 *					overflow.
 *      Carlos Picoto           :       PIMv1 Support
 *	Pavlin Ivanov Radoslavov:	PIMv2 Registers must checksum only PIM header
25
 *					Relax this requirement to work with older peers.
L
Linus Torvalds 已提交
26 27 28 29 30 31
 *
 */

#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/types.h>
32
#include <linux/capability.h>
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
#include <linux/errno.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/kernel.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/mroute.h>
#include <linux/init.h>
49
#include <linux/if_ether.h>
50
#include <linux/slab.h>
51
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
52 53 54
#include <net/ip.h>
#include <net/protocol.h>
#include <linux/skbuff.h>
55
#include <net/route.h>
L
Linus Torvalds 已提交
56 57 58 59 60 61 62
#include <net/sock.h>
#include <net/icmp.h>
#include <net/udp.h>
#include <net/raw.h>
#include <linux/notifier.h>
#include <linux/if_arp.h>
#include <linux/netfilter_ipv4.h>
63
#include <linux/compat.h>
L
Linus Torvalds 已提交
64 65
#include <net/ipip.h>
#include <net/checksum.h>
66
#include <net/netlink.h>
67
#include <net/fib_rules.h>
L
Linus Torvalds 已提交
68 69 70 71 72

#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
#define CONFIG_IP_PIMSM	1
#endif

73
struct mr_table {
74
	struct list_head	list;
75 76 77
#ifdef CONFIG_NET_NS
	struct net		*net;
#endif
78
	u32			id;
E
Eric Dumazet 已提交
79
	struct sock __rcu	*mroute_sk;
80 81 82 83 84 85 86 87 88 89 90 91 92
	struct timer_list	ipmr_expire_timer;
	struct list_head	mfc_unres_queue;
	struct list_head	mfc_cache_array[MFC_LINES];
	struct vif_device	vif_table[MAXVIFS];
	int			maxvif;
	atomic_t		cache_resolve_queue_len;
	int			mroute_do_assert;
	int			mroute_do_pim;
#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
	int			mroute_reg_vif_num;
#endif
};

93 94 95 96 97 98 99 100
struct ipmr_rule {
	struct fib_rule		common;
};

struct ipmr_result {
	struct mr_table		*mrt;
};

L
Linus Torvalds 已提交
101
/* Big lock, protecting vif table, mrt cache and mroute socket state.
E
Eric Dumazet 已提交
102
 * Note that the changes are semaphored via rtnl_lock.
L
Linus Torvalds 已提交
103 104 105 106 107 108 109 110
 */

static DEFINE_RWLOCK(mrt_lock);

/*
 *	Multicast router control variables
 */

111
#define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
L
Linus Torvalds 已提交
112 113 114 115 116

/* Special spinlock for queue of unresolved entries */
static DEFINE_SPINLOCK(mfc_unres_lock);

/* We return to original Alan's scheme. Hash table of resolved
E
Eric Dumazet 已提交
117 118 119 120 121
 * entries is changed only in process context and protected
 * with weak lock mrt_lock. Queue of unresolved entries is protected
 * with strong spinlock mfc_unres_lock.
 *
 * In this case data path is free of exclusive locks at all.
L
Linus Torvalds 已提交
122 123
 */

124
static struct kmem_cache *mrt_cachep __read_mostly;
L
Linus Torvalds 已提交
125

126
static struct mr_table *ipmr_new_table(struct net *net, u32 id);
127 128 129 130
static int ip_mr_forward(struct net *net, struct mr_table *mrt,
			 struct sk_buff *skb, struct mfc_cache *cache,
			 int local);
static int ipmr_cache_report(struct mr_table *mrt,
131
			     struct sk_buff *pkt, vifi_t vifi, int assert);
132 133
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			      struct mfc_cache *c, struct rtmsg *rtm);
134 135 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
static void ipmr_expire_process(unsigned long arg);

#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
#define ipmr_for_each_table(mrt, net) \
	list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)

static struct mr_table *ipmr_get_table(struct net *net, u32 id)
{
	struct mr_table *mrt;

	ipmr_for_each_table(mrt, net) {
		if (mrt->id == id)
			return mrt;
	}
	return NULL;
}

static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
			   struct mr_table **mrt)
{
	struct ipmr_result res;
	struct fib_lookup_arg arg = { .result = &res, };
	int err;

	err = fib_rules_lookup(net->ipv4.mr_rules_ops, flp, 0, &arg);
	if (err < 0)
		return err;
	*mrt = res.mrt;
	return 0;
}

static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
			    int flags, struct fib_lookup_arg *arg)
{
	struct ipmr_result *res = arg->result;
	struct mr_table *mrt;
L
Linus Torvalds 已提交
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
	switch (rule->action) {
	case FR_ACT_TO_TBL:
		break;
	case FR_ACT_UNREACHABLE:
		return -ENETUNREACH;
	case FR_ACT_PROHIBIT:
		return -EACCES;
	case FR_ACT_BLACKHOLE:
	default:
		return -EINVAL;
	}

	mrt = ipmr_get_table(rule->fr_net, rule->table);
	if (mrt == NULL)
		return -EAGAIN;
	res->mrt = mrt;
	return 0;
}

static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
{
	return 1;
}

static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
	FRA_GENERIC_POLICY,
};

static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
			       struct fib_rule_hdr *frh, struct nlattr **tb)
{
	return 0;
}

static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
			     struct nlattr **tb)
{
	return 1;
}

static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
			  struct fib_rule_hdr *frh)
{
	frh->dst_len = 0;
	frh->src_len = 0;
	frh->tos     = 0;
	return 0;
}

220
static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
221
	.family		= RTNL_FAMILY_IPMR,
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
	.rule_size	= sizeof(struct ipmr_rule),
	.addr_size	= sizeof(u32),
	.action		= ipmr_rule_action,
	.match		= ipmr_rule_match,
	.configure	= ipmr_rule_configure,
	.compare	= ipmr_rule_compare,
	.default_pref	= fib_default_rule_pref,
	.fill		= ipmr_rule_fill,
	.nlgroup	= RTNLGRP_IPV4_RULE,
	.policy		= ipmr_rule_policy,
	.owner		= THIS_MODULE,
};

static int __net_init ipmr_rules_init(struct net *net)
{
	struct fib_rules_ops *ops;
	struct mr_table *mrt;
	int err;

	ops = fib_rules_register(&ipmr_rules_ops_template, net);
	if (IS_ERR(ops))
		return PTR_ERR(ops);

	INIT_LIST_HEAD(&net->ipv4.mr_tables);

	mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
	if (mrt == NULL) {
		err = -ENOMEM;
		goto err1;
	}

	err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
	if (err < 0)
		goto err2;

	net->ipv4.mr_rules_ops = ops;
	return 0;

err2:
	kfree(mrt);
err1:
	fib_rules_unregister(ops);
	return err;
}

static void __net_exit ipmr_rules_exit(struct net *net)
{
	struct mr_table *mrt, *next;

E
Eric Dumazet 已提交
271 272
	list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
		list_del(&mrt->list);
273
		kfree(mrt);
E
Eric Dumazet 已提交
274
	}
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
	fib_rules_unregister(net->ipv4.mr_rules_ops);
}
#else
#define ipmr_for_each_table(mrt, net) \
	for (mrt = net->ipv4.mrt; mrt; mrt = NULL)

static struct mr_table *ipmr_get_table(struct net *net, u32 id)
{
	return net->ipv4.mrt;
}

static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
			   struct mr_table **mrt)
{
	*mrt = net->ipv4.mrt;
	return 0;
}

static int __net_init ipmr_rules_init(struct net *net)
{
	net->ipv4.mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
	return net->ipv4.mrt ? 0 : -ENOMEM;
}

static void __net_exit ipmr_rules_exit(struct net *net)
{
	kfree(net->ipv4.mrt);
}
#endif

static struct mr_table *ipmr_new_table(struct net *net, u32 id)
{
	struct mr_table *mrt;
	unsigned int i;
L
Linus Torvalds 已提交
309

310 311 312 313 314 315 316
	mrt = ipmr_get_table(net, id);
	if (mrt != NULL)
		return mrt;

	mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
	if (mrt == NULL)
		return NULL;
317
	write_pnet(&mrt->net, net);
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
	mrt->id = id;

	/* Forwarding cache */
	for (i = 0; i < MFC_LINES; i++)
		INIT_LIST_HEAD(&mrt->mfc_cache_array[i]);

	INIT_LIST_HEAD(&mrt->mfc_unres_queue);

	setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
		    (unsigned long)mrt);

#ifdef CONFIG_IP_PIMSM
	mrt->mroute_reg_vif_num = -1;
#endif
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
	list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
#endif
	return mrt;
}
L
Linus Torvalds 已提交
337 338 339

/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */

340 341
static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
{
342 343
	struct net *net = dev_net(dev);

344 345
	dev_close(dev);

346
	dev = __dev_get_by_name(net, "tunl0");
347
	if (dev) {
348
		const struct net_device_ops *ops = dev->netdev_ops;
349 350 351 352 353 354 355 356 357 358 359 360
		struct ifreq ifr;
		struct ip_tunnel_parm p;

		memset(&p, 0, sizeof(p));
		p.iph.daddr = v->vifc_rmt_addr.s_addr;
		p.iph.saddr = v->vifc_lcl_addr.s_addr;
		p.iph.version = 4;
		p.iph.ihl = 5;
		p.iph.protocol = IPPROTO_IPIP;
		sprintf(p.name, "dvmrp%d", v->vifc_vifi);
		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;

361 362 363 364 365 366 367
		if (ops->ndo_do_ioctl) {
			mm_segment_t oldfs = get_fs();

			set_fs(KERNEL_DS);
			ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
			set_fs(oldfs);
		}
368 369 370
	}
}

L
Linus Torvalds 已提交
371
static
372
struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
L
Linus Torvalds 已提交
373 374 375
{
	struct net_device  *dev;

376
	dev = __dev_get_by_name(net, "tunl0");
L
Linus Torvalds 已提交
377 378

	if (dev) {
379
		const struct net_device_ops *ops = dev->netdev_ops;
L
Linus Torvalds 已提交
380 381 382 383 384 385 386 387 388 389 390 391
		int err;
		struct ifreq ifr;
		struct ip_tunnel_parm p;
		struct in_device  *in_dev;

		memset(&p, 0, sizeof(p));
		p.iph.daddr = v->vifc_rmt_addr.s_addr;
		p.iph.saddr = v->vifc_lcl_addr.s_addr;
		p.iph.version = 4;
		p.iph.ihl = 5;
		p.iph.protocol = IPPROTO_IPIP;
		sprintf(p.name, "dvmrp%d", v->vifc_vifi);
S
Stephen Hemminger 已提交
392
		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
L
Linus Torvalds 已提交
393

394 395 396 397 398 399
		if (ops->ndo_do_ioctl) {
			mm_segment_t oldfs = get_fs();

			set_fs(KERNEL_DS);
			err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
			set_fs(oldfs);
E
Eric Dumazet 已提交
400
		} else {
401
			err = -EOPNOTSUPP;
E
Eric Dumazet 已提交
402
		}
L
Linus Torvalds 已提交
403 404
		dev = NULL;

405 406
		if (err == 0 &&
		    (dev = __dev_get_by_name(net, p.name)) != NULL) {
L
Linus Torvalds 已提交
407 408
			dev->flags |= IFF_MULTICAST;

409
			in_dev = __in_dev_get_rtnl(dev);
410
			if (in_dev == NULL)
L
Linus Torvalds 已提交
411
				goto failure;
412 413 414

			ipv4_devconf_setall(in_dev);
			IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
L
Linus Torvalds 已提交
415 416 417

			if (dev_open(dev))
				goto failure;
418
			dev_hold(dev);
L
Linus Torvalds 已提交
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
		}
	}
	return dev;

failure:
	/* allow the register to be completed before unregistering. */
	rtnl_unlock();
	rtnl_lock();

	unregister_netdevice(dev);
	return NULL;
}

#ifdef CONFIG_IP_PIMSM

434
static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
435
{
436
	struct net *net = dev_net(dev);
437 438 439 440 441 442 443 444 445
	struct mr_table *mrt;
	struct flowi fl = {
		.oif		= dev->ifindex,
		.iif		= skb->skb_iif,
		.mark		= skb->mark,
	};
	int err;

	err = ipmr_fib_lookup(net, &fl, &mrt);
446 447
	if (err < 0) {
		kfree_skb(skb);
448
		return err;
449
	}
450

L
Linus Torvalds 已提交
451
	read_lock(&mrt_lock);
452 453
	dev->stats.tx_bytes += skb->len;
	dev->stats.tx_packets++;
454
	ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
L
Linus Torvalds 已提交
455 456
	read_unlock(&mrt_lock);
	kfree_skb(skb);
457
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
458 459
}

460 461 462 463
static const struct net_device_ops reg_vif_netdev_ops = {
	.ndo_start_xmit	= reg_vif_xmit,
};

L
Linus Torvalds 已提交
464 465 466
static void reg_vif_setup(struct net_device *dev)
{
	dev->type		= ARPHRD_PIMREG;
467
	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 8;
L
Linus Torvalds 已提交
468
	dev->flags		= IFF_NOARP;
469
	dev->netdev_ops		= &reg_vif_netdev_ops,
L
Linus Torvalds 已提交
470
	dev->destructor		= free_netdev;
T
Tom Goff 已提交
471
	dev->features		|= NETIF_F_NETNS_LOCAL;
L
Linus Torvalds 已提交
472 473
}

474
static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
L
Linus Torvalds 已提交
475 476 477
{
	struct net_device *dev;
	struct in_device *in_dev;
478
	char name[IFNAMSIZ];
L
Linus Torvalds 已提交
479

480 481 482 483
	if (mrt->id == RT_TABLE_DEFAULT)
		sprintf(name, "pimreg");
	else
		sprintf(name, "pimreg%u", mrt->id);
L
Linus Torvalds 已提交
484

485
	dev = alloc_netdev(0, name, reg_vif_setup);
L
Linus Torvalds 已提交
486 487 488 489

	if (dev == NULL)
		return NULL;

T
Tom Goff 已提交
490 491
	dev_net_set(dev, net);

L
Linus Torvalds 已提交
492 493 494 495 496 497
	if (register_netdevice(dev)) {
		free_netdev(dev);
		return NULL;
	}
	dev->iflink = 0;

498
	rcu_read_lock();
E
Eric Dumazet 已提交
499 500
	in_dev = __in_dev_get_rcu(dev);
	if (!in_dev) {
501
		rcu_read_unlock();
L
Linus Torvalds 已提交
502
		goto failure;
503
	}
L
Linus Torvalds 已提交
504

505 506 507
	ipv4_devconf_setall(in_dev);
	IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
	rcu_read_unlock();
L
Linus Torvalds 已提交
508 509 510 511

	if (dev_open(dev))
		goto failure;

512 513
	dev_hold(dev);

L
Linus Torvalds 已提交
514 515 516 517 518 519 520 521 522 523 524 525 526 527
	return dev;

failure:
	/* allow the register to be completed before unregistering. */
	rtnl_unlock();
	rtnl_lock();

	unregister_netdevice(dev);
	return NULL;
}
#endif

/*
 *	Delete a VIF entry
528
 *	@notify: Set to 1, if the caller is a notifier_call
L
Linus Torvalds 已提交
529
 */
530

531
static int vif_delete(struct mr_table *mrt, int vifi, int notify,
532
		      struct list_head *head)
L
Linus Torvalds 已提交
533 534 535 536 537
{
	struct vif_device *v;
	struct net_device *dev;
	struct in_device *in_dev;

538
	if (vifi < 0 || vifi >= mrt->maxvif)
L
Linus Torvalds 已提交
539 540
		return -EADDRNOTAVAIL;

541
	v = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549 550 551 552

	write_lock_bh(&mrt_lock);
	dev = v->dev;
	v->dev = NULL;

	if (!dev) {
		write_unlock_bh(&mrt_lock);
		return -EADDRNOTAVAIL;
	}

#ifdef CONFIG_IP_PIMSM
553 554
	if (vifi == mrt->mroute_reg_vif_num)
		mrt->mroute_reg_vif_num = -1;
L
Linus Torvalds 已提交
555 556
#endif

E
Eric Dumazet 已提交
557
	if (vifi + 1 == mrt->maxvif) {
L
Linus Torvalds 已提交
558
		int tmp;
E
Eric Dumazet 已提交
559 560

		for (tmp = vifi - 1; tmp >= 0; tmp--) {
561
			if (VIF_EXISTS(mrt, tmp))
L
Linus Torvalds 已提交
562 563
				break;
		}
564
		mrt->maxvif = tmp+1;
L
Linus Torvalds 已提交
565 566 567 568 569 570
	}

	write_unlock_bh(&mrt_lock);

	dev_set_allmulti(dev, -1);

E
Eric Dumazet 已提交
571 572
	in_dev = __in_dev_get_rtnl(dev);
	if (in_dev) {
573
		IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
L
Linus Torvalds 已提交
574 575 576
		ip_rt_multicast_event(in_dev);
	}

E
Eric Dumazet 已提交
577
	if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
578
		unregister_netdevice_queue(dev, head);
L
Linus Torvalds 已提交
579 580 581 582 583

	dev_put(dev);
	return 0;
}

584
static void ipmr_cache_free_rcu(struct rcu_head *head)
585
{
586 587
	struct mfc_cache *c = container_of(head, struct mfc_cache, rcu);

588 589 590
	kmem_cache_free(mrt_cachep, c);
}

591 592 593 594 595
static inline void ipmr_cache_free(struct mfc_cache *c)
{
	call_rcu(&c->rcu, ipmr_cache_free_rcu);
}

L
Linus Torvalds 已提交
596
/* Destroy an unresolved cache entry, killing queued skbs
E
Eric Dumazet 已提交
597
 * and reporting error to netlink readers.
L
Linus Torvalds 已提交
598 599
 */

600
static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
L
Linus Torvalds 已提交
601
{
602
	struct net *net = read_pnet(&mrt->net);
L
Linus Torvalds 已提交
603
	struct sk_buff *skb;
604
	struct nlmsgerr *e;
L
Linus Torvalds 已提交
605

606
	atomic_dec(&mrt->cache_resolve_queue_len);
L
Linus Torvalds 已提交
607

J
Jianjun Kong 已提交
608
	while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
609
		if (ip_hdr(skb)->version == 0) {
L
Linus Torvalds 已提交
610 611 612 613
			struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
			nlh->nlmsg_type = NLMSG_ERROR;
			nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
			skb_trim(skb, nlh->nlmsg_len);
614 615 616
			e = NLMSG_DATA(nlh);
			e->error = -ETIMEDOUT;
			memset(&e->msg, 0, sizeof(e->msg));
617

618
			rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
E
Eric Dumazet 已提交
619
		} else {
L
Linus Torvalds 已提交
620
			kfree_skb(skb);
E
Eric Dumazet 已提交
621
		}
L
Linus Torvalds 已提交
622 623
	}

624
	ipmr_cache_free(c);
L
Linus Torvalds 已提交
625 626 627
}


628
/* Timer process for the unresolved queue. */
L
Linus Torvalds 已提交
629

630
static void ipmr_expire_process(unsigned long arg)
L
Linus Torvalds 已提交
631
{
632
	struct mr_table *mrt = (struct mr_table *)arg;
L
Linus Torvalds 已提交
633 634
	unsigned long now;
	unsigned long expires;
635
	struct mfc_cache *c, *next;
L
Linus Torvalds 已提交
636 637

	if (!spin_trylock(&mfc_unres_lock)) {
638
		mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
L
Linus Torvalds 已提交
639 640 641
		return;
	}

642
	if (list_empty(&mrt->mfc_unres_queue))
L
Linus Torvalds 已提交
643 644 645 646 647
		goto out;

	now = jiffies;
	expires = 10*HZ;

648
	list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
L
Linus Torvalds 已提交
649 650 651 652 653 654 655
		if (time_after(c->mfc_un.unres.expires, now)) {
			unsigned long interval = c->mfc_un.unres.expires - now;
			if (interval < expires)
				expires = interval;
			continue;
		}

656
		list_del(&c->list);
657
		ipmr_destroy_unres(mrt, c);
L
Linus Torvalds 已提交
658 659
	}

660 661
	if (!list_empty(&mrt->mfc_unres_queue))
		mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
L
Linus Torvalds 已提交
662 663 664 665 666 667 668

out:
	spin_unlock(&mfc_unres_lock);
}

/* Fill oifs list. It is called under write locked mrt_lock. */

669
static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
670
				   unsigned char *ttls)
L
Linus Torvalds 已提交
671 672 673 674 675 676 677
{
	int vifi;

	cache->mfc_un.res.minvif = MAXVIFS;
	cache->mfc_un.res.maxvif = 0;
	memset(cache->mfc_un.res.ttls, 255, MAXVIFS);

678 679
	for (vifi = 0; vifi < mrt->maxvif; vifi++) {
		if (VIF_EXISTS(mrt, vifi) &&
680
		    ttls[vifi] && ttls[vifi] < 255) {
L
Linus Torvalds 已提交
681 682 683 684 685 686 687 688 689
			cache->mfc_un.res.ttls[vifi] = ttls[vifi];
			if (cache->mfc_un.res.minvif > vifi)
				cache->mfc_un.res.minvif = vifi;
			if (cache->mfc_un.res.maxvif <= vifi)
				cache->mfc_un.res.maxvif = vifi + 1;
		}
	}
}

690 691
static int vif_add(struct net *net, struct mr_table *mrt,
		   struct vifctl *vifc, int mrtsock)
L
Linus Torvalds 已提交
692 693
{
	int vifi = vifc->vifc_vifi;
694
	struct vif_device *v = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
695 696
	struct net_device *dev;
	struct in_device *in_dev;
697
	int err;
L
Linus Torvalds 已提交
698 699

	/* Is vif busy ? */
700
	if (VIF_EXISTS(mrt, vifi))
L
Linus Torvalds 已提交
701 702 703 704 705 706 707 708 709
		return -EADDRINUSE;

	switch (vifc->vifc_flags) {
#ifdef CONFIG_IP_PIMSM
	case VIFF_REGISTER:
		/*
		 * Special Purpose VIF in PIM
		 * All the packets will be sent to the daemon
		 */
710
		if (mrt->mroute_reg_vif_num >= 0)
L
Linus Torvalds 已提交
711
			return -EADDRINUSE;
712
		dev = ipmr_reg_vif(net, mrt);
L
Linus Torvalds 已提交
713 714
		if (!dev)
			return -ENOBUFS;
715 716 717
		err = dev_set_allmulti(dev, 1);
		if (err) {
			unregister_netdevice(dev);
718
			dev_put(dev);
719 720
			return err;
		}
L
Linus Torvalds 已提交
721 722
		break;
#endif
723
	case VIFF_TUNNEL:
724
		dev = ipmr_new_tunnel(net, vifc);
L
Linus Torvalds 已提交
725 726
		if (!dev)
			return -ENOBUFS;
727 728 729
		err = dev_set_allmulti(dev, 1);
		if (err) {
			ipmr_del_tunnel(dev, vifc);
730
			dev_put(dev);
731 732
			return err;
		}
L
Linus Torvalds 已提交
733
		break;
734 735

	case VIFF_USE_IFINDEX:
L
Linus Torvalds 已提交
736
	case 0:
737 738
		if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
			dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
E
Eric Dumazet 已提交
739
			if (dev && __in_dev_get_rtnl(dev) == NULL) {
740 741 742
				dev_put(dev);
				return -EADDRNOTAVAIL;
			}
E
Eric Dumazet 已提交
743
		} else {
744
			dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
E
Eric Dumazet 已提交
745
		}
L
Linus Torvalds 已提交
746 747
		if (!dev)
			return -EADDRNOTAVAIL;
748
		err = dev_set_allmulti(dev, 1);
749 750
		if (err) {
			dev_put(dev);
751
			return err;
752
		}
L
Linus Torvalds 已提交
753 754 755 756 757
		break;
	default:
		return -EINVAL;
	}

E
Eric Dumazet 已提交
758 759
	in_dev = __in_dev_get_rtnl(dev);
	if (!in_dev) {
760
		dev_put(dev);
L
Linus Torvalds 已提交
761
		return -EADDRNOTAVAIL;
762
	}
763
	IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
L
Linus Torvalds 已提交
764 765
	ip_rt_multicast_event(in_dev);

E
Eric Dumazet 已提交
766 767
	/* Fill in the VIF structures */

J
Jianjun Kong 已提交
768 769 770 771
	v->rate_limit = vifc->vifc_rate_limit;
	v->local = vifc->vifc_lcl_addr.s_addr;
	v->remote = vifc->vifc_rmt_addr.s_addr;
	v->flags = vifc->vifc_flags;
L
Linus Torvalds 已提交
772 773
	if (!mrtsock)
		v->flags |= VIFF_STATIC;
J
Jianjun Kong 已提交
774
	v->threshold = vifc->vifc_threshold;
L
Linus Torvalds 已提交
775 776 777 778 779
	v->bytes_in = 0;
	v->bytes_out = 0;
	v->pkt_in = 0;
	v->pkt_out = 0;
	v->link = dev->ifindex;
E
Eric Dumazet 已提交
780
	if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
L
Linus Torvalds 已提交
781 782 783 784
		v->link = dev->iflink;

	/* And finish update writing critical data */
	write_lock_bh(&mrt_lock);
J
Jianjun Kong 已提交
785
	v->dev = dev;
L
Linus Torvalds 已提交
786
#ifdef CONFIG_IP_PIMSM
E
Eric Dumazet 已提交
787
	if (v->flags & VIFF_REGISTER)
788
		mrt->mroute_reg_vif_num = vifi;
L
Linus Torvalds 已提交
789
#endif
790 791
	if (vifi+1 > mrt->maxvif)
		mrt->maxvif = vifi+1;
L
Linus Torvalds 已提交
792 793 794 795
	write_unlock_bh(&mrt_lock);
	return 0;
}

796
/* called with rcu_read_lock() */
797
static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
798 799
					 __be32 origin,
					 __be32 mcastgrp)
L
Linus Torvalds 已提交
800
{
J
Jianjun Kong 已提交
801
	int line = MFC_HASH(mcastgrp, origin);
L
Linus Torvalds 已提交
802 803
	struct mfc_cache *c;

804
	list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list) {
805 806
		if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
			return c;
L
Linus Torvalds 已提交
807
	}
808
	return NULL;
L
Linus Torvalds 已提交
809 810 811 812 813
}

/*
 *	Allocate a multicast cache entry
 */
814
static struct mfc_cache *ipmr_cache_alloc(void)
L
Linus Torvalds 已提交
815
{
J
Jianjun Kong 已提交
816
	struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
817 818 819

	if (c)
		c->mfc_un.res.minvif = MAXVIFS;
L
Linus Torvalds 已提交
820 821 822
	return c;
}

823
static struct mfc_cache *ipmr_cache_alloc_unres(void)
L
Linus Torvalds 已提交
824
{
J
Jianjun Kong 已提交
825
	struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
826 827 828 829 830

	if (c) {
		skb_queue_head_init(&c->mfc_un.unres.unresolved);
		c->mfc_un.unres.expires = jiffies + 10*HZ;
	}
L
Linus Torvalds 已提交
831 832 833 834 835 836
	return c;
}

/*
 *	A cache entry has gone into a resolved state from queued
 */
837

838 839
static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
			       struct mfc_cache *uc, struct mfc_cache *c)
L
Linus Torvalds 已提交
840 841
{
	struct sk_buff *skb;
842
	struct nlmsgerr *e;
L
Linus Torvalds 已提交
843

E
Eric Dumazet 已提交
844
	/* Play the pending entries through our router */
L
Linus Torvalds 已提交
845

J
Jianjun Kong 已提交
846
	while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
847
		if (ip_hdr(skb)->version == 0) {
L
Linus Torvalds 已提交
848 849
			struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));

850
			if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
E
Eric Dumazet 已提交
851 852
				nlh->nlmsg_len = skb_tail_pointer(skb) -
						 (u8 *)nlh;
L
Linus Torvalds 已提交
853 854 855 856
			} else {
				nlh->nlmsg_type = NLMSG_ERROR;
				nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
				skb_trim(skb, nlh->nlmsg_len);
857 858 859
				e = NLMSG_DATA(nlh);
				e->error = -EMSGSIZE;
				memset(&e->msg, 0, sizeof(e->msg));
L
Linus Torvalds 已提交
860
			}
861

862
			rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
E
Eric Dumazet 已提交
863
		} else {
864
			ip_mr_forward(net, mrt, skb, c, 0);
E
Eric Dumazet 已提交
865
		}
L
Linus Torvalds 已提交
866 867 868 869 870 871 872 873 874
	}
}

/*
 *	Bounce a cache query up to mrouted. We could use netlink for this but mrouted
 *	expects the following bizarre scheme.
 *
 *	Called under mrt_lock.
 */
875

876
static int ipmr_cache_report(struct mr_table *mrt,
877
			     struct sk_buff *pkt, vifi_t vifi, int assert)
L
Linus Torvalds 已提交
878 879
{
	struct sk_buff *skb;
880
	const int ihl = ip_hdrlen(pkt);
L
Linus Torvalds 已提交
881 882
	struct igmphdr *igmp;
	struct igmpmsg *msg;
E
Eric Dumazet 已提交
883
	struct sock *mroute_sk;
L
Linus Torvalds 已提交
884 885 886 887 888 889 890 891 892
	int ret;

#ifdef CONFIG_IP_PIMSM
	if (assert == IGMPMSG_WHOLEPKT)
		skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
	else
#endif
		skb = alloc_skb(128, GFP_ATOMIC);

S
Stephen Hemminger 已提交
893
	if (!skb)
L
Linus Torvalds 已提交
894 895 896 897 898
		return -ENOBUFS;

#ifdef CONFIG_IP_PIMSM
	if (assert == IGMPMSG_WHOLEPKT) {
		/* Ugly, but we have no choice with this interface.
E
Eric Dumazet 已提交
899 900 901
		 * Duplicate old header, fix ihl, length etc.
		 * And all this only to mangle msg->im_msgtype and
		 * to set msg->im_mbz to "mbz" :-)
L
Linus Torvalds 已提交
902
		 */
903 904
		skb_push(skb, sizeof(struct iphdr));
		skb_reset_network_header(skb);
905
		skb_reset_transport_header(skb);
906
		msg = (struct igmpmsg *)skb_network_header(skb);
907
		memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
L
Linus Torvalds 已提交
908 909
		msg->im_msgtype = IGMPMSG_WHOLEPKT;
		msg->im_mbz = 0;
910
		msg->im_vif = mrt->mroute_reg_vif_num;
911 912 913
		ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
		ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
					     sizeof(struct iphdr));
914
	} else
L
Linus Torvalds 已提交
915
#endif
916 917
	{

E
Eric Dumazet 已提交
918
	/* Copy the IP header */
L
Linus Torvalds 已提交
919

920
	skb->network_header = skb->tail;
921
	skb_put(skb, ihl);
922
	skb_copy_to_linear_data(skb, pkt->data, ihl);
E
Eric Dumazet 已提交
923
	ip_hdr(skb)->protocol = 0;	/* Flag to the kernel this is a route add */
924
	msg = (struct igmpmsg *)skb_network_header(skb);
L
Linus Torvalds 已提交
925
	msg->im_vif = vifi;
E
Eric Dumazet 已提交
926
	skb_dst_set(skb, dst_clone(skb_dst(pkt)));
L
Linus Torvalds 已提交
927

E
Eric Dumazet 已提交
928
	/* Add our header */
L
Linus Torvalds 已提交
929

E
Eric Dumazet 已提交
930
	igmp = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
L
Linus Torvalds 已提交
931 932
	igmp->type	=
	msg->im_msgtype = assert;
E
Eric Dumazet 已提交
933 934
	igmp->code	= 0;
	ip_hdr(skb)->tot_len = htons(skb->len);		/* Fix the length */
935
	skb->transport_header = skb->network_header;
936
	}
L
Linus Torvalds 已提交
937

E
Eric Dumazet 已提交
938 939 940 941
	rcu_read_lock();
	mroute_sk = rcu_dereference(mrt->mroute_sk);
	if (mroute_sk == NULL) {
		rcu_read_unlock();
L
Linus Torvalds 已提交
942 943 944 945
		kfree_skb(skb);
		return -EINVAL;
	}

E
Eric Dumazet 已提交
946 947
	/* Deliver to mrouted */

E
Eric Dumazet 已提交
948 949
	ret = sock_queue_rcv_skb(mroute_sk, skb);
	rcu_read_unlock();
950
	if (ret < 0) {
L
Linus Torvalds 已提交
951 952 953 954 955 956 957 958 959 960 961
		if (net_ratelimit())
			printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
		kfree_skb(skb);
	}

	return ret;
}

/*
 *	Queue a packet for resolution. It gets locked cache entry!
 */
962

L
Linus Torvalds 已提交
963
static int
964
ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
L
Linus Torvalds 已提交
965
{
966
	bool found = false;
L
Linus Torvalds 已提交
967 968
	int err;
	struct mfc_cache *c;
969
	const struct iphdr *iph = ip_hdr(skb);
L
Linus Torvalds 已提交
970 971

	spin_lock_bh(&mfc_unres_lock);
972
	list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
973
		if (c->mfc_mcastgrp == iph->daddr &&
974 975
		    c->mfc_origin == iph->saddr) {
			found = true;
L
Linus Torvalds 已提交
976
			break;
977
		}
L
Linus Torvalds 已提交
978 979
	}

980
	if (!found) {
E
Eric Dumazet 已提交
981
		/* Create a new entry if allowable */
L
Linus Torvalds 已提交
982

983
		if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
984
		    (c = ipmr_cache_alloc_unres()) == NULL) {
L
Linus Torvalds 已提交
985 986 987 988 989 990
			spin_unlock_bh(&mfc_unres_lock);

			kfree_skb(skb);
			return -ENOBUFS;
		}

E
Eric Dumazet 已提交
991 992
		/* Fill in the new cache entry */

993 994 995
		c->mfc_parent	= -1;
		c->mfc_origin	= iph->saddr;
		c->mfc_mcastgrp	= iph->daddr;
L
Linus Torvalds 已提交
996

E
Eric Dumazet 已提交
997 998
		/* Reflect first query at mrouted. */

999
		err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
1000
		if (err < 0) {
1001
			/* If the report failed throw the cache entry
L
Linus Torvalds 已提交
1002 1003 1004 1005
			   out - Brad Parker
			 */
			spin_unlock_bh(&mfc_unres_lock);

1006
			ipmr_cache_free(c);
L
Linus Torvalds 已提交
1007 1008 1009 1010
			kfree_skb(skb);
			return err;
		}

1011 1012
		atomic_inc(&mrt->cache_resolve_queue_len);
		list_add(&c->list, &mrt->mfc_unres_queue);
L
Linus Torvalds 已提交
1013

1014 1015
		if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
			mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
L
Linus Torvalds 已提交
1016 1017
	}

E
Eric Dumazet 已提交
1018 1019 1020
	/* See if we can append the packet */

	if (c->mfc_un.unres.unresolved.qlen > 3) {
L
Linus Torvalds 已提交
1021 1022 1023
		kfree_skb(skb);
		err = -ENOBUFS;
	} else {
J
Jianjun Kong 已提交
1024
		skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
		err = 0;
	}

	spin_unlock_bh(&mfc_unres_lock);
	return err;
}

/*
 *	MFC cache manipulation by user space mroute daemon
 */

1036
static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc)
L
Linus Torvalds 已提交
1037 1038
{
	int line;
1039
	struct mfc_cache *c, *next;
L
Linus Torvalds 已提交
1040

J
Jianjun Kong 已提交
1041
	line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
L
Linus Torvalds 已提交
1042

1043
	list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
L
Linus Torvalds 已提交
1044 1045
		if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
		    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
1046
			list_del_rcu(&c->list);
L
Linus Torvalds 已提交
1047

1048
			ipmr_cache_free(c);
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053 1054
			return 0;
		}
	}
	return -ENOENT;
}

1055 1056
static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
			struct mfcctl *mfc, int mrtsock)
L
Linus Torvalds 已提交
1057
{
1058
	bool found = false;
L
Linus Torvalds 已提交
1059
	int line;
1060
	struct mfc_cache *uc, *c;
L
Linus Torvalds 已提交
1061

1062 1063 1064
	if (mfc->mfcc_parent >= MAXVIFS)
		return -ENFILE;

J
Jianjun Kong 已提交
1065
	line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
L
Linus Torvalds 已提交
1066

1067
	list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
L
Linus Torvalds 已提交
1068
		if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
1069 1070
		    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
			found = true;
L
Linus Torvalds 已提交
1071
			break;
1072
		}
L
Linus Torvalds 已提交
1073 1074
	}

1075
	if (found) {
L
Linus Torvalds 已提交
1076 1077
		write_lock_bh(&mrt_lock);
		c->mfc_parent = mfc->mfcc_parent;
1078
		ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
L
Linus Torvalds 已提交
1079 1080 1081 1082 1083 1084
		if (!mrtsock)
			c->mfc_flags |= MFC_STATIC;
		write_unlock_bh(&mrt_lock);
		return 0;
	}

1085
	if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
L
Linus Torvalds 已提交
1086 1087
		return -EINVAL;

1088
	c = ipmr_cache_alloc();
J
Jianjun Kong 已提交
1089
	if (c == NULL)
L
Linus Torvalds 已提交
1090 1091
		return -ENOMEM;

J
Jianjun Kong 已提交
1092 1093 1094
	c->mfc_origin = mfc->mfcc_origin.s_addr;
	c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
	c->mfc_parent = mfc->mfcc_parent;
1095
	ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
L
Linus Torvalds 已提交
1096 1097 1098
	if (!mrtsock)
		c->mfc_flags |= MFC_STATIC;

1099
	list_add_rcu(&c->list, &mrt->mfc_cache_array[line]);
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104

	/*
	 *	Check to see if we resolved a queued list. If so we
	 *	need to send on the frames and tidy up.
	 */
1105
	found = false;
L
Linus Torvalds 已提交
1106
	spin_lock_bh(&mfc_unres_lock);
1107
	list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
1108
		if (uc->mfc_origin == c->mfc_origin &&
L
Linus Torvalds 已提交
1109
		    uc->mfc_mcastgrp == c->mfc_mcastgrp) {
1110
			list_del(&uc->list);
1111
			atomic_dec(&mrt->cache_resolve_queue_len);
1112
			found = true;
L
Linus Torvalds 已提交
1113 1114 1115
			break;
		}
	}
1116 1117
	if (list_empty(&mrt->mfc_unres_queue))
		del_timer(&mrt->ipmr_expire_timer);
L
Linus Torvalds 已提交
1118 1119
	spin_unlock_bh(&mfc_unres_lock);

1120
	if (found) {
1121
		ipmr_cache_resolve(net, mrt, uc, c);
1122
		ipmr_cache_free(uc);
L
Linus Torvalds 已提交
1123 1124 1125 1126 1127 1128 1129
	}
	return 0;
}

/*
 *	Close the multicast socket, and clear the vif tables etc
 */
1130

1131
static void mroute_clean_tables(struct mr_table *mrt)
L
Linus Torvalds 已提交
1132 1133
{
	int i;
1134
	LIST_HEAD(list);
1135
	struct mfc_cache *c, *next;
1136

E
Eric Dumazet 已提交
1137 1138
	/* Shut down all active vif entries */

1139
	for (i = 0; i < mrt->maxvif; i++) {
E
Eric Dumazet 已提交
1140
		if (!(mrt->vif_table[i].flags & VIFF_STATIC))
1141
			vif_delete(mrt, i, 0, &list);
L
Linus Torvalds 已提交
1142
	}
1143
	unregister_netdevice_many(&list);
L
Linus Torvalds 已提交
1144

E
Eric Dumazet 已提交
1145 1146
	/* Wipe the cache */

1147
	for (i = 0; i < MFC_LINES; i++) {
1148
		list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
1149
			if (c->mfc_flags & MFC_STATIC)
L
Linus Torvalds 已提交
1150
				continue;
1151
			list_del_rcu(&c->list);
1152
			ipmr_cache_free(c);
L
Linus Torvalds 已提交
1153 1154 1155
		}
	}

1156
	if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
L
Linus Torvalds 已提交
1157
		spin_lock_bh(&mfc_unres_lock);
1158
		list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
1159
			list_del(&c->list);
1160
			ipmr_destroy_unres(mrt, c);
L
Linus Torvalds 已提交
1161 1162 1163 1164 1165
		}
		spin_unlock_bh(&mfc_unres_lock);
	}
}

E
Eric Dumazet 已提交
1166 1167 1168
/* called from ip_ra_control(), before an RCU grace period,
 * we dont need to call synchronize_rcu() here
 */
L
Linus Torvalds 已提交
1169 1170
static void mrtsock_destruct(struct sock *sk)
{
1171
	struct net *net = sock_net(sk);
1172
	struct mr_table *mrt;
1173

L
Linus Torvalds 已提交
1174
	rtnl_lock();
1175
	ipmr_for_each_table(mrt, net) {
E
Eric Dumazet 已提交
1176
		if (sk == rtnl_dereference(mrt->mroute_sk)) {
1177
			IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
E
Eric Dumazet 已提交
1178
			rcu_assign_pointer(mrt->mroute_sk, NULL);
1179 1180
			mroute_clean_tables(mrt);
		}
L
Linus Torvalds 已提交
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
	}
	rtnl_unlock();
}

/*
 *	Socket options and virtual interface manipulation. The whole
 *	virtual interface system is a complete heap, but unfortunately
 *	that's how BSD mrouted happens to think. Maybe one day with a proper
 *	MOSPF/PIM router set up we can clean this up.
 */
1191

1192
int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
L
Linus Torvalds 已提交
1193 1194 1195 1196
{
	int ret;
	struct vifctl vif;
	struct mfcctl mfc;
1197
	struct net *net = sock_net(sk);
1198 1199 1200 1201 1202
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return -ENOENT;
1203

S
Stephen Hemminger 已提交
1204
	if (optname != MRT_INIT) {
E
Eric Dumazet 已提交
1205 1206
		if (sk != rcu_dereference_raw(mrt->mroute_sk) &&
		    !capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1207 1208 1209
			return -EACCES;
	}

S
Stephen Hemminger 已提交
1210 1211 1212
	switch (optname) {
	case MRT_INIT:
		if (sk->sk_type != SOCK_RAW ||
E
Eric Dumazet 已提交
1213
		    inet_sk(sk)->inet_num != IPPROTO_IGMP)
S
Stephen Hemminger 已提交
1214
			return -EOPNOTSUPP;
J
Jianjun Kong 已提交
1215
		if (optlen != sizeof(int))
S
Stephen Hemminger 已提交
1216
			return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1217

S
Stephen Hemminger 已提交
1218
		rtnl_lock();
E
Eric Dumazet 已提交
1219
		if (rtnl_dereference(mrt->mroute_sk)) {
L
Linus Torvalds 已提交
1220
			rtnl_unlock();
S
Stephen Hemminger 已提交
1221 1222 1223 1224 1225
			return -EADDRINUSE;
		}

		ret = ip_ra_control(sk, 1, mrtsock_destruct);
		if (ret == 0) {
E
Eric Dumazet 已提交
1226
			rcu_assign_pointer(mrt->mroute_sk, sk);
1227
			IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
S
Stephen Hemminger 已提交
1228 1229 1230 1231
		}
		rtnl_unlock();
		return ret;
	case MRT_DONE:
E
Eric Dumazet 已提交
1232
		if (sk != rcu_dereference_raw(mrt->mroute_sk))
S
Stephen Hemminger 已提交
1233 1234 1235 1236
			return -EACCES;
		return ip_ra_control(sk, 0, NULL);
	case MRT_ADD_VIF:
	case MRT_DEL_VIF:
J
Jianjun Kong 已提交
1237
		if (optlen != sizeof(vif))
S
Stephen Hemminger 已提交
1238
			return -EINVAL;
J
Jianjun Kong 已提交
1239
		if (copy_from_user(&vif, optval, sizeof(vif)))
S
Stephen Hemminger 已提交
1240 1241 1242 1243
			return -EFAULT;
		if (vif.vifc_vifi >= MAXVIFS)
			return -ENFILE;
		rtnl_lock();
J
Jianjun Kong 已提交
1244
		if (optname == MRT_ADD_VIF) {
E
Eric Dumazet 已提交
1245 1246
			ret = vif_add(net, mrt, &vif,
				      sk == rtnl_dereference(mrt->mroute_sk));
S
Stephen Hemminger 已提交
1247
		} else {
1248
			ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
S
Stephen Hemminger 已提交
1249 1250 1251
		}
		rtnl_unlock();
		return ret;
L
Linus Torvalds 已提交
1252 1253 1254 1255 1256

		/*
		 *	Manipulate the forwarding caches. These live
		 *	in a sort of kernel/user symbiosis.
		 */
S
Stephen Hemminger 已提交
1257 1258
	case MRT_ADD_MFC:
	case MRT_DEL_MFC:
J
Jianjun Kong 已提交
1259
		if (optlen != sizeof(mfc))
S
Stephen Hemminger 已提交
1260
			return -EINVAL;
J
Jianjun Kong 已提交
1261
		if (copy_from_user(&mfc, optval, sizeof(mfc)))
S
Stephen Hemminger 已提交
1262 1263
			return -EFAULT;
		rtnl_lock();
J
Jianjun Kong 已提交
1264
		if (optname == MRT_DEL_MFC)
1265
			ret = ipmr_mfc_delete(mrt, &mfc);
S
Stephen Hemminger 已提交
1266
		else
E
Eric Dumazet 已提交
1267 1268
			ret = ipmr_mfc_add(net, mrt, &mfc,
					   sk == rtnl_dereference(mrt->mroute_sk));
S
Stephen Hemminger 已提交
1269 1270
		rtnl_unlock();
		return ret;
L
Linus Torvalds 已提交
1271 1272 1273
		/*
		 *	Control PIM assert.
		 */
S
Stephen Hemminger 已提交
1274 1275 1276
	case MRT_ASSERT:
	{
		int v;
E
Eric Dumazet 已提交
1277
		if (get_user(v, (int __user *)optval))
S
Stephen Hemminger 已提交
1278
			return -EFAULT;
1279
		mrt->mroute_do_assert = (v) ? 1 : 0;
S
Stephen Hemminger 已提交
1280 1281
		return 0;
	}
L
Linus Torvalds 已提交
1282
#ifdef CONFIG_IP_PIMSM
S
Stephen Hemminger 已提交
1283 1284
	case MRT_PIM:
	{
S
Stephen Hemminger 已提交
1285 1286
		int v;

E
Eric Dumazet 已提交
1287
		if (get_user(v, (int __user *)optval))
S
Stephen Hemminger 已提交
1288
			return -EFAULT;
S
Stephen Hemminger 已提交
1289 1290
		v = (v) ? 1 : 0;

S
Stephen Hemminger 已提交
1291 1292
		rtnl_lock();
		ret = 0;
1293 1294 1295
		if (v != mrt->mroute_do_pim) {
			mrt->mroute_do_pim = v;
			mrt->mroute_do_assert = v;
L
Linus Torvalds 已提交
1296
		}
S
Stephen Hemminger 已提交
1297 1298 1299
		rtnl_unlock();
		return ret;
	}
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
#endif
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
	case MRT_TABLE:
	{
		u32 v;

		if (optlen != sizeof(u32))
			return -EINVAL;
		if (get_user(v, (u32 __user *)optval))
			return -EFAULT;

		rtnl_lock();
		ret = 0;
E
Eric Dumazet 已提交
1313 1314 1315 1316 1317 1318 1319
		if (sk == rtnl_dereference(mrt->mroute_sk)) {
			ret = -EBUSY;
		} else {
			if (!ipmr_new_table(net, v))
				ret = -ENOMEM;
			raw_sk(sk)->ipmr_table = v;
		}
1320 1321 1322
		rtnl_unlock();
		return ret;
	}
L
Linus Torvalds 已提交
1323
#endif
S
Stephen Hemminger 已提交
1324 1325 1326 1327 1328 1329
	/*
	 *	Spurious command, or MRT_VERSION which you cannot
	 *	set.
	 */
	default:
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1330 1331 1332 1333 1334 1335
	}
}

/*
 *	Getsock opt support for the multicast routing system.
 */
1336

J
Jianjun Kong 已提交
1337
int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
L
Linus Torvalds 已提交
1338 1339 1340
{
	int olr;
	int val;
1341
	struct net *net = sock_net(sk);
1342 1343 1344 1345 1346
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return -ENOENT;
L
Linus Torvalds 已提交
1347

J
Jianjun Kong 已提交
1348
	if (optname != MRT_VERSION &&
L
Linus Torvalds 已提交
1349
#ifdef CONFIG_IP_PIMSM
E
Eric Dumazet 已提交
1350
	   optname != MRT_PIM &&
L
Linus Torvalds 已提交
1351
#endif
E
Eric Dumazet 已提交
1352
	   optname != MRT_ASSERT)
L
Linus Torvalds 已提交
1353 1354 1355 1356 1357 1358 1359 1360
		return -ENOPROTOOPT;

	if (get_user(olr, optlen))
		return -EFAULT;

	olr = min_t(unsigned int, olr, sizeof(int));
	if (olr < 0)
		return -EINVAL;
1361

J
Jianjun Kong 已提交
1362
	if (put_user(olr, optlen))
L
Linus Torvalds 已提交
1363
		return -EFAULT;
J
Jianjun Kong 已提交
1364 1365
	if (optname == MRT_VERSION)
		val = 0x0305;
L
Linus Torvalds 已提交
1366
#ifdef CONFIG_IP_PIMSM
J
Jianjun Kong 已提交
1367
	else if (optname == MRT_PIM)
1368
		val = mrt->mroute_do_pim;
L
Linus Torvalds 已提交
1369 1370
#endif
	else
1371
		val = mrt->mroute_do_assert;
J
Jianjun Kong 已提交
1372
	if (copy_to_user(optval, &val, olr))
L
Linus Torvalds 已提交
1373 1374 1375 1376 1377 1378 1379
		return -EFAULT;
	return 0;
}

/*
 *	The IP multicast ioctl support routines.
 */
1380

L
Linus Torvalds 已提交
1381 1382 1383 1384 1385 1386
int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
{
	struct sioc_sg_req sr;
	struct sioc_vif_req vr;
	struct vif_device *vif;
	struct mfc_cache *c;
1387
	struct net *net = sock_net(sk);
1388 1389 1390 1391 1392
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return -ENOENT;
1393

S
Stephen Hemminger 已提交
1394 1395
	switch (cmd) {
	case SIOCGETVIFCNT:
J
Jianjun Kong 已提交
1396
		if (copy_from_user(&vr, arg, sizeof(vr)))
S
Stephen Hemminger 已提交
1397
			return -EFAULT;
1398
		if (vr.vifi >= mrt->maxvif)
S
Stephen Hemminger 已提交
1399 1400
			return -EINVAL;
		read_lock(&mrt_lock);
1401 1402
		vif = &mrt->vif_table[vr.vifi];
		if (VIF_EXISTS(mrt, vr.vifi)) {
J
Jianjun Kong 已提交
1403 1404 1405 1406
			vr.icount = vif->pkt_in;
			vr.ocount = vif->pkt_out;
			vr.ibytes = vif->bytes_in;
			vr.obytes = vif->bytes_out;
L
Linus Torvalds 已提交
1407 1408
			read_unlock(&mrt_lock);

J
Jianjun Kong 已提交
1409
			if (copy_to_user(arg, &vr, sizeof(vr)))
S
Stephen Hemminger 已提交
1410 1411 1412 1413 1414 1415
				return -EFAULT;
			return 0;
		}
		read_unlock(&mrt_lock);
		return -EADDRNOTAVAIL;
	case SIOCGETSGCNT:
J
Jianjun Kong 已提交
1416
		if (copy_from_user(&sr, arg, sizeof(sr)))
S
Stephen Hemminger 已提交
1417 1418
			return -EFAULT;

1419
		rcu_read_lock();
1420
		c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
S
Stephen Hemminger 已提交
1421 1422 1423 1424
		if (c) {
			sr.pktcnt = c->mfc_un.res.pkt;
			sr.bytecnt = c->mfc_un.res.bytes;
			sr.wrong_if = c->mfc_un.res.wrong_if;
1425
			rcu_read_unlock();
S
Stephen Hemminger 已提交
1426

J
Jianjun Kong 已提交
1427
			if (copy_to_user(arg, &sr, sizeof(sr)))
S
Stephen Hemminger 已提交
1428 1429 1430
				return -EFAULT;
			return 0;
		}
1431
		rcu_read_unlock();
S
Stephen Hemminger 已提交
1432 1433 1434
		return -EADDRNOTAVAIL;
	default:
		return -ENOIOCTLCMD;
L
Linus Torvalds 已提交
1435 1436 1437
	}
}

1438 1439 1440 1441 1442 1443 1444 1445 1446
#ifdef CONFIG_COMPAT
struct compat_sioc_sg_req {
	struct in_addr src;
	struct in_addr grp;
	compat_ulong_t pktcnt;
	compat_ulong_t bytecnt;
	compat_ulong_t wrong_if;
};

1447 1448 1449 1450 1451 1452 1453 1454
struct compat_sioc_vif_req {
	vifi_t	vifi;		/* Which iface */
	compat_ulong_t icount;
	compat_ulong_t ocount;
	compat_ulong_t ibytes;
	compat_ulong_t obytes;
};

1455 1456
int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
{
1457
	struct compat_sioc_sg_req sr;
1458 1459
	struct compat_sioc_vif_req vr;
	struct vif_device *vif;
1460 1461 1462 1463 1464 1465 1466 1467 1468
	struct mfc_cache *c;
	struct net *net = sock_net(sk);
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return -ENOENT;

	switch (cmd) {
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
	case SIOCGETVIFCNT:
		if (copy_from_user(&vr, arg, sizeof(vr)))
			return -EFAULT;
		if (vr.vifi >= mrt->maxvif)
			return -EINVAL;
		read_lock(&mrt_lock);
		vif = &mrt->vif_table[vr.vifi];
		if (VIF_EXISTS(mrt, vr.vifi)) {
			vr.icount = vif->pkt_in;
			vr.ocount = vif->pkt_out;
			vr.ibytes = vif->bytes_in;
			vr.obytes = vif->bytes_out;
			read_unlock(&mrt_lock);

			if (copy_to_user(arg, &vr, sizeof(vr)))
				return -EFAULT;
			return 0;
		}
		read_unlock(&mrt_lock);
		return -EADDRNOTAVAIL;
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
	case SIOCGETSGCNT:
		if (copy_from_user(&sr, arg, sizeof(sr)))
			return -EFAULT;

		rcu_read_lock();
		c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
		if (c) {
			sr.pktcnt = c->mfc_un.res.pkt;
			sr.bytecnt = c->mfc_un.res.bytes;
			sr.wrong_if = c->mfc_un.res.wrong_if;
			rcu_read_unlock();

			if (copy_to_user(arg, &sr, sizeof(sr)))
				return -EFAULT;
			return 0;
		}
		rcu_read_unlock();
		return -EADDRNOTAVAIL;
	default:
		return -ENOIOCTLCMD;
	}
}
#endif

L
Linus Torvalds 已提交
1513 1514 1515

static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
{
1516
	struct net_device *dev = ptr;
1517
	struct net *net = dev_net(dev);
1518
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1519 1520
	struct vif_device *v;
	int ct;
1521
	LIST_HEAD(list);
1522

L
Linus Torvalds 已提交
1523 1524
	if (event != NETDEV_UNREGISTER)
		return NOTIFY_DONE;
1525 1526 1527 1528 1529 1530 1531

	ipmr_for_each_table(mrt, net) {
		v = &mrt->vif_table[0];
		for (ct = 0; ct < mrt->maxvif; ct++, v++) {
			if (v->dev == dev)
				vif_delete(mrt, ct, 1, &list);
		}
L
Linus Torvalds 已提交
1532
	}
1533
	unregister_netdevice_many(&list);
L
Linus Torvalds 已提交
1534 1535 1536 1537
	return NOTIFY_DONE;
}


J
Jianjun Kong 已提交
1538
static struct notifier_block ip_mr_notifier = {
L
Linus Torvalds 已提交
1539 1540 1541 1542
	.notifier_call = ipmr_device_event,
};

/*
E
Eric Dumazet 已提交
1543
 *	Encapsulate a packet by attaching a valid IPIP header to it.
L
Linus Torvalds 已提交
1544 1545 1546
 *	This avoids tunnel drivers and other mess and gives us the speed so
 *	important for multicast video.
 */
1547

A
Al Viro 已提交
1548
static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
L
Linus Torvalds 已提交
1549
{
1550
	struct iphdr *iph;
1551
	struct iphdr *old_iph = ip_hdr(skb);
1552 1553

	skb_push(skb, sizeof(struct iphdr));
1554
	skb->transport_header = skb->network_header;
1555
	skb_reset_network_header(skb);
1556
	iph = ip_hdr(skb);
L
Linus Torvalds 已提交
1557

E
Eric Dumazet 已提交
1558
	iph->version	=	4;
1559 1560
	iph->tos	=	old_iph->tos;
	iph->ttl	=	old_iph->ttl;
L
Linus Torvalds 已提交
1561 1562 1563 1564 1565 1566
	iph->frag_off	=	0;
	iph->daddr	=	daddr;
	iph->saddr	=	saddr;
	iph->protocol	=	IPPROTO_IPIP;
	iph->ihl	=	5;
	iph->tot_len	=	htons(skb->len);
E
Eric Dumazet 已提交
1567
	ip_select_ident(iph, skb_dst(skb), NULL);
L
Linus Torvalds 已提交
1568 1569 1570 1571 1572 1573 1574 1575
	ip_send_check(iph);

	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
	nf_reset(skb);
}

static inline int ipmr_forward_finish(struct sk_buff *skb)
{
E
Eric Dumazet 已提交
1576
	struct ip_options *opt = &(IPCB(skb)->opt);
L
Linus Torvalds 已提交
1577

E
Eric Dumazet 已提交
1578
	IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
L
Linus Torvalds 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589

	if (unlikely(opt->optlen))
		ip_forward_options(skb);

	return dst_output(skb);
}

/*
 *	Processing handlers for ipmr_forward
 */

1590 1591
static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
			    struct sk_buff *skb, struct mfc_cache *c, int vifi)
L
Linus Torvalds 已提交
1592
{
1593
	const struct iphdr *iph = ip_hdr(skb);
1594
	struct vif_device *vif = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
	struct net_device *dev;
	struct rtable *rt;
	int    encap = 0;

	if (vif->dev == NULL)
		goto out_free;

#ifdef CONFIG_IP_PIMSM
	if (vif->flags & VIFF_REGISTER) {
		vif->pkt_out++;
J
Jianjun Kong 已提交
1605
		vif->bytes_out += skb->len;
1606 1607
		vif->dev->stats.tx_bytes += skb->len;
		vif->dev->stats.tx_packets++;
1608
		ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
1609
		goto out_free;
L
Linus Torvalds 已提交
1610 1611 1612
	}
#endif

E
Eric Dumazet 已提交
1613 1614 1615
	if (vif->flags & VIFF_TUNNEL) {
		struct flowi fl = {
			.oif = vif->link,
1616 1617 1618
			.fl4_dst = vif->remote,
			.fl4_src = vif->local,
			.fl4_tos = RT_TOS(iph->tos),
E
Eric Dumazet 已提交
1619 1620
			.proto = IPPROTO_IPIP
		};
1621 1622
		rt = ip_route_output_key(net, &fl);
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
1623 1624 1625
			goto out_free;
		encap = sizeof(struct iphdr);
	} else {
E
Eric Dumazet 已提交
1626 1627
		struct flowi fl = {
			.oif = vif->link,
1628 1629
			.fl4_dst = iph->daddr,
			.fl4_tos = RT_TOS(iph->tos),
E
Eric Dumazet 已提交
1630 1631
			.proto = IPPROTO_IPIP
		};
1632 1633
		rt = ip_route_output_key(net, &fl);
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
1634 1635 1636
			goto out_free;
	}

1637
	dev = rt->dst.dev;
L
Linus Torvalds 已提交
1638

1639
	if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
L
Linus Torvalds 已提交
1640
		/* Do not fragment multicasts. Alas, IPv4 does not
E
Eric Dumazet 已提交
1641 1642
		 * allow to send ICMP, so that packets will disappear
		 * to blackhole.
L
Linus Torvalds 已提交
1643 1644
		 */

1645
		IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
L
Linus Torvalds 已提交
1646 1647 1648 1649
		ip_rt_put(rt);
		goto out_free;
	}

1650
	encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
L
Linus Torvalds 已提交
1651 1652

	if (skb_cow(skb, encap)) {
1653
		ip_rt_put(rt);
L
Linus Torvalds 已提交
1654 1655 1656 1657
		goto out_free;
	}

	vif->pkt_out++;
J
Jianjun Kong 已提交
1658
	vif->bytes_out += skb->len;
L
Linus Torvalds 已提交
1659

E
Eric Dumazet 已提交
1660
	skb_dst_drop(skb);
1661
	skb_dst_set(skb, &rt->dst);
1662
	ip_decrease_ttl(ip_hdr(skb));
L
Linus Torvalds 已提交
1663 1664

	/* FIXME: forward and output firewalls used to be called here.
E
Eric Dumazet 已提交
1665 1666
	 * What do we do with netfilter? -- RR
	 */
L
Linus Torvalds 已提交
1667 1668 1669
	if (vif->flags & VIFF_TUNNEL) {
		ip_encap(skb, vif->local, vif->remote);
		/* FIXME: extra output firewall step used to be here. --RR */
1670 1671
		vif->dev->stats.tx_packets++;
		vif->dev->stats.tx_bytes += skb->len;
L
Linus Torvalds 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
	}

	IPCB(skb)->flags |= IPSKB_FORWARDED;

	/*
	 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
	 * not only before forwarding, but after forwarding on all output
	 * interfaces. It is clear, if mrouter runs a multicasting
	 * program, it should receive packets not depending to what interface
	 * program is joined.
	 * If we will not make it, the program will have to join on all
	 * interfaces. On the other hand, multihoming host (or router, but
	 * not mrouter) cannot join to more than one interface - it will
	 * result in receiving multiple packets.
	 */
1687
	NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
L
Linus Torvalds 已提交
1688 1689 1690 1691 1692 1693 1694
		ipmr_forward_finish);
	return;

out_free:
	kfree_skb(skb);
}

1695
static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
L
Linus Torvalds 已提交
1696 1697
{
	int ct;
1698 1699 1700

	for (ct = mrt->maxvif-1; ct >= 0; ct--) {
		if (mrt->vif_table[ct].dev == dev)
L
Linus Torvalds 已提交
1701 1702 1703 1704 1705 1706 1707
			break;
	}
	return ct;
}

/* "local" means that we should preserve one skb (for local delivery) */

1708 1709 1710
static int ip_mr_forward(struct net *net, struct mr_table *mrt,
			 struct sk_buff *skb, struct mfc_cache *cache,
			 int local)
L
Linus Torvalds 已提交
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
{
	int psend = -1;
	int vif, ct;

	vif = cache->mfc_parent;
	cache->mfc_un.res.pkt++;
	cache->mfc_un.res.bytes += skb->len;

	/*
	 * Wrong interface: drop packet and (maybe) send PIM assert.
	 */
1722
	if (mrt->vif_table[vif].dev != skb->dev) {
L
Linus Torvalds 已提交
1723 1724
		int true_vifi;

1725
		if (rt_is_output_route(skb_rtable(skb))) {
L
Linus Torvalds 已提交
1726
			/* It is our own packet, looped back.
E
Eric Dumazet 已提交
1727 1728 1729 1730 1731 1732 1733 1734 1735
			 * Very complicated situation...
			 *
			 * The best workaround until routing daemons will be
			 * fixed is not to redistribute packet, if it was
			 * send through wrong interface. It means, that
			 * multicast applications WILL NOT work for
			 * (S,G), which have default multicast route pointing
			 * to wrong oif. In any case, it is not a good
			 * idea to use multicasting applications on router.
L
Linus Torvalds 已提交
1736 1737 1738 1739 1740
			 */
			goto dont_forward;
		}

		cache->mfc_un.res.wrong_if++;
1741
		true_vifi = ipmr_find_vif(mrt, skb->dev);
L
Linus Torvalds 已提交
1742

1743
		if (true_vifi >= 0 && mrt->mroute_do_assert &&
L
Linus Torvalds 已提交
1744
		    /* pimsm uses asserts, when switching from RPT to SPT,
E
Eric Dumazet 已提交
1745 1746 1747
		     * so that we cannot check that packet arrived on an oif.
		     * It is bad, but otherwise we would need to move pretty
		     * large chunk of pimd to kernel. Ough... --ANK
L
Linus Torvalds 已提交
1748
		     */
1749
		    (mrt->mroute_do_pim ||
1750
		     cache->mfc_un.res.ttls[true_vifi] < 255) &&
1751
		    time_after(jiffies,
L
Linus Torvalds 已提交
1752 1753
			       cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
			cache->mfc_un.res.last_assert = jiffies;
1754
			ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
L
Linus Torvalds 已提交
1755 1756 1757 1758
		}
		goto dont_forward;
	}

1759 1760
	mrt->vif_table[vif].pkt_in++;
	mrt->vif_table[vif].bytes_in += skb->len;
L
Linus Torvalds 已提交
1761 1762 1763 1764

	/*
	 *	Forward the frame
	 */
E
Eric Dumazet 已提交
1765 1766
	for (ct = cache->mfc_un.res.maxvif - 1;
	     ct >= cache->mfc_un.res.minvif; ct--) {
1767
		if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
L
Linus Torvalds 已提交
1768 1769
			if (psend != -1) {
				struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
E
Eric Dumazet 已提交
1770

L
Linus Torvalds 已提交
1771
				if (skb2)
1772 1773
					ipmr_queue_xmit(net, mrt, skb2, cache,
							psend);
L
Linus Torvalds 已提交
1774
			}
J
Jianjun Kong 已提交
1775
			psend = ct;
L
Linus Torvalds 已提交
1776 1777 1778 1779 1780
		}
	}
	if (psend != -1) {
		if (local) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
E
Eric Dumazet 已提交
1781

L
Linus Torvalds 已提交
1782
			if (skb2)
1783
				ipmr_queue_xmit(net, mrt, skb2, cache, psend);
L
Linus Torvalds 已提交
1784
		} else {
1785
			ipmr_queue_xmit(net, mrt, skb, cache, psend);
L
Linus Torvalds 已提交
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
			return 0;
		}
	}

dont_forward:
	if (!local)
		kfree_skb(skb);
	return 0;
}

1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct rtable *rt)
{
	struct flowi fl = {
		.fl4_dst = rt->rt_key_dst,
		.fl4_src = rt->rt_key_src,
		.fl4_tos = rt->rt_tos,
		.oif = rt->rt_oif,
		.iif = rt->rt_iif,
		.mark = rt->rt_mark,
	};
	struct mr_table *mrt;
	int err;

	err = ipmr_fib_lookup(net, &fl, &mrt);
	if (err)
		return ERR_PTR(err);
	return mrt;
}
L
Linus Torvalds 已提交
1814 1815 1816

/*
 *	Multicast packets for forwarding arrive here
E
Eric Dumazet 已提交
1817
 *	Called with rcu_read_lock();
L
Linus Torvalds 已提交
1818 1819 1820 1821 1822
 */

int ip_mr_input(struct sk_buff *skb)
{
	struct mfc_cache *cache;
1823
	struct net *net = dev_net(skb->dev);
E
Eric Dumazet 已提交
1824
	int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1825
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1826 1827

	/* Packet is looped back after forward, it should not be
E
Eric Dumazet 已提交
1828
	 * forwarded second time, but still can be delivered locally.
L
Linus Torvalds 已提交
1829
	 */
E
Eric Dumazet 已提交
1830
	if (IPCB(skb)->flags & IPSKB_FORWARDED)
L
Linus Torvalds 已提交
1831 1832
		goto dont_forward;

1833 1834 1835 1836
	mrt = ipmr_rt_fib_lookup(net, skb_rtable(skb));
	if (IS_ERR(mrt)) {
		kfree_skb(skb);
		return PTR_ERR(mrt);
1837
	}
L
Linus Torvalds 已提交
1838
	if (!local) {
E
Eric Dumazet 已提交
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856
		if (IPCB(skb)->opt.router_alert) {
			if (ip_call_ra_chain(skb))
				return 0;
		} else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) {
			/* IGMPv1 (and broken IGMPv2 implementations sort of
			 * Cisco IOS <= 11.2(8)) do not put router alert
			 * option to IGMP packets destined to routable
			 * groups. It is very bad, because it means
			 * that we can forward NO IGMP messages.
			 */
			struct sock *mroute_sk;

			mroute_sk = rcu_dereference(mrt->mroute_sk);
			if (mroute_sk) {
				nf_reset(skb);
				raw_rcv(mroute_sk, skb);
				return 0;
			}
L
Linus Torvalds 已提交
1857 1858 1859
		    }
	}

1860
	/* already under rcu_read_lock() */
1861
	cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
L
Linus Torvalds 已提交
1862 1863 1864 1865

	/*
	 *	No usable cache entry
	 */
J
Jianjun Kong 已提交
1866
	if (cache == NULL) {
L
Linus Torvalds 已提交
1867 1868 1869 1870 1871
		int vif;

		if (local) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
			ip_local_deliver(skb);
1872
			if (skb2 == NULL)
L
Linus Torvalds 已提交
1873 1874 1875 1876
				return -ENOBUFS;
			skb = skb2;
		}

1877
		read_lock(&mrt_lock);
1878
		vif = ipmr_find_vif(mrt, skb->dev);
L
Linus Torvalds 已提交
1879
		if (vif >= 0) {
1880
			int err2 = ipmr_cache_unresolved(mrt, vif, skb);
L
Linus Torvalds 已提交
1881 1882
			read_unlock(&mrt_lock);

1883
			return err2;
L
Linus Torvalds 已提交
1884 1885 1886 1887 1888 1889
		}
		read_unlock(&mrt_lock);
		kfree_skb(skb);
		return -ENODEV;
	}

1890
	read_lock(&mrt_lock);
1891
	ip_mr_forward(net, mrt, skb, cache, local);
L
Linus Torvalds 已提交
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
	read_unlock(&mrt_lock);

	if (local)
		return ip_local_deliver(skb);

	return 0;

dont_forward:
	if (local)
		return ip_local_deliver(skb);
	kfree_skb(skb);
	return 0;
}

I
Ilpo Järvinen 已提交
1906
#ifdef CONFIG_IP_PIMSM
1907
/* called with rcu_read_lock() */
1908 1909
static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
		     unsigned int pimlen)
L
Linus Torvalds 已提交
1910
{
I
Ilpo Järvinen 已提交
1911 1912
	struct net_device *reg_dev = NULL;
	struct iphdr *encap;
L
Linus Torvalds 已提交
1913

I
Ilpo Järvinen 已提交
1914
	encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
L
Linus Torvalds 已提交
1915
	/*
E
Eric Dumazet 已提交
1916 1917 1918 1919
	 * Check that:
	 * a. packet is really sent to a multicast group
	 * b. packet is not a NULL-REGISTER
	 * c. packet is not truncated
L
Linus Torvalds 已提交
1920
	 */
1921
	if (!ipv4_is_multicast(encap->daddr) ||
L
Linus Torvalds 已提交
1922
	    encap->tot_len == 0 ||
I
Ilpo Järvinen 已提交
1923 1924
	    ntohs(encap->tot_len) + pimlen > skb->len)
		return 1;
L
Linus Torvalds 已提交
1925 1926

	read_lock(&mrt_lock);
1927 1928
	if (mrt->mroute_reg_vif_num >= 0)
		reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
L
Linus Torvalds 已提交
1929 1930
	read_unlock(&mrt_lock);

1931
	if (reg_dev == NULL)
I
Ilpo Järvinen 已提交
1932
		return 1;
L
Linus Torvalds 已提交
1933

1934
	skb->mac_header = skb->network_header;
1935
	skb_pull(skb, (u8 *)encap - skb->data);
1936
	skb_reset_network_header(skb);
L
Linus Torvalds 已提交
1937
	skb->protocol = htons(ETH_P_IP);
1938
	skb->ip_summed = CHECKSUM_NONE;
L
Linus Torvalds 已提交
1939
	skb->pkt_type = PACKET_HOST;
1940 1941 1942

	skb_tunnel_rx(skb, reg_dev);

L
Linus Torvalds 已提交
1943
	netif_rx(skb);
I
Ilpo Järvinen 已提交
1944

1945
	return NET_RX_SUCCESS;
I
Ilpo Järvinen 已提交
1946 1947 1948 1949 1950 1951 1952 1953
}
#endif

#ifdef CONFIG_IP_PIMSM_V1
/*
 * Handle IGMP messages of PIMv1
 */

E
Eric Dumazet 已提交
1954
int pim_rcv_v1(struct sk_buff *skb)
I
Ilpo Järvinen 已提交
1955 1956
{
	struct igmphdr *pim;
1957
	struct net *net = dev_net(skb->dev);
1958
	struct mr_table *mrt;
I
Ilpo Järvinen 已提交
1959 1960 1961 1962 1963 1964

	if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
		goto drop;

	pim = igmp_hdr(skb);

1965 1966 1967
	mrt = ipmr_rt_fib_lookup(net, skb_rtable(skb));
	if (IS_ERR(mrt))
		goto drop;
1968
	if (!mrt->mroute_do_pim ||
I
Ilpo Järvinen 已提交
1969 1970 1971
	    pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
		goto drop;

1972
	if (__pim_rcv(mrt, skb, sizeof(*pim))) {
I
Ilpo Järvinen 已提交
1973 1974 1975
drop:
		kfree_skb(skb);
	}
L
Linus Torvalds 已提交
1976 1977 1978 1979 1980
	return 0;
}
#endif

#ifdef CONFIG_IP_PIMSM_V2
E
Eric Dumazet 已提交
1981
static int pim_rcv(struct sk_buff *skb)
L
Linus Torvalds 已提交
1982 1983
{
	struct pimreghdr *pim;
1984 1985
	struct net *net = dev_net(skb->dev);
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1986

I
Ilpo Järvinen 已提交
1987
	if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
L
Linus Torvalds 已提交
1988 1989
		goto drop;

1990
	pim = (struct pimreghdr *)skb_transport_header(skb);
E
Eric Dumazet 已提交
1991 1992
	if (pim->type != ((PIM_VERSION << 4) | (PIM_REGISTER)) ||
	    (pim->flags & PIM_NULL_REGISTER) ||
1993
	    (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1994
	     csum_fold(skb_checksum(skb, 0, skb->len, 0))))
L
Linus Torvalds 已提交
1995 1996
		goto drop;

1997 1998 1999
	mrt = ipmr_rt_fib_lookup(net, skb_rtable(skb));
	if (IS_ERR(mrt))
		goto drop;
2000
	if (__pim_rcv(mrt, skb, sizeof(*pim))) {
I
Ilpo Järvinen 已提交
2001 2002 2003
drop:
		kfree_skb(skb);
	}
L
Linus Torvalds 已提交
2004 2005 2006 2007
	return 0;
}
#endif

2008 2009
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			      struct mfc_cache *c, struct rtmsg *rtm)
L
Linus Torvalds 已提交
2010 2011 2012
{
	int ct;
	struct rtnexthop *nhp;
2013
	u8 *b = skb_tail_pointer(skb);
L
Linus Torvalds 已提交
2014 2015
	struct rtattr *mp_head;

2016
	/* If cache is unresolved, don't try to parse IIF and OIF */
2017
	if (c->mfc_parent >= MAXVIFS)
2018 2019
		return -ENOENT;

2020 2021
	if (VIF_EXISTS(mrt, c->mfc_parent))
		RTA_PUT(skb, RTA_IIF, 4, &mrt->vif_table[c->mfc_parent].dev->ifindex);
L
Linus Torvalds 已提交
2022

J
Jianjun Kong 已提交
2023
	mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
L
Linus Torvalds 已提交
2024 2025

	for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2026
		if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
L
Linus Torvalds 已提交
2027 2028
			if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
				goto rtattr_failure;
J
Jianjun Kong 已提交
2029
			nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
L
Linus Torvalds 已提交
2030 2031
			nhp->rtnh_flags = 0;
			nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2032
			nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
L
Linus Torvalds 已提交
2033 2034 2035 2036
			nhp->rtnh_len = sizeof(*nhp);
		}
	}
	mp_head->rta_type = RTA_MULTIPATH;
2037
	mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
L
Linus Torvalds 已提交
2038 2039 2040 2041
	rtm->rtm_type = RTN_MULTICAST;
	return 1;

rtattr_failure:
2042
	nlmsg_trim(skb, b);
L
Linus Torvalds 已提交
2043 2044 2045
	return -EMSGSIZE;
}

2046 2047
int ipmr_get_route(struct net *net,
		   struct sk_buff *skb, struct rtmsg *rtm, int nowait)
L
Linus Torvalds 已提交
2048 2049
{
	int err;
2050
	struct mr_table *mrt;
L
Linus Torvalds 已提交
2051
	struct mfc_cache *cache;
E
Eric Dumazet 已提交
2052
	struct rtable *rt = skb_rtable(skb);
L
Linus Torvalds 已提交
2053

2054 2055 2056 2057
	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return -ENOENT;

2058
	rcu_read_lock();
2059
	cache = ipmr_cache_find(mrt, rt->rt_src, rt->rt_dst);
L
Linus Torvalds 已提交
2060

J
Jianjun Kong 已提交
2061
	if (cache == NULL) {
2062
		struct sk_buff *skb2;
2063
		struct iphdr *iph;
L
Linus Torvalds 已提交
2064
		struct net_device *dev;
E
Eric Dumazet 已提交
2065
		int vif = -1;
L
Linus Torvalds 已提交
2066 2067

		if (nowait) {
2068
			rcu_read_unlock();
L
Linus Torvalds 已提交
2069 2070 2071 2072
			return -EAGAIN;
		}

		dev = skb->dev;
2073
		read_lock(&mrt_lock);
E
Eric Dumazet 已提交
2074 2075 2076
		if (dev)
			vif = ipmr_find_vif(mrt, dev);
		if (vif < 0) {
L
Linus Torvalds 已提交
2077
			read_unlock(&mrt_lock);
2078
			rcu_read_unlock();
L
Linus Torvalds 已提交
2079 2080
			return -ENODEV;
		}
2081 2082 2083
		skb2 = skb_clone(skb, GFP_ATOMIC);
		if (!skb2) {
			read_unlock(&mrt_lock);
2084
			rcu_read_unlock();
2085 2086 2087
			return -ENOMEM;
		}

2088 2089
		skb_push(skb2, sizeof(struct iphdr));
		skb_reset_network_header(skb2);
2090 2091 2092 2093 2094
		iph = ip_hdr(skb2);
		iph->ihl = sizeof(struct iphdr) >> 2;
		iph->saddr = rt->rt_src;
		iph->daddr = rt->rt_dst;
		iph->version = 0;
2095
		err = ipmr_cache_unresolved(mrt, vif, skb2);
L
Linus Torvalds 已提交
2096
		read_unlock(&mrt_lock);
2097
		rcu_read_unlock();
L
Linus Torvalds 已提交
2098 2099 2100
		return err;
	}

2101 2102
	read_lock(&mrt_lock);
	if (!nowait && (rtm->rtm_flags & RTM_F_NOTIFY))
L
Linus Torvalds 已提交
2103
		cache->mfc_flags |= MFC_NOTIFY;
2104
	err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
L
Linus Torvalds 已提交
2105
	read_unlock(&mrt_lock);
2106
	rcu_read_unlock();
L
Linus Torvalds 已提交
2107 2108 2109
	return err;
}

2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			    u32 pid, u32 seq, struct mfc_cache *c)
{
	struct nlmsghdr *nlh;
	struct rtmsg *rtm;

	nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
	if (nlh == NULL)
		return -EMSGSIZE;

	rtm = nlmsg_data(nlh);
	rtm->rtm_family   = RTNL_FAMILY_IPMR;
	rtm->rtm_dst_len  = 32;
	rtm->rtm_src_len  = 32;
	rtm->rtm_tos      = 0;
	rtm->rtm_table    = mrt->id;
	NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
	rtm->rtm_type     = RTN_MULTICAST;
	rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
	rtm->rtm_protocol = RTPROT_UNSPEC;
	rtm->rtm_flags    = 0;

	NLA_PUT_BE32(skb, RTA_SRC, c->mfc_origin);
	NLA_PUT_BE32(skb, RTA_DST, c->mfc_mcastgrp);

	if (__ipmr_fill_mroute(mrt, skb, c, rtm) < 0)
		goto nla_put_failure;

	return nlmsg_end(skb, nlh);

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

static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	struct mr_table *mrt;
	struct mfc_cache *mfc;
	unsigned int t = 0, s_t;
	unsigned int h = 0, s_h;
	unsigned int e = 0, s_e;

	s_t = cb->args[0];
	s_h = cb->args[1];
	s_e = cb->args[2];

2158
	rcu_read_lock();
2159 2160 2161 2162 2163 2164
	ipmr_for_each_table(mrt, net) {
		if (t < s_t)
			goto next_table;
		if (t > s_t)
			s_h = 0;
		for (h = s_h; h < MFC_LINES; h++) {
2165
			list_for_each_entry_rcu(mfc, &mrt->mfc_cache_array[h], list) {
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
				if (e < s_e)
					goto next_entry;
				if (ipmr_fill_mroute(mrt, skb,
						     NETLINK_CB(cb->skb).pid,
						     cb->nlh->nlmsg_seq,
						     mfc) < 0)
					goto done;
next_entry:
				e++;
			}
			e = s_e = 0;
		}
		s_h = 0;
next_table:
		t++;
	}
done:
2183
	rcu_read_unlock();
2184 2185 2186 2187 2188 2189 2190 2191

	cb->args[2] = e;
	cb->args[1] = h;
	cb->args[0] = t;

	return skb->len;
}

2192
#ifdef CONFIG_PROC_FS
L
Linus Torvalds 已提交
2193
/*
E
Eric Dumazet 已提交
2194 2195
 *	The /proc interfaces to multicast routing :
 *	/proc/net/ip_mr_cache & /proc/net/ip_mr_vif
L
Linus Torvalds 已提交
2196 2197
 */
struct ipmr_vif_iter {
2198
	struct seq_net_private p;
2199
	struct mr_table *mrt;
L
Linus Torvalds 已提交
2200 2201 2202
	int ct;
};

2203 2204
static struct vif_device *ipmr_vif_seq_idx(struct net *net,
					   struct ipmr_vif_iter *iter,
L
Linus Torvalds 已提交
2205 2206
					   loff_t pos)
{
2207
	struct mr_table *mrt = iter->mrt;
2208 2209 2210

	for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
		if (!VIF_EXISTS(mrt, iter->ct))
L
Linus Torvalds 已提交
2211
			continue;
2212
		if (pos-- == 0)
2213
			return &mrt->vif_table[iter->ct];
L
Linus Torvalds 已提交
2214 2215 2216 2217 2218
	}
	return NULL;
}

static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
S
Stephen Hemminger 已提交
2219
	__acquires(mrt_lock)
L
Linus Torvalds 已提交
2220
{
2221
	struct ipmr_vif_iter *iter = seq->private;
2222
	struct net *net = seq_file_net(seq);
2223 2224 2225 2226 2227 2228 2229
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return ERR_PTR(-ENOENT);

	iter->mrt = mrt;
2230

L
Linus Torvalds 已提交
2231
	read_lock(&mrt_lock);
2232
	return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
L
Linus Torvalds 已提交
2233 2234 2235 2236 2237 2238
		: SEQ_START_TOKEN;
}

static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct ipmr_vif_iter *iter = seq->private;
2239
	struct net *net = seq_file_net(seq);
2240
	struct mr_table *mrt = iter->mrt;
L
Linus Torvalds 已提交
2241 2242 2243

	++*pos;
	if (v == SEQ_START_TOKEN)
2244
		return ipmr_vif_seq_idx(net, iter, 0);
2245

2246 2247
	while (++iter->ct < mrt->maxvif) {
		if (!VIF_EXISTS(mrt, iter->ct))
L
Linus Torvalds 已提交
2248
			continue;
2249
		return &mrt->vif_table[iter->ct];
L
Linus Torvalds 已提交
2250 2251 2252 2253 2254
	}
	return NULL;
}

static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
S
Stephen Hemminger 已提交
2255
	__releases(mrt_lock)
L
Linus Torvalds 已提交
2256 2257 2258 2259 2260 2261
{
	read_unlock(&mrt_lock);
}

static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
{
2262 2263
	struct ipmr_vif_iter *iter = seq->private;
	struct mr_table *mrt = iter->mrt;
2264

L
Linus Torvalds 已提交
2265
	if (v == SEQ_START_TOKEN) {
2266
		seq_puts(seq,
L
Linus Torvalds 已提交
2267 2268 2269 2270 2271 2272 2273
			 "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags Local    Remote\n");
	} else {
		const struct vif_device *vif = v;
		const char *name =  vif->dev ? vif->dev->name : "none";

		seq_printf(seq,
			   "%2Zd %-10s %8ld %7ld  %8ld %7ld %05X %08X %08X\n",
2274
			   vif - mrt->vif_table,
2275
			   name, vif->bytes_in, vif->pkt_in,
L
Linus Torvalds 已提交
2276 2277 2278 2279 2280 2281
			   vif->bytes_out, vif->pkt_out,
			   vif->flags, vif->local, vif->remote);
	}
	return 0;
}

2282
static const struct seq_operations ipmr_vif_seq_ops = {
L
Linus Torvalds 已提交
2283 2284 2285 2286 2287 2288 2289 2290
	.start = ipmr_vif_seq_start,
	.next  = ipmr_vif_seq_next,
	.stop  = ipmr_vif_seq_stop,
	.show  = ipmr_vif_seq_show,
};

static int ipmr_vif_open(struct inode *inode, struct file *file)
{
2291 2292
	return seq_open_net(inode, file, &ipmr_vif_seq_ops,
			    sizeof(struct ipmr_vif_iter));
L
Linus Torvalds 已提交
2293 2294
}

2295
static const struct file_operations ipmr_vif_fops = {
L
Linus Torvalds 已提交
2296 2297 2298 2299
	.owner	 = THIS_MODULE,
	.open    = ipmr_vif_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
2300
	.release = seq_release_net,
L
Linus Torvalds 已提交
2301 2302 2303
};

struct ipmr_mfc_iter {
2304
	struct seq_net_private p;
2305
	struct mr_table *mrt;
2306
	struct list_head *cache;
L
Linus Torvalds 已提交
2307 2308 2309 2310
	int ct;
};


2311 2312
static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
					  struct ipmr_mfc_iter *it, loff_t pos)
L
Linus Torvalds 已提交
2313
{
2314
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2315 2316
	struct mfc_cache *mfc;

2317
	rcu_read_lock();
2318
	for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
2319
		it->cache = &mrt->mfc_cache_array[it->ct];
2320
		list_for_each_entry_rcu(mfc, it->cache, list)
2321
			if (pos-- == 0)
L
Linus Torvalds 已提交
2322
				return mfc;
2323
	}
2324
	rcu_read_unlock();
L
Linus Torvalds 已提交
2325 2326

	spin_lock_bh(&mfc_unres_lock);
2327
	it->cache = &mrt->mfc_unres_queue;
2328
	list_for_each_entry(mfc, it->cache, list)
2329
		if (pos-- == 0)
L
Linus Torvalds 已提交
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340
			return mfc;
	spin_unlock_bh(&mfc_unres_lock);

	it->cache = NULL;
	return NULL;
}


static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
{
	struct ipmr_mfc_iter *it = seq->private;
2341
	struct net *net = seq_file_net(seq);
2342
	struct mr_table *mrt;
2343

2344 2345 2346
	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return ERR_PTR(-ENOENT);
2347

2348
	it->mrt = mrt;
L
Linus Torvalds 已提交
2349 2350
	it->cache = NULL;
	it->ct = 0;
2351
	return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
L
Linus Torvalds 已提交
2352 2353 2354 2355 2356 2357 2358
		: SEQ_START_TOKEN;
}

static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct mfc_cache *mfc = v;
	struct ipmr_mfc_iter *it = seq->private;
2359
	struct net *net = seq_file_net(seq);
2360
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2361 2362 2363 2364

	++*pos;

	if (v == SEQ_START_TOKEN)
2365
		return ipmr_mfc_seq_idx(net, seq->private, 0);
L
Linus Torvalds 已提交
2366

2367 2368
	if (mfc->list.next != it->cache)
		return list_entry(mfc->list.next, struct mfc_cache, list);
2369

2370
	if (it->cache == &mrt->mfc_unres_queue)
L
Linus Torvalds 已提交
2371 2372
		goto end_of_list;

2373
	BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
L
Linus Torvalds 已提交
2374 2375

	while (++it->ct < MFC_LINES) {
2376
		it->cache = &mrt->mfc_cache_array[it->ct];
2377 2378 2379
		if (list_empty(it->cache))
			continue;
		return list_first_entry(it->cache, struct mfc_cache, list);
L
Linus Torvalds 已提交
2380 2381 2382
	}

	/* exhausted cache_array, show unresolved */
2383
	rcu_read_unlock();
2384
	it->cache = &mrt->mfc_unres_queue;
L
Linus Torvalds 已提交
2385
	it->ct = 0;
2386

L
Linus Torvalds 已提交
2387
	spin_lock_bh(&mfc_unres_lock);
2388 2389
	if (!list_empty(it->cache))
		return list_first_entry(it->cache, struct mfc_cache, list);
L
Linus Torvalds 已提交
2390

E
Eric Dumazet 已提交
2391
end_of_list:
L
Linus Torvalds 已提交
2392 2393 2394 2395 2396 2397 2398 2399 2400
	spin_unlock_bh(&mfc_unres_lock);
	it->cache = NULL;

	return NULL;
}

static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
{
	struct ipmr_mfc_iter *it = seq->private;
2401
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2402

2403
	if (it->cache == &mrt->mfc_unres_queue)
L
Linus Torvalds 已提交
2404
		spin_unlock_bh(&mfc_unres_lock);
2405
	else if (it->cache == &mrt->mfc_cache_array[it->ct])
2406
		rcu_read_unlock();
L
Linus Torvalds 已提交
2407 2408 2409 2410 2411 2412 2413
}

static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
{
	int n;

	if (v == SEQ_START_TOKEN) {
2414
		seq_puts(seq,
L
Linus Torvalds 已提交
2415 2416 2417 2418
		 "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
	} else {
		const struct mfc_cache *mfc = v;
		const struct ipmr_mfc_iter *it = seq->private;
2419
		const struct mr_table *mrt = it->mrt;
2420

2421 2422 2423
		seq_printf(seq, "%08X %08X %-3hd",
			   (__force u32) mfc->mfc_mcastgrp,
			   (__force u32) mfc->mfc_origin,
2424
			   mfc->mfc_parent);
L
Linus Torvalds 已提交
2425

2426
		if (it->cache != &mrt->mfc_unres_queue) {
2427 2428 2429 2430
			seq_printf(seq, " %8lu %8lu %8lu",
				   mfc->mfc_un.res.pkt,
				   mfc->mfc_un.res.bytes,
				   mfc->mfc_un.res.wrong_if);
S
Stephen Hemminger 已提交
2431
			for (n = mfc->mfc_un.res.minvif;
E
Eric Dumazet 已提交
2432
			     n < mfc->mfc_un.res.maxvif; n++) {
2433
				if (VIF_EXISTS(mrt, n) &&
2434 2435
				    mfc->mfc_un.res.ttls[n] < 255)
					seq_printf(seq,
2436
					   " %2d:%-3d",
L
Linus Torvalds 已提交
2437 2438
					   n, mfc->mfc_un.res.ttls[n]);
			}
2439 2440 2441 2442 2443
		} else {
			/* unresolved mfc_caches don't contain
			 * pkt, bytes and wrong_if values
			 */
			seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
L
Linus Torvalds 已提交
2444 2445 2446 2447 2448 2449
		}
		seq_putc(seq, '\n');
	}
	return 0;
}

2450
static const struct seq_operations ipmr_mfc_seq_ops = {
L
Linus Torvalds 已提交
2451 2452 2453 2454 2455 2456 2457 2458
	.start = ipmr_mfc_seq_start,
	.next  = ipmr_mfc_seq_next,
	.stop  = ipmr_mfc_seq_stop,
	.show  = ipmr_mfc_seq_show,
};

static int ipmr_mfc_open(struct inode *inode, struct file *file)
{
2459 2460
	return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
			    sizeof(struct ipmr_mfc_iter));
L
Linus Torvalds 已提交
2461 2462
}

2463
static const struct file_operations ipmr_mfc_fops = {
L
Linus Torvalds 已提交
2464 2465 2466 2467
	.owner	 = THIS_MODULE,
	.open    = ipmr_mfc_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
2468
	.release = seq_release_net,
L
Linus Torvalds 已提交
2469
};
2470
#endif
L
Linus Torvalds 已提交
2471 2472

#ifdef CONFIG_IP_PIMSM_V2
2473
static const struct net_protocol pim_protocol = {
L
Linus Torvalds 已提交
2474
	.handler	=	pim_rcv,
T
Tom Goff 已提交
2475
	.netns_ok	=	1,
L
Linus Torvalds 已提交
2476 2477 2478 2479 2480 2481 2482
};
#endif


/*
 *	Setup for IP multicast routing
 */
2483 2484
static int __net_init ipmr_net_init(struct net *net)
{
2485
	int err;
2486

2487 2488
	err = ipmr_rules_init(net);
	if (err < 0)
2489
		goto fail;
2490 2491 2492 2493 2494 2495 2496 2497

#ifdef CONFIG_PROC_FS
	err = -ENOMEM;
	if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
		goto proc_vif_fail;
	if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
		goto proc_cache_fail;
#endif
2498 2499
	return 0;

2500 2501 2502 2503
#ifdef CONFIG_PROC_FS
proc_cache_fail:
	proc_net_remove(net, "ip_mr_vif");
proc_vif_fail:
2504
	ipmr_rules_exit(net);
2505
#endif
2506 2507 2508 2509 2510 2511
fail:
	return err;
}

static void __net_exit ipmr_net_exit(struct net *net)
{
2512 2513 2514 2515
#ifdef CONFIG_PROC_FS
	proc_net_remove(net, "ip_mr_cache");
	proc_net_remove(net, "ip_mr_vif");
#endif
2516
	ipmr_rules_exit(net);
2517 2518 2519 2520 2521 2522
}

static struct pernet_operations ipmr_net_ops = {
	.init = ipmr_net_init,
	.exit = ipmr_net_exit,
};
2523

W
Wang Chen 已提交
2524
int __init ip_mr_init(void)
L
Linus Torvalds 已提交
2525
{
W
Wang Chen 已提交
2526 2527
	int err;

L
Linus Torvalds 已提交
2528 2529
	mrt_cachep = kmem_cache_create("ip_mrt_cache",
				       sizeof(struct mfc_cache),
2530
				       0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
2531
				       NULL);
W
Wang Chen 已提交
2532 2533 2534
	if (!mrt_cachep)
		return -ENOMEM;

2535 2536 2537 2538
	err = register_pernet_subsys(&ipmr_net_ops);
	if (err)
		goto reg_pernet_fail;

W
Wang Chen 已提交
2539 2540 2541
	err = register_netdevice_notifier(&ip_mr_notifier);
	if (err)
		goto reg_notif_fail;
T
Tom Goff 已提交
2542 2543 2544 2545 2546 2547 2548
#ifdef CONFIG_IP_PIMSM_V2
	if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
		printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n");
		err = -EAGAIN;
		goto add_proto_fail;
	}
#endif
2549
	rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE, NULL, ipmr_rtm_dumproute);
W
Wang Chen 已提交
2550
	return 0;
2551

T
Tom Goff 已提交
2552 2553 2554 2555
#ifdef CONFIG_IP_PIMSM_V2
add_proto_fail:
	unregister_netdevice_notifier(&ip_mr_notifier);
#endif
B
Benjamin Thery 已提交
2556
reg_notif_fail:
2557 2558
	unregister_pernet_subsys(&ipmr_net_ops);
reg_pernet_fail:
B
Benjamin Thery 已提交
2559
	kmem_cache_destroy(mrt_cachep);
W
Wang Chen 已提交
2560
	return err;
L
Linus Torvalds 已提交
2561
}