ipmr.c 55.3 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 63 64
#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>
#include <net/ipip.h>
#include <net/checksum.h>
65
#include <net/netlink.h>
66
#include <net/fib_rules.h>
L
Linus Torvalds 已提交
67 68 69 70 71

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

72
struct mr_table {
73
	struct list_head	list;
74 75 76
#ifdef CONFIG_NET_NS
	struct net		*net;
#endif
77
	u32			id;
E
Eric Dumazet 已提交
78
	struct sock __rcu	*mroute_sk;
79 80 81 82 83 84 85 86 87 88 89 90 91
	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
};

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

struct ipmr_result {
	struct mr_table		*mrt;
};

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

static DEFINE_RWLOCK(mrt_lock);

/*
 *	Multicast router control variables
 */

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

/* 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 已提交
116 117 118 119 120
 * 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 已提交
121 122
 */

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

125
static struct mr_table *ipmr_new_table(struct net *net, u32 id);
126 127 128 129
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,
130
			     struct sk_buff *pkt, vifi_t vifi, int assert);
131 132
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			      struct mfc_cache *c, struct rtmsg *rtm);
133 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
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 已提交
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
	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;
}

219
static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
220
	.family		= RTNL_FAMILY_IPMR,
221 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
	.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 已提交
270 271
	list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
		list_del(&mrt->list);
272
		kfree(mrt);
E
Eric Dumazet 已提交
273
	}
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
	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 已提交
308

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

	mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
	if (mrt == NULL)
		return NULL;
316
	write_pnet(&mrt->net, net);
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	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 已提交
336 337 338

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

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

343 344
	dev_close(dev);

345
	dev = __dev_get_by_name(net, "tunl0");
346
	if (dev) {
347
		const struct net_device_ops *ops = dev->netdev_ops;
348 349 350 351 352 353 354 355 356 357 358 359
		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;

360 361 362 363 364 365 366
		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);
		}
367 368 369
	}
}

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

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

	if (dev) {
378
		const struct net_device_ops *ops = dev->netdev_ops;
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386 387 388 389 390
		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 已提交
391
		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
L
Linus Torvalds 已提交
392

393 394 395 396 397 398
		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 已提交
399
		} else {
400
			err = -EOPNOTSUPP;
E
Eric Dumazet 已提交
401
		}
L
Linus Torvalds 已提交
402 403
		dev = NULL;

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

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

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

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

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

	unregister_netdevice(dev);
	return NULL;
}

#ifdef CONFIG_IP_PIMSM

433
static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
434
{
435
	struct net *net = dev_net(dev);
436 437 438 439 440 441 442 443 444
	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);
445 446
	if (err < 0) {
		kfree_skb(skb);
447
		return err;
448
	}
449

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

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

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

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

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

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

	if (dev == NULL)
		return NULL;

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

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

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

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

	if (dev_open(dev))
		goto failure;

511 512
	dev_hold(dev);

L
Linus Torvalds 已提交
513 514 515 516 517 518 519 520 521 522 523 524 525 526
	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
527
 *	@notify: Set to 1, if the caller is a notifier_call
L
Linus Torvalds 已提交
528
 */
529

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

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

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

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

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

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

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

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

	write_unlock_bh(&mrt_lock);

	dev_set_allmulti(dev, -1);

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

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

	dev_put(dev);
	return 0;
}

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

587 588 589
	kmem_cache_free(mrt_cachep, c);
}

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

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

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

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

J
Jianjun Kong 已提交
607
	while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
608
		if (ip_hdr(skb)->version == 0) {
L
Linus Torvalds 已提交
609 610 611 612
			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);
613 614 615
			e = NLMSG_DATA(nlh);
			e->error = -ETIMEDOUT;
			memset(&e->msg, 0, sizeof(e->msg));
616

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

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


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

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

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

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

	now = jiffies;
	expires = 10*HZ;

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

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

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

out:
	spin_unlock(&mfc_unres_lock);
}

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

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

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

677 678
	for (vifi = 0; vifi < mrt->maxvif; vifi++) {
		if (VIF_EXISTS(mrt, vifi) &&
679
		    ttls[vifi] && ttls[vifi] < 255) {
L
Linus Torvalds 已提交
680 681 682 683 684 685 686 687 688
			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;
		}
	}
}

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

	/* Is vif busy ? */
699
	if (VIF_EXISTS(mrt, vifi))
L
Linus Torvalds 已提交
700 701 702 703 704 705 706 707 708
		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
		 */
709
		if (mrt->mroute_reg_vif_num >= 0)
L
Linus Torvalds 已提交
710
			return -EADDRINUSE;
711
		dev = ipmr_reg_vif(net, mrt);
L
Linus Torvalds 已提交
712 713
		if (!dev)
			return -ENOBUFS;
714 715 716
		err = dev_set_allmulti(dev, 1);
		if (err) {
			unregister_netdevice(dev);
717
			dev_put(dev);
718 719
			return err;
		}
L
Linus Torvalds 已提交
720 721
		break;
#endif
722
	case VIFF_TUNNEL:
723
		dev = ipmr_new_tunnel(net, vifc);
L
Linus Torvalds 已提交
724 725
		if (!dev)
			return -ENOBUFS;
726 727 728
		err = dev_set_allmulti(dev, 1);
		if (err) {
			ipmr_del_tunnel(dev, vifc);
729
			dev_put(dev);
730 731
			return err;
		}
L
Linus Torvalds 已提交
732
		break;
733 734

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

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

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

J
Jianjun Kong 已提交
767 768 769 770
	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 已提交
771 772
	if (!mrtsock)
		v->flags |= VIFF_STATIC;
J
Jianjun Kong 已提交
773
	v->threshold = vifc->vifc_threshold;
L
Linus Torvalds 已提交
774 775 776 777 778
	v->bytes_in = 0;
	v->bytes_out = 0;
	v->pkt_in = 0;
	v->pkt_out = 0;
	v->link = dev->ifindex;
E
Eric Dumazet 已提交
779
	if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
L
Linus Torvalds 已提交
780 781 782 783
		v->link = dev->iflink;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

875
static int ipmr_cache_report(struct mr_table *mrt,
876
			     struct sk_buff *pkt, vifi_t vifi, int assert)
L
Linus Torvalds 已提交
877 878
{
	struct sk_buff *skb;
879
	const int ihl = ip_hdrlen(pkt);
L
Linus Torvalds 已提交
880 881
	struct igmphdr *igmp;
	struct igmpmsg *msg;
E
Eric Dumazet 已提交
882
	struct sock *mroute_sk;
L
Linus Torvalds 已提交
883 884 885 886 887 888 889 890 891
	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 已提交
892
	if (!skb)
L
Linus Torvalds 已提交
893 894 895 896 897
		return -ENOBUFS;

#ifdef CONFIG_IP_PIMSM
	if (assert == IGMPMSG_WHOLEPKT) {
		/* Ugly, but we have no choice with this interface.
E
Eric Dumazet 已提交
898 899 900
		 * 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 已提交
901
		 */
902 903
		skb_push(skb, sizeof(struct iphdr));
		skb_reset_network_header(skb);
904
		skb_reset_transport_header(skb);
905
		msg = (struct igmpmsg *)skb_network_header(skb);
906
		memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
L
Linus Torvalds 已提交
907 908
		msg->im_msgtype = IGMPMSG_WHOLEPKT;
		msg->im_mbz = 0;
909
		msg->im_vif = mrt->mroute_reg_vif_num;
910 911 912
		ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
		ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
					     sizeof(struct iphdr));
913
	} else
L
Linus Torvalds 已提交
914
#endif
915 916
	{

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

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

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

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

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

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

E
Eric Dumazet 已提交
947 948
	ret = sock_queue_rcv_skb(mroute_sk, skb);
	rcu_read_unlock();
949
	if (ret < 0) {
L
Linus Torvalds 已提交
950 951 952 953 954 955 956 957 958 959 960
		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!
 */
961

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

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

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

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

			kfree_skb(skb);
			return -ENOBUFS;
		}

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

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

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

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

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

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

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

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

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

	spin_unlock_bh(&mfc_unres_lock);
	return err;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

S
Stephen Hemminger 已提交
1290 1291
		rtnl_lock();
		ret = 0;
1292 1293 1294
		if (v != mrt->mroute_do_pim) {
			mrt->mroute_do_pim = v;
			mrt->mroute_do_assert = v;
L
Linus Torvalds 已提交
1295
		}
S
Stephen Hemminger 已提交
1296 1297 1298
		rtnl_unlock();
		return ret;
	}
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
#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 已提交
1312 1313 1314 1315 1316 1317 1318
		if (sk == rtnl_dereference(mrt->mroute_sk)) {
			ret = -EBUSY;
		} else {
			if (!ipmr_new_table(net, v))
				ret = -ENOMEM;
			raw_sk(sk)->ipmr_table = v;
		}
1319 1320 1321
		rtnl_unlock();
		return ret;
	}
L
Linus Torvalds 已提交
1322
#endif
S
Stephen Hemminger 已提交
1323 1324 1325 1326 1327 1328
	/*
	 *	Spurious command, or MRT_VERSION which you cannot
	 *	set.
	 */
	default:
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1329 1330 1331 1332 1333 1334
	}
}

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

J
Jianjun Kong 已提交
1336
int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
L
Linus Torvalds 已提交
1337 1338 1339
{
	int olr;
	int val;
1340
	struct net *net = sock_net(sk);
1341 1342 1343 1344 1345
	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 已提交
1346

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

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

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

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

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

L
Linus Torvalds 已提交
1380 1381 1382 1383 1384 1385
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;
1386
	struct net *net = sock_net(sk);
1387 1388 1389 1390 1391
	struct mr_table *mrt;

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

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

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

1418
		rcu_read_lock();
1419
		c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
S
Stephen Hemminger 已提交
1420 1421 1422 1423
		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;
1424
			rcu_read_unlock();
S
Stephen Hemminger 已提交
1425

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


static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
{
1440
	struct net_device *dev = ptr;
1441
	struct net *net = dev_net(dev);
1442
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1443 1444
	struct vif_device *v;
	int ct;
1445
	LIST_HEAD(list);
1446

L
Linus Torvalds 已提交
1447 1448
	if (event != NETDEV_UNREGISTER)
		return NOTIFY_DONE;
1449 1450 1451 1452 1453 1454 1455

	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 已提交
1456
	}
1457
	unregister_netdevice_many(&list);
L
Linus Torvalds 已提交
1458 1459 1460 1461
	return NOTIFY_DONE;
}


J
Jianjun Kong 已提交
1462
static struct notifier_block ip_mr_notifier = {
L
Linus Torvalds 已提交
1463 1464 1465 1466
	.notifier_call = ipmr_device_event,
};

/*
E
Eric Dumazet 已提交
1467
 *	Encapsulate a packet by attaching a valid IPIP header to it.
L
Linus Torvalds 已提交
1468 1469 1470
 *	This avoids tunnel drivers and other mess and gives us the speed so
 *	important for multicast video.
 */
1471

A
Al Viro 已提交
1472
static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
L
Linus Torvalds 已提交
1473
{
1474
	struct iphdr *iph;
1475
	struct iphdr *old_iph = ip_hdr(skb);
1476 1477

	skb_push(skb, sizeof(struct iphdr));
1478
	skb->transport_header = skb->network_header;
1479
	skb_reset_network_header(skb);
1480
	iph = ip_hdr(skb);
L
Linus Torvalds 已提交
1481

E
Eric Dumazet 已提交
1482
	iph->version	=	4;
1483 1484
	iph->tos	=	old_iph->tos;
	iph->ttl	=	old_iph->ttl;
L
Linus Torvalds 已提交
1485 1486 1487 1488 1489 1490
	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 已提交
1491
	ip_select_ident(iph, skb_dst(skb), NULL);
L
Linus Torvalds 已提交
1492 1493 1494 1495 1496 1497 1498 1499
	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 已提交
1500
	struct ip_options *opt = &(IPCB(skb)->opt);
L
Linus Torvalds 已提交
1501

E
Eric Dumazet 已提交
1502
	IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
L
Linus Torvalds 已提交
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

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

	return dst_output(skb);
}

/*
 *	Processing handlers for ipmr_forward
 */

1514 1515
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 已提交
1516
{
1517
	const struct iphdr *iph = ip_hdr(skb);
1518
	struct vif_device *vif = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
	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 已提交
1529
		vif->bytes_out += skb->len;
1530 1531
		vif->dev->stats.tx_bytes += skb->len;
		vif->dev->stats.tx_packets++;
1532
		ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
1533
		goto out_free;
L
Linus Torvalds 已提交
1534 1535 1536
	}
#endif

E
Eric Dumazet 已提交
1537 1538 1539
	if (vif->flags & VIFF_TUNNEL) {
		struct flowi fl = {
			.oif = vif->link,
1540 1541 1542
			.fl4_dst = vif->remote,
			.fl4_src = vif->local,
			.fl4_tos = RT_TOS(iph->tos),
E
Eric Dumazet 已提交
1543 1544 1545
			.proto = IPPROTO_IPIP
		};

1546
		if (ip_route_output_key(net, &rt, &fl))
L
Linus Torvalds 已提交
1547 1548 1549
			goto out_free;
		encap = sizeof(struct iphdr);
	} else {
E
Eric Dumazet 已提交
1550 1551
		struct flowi fl = {
			.oif = vif->link,
1552 1553
			.fl4_dst = iph->daddr,
			.fl4_tos = RT_TOS(iph->tos),
E
Eric Dumazet 已提交
1554 1555 1556
			.proto = IPPROTO_IPIP
		};

1557
		if (ip_route_output_key(net, &rt, &fl))
L
Linus Torvalds 已提交
1558 1559 1560
			goto out_free;
	}

1561
	dev = rt->dst.dev;
L
Linus Torvalds 已提交
1562

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

1569
		IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
L
Linus Torvalds 已提交
1570 1571 1572 1573
		ip_rt_put(rt);
		goto out_free;
	}

1574
	encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
L
Linus Torvalds 已提交
1575 1576

	if (skb_cow(skb, encap)) {
1577
		ip_rt_put(rt);
L
Linus Torvalds 已提交
1578 1579 1580 1581
		goto out_free;
	}

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

E
Eric Dumazet 已提交
1584
	skb_dst_drop(skb);
1585
	skb_dst_set(skb, &rt->dst);
1586
	ip_decrease_ttl(ip_hdr(skb));
L
Linus Torvalds 已提交
1587 1588

	/* FIXME: forward and output firewalls used to be called here.
E
Eric Dumazet 已提交
1589 1590
	 * What do we do with netfilter? -- RR
	 */
L
Linus Torvalds 已提交
1591 1592 1593
	if (vif->flags & VIFF_TUNNEL) {
		ip_encap(skb, vif->local, vif->remote);
		/* FIXME: extra output firewall step used to be here. --RR */
1594 1595
		vif->dev->stats.tx_packets++;
		vif->dev->stats.tx_bytes += skb->len;
L
Linus Torvalds 已提交
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
	}

	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.
	 */
1611
	NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
L
Linus Torvalds 已提交
1612 1613 1614 1615 1616 1617 1618
		ipmr_forward_finish);
	return;

out_free:
	kfree_skb(skb);
}

1619
static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
L
Linus Torvalds 已提交
1620 1621
{
	int ct;
1622 1623 1624

	for (ct = mrt->maxvif-1; ct >= 0; ct--) {
		if (mrt->vif_table[ct].dev == dev)
L
Linus Torvalds 已提交
1625 1626 1627 1628 1629 1630 1631
			break;
	}
	return ct;
}

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

1632 1633 1634
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 已提交
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
{
	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.
	 */
1646
	if (mrt->vif_table[vif].dev != skb->dev) {
L
Linus Torvalds 已提交
1647 1648
		int true_vifi;

1649
		if (rt_is_output_route(skb_rtable(skb))) {
L
Linus Torvalds 已提交
1650
			/* It is our own packet, looped back.
E
Eric Dumazet 已提交
1651 1652 1653 1654 1655 1656 1657 1658 1659
			 * 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 已提交
1660 1661 1662 1663 1664
			 */
			goto dont_forward;
		}

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

1667
		if (true_vifi >= 0 && mrt->mroute_do_assert &&
L
Linus Torvalds 已提交
1668
		    /* pimsm uses asserts, when switching from RPT to SPT,
E
Eric Dumazet 已提交
1669 1670 1671
		     * 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 已提交
1672
		     */
1673
		    (mrt->mroute_do_pim ||
1674
		     cache->mfc_un.res.ttls[true_vifi] < 255) &&
1675
		    time_after(jiffies,
L
Linus Torvalds 已提交
1676 1677
			       cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
			cache->mfc_un.res.last_assert = jiffies;
1678
			ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
L
Linus Torvalds 已提交
1679 1680 1681 1682
		}
		goto dont_forward;
	}

1683 1684
	mrt->vif_table[vif].pkt_in++;
	mrt->vif_table[vif].bytes_in += skb->len;
L
Linus Torvalds 已提交
1685 1686 1687 1688

	/*
	 *	Forward the frame
	 */
E
Eric Dumazet 已提交
1689 1690
	for (ct = cache->mfc_un.res.maxvif - 1;
	     ct >= cache->mfc_un.res.minvif; ct--) {
1691
		if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
L
Linus Torvalds 已提交
1692 1693
			if (psend != -1) {
				struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
E
Eric Dumazet 已提交
1694

L
Linus Torvalds 已提交
1695
				if (skb2)
1696 1697
					ipmr_queue_xmit(net, mrt, skb2, cache,
							psend);
L
Linus Torvalds 已提交
1698
			}
J
Jianjun Kong 已提交
1699
			psend = ct;
L
Linus Torvalds 已提交
1700 1701 1702 1703 1704
		}
	}
	if (psend != -1) {
		if (local) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
E
Eric Dumazet 已提交
1705

L
Linus Torvalds 已提交
1706
			if (skb2)
1707
				ipmr_queue_xmit(net, mrt, skb2, cache, psend);
L
Linus Torvalds 已提交
1708
		} else {
1709
			ipmr_queue_xmit(net, mrt, skb, cache, psend);
L
Linus Torvalds 已提交
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
			return 0;
		}
	}

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


/*
 *	Multicast packets for forwarding arrive here
E
Eric Dumazet 已提交
1723
 *	Called with rcu_read_lock();
L
Linus Torvalds 已提交
1724 1725 1726 1727 1728
 */

int ip_mr_input(struct sk_buff *skb)
{
	struct mfc_cache *cache;
1729
	struct net *net = dev_net(skb->dev);
E
Eric Dumazet 已提交
1730
	int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1731 1732
	struct mr_table *mrt;
	int err;
L
Linus Torvalds 已提交
1733 1734

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

1740
	err = ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt);
1741 1742
	if (err < 0) {
		kfree_skb(skb);
1743
		return err;
1744
	}
1745

L
Linus Torvalds 已提交
1746
	if (!local) {
E
Eric Dumazet 已提交
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
		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 已提交
1765 1766 1767
		    }
	}

1768
	/* already under rcu_read_lock() */
1769
	cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
L
Linus Torvalds 已提交
1770 1771 1772 1773

	/*
	 *	No usable cache entry
	 */
J
Jianjun Kong 已提交
1774
	if (cache == NULL) {
L
Linus Torvalds 已提交
1775 1776 1777 1778 1779
		int vif;

		if (local) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
			ip_local_deliver(skb);
1780
			if (skb2 == NULL)
L
Linus Torvalds 已提交
1781 1782 1783 1784
				return -ENOBUFS;
			skb = skb2;
		}

1785
		read_lock(&mrt_lock);
1786
		vif = ipmr_find_vif(mrt, skb->dev);
L
Linus Torvalds 已提交
1787
		if (vif >= 0) {
1788
			int err2 = ipmr_cache_unresolved(mrt, vif, skb);
L
Linus Torvalds 已提交
1789 1790
			read_unlock(&mrt_lock);

1791
			return err2;
L
Linus Torvalds 已提交
1792 1793 1794 1795 1796 1797
		}
		read_unlock(&mrt_lock);
		kfree_skb(skb);
		return -ENODEV;
	}

1798
	read_lock(&mrt_lock);
1799
	ip_mr_forward(net, mrt, skb, cache, local);
L
Linus Torvalds 已提交
1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
	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 已提交
1814
#ifdef CONFIG_IP_PIMSM
1815
/* called with rcu_read_lock() */
1816 1817
static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
		     unsigned int pimlen)
L
Linus Torvalds 已提交
1818
{
I
Ilpo Järvinen 已提交
1819 1820
	struct net_device *reg_dev = NULL;
	struct iphdr *encap;
L
Linus Torvalds 已提交
1821

I
Ilpo Järvinen 已提交
1822
	encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
L
Linus Torvalds 已提交
1823
	/*
E
Eric Dumazet 已提交
1824 1825 1826 1827
	 * 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 已提交
1828
	 */
1829
	if (!ipv4_is_multicast(encap->daddr) ||
L
Linus Torvalds 已提交
1830
	    encap->tot_len == 0 ||
I
Ilpo Järvinen 已提交
1831 1832
	    ntohs(encap->tot_len) + pimlen > skb->len)
		return 1;
L
Linus Torvalds 已提交
1833 1834

	read_lock(&mrt_lock);
1835 1836
	if (mrt->mroute_reg_vif_num >= 0)
		reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
L
Linus Torvalds 已提交
1837 1838
	read_unlock(&mrt_lock);

1839
	if (reg_dev == NULL)
I
Ilpo Järvinen 已提交
1840
		return 1;
L
Linus Torvalds 已提交
1841

1842
	skb->mac_header = skb->network_header;
1843
	skb_pull(skb, (u8 *)encap - skb->data);
1844
	skb_reset_network_header(skb);
L
Linus Torvalds 已提交
1845
	skb->protocol = htons(ETH_P_IP);
1846
	skb->ip_summed = CHECKSUM_NONE;
L
Linus Torvalds 已提交
1847
	skb->pkt_type = PACKET_HOST;
1848 1849 1850

	skb_tunnel_rx(skb, reg_dev);

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

1853
	return NET_RX_SUCCESS;
I
Ilpo Järvinen 已提交
1854 1855 1856 1857 1858 1859 1860 1861
}
#endif

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

E
Eric Dumazet 已提交
1862
int pim_rcv_v1(struct sk_buff *skb)
I
Ilpo Järvinen 已提交
1863 1864
{
	struct igmphdr *pim;
1865
	struct net *net = dev_net(skb->dev);
1866
	struct mr_table *mrt;
I
Ilpo Järvinen 已提交
1867 1868 1869 1870 1871 1872

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

	pim = igmp_hdr(skb);

1873 1874 1875
	if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
		goto drop;

1876
	if (!mrt->mroute_do_pim ||
I
Ilpo Järvinen 已提交
1877 1878 1879
	    pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
		goto drop;

1880
	if (__pim_rcv(mrt, skb, sizeof(*pim))) {
I
Ilpo Järvinen 已提交
1881 1882 1883
drop:
		kfree_skb(skb);
	}
L
Linus Torvalds 已提交
1884 1885 1886 1887 1888
	return 0;
}
#endif

#ifdef CONFIG_IP_PIMSM_V2
E
Eric Dumazet 已提交
1889
static int pim_rcv(struct sk_buff *skb)
L
Linus Torvalds 已提交
1890 1891
{
	struct pimreghdr *pim;
1892 1893
	struct net *net = dev_net(skb->dev);
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1894

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

1898
	pim = (struct pimreghdr *)skb_transport_header(skb);
E
Eric Dumazet 已提交
1899 1900
	if (pim->type != ((PIM_VERSION << 4) | (PIM_REGISTER)) ||
	    (pim->flags & PIM_NULL_REGISTER) ||
1901
	    (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1902
	     csum_fold(skb_checksum(skb, 0, skb->len, 0))))
L
Linus Torvalds 已提交
1903 1904
		goto drop;

1905 1906 1907 1908
	if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
		goto drop;

	if (__pim_rcv(mrt, skb, sizeof(*pim))) {
I
Ilpo Järvinen 已提交
1909 1910 1911
drop:
		kfree_skb(skb);
	}
L
Linus Torvalds 已提交
1912 1913 1914 1915
	return 0;
}
#endif

1916 1917
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			      struct mfc_cache *c, struct rtmsg *rtm)
L
Linus Torvalds 已提交
1918 1919 1920
{
	int ct;
	struct rtnexthop *nhp;
1921
	u8 *b = skb_tail_pointer(skb);
L
Linus Torvalds 已提交
1922 1923
	struct rtattr *mp_head;

1924
	/* If cache is unresolved, don't try to parse IIF and OIF */
1925
	if (c->mfc_parent >= MAXVIFS)
1926 1927
		return -ENOENT;

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

J
Jianjun Kong 已提交
1931
	mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
L
Linus Torvalds 已提交
1932 1933

	for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1934
		if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
L
Linus Torvalds 已提交
1935 1936
			if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
				goto rtattr_failure;
J
Jianjun Kong 已提交
1937
			nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
L
Linus Torvalds 已提交
1938 1939
			nhp->rtnh_flags = 0;
			nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1940
			nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
L
Linus Torvalds 已提交
1941 1942 1943 1944
			nhp->rtnh_len = sizeof(*nhp);
		}
	}
	mp_head->rta_type = RTA_MULTIPATH;
1945
	mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
L
Linus Torvalds 已提交
1946 1947 1948 1949
	rtm->rtm_type = RTN_MULTICAST;
	return 1;

rtattr_failure:
1950
	nlmsg_trim(skb, b);
L
Linus Torvalds 已提交
1951 1952 1953
	return -EMSGSIZE;
}

1954 1955
int ipmr_get_route(struct net *net,
		   struct sk_buff *skb, struct rtmsg *rtm, int nowait)
L
Linus Torvalds 已提交
1956 1957
{
	int err;
1958
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1959
	struct mfc_cache *cache;
E
Eric Dumazet 已提交
1960
	struct rtable *rt = skb_rtable(skb);
L
Linus Torvalds 已提交
1961

1962 1963 1964 1965
	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return -ENOENT;

1966
	rcu_read_lock();
1967
	cache = ipmr_cache_find(mrt, rt->rt_src, rt->rt_dst);
L
Linus Torvalds 已提交
1968

J
Jianjun Kong 已提交
1969
	if (cache == NULL) {
1970
		struct sk_buff *skb2;
1971
		struct iphdr *iph;
L
Linus Torvalds 已提交
1972
		struct net_device *dev;
E
Eric Dumazet 已提交
1973
		int vif = -1;
L
Linus Torvalds 已提交
1974 1975

		if (nowait) {
1976
			rcu_read_unlock();
L
Linus Torvalds 已提交
1977 1978 1979 1980
			return -EAGAIN;
		}

		dev = skb->dev;
1981
		read_lock(&mrt_lock);
E
Eric Dumazet 已提交
1982 1983 1984
		if (dev)
			vif = ipmr_find_vif(mrt, dev);
		if (vif < 0) {
L
Linus Torvalds 已提交
1985
			read_unlock(&mrt_lock);
1986
			rcu_read_unlock();
L
Linus Torvalds 已提交
1987 1988
			return -ENODEV;
		}
1989 1990 1991
		skb2 = skb_clone(skb, GFP_ATOMIC);
		if (!skb2) {
			read_unlock(&mrt_lock);
1992
			rcu_read_unlock();
1993 1994 1995
			return -ENOMEM;
		}

1996 1997
		skb_push(skb2, sizeof(struct iphdr));
		skb_reset_network_header(skb2);
1998 1999 2000 2001 2002
		iph = ip_hdr(skb2);
		iph->ihl = sizeof(struct iphdr) >> 2;
		iph->saddr = rt->rt_src;
		iph->daddr = rt->rt_dst;
		iph->version = 0;
2003
		err = ipmr_cache_unresolved(mrt, vif, skb2);
L
Linus Torvalds 已提交
2004
		read_unlock(&mrt_lock);
2005
		rcu_read_unlock();
L
Linus Torvalds 已提交
2006 2007 2008
		return err;
	}

2009 2010
	read_lock(&mrt_lock);
	if (!nowait && (rtm->rtm_flags & RTM_F_NOTIFY))
L
Linus Torvalds 已提交
2011
		cache->mfc_flags |= MFC_NOTIFY;
2012
	err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
L
Linus Torvalds 已提交
2013
	read_unlock(&mrt_lock);
2014
	rcu_read_unlock();
L
Linus Torvalds 已提交
2015 2016 2017
	return err;
}

2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
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];

2066
	rcu_read_lock();
2067 2068 2069 2070 2071 2072
	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++) {
2073
			list_for_each_entry_rcu(mfc, &mrt->mfc_cache_array[h], list) {
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
				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:
2091
	rcu_read_unlock();
2092 2093 2094 2095 2096 2097 2098 2099

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

	return skb->len;
}

2100
#ifdef CONFIG_PROC_FS
L
Linus Torvalds 已提交
2101
/*
E
Eric Dumazet 已提交
2102 2103
 *	The /proc interfaces to multicast routing :
 *	/proc/net/ip_mr_cache & /proc/net/ip_mr_vif
L
Linus Torvalds 已提交
2104 2105
 */
struct ipmr_vif_iter {
2106
	struct seq_net_private p;
2107
	struct mr_table *mrt;
L
Linus Torvalds 已提交
2108 2109 2110
	int ct;
};

2111 2112
static struct vif_device *ipmr_vif_seq_idx(struct net *net,
					   struct ipmr_vif_iter *iter,
L
Linus Torvalds 已提交
2113 2114
					   loff_t pos)
{
2115
	struct mr_table *mrt = iter->mrt;
2116 2117 2118

	for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
		if (!VIF_EXISTS(mrt, iter->ct))
L
Linus Torvalds 已提交
2119
			continue;
2120
		if (pos-- == 0)
2121
			return &mrt->vif_table[iter->ct];
L
Linus Torvalds 已提交
2122 2123 2124 2125 2126
	}
	return NULL;
}

static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
S
Stephen Hemminger 已提交
2127
	__acquires(mrt_lock)
L
Linus Torvalds 已提交
2128
{
2129
	struct ipmr_vif_iter *iter = seq->private;
2130
	struct net *net = seq_file_net(seq);
2131 2132 2133 2134 2135 2136 2137
	struct mr_table *mrt;

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

	iter->mrt = mrt;
2138

L
Linus Torvalds 已提交
2139
	read_lock(&mrt_lock);
2140
	return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
L
Linus Torvalds 已提交
2141 2142 2143 2144 2145 2146
		: 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;
2147
	struct net *net = seq_file_net(seq);
2148
	struct mr_table *mrt = iter->mrt;
L
Linus Torvalds 已提交
2149 2150 2151

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

2154 2155
	while (++iter->ct < mrt->maxvif) {
		if (!VIF_EXISTS(mrt, iter->ct))
L
Linus Torvalds 已提交
2156
			continue;
2157
		return &mrt->vif_table[iter->ct];
L
Linus Torvalds 已提交
2158 2159 2160 2161 2162
	}
	return NULL;
}

static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
S
Stephen Hemminger 已提交
2163
	__releases(mrt_lock)
L
Linus Torvalds 已提交
2164 2165 2166 2167 2168 2169
{
	read_unlock(&mrt_lock);
}

static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
{
2170 2171
	struct ipmr_vif_iter *iter = seq->private;
	struct mr_table *mrt = iter->mrt;
2172

L
Linus Torvalds 已提交
2173
	if (v == SEQ_START_TOKEN) {
2174
		seq_puts(seq,
L
Linus Torvalds 已提交
2175 2176 2177 2178 2179 2180 2181
			 "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",
2182
			   vif - mrt->vif_table,
2183
			   name, vif->bytes_in, vif->pkt_in,
L
Linus Torvalds 已提交
2184 2185 2186 2187 2188 2189
			   vif->bytes_out, vif->pkt_out,
			   vif->flags, vif->local, vif->remote);
	}
	return 0;
}

2190
static const struct seq_operations ipmr_vif_seq_ops = {
L
Linus Torvalds 已提交
2191 2192 2193 2194 2195 2196 2197 2198
	.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)
{
2199 2200
	return seq_open_net(inode, file, &ipmr_vif_seq_ops,
			    sizeof(struct ipmr_vif_iter));
L
Linus Torvalds 已提交
2201 2202
}

2203
static const struct file_operations ipmr_vif_fops = {
L
Linus Torvalds 已提交
2204 2205 2206 2207
	.owner	 = THIS_MODULE,
	.open    = ipmr_vif_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
2208
	.release = seq_release_net,
L
Linus Torvalds 已提交
2209 2210 2211
};

struct ipmr_mfc_iter {
2212
	struct seq_net_private p;
2213
	struct mr_table *mrt;
2214
	struct list_head *cache;
L
Linus Torvalds 已提交
2215 2216 2217 2218
	int ct;
};


2219 2220
static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
					  struct ipmr_mfc_iter *it, loff_t pos)
L
Linus Torvalds 已提交
2221
{
2222
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2223 2224
	struct mfc_cache *mfc;

2225
	rcu_read_lock();
2226
	for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
2227
		it->cache = &mrt->mfc_cache_array[it->ct];
2228
		list_for_each_entry_rcu(mfc, it->cache, list)
2229
			if (pos-- == 0)
L
Linus Torvalds 已提交
2230
				return mfc;
2231
	}
2232
	rcu_read_unlock();
L
Linus Torvalds 已提交
2233 2234

	spin_lock_bh(&mfc_unres_lock);
2235
	it->cache = &mrt->mfc_unres_queue;
2236
	list_for_each_entry(mfc, it->cache, list)
2237
		if (pos-- == 0)
L
Linus Torvalds 已提交
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
			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;
2249
	struct net *net = seq_file_net(seq);
2250
	struct mr_table *mrt;
2251

2252 2253 2254
	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
	if (mrt == NULL)
		return ERR_PTR(-ENOENT);
2255

2256
	it->mrt = mrt;
L
Linus Torvalds 已提交
2257 2258
	it->cache = NULL;
	it->ct = 0;
2259
	return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
L
Linus Torvalds 已提交
2260 2261 2262 2263 2264 2265 2266
		: 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;
2267
	struct net *net = seq_file_net(seq);
2268
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2269 2270 2271 2272

	++*pos;

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

2275 2276
	if (mfc->list.next != it->cache)
		return list_entry(mfc->list.next, struct mfc_cache, list);
2277

2278
	if (it->cache == &mrt->mfc_unres_queue)
L
Linus Torvalds 已提交
2279 2280
		goto end_of_list;

2281
	BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
L
Linus Torvalds 已提交
2282 2283

	while (++it->ct < MFC_LINES) {
2284
		it->cache = &mrt->mfc_cache_array[it->ct];
2285 2286 2287
		if (list_empty(it->cache))
			continue;
		return list_first_entry(it->cache, struct mfc_cache, list);
L
Linus Torvalds 已提交
2288 2289 2290
	}

	/* exhausted cache_array, show unresolved */
2291
	rcu_read_unlock();
2292
	it->cache = &mrt->mfc_unres_queue;
L
Linus Torvalds 已提交
2293
	it->ct = 0;
2294

L
Linus Torvalds 已提交
2295
	spin_lock_bh(&mfc_unres_lock);
2296 2297
	if (!list_empty(it->cache))
		return list_first_entry(it->cache, struct mfc_cache, list);
L
Linus Torvalds 已提交
2298

E
Eric Dumazet 已提交
2299
end_of_list:
L
Linus Torvalds 已提交
2300 2301 2302 2303 2304 2305 2306 2307 2308
	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;
2309
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2310

2311
	if (it->cache == &mrt->mfc_unres_queue)
L
Linus Torvalds 已提交
2312
		spin_unlock_bh(&mfc_unres_lock);
2313
	else if (it->cache == &mrt->mfc_cache_array[it->ct])
2314
		rcu_read_unlock();
L
Linus Torvalds 已提交
2315 2316 2317 2318 2319 2320 2321
}

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

	if (v == SEQ_START_TOKEN) {
2322
		seq_puts(seq,
L
Linus Torvalds 已提交
2323 2324 2325 2326
		 "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
	} else {
		const struct mfc_cache *mfc = v;
		const struct ipmr_mfc_iter *it = seq->private;
2327
		const struct mr_table *mrt = it->mrt;
2328

2329 2330 2331
		seq_printf(seq, "%08X %08X %-3hd",
			   (__force u32) mfc->mfc_mcastgrp,
			   (__force u32) mfc->mfc_origin,
2332
			   mfc->mfc_parent);
L
Linus Torvalds 已提交
2333

2334
		if (it->cache != &mrt->mfc_unres_queue) {
2335 2336 2337 2338
			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 已提交
2339
			for (n = mfc->mfc_un.res.minvif;
E
Eric Dumazet 已提交
2340
			     n < mfc->mfc_un.res.maxvif; n++) {
2341
				if (VIF_EXISTS(mrt, n) &&
2342 2343
				    mfc->mfc_un.res.ttls[n] < 255)
					seq_printf(seq,
2344
					   " %2d:%-3d",
L
Linus Torvalds 已提交
2345 2346
					   n, mfc->mfc_un.res.ttls[n]);
			}
2347 2348 2349 2350 2351
		} 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 已提交
2352 2353 2354 2355 2356 2357
		}
		seq_putc(seq, '\n');
	}
	return 0;
}

2358
static const struct seq_operations ipmr_mfc_seq_ops = {
L
Linus Torvalds 已提交
2359 2360 2361 2362 2363 2364 2365 2366
	.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)
{
2367 2368
	return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
			    sizeof(struct ipmr_mfc_iter));
L
Linus Torvalds 已提交
2369 2370
}

2371
static const struct file_operations ipmr_mfc_fops = {
L
Linus Torvalds 已提交
2372 2373 2374 2375
	.owner	 = THIS_MODULE,
	.open    = ipmr_mfc_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
2376
	.release = seq_release_net,
L
Linus Torvalds 已提交
2377
};
2378
#endif
L
Linus Torvalds 已提交
2379 2380

#ifdef CONFIG_IP_PIMSM_V2
2381
static const struct net_protocol pim_protocol = {
L
Linus Torvalds 已提交
2382
	.handler	=	pim_rcv,
T
Tom Goff 已提交
2383
	.netns_ok	=	1,
L
Linus Torvalds 已提交
2384 2385 2386 2387 2388 2389 2390
};
#endif


/*
 *	Setup for IP multicast routing
 */
2391 2392
static int __net_init ipmr_net_init(struct net *net)
{
2393
	int err;
2394

2395 2396
	err = ipmr_rules_init(net);
	if (err < 0)
2397
		goto fail;
2398 2399 2400 2401 2402 2403 2404 2405

#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
2406 2407
	return 0;

2408 2409 2410 2411
#ifdef CONFIG_PROC_FS
proc_cache_fail:
	proc_net_remove(net, "ip_mr_vif");
proc_vif_fail:
2412
	ipmr_rules_exit(net);
2413
#endif
2414 2415 2416 2417 2418 2419
fail:
	return err;
}

static void __net_exit ipmr_net_exit(struct net *net)
{
2420 2421 2422 2423
#ifdef CONFIG_PROC_FS
	proc_net_remove(net, "ip_mr_cache");
	proc_net_remove(net, "ip_mr_vif");
#endif
2424
	ipmr_rules_exit(net);
2425 2426 2427 2428 2429 2430
}

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

W
Wang Chen 已提交
2432
int __init ip_mr_init(void)
L
Linus Torvalds 已提交
2433
{
W
Wang Chen 已提交
2434 2435
	int err;

L
Linus Torvalds 已提交
2436 2437
	mrt_cachep = kmem_cache_create("ip_mrt_cache",
				       sizeof(struct mfc_cache),
2438
				       0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
2439
				       NULL);
W
Wang Chen 已提交
2440 2441 2442
	if (!mrt_cachep)
		return -ENOMEM;

2443 2444 2445 2446
	err = register_pernet_subsys(&ipmr_net_ops);
	if (err)
		goto reg_pernet_fail;

W
Wang Chen 已提交
2447 2448 2449
	err = register_netdevice_notifier(&ip_mr_notifier);
	if (err)
		goto reg_notif_fail;
T
Tom Goff 已提交
2450 2451 2452 2453 2454 2455 2456
#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
2457
	rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE, NULL, ipmr_rtm_dumproute);
W
Wang Chen 已提交
2458
	return 0;
2459

T
Tom Goff 已提交
2460 2461 2462 2463
#ifdef CONFIG_IP_PIMSM_V2
add_proto_fail:
	unregister_netdevice_notifier(&ip_mr_notifier);
#endif
B
Benjamin Thery 已提交
2464
reg_notif_fail:
2465 2466
	unregister_pernet_subsys(&ipmr_net_ops);
reg_pernet_fail:
B
Benjamin Thery 已提交
2467
	kmem_cache_destroy(mrt_cachep);
W
Wang Chen 已提交
2468
	return err;
L
Linus Torvalds 已提交
2469
}