ipmr.c 63.8 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
 *
 */

#include <asm/uaccess.h>
#include <linux/types.h>
31
#include <linux/capability.h>
L
Linus Torvalds 已提交
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
#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>
48
#include <linux/if_ether.h>
49
#include <linux/slab.h>
50
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
51 52 53
#include <net/ip.h>
#include <net/protocol.h>
#include <linux/skbuff.h>
54
#include <net/route.h>
L
Linus Torvalds 已提交
55 56 57 58 59 60 61
#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>
62
#include <linux/compat.h>
63
#include <linux/export.h>
64
#include <net/ip_tunnels.h>
L
Linus Torvalds 已提交
65
#include <net/checksum.h>
66
#include <net/netlink.h>
67
#include <net/fib_rules.h>
68
#include <linux/netconf.h>
L
Linus Torvalds 已提交
69 70 71 72 73

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

74
struct mr_table {
75
	struct list_head	list;
76
	possible_net_t		net;
77
	u32			id;
E
Eric Dumazet 已提交
78
	struct sock __rcu	*mroute_sk;
79 80 81 82 83 84
	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;
85 86
	bool			mroute_do_assert;
	bool			mroute_do_pim;
87 88 89 90 91
#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
static void ipmr_free_table(struct mr_table *mrt);

128 129 130
static void ip_mr_forward(struct net *net, struct mr_table *mrt,
			  struct sk_buff *skb, struct mfc_cache *cache,
			  int local);
131
static int ipmr_cache_report(struct mr_table *mrt,
132
			     struct sk_buff *pkt, vifi_t vifi, int assert);
133 134
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			      struct mfc_cache *c, struct rtmsg *rtm);
135 136
static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
				 int cmd);
137
static void mroute_clean_tables(struct mr_table *mrt, bool all);
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
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;
}

D
David S. Miller 已提交
155
static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
156 157 158
			   struct mr_table **mrt)
{
	int err;
159 160 161 162 163
	struct ipmr_result res;
	struct fib_lookup_arg arg = {
		.result = &res,
		.flags = FIB_LOOKUP_NOREF,
	};
164

D
David S. Miller 已提交
165 166
	err = fib_rules_lookup(net->ipv4.mr_rules_ops,
			       flowi4_to_flowi(flp4), 0, &arg);
167 168 169 170 171 172 173 174 175 176 177
	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 已提交
178

179 180 181 182 183 184 185 186 187 188 189 190 191
	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);
192
	if (!mrt)
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
		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;
}

228
static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = {
229
	.family		= RTNL_FAMILY_IPMR,
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
	.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,
	.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);
255
	if (!mrt) {
256 257 258 259 260 261 262 263 264 265 266 267
		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:
268
	ipmr_free_table(mrt);
269 270 271 272 273 274 275 276 277
err1:
	fib_rules_unregister(ops);
	return err;
}

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

278
	rtnl_lock();
E
Eric Dumazet 已提交
279 280
	list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
		list_del(&mrt->list);
281
		ipmr_free_table(mrt);
E
Eric Dumazet 已提交
282
	}
283
	fib_rules_unregister(net->ipv4.mr_rules_ops);
284
	rtnl_unlock();
285 286 287 288 289 290 291 292 293 294
}
#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;
}

D
David S. Miller 已提交
295
static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
296 297 298 299 300 301 302 303 304 305 306 307 308 309
			   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)
{
310
	rtnl_lock();
311
	ipmr_free_table(net->ipv4.mrt);
312 313
	net->ipv4.mrt = NULL;
	rtnl_unlock();
314 315 316 317 318 319 320
}
#endif

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

322
	mrt = ipmr_get_table(net, id);
323
	if (mrt)
324 325 326
		return mrt;

	mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
327
	if (!mrt)
328
		return NULL;
329
	write_pnet(&mrt->net, net);
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
	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 已提交
349

350 351 352
static void ipmr_free_table(struct mr_table *mrt)
{
	del_timer_sync(&mrt->ipmr_expire_timer);
353
	mroute_clean_tables(mrt, true);
354 355 356
	kfree(mrt);
}

L
Linus Torvalds 已提交
357 358
/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */

359 360
static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
{
361 362
	struct net *net = dev_net(dev);

363 364
	dev_close(dev);

365
	dev = __dev_get_by_name(net, "tunl0");
366
	if (dev) {
367
		const struct net_device_ops *ops = dev->netdev_ops;
368 369 370 371 372 373 374 375 376 377 378 379
		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;

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

L
Linus Torvalds 已提交
390
static
391
struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
L
Linus Torvalds 已提交
392 393 394
{
	struct net_device  *dev;

395
	dev = __dev_get_by_name(net, "tunl0");
L
Linus Torvalds 已提交
396 397

	if (dev) {
398
		const struct net_device_ops *ops = dev->netdev_ops;
L
Linus Torvalds 已提交
399 400 401 402 403 404 405 406 407 408 409 410
		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 已提交
411
		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
L
Linus Torvalds 已提交
412

413 414 415 416 417 418
		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 已提交
419
		} else {
420
			err = -EOPNOTSUPP;
E
Eric Dumazet 已提交
421
		}
L
Linus Torvalds 已提交
422 423
		dev = NULL;

424 425
		if (err == 0 &&
		    (dev = __dev_get_by_name(net, p.name)) != NULL) {
L
Linus Torvalds 已提交
426 427
			dev->flags |= IFF_MULTICAST;

428
			in_dev = __in_dev_get_rtnl(dev);
429
			if (!in_dev)
L
Linus Torvalds 已提交
430
				goto failure;
431 432

			ipv4_devconf_setall(in_dev);
433
			neigh_parms_data_state_setall(in_dev->arp_parms);
434
			IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
L
Linus Torvalds 已提交
435 436 437

			if (dev_open(dev))
				goto failure;
438
			dev_hold(dev);
L
Linus Torvalds 已提交
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
		}
	}
	return dev;

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

	unregister_netdevice(dev);
	return NULL;
}

#ifdef CONFIG_IP_PIMSM

454
static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
455
{
456
	struct net *net = dev_net(dev);
457
	struct mr_table *mrt;
D
David S. Miller 已提交
458 459
	struct flowi4 fl4 = {
		.flowi4_oif	= dev->ifindex,
460
		.flowi4_iif	= skb->skb_iif ? : LOOPBACK_IFINDEX,
D
David S. Miller 已提交
461
		.flowi4_mark	= skb->mark,
462 463 464
	};
	int err;

D
David S. Miller 已提交
465
	err = ipmr_fib_lookup(net, &fl4, &mrt);
466 467
	if (err < 0) {
		kfree_skb(skb);
468
		return err;
469
	}
470

L
Linus Torvalds 已提交
471
	read_lock(&mrt_lock);
472 473
	dev->stats.tx_bytes += skb->len;
	dev->stats.tx_packets++;
474
	ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
L
Linus Torvalds 已提交
475 476
	read_unlock(&mrt_lock);
	kfree_skb(skb);
477
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
478 479
}

480 481 482 483 484
static int reg_vif_get_iflink(const struct net_device *dev)
{
	return 0;
}

485 486
static const struct net_device_ops reg_vif_netdev_ops = {
	.ndo_start_xmit	= reg_vif_xmit,
487
	.ndo_get_iflink = reg_vif_get_iflink,
488 489
};

L
Linus Torvalds 已提交
490 491 492
static void reg_vif_setup(struct net_device *dev)
{
	dev->type		= ARPHRD_PIMREG;
493
	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 8;
L
Linus Torvalds 已提交
494
	dev->flags		= IFF_NOARP;
495
	dev->netdev_ops		= &reg_vif_netdev_ops;
L
Linus Torvalds 已提交
496
	dev->destructor		= free_netdev;
T
Tom Goff 已提交
497
	dev->features		|= NETIF_F_NETNS_LOCAL;
L
Linus Torvalds 已提交
498 499
}

500
static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
L
Linus Torvalds 已提交
501 502 503
{
	struct net_device *dev;
	struct in_device *in_dev;
504
	char name[IFNAMSIZ];
L
Linus Torvalds 已提交
505

506 507 508 509
	if (mrt->id == RT_TABLE_DEFAULT)
		sprintf(name, "pimreg");
	else
		sprintf(name, "pimreg%u", mrt->id);
L
Linus Torvalds 已提交
510

511
	dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
L
Linus Torvalds 已提交
512

513
	if (!dev)
L
Linus Torvalds 已提交
514 515
		return NULL;

T
Tom Goff 已提交
516 517
	dev_net_set(dev, net);

L
Linus Torvalds 已提交
518 519 520 521 522
	if (register_netdevice(dev)) {
		free_netdev(dev);
		return NULL;
	}

523
	rcu_read_lock();
E
Eric Dumazet 已提交
524 525
	in_dev = __in_dev_get_rcu(dev);
	if (!in_dev) {
526
		rcu_read_unlock();
L
Linus Torvalds 已提交
527
		goto failure;
528
	}
L
Linus Torvalds 已提交
529

530
	ipv4_devconf_setall(in_dev);
531
	neigh_parms_data_state_setall(in_dev->arp_parms);
532 533
	IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
	rcu_read_unlock();
L
Linus Torvalds 已提交
534 535 536 537

	if (dev_open(dev))
		goto failure;

538 539
	dev_hold(dev);

L
Linus Torvalds 已提交
540 541 542 543 544 545 546 547 548 549 550 551
	return dev;

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

	unregister_netdevice(dev);
	return NULL;
}
#endif

552 553
/**
 *	vif_delete - Delete a VIF entry
554
 *	@notify: Set to 1, if the caller is a notifier_call
L
Linus Torvalds 已提交
555
 */
556

557
static int vif_delete(struct mr_table *mrt, int vifi, int notify,
558
		      struct list_head *head)
L
Linus Torvalds 已提交
559 560 561 562 563
{
	struct vif_device *v;
	struct net_device *dev;
	struct in_device *in_dev;

564
	if (vifi < 0 || vifi >= mrt->maxvif)
L
Linus Torvalds 已提交
565 566
		return -EADDRNOTAVAIL;

567
	v = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
568 569 570 571 572 573 574 575 576 577 578

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

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

#ifdef CONFIG_IP_PIMSM
579 580
	if (vifi == mrt->mroute_reg_vif_num)
		mrt->mroute_reg_vif_num = -1;
L
Linus Torvalds 已提交
581 582
#endif

E
Eric Dumazet 已提交
583
	if (vifi + 1 == mrt->maxvif) {
L
Linus Torvalds 已提交
584
		int tmp;
E
Eric Dumazet 已提交
585 586

		for (tmp = vifi - 1; tmp >= 0; tmp--) {
587
			if (VIF_EXISTS(mrt, tmp))
L
Linus Torvalds 已提交
588 589
				break;
		}
590
		mrt->maxvif = tmp+1;
L
Linus Torvalds 已提交
591 592 593 594 595 596
	}

	write_unlock_bh(&mrt_lock);

	dev_set_allmulti(dev, -1);

E
Eric Dumazet 已提交
597 598
	in_dev = __in_dev_get_rtnl(dev);
	if (in_dev) {
599
		IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
600 601 602
		inet_netconf_notify_devconf(dev_net(dev),
					    NETCONFA_MC_FORWARDING,
					    dev->ifindex, &in_dev->cnf);
L
Linus Torvalds 已提交
603 604 605
		ip_rt_multicast_event(in_dev);
	}

E
Eric Dumazet 已提交
606
	if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
607
		unregister_netdevice_queue(dev, head);
L
Linus Torvalds 已提交
608 609 610 611 612

	dev_put(dev);
	return 0;
}

613
static void ipmr_cache_free_rcu(struct rcu_head *head)
614
{
615 616
	struct mfc_cache *c = container_of(head, struct mfc_cache, rcu);

617 618 619
	kmem_cache_free(mrt_cachep, c);
}

620 621 622 623 624
static inline void ipmr_cache_free(struct mfc_cache *c)
{
	call_rcu(&c->rcu, ipmr_cache_free_rcu);
}

L
Linus Torvalds 已提交
625
/* Destroy an unresolved cache entry, killing queued skbs
E
Eric Dumazet 已提交
626
 * and reporting error to netlink readers.
L
Linus Torvalds 已提交
627 628
 */

629
static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
L
Linus Torvalds 已提交
630
{
631
	struct net *net = read_pnet(&mrt->net);
L
Linus Torvalds 已提交
632
	struct sk_buff *skb;
633
	struct nlmsgerr *e;
L
Linus Torvalds 已提交
634

635
	atomic_dec(&mrt->cache_resolve_queue_len);
L
Linus Torvalds 已提交
636

J
Jianjun Kong 已提交
637
	while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
638
		if (ip_hdr(skb)->version == 0) {
L
Linus Torvalds 已提交
639 640
			struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
			nlh->nlmsg_type = NLMSG_ERROR;
641
			nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
L
Linus Torvalds 已提交
642
			skb_trim(skb, nlh->nlmsg_len);
643
			e = nlmsg_data(nlh);
644 645
			e->error = -ETIMEDOUT;
			memset(&e->msg, 0, sizeof(e->msg));
646

647
			rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
E
Eric Dumazet 已提交
648
		} else {
L
Linus Torvalds 已提交
649
			kfree_skb(skb);
E
Eric Dumazet 已提交
650
		}
L
Linus Torvalds 已提交
651 652
	}

653
	ipmr_cache_free(c);
L
Linus Torvalds 已提交
654 655 656
}


657
/* Timer process for the unresolved queue. */
L
Linus Torvalds 已提交
658

659
static void ipmr_expire_process(unsigned long arg)
L
Linus Torvalds 已提交
660
{
661
	struct mr_table *mrt = (struct mr_table *)arg;
L
Linus Torvalds 已提交
662 663
	unsigned long now;
	unsigned long expires;
664
	struct mfc_cache *c, *next;
L
Linus Torvalds 已提交
665 666

	if (!spin_trylock(&mfc_unres_lock)) {
667
		mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
L
Linus Torvalds 已提交
668 669 670
		return;
	}

671
	if (list_empty(&mrt->mfc_unres_queue))
L
Linus Torvalds 已提交
672 673 674 675 676
		goto out;

	now = jiffies;
	expires = 10*HZ;

677
	list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
L
Linus Torvalds 已提交
678 679 680 681 682 683 684
		if (time_after(c->mfc_un.unres.expires, now)) {
			unsigned long interval = c->mfc_un.unres.expires - now;
			if (interval < expires)
				expires = interval;
			continue;
		}

685
		list_del(&c->list);
686
		mroute_netlink_event(mrt, c, RTM_DELROUTE);
687
		ipmr_destroy_unres(mrt, c);
L
Linus Torvalds 已提交
688 689
	}

690 691
	if (!list_empty(&mrt->mfc_unres_queue))
		mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
L
Linus Torvalds 已提交
692 693 694 695 696 697 698

out:
	spin_unlock(&mfc_unres_lock);
}

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

699
static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
700
				   unsigned char *ttls)
L
Linus Torvalds 已提交
701 702 703 704 705 706 707
{
	int vifi;

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

708 709
	for (vifi = 0; vifi < mrt->maxvif; vifi++) {
		if (VIF_EXISTS(mrt, vifi) &&
710
		    ttls[vifi] && ttls[vifi] < 255) {
L
Linus Torvalds 已提交
711 712 713 714 715 716 717 718 719
			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;
		}
	}
}

720 721
static int vif_add(struct net *net, struct mr_table *mrt,
		   struct vifctl *vifc, int mrtsock)
L
Linus Torvalds 已提交
722 723
{
	int vifi = vifc->vifc_vifi;
724
	struct vif_device *v = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
725 726
	struct net_device *dev;
	struct in_device *in_dev;
727
	int err;
L
Linus Torvalds 已提交
728 729

	/* Is vif busy ? */
730
	if (VIF_EXISTS(mrt, vifi))
L
Linus Torvalds 已提交
731 732 733 734 735 736 737 738 739
		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
		 */
740
		if (mrt->mroute_reg_vif_num >= 0)
L
Linus Torvalds 已提交
741
			return -EADDRINUSE;
742
		dev = ipmr_reg_vif(net, mrt);
L
Linus Torvalds 已提交
743 744
		if (!dev)
			return -ENOBUFS;
745 746 747
		err = dev_set_allmulti(dev, 1);
		if (err) {
			unregister_netdevice(dev);
748
			dev_put(dev);
749 750
			return err;
		}
L
Linus Torvalds 已提交
751 752
		break;
#endif
753
	case VIFF_TUNNEL:
754
		dev = ipmr_new_tunnel(net, vifc);
L
Linus Torvalds 已提交
755 756
		if (!dev)
			return -ENOBUFS;
757 758 759
		err = dev_set_allmulti(dev, 1);
		if (err) {
			ipmr_del_tunnel(dev, vifc);
760
			dev_put(dev);
761 762
			return err;
		}
L
Linus Torvalds 已提交
763
		break;
764 765

	case VIFF_USE_IFINDEX:
L
Linus Torvalds 已提交
766
	case 0:
767 768
		if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
			dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
769
			if (dev && !__in_dev_get_rtnl(dev)) {
770 771 772
				dev_put(dev);
				return -EADDRNOTAVAIL;
			}
E
Eric Dumazet 已提交
773
		} else {
774
			dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
E
Eric Dumazet 已提交
775
		}
L
Linus Torvalds 已提交
776 777
		if (!dev)
			return -EADDRNOTAVAIL;
778
		err = dev_set_allmulti(dev, 1);
779 780
		if (err) {
			dev_put(dev);
781
			return err;
782
		}
L
Linus Torvalds 已提交
783 784 785 786 787
		break;
	default:
		return -EINVAL;
	}

E
Eric Dumazet 已提交
788 789
	in_dev = __in_dev_get_rtnl(dev);
	if (!in_dev) {
790
		dev_put(dev);
L
Linus Torvalds 已提交
791
		return -EADDRNOTAVAIL;
792
	}
793
	IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
794 795
	inet_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING, dev->ifindex,
				    &in_dev->cnf);
L
Linus Torvalds 已提交
796 797
	ip_rt_multicast_event(in_dev);

E
Eric Dumazet 已提交
798 799
	/* Fill in the VIF structures */

J
Jianjun Kong 已提交
800 801 802 803
	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 已提交
804 805
	if (!mrtsock)
		v->flags |= VIFF_STATIC;
J
Jianjun Kong 已提交
806
	v->threshold = vifc->vifc_threshold;
L
Linus Torvalds 已提交
807 808 809 810 811
	v->bytes_in = 0;
	v->bytes_out = 0;
	v->pkt_in = 0;
	v->pkt_out = 0;
	v->link = dev->ifindex;
E
Eric Dumazet 已提交
812
	if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
813
		v->link = dev_get_iflink(dev);
L
Linus Torvalds 已提交
814 815 816

	/* And finish update writing critical data */
	write_lock_bh(&mrt_lock);
J
Jianjun Kong 已提交
817
	v->dev = dev;
L
Linus Torvalds 已提交
818
#ifdef CONFIG_IP_PIMSM
E
Eric Dumazet 已提交
819
	if (v->flags & VIFF_REGISTER)
820
		mrt->mroute_reg_vif_num = vifi;
L
Linus Torvalds 已提交
821
#endif
822 823
	if (vifi+1 > mrt->maxvif)
		mrt->maxvif = vifi+1;
L
Linus Torvalds 已提交
824 825 826 827
	write_unlock_bh(&mrt_lock);
	return 0;
}

828
/* called with rcu_read_lock() */
829
static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
830 831
					 __be32 origin,
					 __be32 mcastgrp)
L
Linus Torvalds 已提交
832
{
J
Jianjun Kong 已提交
833
	int line = MFC_HASH(mcastgrp, origin);
L
Linus Torvalds 已提交
834 835
	struct mfc_cache *c;

836
	list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list) {
837 838
		if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
			return c;
L
Linus Torvalds 已提交
839
	}
840
	return NULL;
L
Linus Torvalds 已提交
841 842
}

843 844 845 846
/* Look for a (*,*,oif) entry */
static struct mfc_cache *ipmr_cache_find_any_parent(struct mr_table *mrt,
						    int vifi)
{
847
	int line = MFC_HASH(htonl(INADDR_ANY), htonl(INADDR_ANY));
848 849 850
	struct mfc_cache *c;

	list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list)
851 852
		if (c->mfc_origin == htonl(INADDR_ANY) &&
		    c->mfc_mcastgrp == htonl(INADDR_ANY) &&
853 854 855 856 857 858 859 860 861 862
		    c->mfc_un.res.ttls[vifi] < 255)
			return c;

	return NULL;
}

/* Look for a (*,G) entry */
static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt,
					     __be32 mcastgrp, int vifi)
{
863
	int line = MFC_HASH(mcastgrp, htonl(INADDR_ANY));
864 865
	struct mfc_cache *c, *proxy;

866
	if (mcastgrp == htonl(INADDR_ANY))
867 868 869
		goto skip;

	list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list)
870
		if (c->mfc_origin == htonl(INADDR_ANY) &&
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
		    c->mfc_mcastgrp == mcastgrp) {
			if (c->mfc_un.res.ttls[vifi] < 255)
				return c;

			/* It's ok if the vifi is part of the static tree */
			proxy = ipmr_cache_find_any_parent(mrt,
							   c->mfc_parent);
			if (proxy && proxy->mfc_un.res.ttls[vifi] < 255)
				return c;
		}

skip:
	return ipmr_cache_find_any_parent(mrt, vifi);
}

L
Linus Torvalds 已提交
886 887 888
/*
 *	Allocate a multicast cache entry
 */
889
static struct mfc_cache *ipmr_cache_alloc(void)
L
Linus Torvalds 已提交
890
{
J
Jianjun Kong 已提交
891
	struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
892 893 894

	if (c)
		c->mfc_un.res.minvif = MAXVIFS;
L
Linus Torvalds 已提交
895 896 897
	return c;
}

898
static struct mfc_cache *ipmr_cache_alloc_unres(void)
L
Linus Torvalds 已提交
899
{
J
Jianjun Kong 已提交
900
	struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
901 902 903 904 905

	if (c) {
		skb_queue_head_init(&c->mfc_un.unres.unresolved);
		c->mfc_un.unres.expires = jiffies + 10*HZ;
	}
L
Linus Torvalds 已提交
906 907 908 909 910 911
	return c;
}

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

913 914
static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
			       struct mfc_cache *uc, struct mfc_cache *c)
L
Linus Torvalds 已提交
915 916
{
	struct sk_buff *skb;
917
	struct nlmsgerr *e;
L
Linus Torvalds 已提交
918

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

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

925
			if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
E
Eric Dumazet 已提交
926 927
				nlh->nlmsg_len = skb_tail_pointer(skb) -
						 (u8 *)nlh;
L
Linus Torvalds 已提交
928 929
			} else {
				nlh->nlmsg_type = NLMSG_ERROR;
930
				nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
L
Linus Torvalds 已提交
931
				skb_trim(skb, nlh->nlmsg_len);
932
				e = nlmsg_data(nlh);
933 934
				e->error = -EMSGSIZE;
				memset(&e->msg, 0, sizeof(e->msg));
L
Linus Torvalds 已提交
935
			}
936

937
			rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
E
Eric Dumazet 已提交
938
		} else {
939
			ip_mr_forward(net, mrt, skb, c, 0);
E
Eric Dumazet 已提交
940
		}
L
Linus Torvalds 已提交
941 942 943 944 945 946 947 948 949
	}
}

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

951
static int ipmr_cache_report(struct mr_table *mrt,
952
			     struct sk_buff *pkt, vifi_t vifi, int assert)
L
Linus Torvalds 已提交
953 954
{
	struct sk_buff *skb;
955
	const int ihl = ip_hdrlen(pkt);
L
Linus Torvalds 已提交
956 957
	struct igmphdr *igmp;
	struct igmpmsg *msg;
E
Eric Dumazet 已提交
958
	struct sock *mroute_sk;
L
Linus Torvalds 已提交
959 960 961 962 963 964 965 966 967
	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 已提交
968
	if (!skb)
L
Linus Torvalds 已提交
969 970 971 972 973
		return -ENOBUFS;

#ifdef CONFIG_IP_PIMSM
	if (assert == IGMPMSG_WHOLEPKT) {
		/* Ugly, but we have no choice with this interface.
E
Eric Dumazet 已提交
974 975 976
		 * 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 已提交
977
		 */
978 979
		skb_push(skb, sizeof(struct iphdr));
		skb_reset_network_header(skb);
980
		skb_reset_transport_header(skb);
981
		msg = (struct igmpmsg *)skb_network_header(skb);
982
		memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
L
Linus Torvalds 已提交
983 984
		msg->im_msgtype = IGMPMSG_WHOLEPKT;
		msg->im_mbz = 0;
985
		msg->im_vif = mrt->mroute_reg_vif_num;
986 987 988
		ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
		ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
					     sizeof(struct iphdr));
989
	} else
L
Linus Torvalds 已提交
990
#endif
991 992
	{

E
Eric Dumazet 已提交
993
	/* Copy the IP header */
L
Linus Torvalds 已提交
994

995
	skb_set_network_header(skb, skb->len);
996
	skb_put(skb, ihl);
997
	skb_copy_to_linear_data(skb, pkt->data, ihl);
E
Eric Dumazet 已提交
998
	ip_hdr(skb)->protocol = 0;	/* Flag to the kernel this is a route add */
999
	msg = (struct igmpmsg *)skb_network_header(skb);
L
Linus Torvalds 已提交
1000
	msg->im_vif = vifi;
E
Eric Dumazet 已提交
1001
	skb_dst_set(skb, dst_clone(skb_dst(pkt)));
L
Linus Torvalds 已提交
1002

E
Eric Dumazet 已提交
1003
	/* Add our header */
L
Linus Torvalds 已提交
1004

E
Eric Dumazet 已提交
1005
	igmp = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
L
Linus Torvalds 已提交
1006 1007
	igmp->type	=
	msg->im_msgtype = assert;
E
Eric Dumazet 已提交
1008 1009
	igmp->code	= 0;
	ip_hdr(skb)->tot_len = htons(skb->len);		/* Fix the length */
1010
	skb->transport_header = skb->network_header;
1011
	}
L
Linus Torvalds 已提交
1012

E
Eric Dumazet 已提交
1013 1014
	rcu_read_lock();
	mroute_sk = rcu_dereference(mrt->mroute_sk);
1015
	if (!mroute_sk) {
E
Eric Dumazet 已提交
1016
		rcu_read_unlock();
L
Linus Torvalds 已提交
1017 1018 1019 1020
		kfree_skb(skb);
		return -EINVAL;
	}

E
Eric Dumazet 已提交
1021 1022
	/* Deliver to mrouted */

E
Eric Dumazet 已提交
1023 1024
	ret = sock_queue_rcv_skb(mroute_sk, skb);
	rcu_read_unlock();
1025
	if (ret < 0) {
1026
		net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
L
Linus Torvalds 已提交
1027 1028 1029 1030 1031 1032 1033 1034 1035
		kfree_skb(skb);
	}

	return ret;
}

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

L
Linus Torvalds 已提交
1037
static int
1038
ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
L
Linus Torvalds 已提交
1039
{
1040
	bool found = false;
L
Linus Torvalds 已提交
1041 1042
	int err;
	struct mfc_cache *c;
1043
	const struct iphdr *iph = ip_hdr(skb);
L
Linus Torvalds 已提交
1044 1045

	spin_lock_bh(&mfc_unres_lock);
1046
	list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
1047
		if (c->mfc_mcastgrp == iph->daddr &&
1048 1049
		    c->mfc_origin == iph->saddr) {
			found = true;
L
Linus Torvalds 已提交
1050
			break;
1051
		}
L
Linus Torvalds 已提交
1052 1053
	}

1054
	if (!found) {
E
Eric Dumazet 已提交
1055
		/* Create a new entry if allowable */
L
Linus Torvalds 已提交
1056

1057
		if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1058
		    (c = ipmr_cache_alloc_unres()) == NULL) {
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064
			spin_unlock_bh(&mfc_unres_lock);

			kfree_skb(skb);
			return -ENOBUFS;
		}

E
Eric Dumazet 已提交
1065 1066
		/* Fill in the new cache entry */

1067 1068 1069
		c->mfc_parent	= -1;
		c->mfc_origin	= iph->saddr;
		c->mfc_mcastgrp	= iph->daddr;
L
Linus Torvalds 已提交
1070

E
Eric Dumazet 已提交
1071 1072
		/* Reflect first query at mrouted. */

1073
		err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
1074
		if (err < 0) {
1075
			/* If the report failed throw the cache entry
L
Linus Torvalds 已提交
1076 1077 1078 1079
			   out - Brad Parker
			 */
			spin_unlock_bh(&mfc_unres_lock);

1080
			ipmr_cache_free(c);
L
Linus Torvalds 已提交
1081 1082 1083 1084
			kfree_skb(skb);
			return err;
		}

1085 1086
		atomic_inc(&mrt->cache_resolve_queue_len);
		list_add(&c->list, &mrt->mfc_unres_queue);
1087
		mroute_netlink_event(mrt, c, RTM_NEWROUTE);
L
Linus Torvalds 已提交
1088

1089 1090
		if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
			mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
L
Linus Torvalds 已提交
1091 1092
	}

E
Eric Dumazet 已提交
1093 1094 1095
	/* See if we can append the packet */

	if (c->mfc_un.unres.unresolved.qlen > 3) {
L
Linus Torvalds 已提交
1096 1097 1098
		kfree_skb(skb);
		err = -ENOBUFS;
	} else {
J
Jianjun Kong 已提交
1099
		skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
		err = 0;
	}

	spin_unlock_bh(&mfc_unres_lock);
	return err;
}

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

1111
static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent)
L
Linus Torvalds 已提交
1112 1113
{
	int line;
1114
	struct mfc_cache *c, *next;
L
Linus Torvalds 已提交
1115

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

1118
	list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
L
Linus Torvalds 已提交
1119
		if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
1120 1121
		    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr &&
		    (parent == -1 || parent == c->mfc_parent)) {
1122
			list_del_rcu(&c->list);
1123
			mroute_netlink_event(mrt, c, RTM_DELROUTE);
1124
			ipmr_cache_free(c);
L
Linus Torvalds 已提交
1125 1126 1127 1128 1129 1130
			return 0;
		}
	}
	return -ENOENT;
}

1131
static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
1132
			struct mfcctl *mfc, int mrtsock, int parent)
L
Linus Torvalds 已提交
1133
{
1134
	bool found = false;
L
Linus Torvalds 已提交
1135
	int line;
1136
	struct mfc_cache *uc, *c;
L
Linus Torvalds 已提交
1137

1138 1139 1140
	if (mfc->mfcc_parent >= MAXVIFS)
		return -ENFILE;

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

1143
	list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
L
Linus Torvalds 已提交
1144
		if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
1145 1146
		    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr &&
		    (parent == -1 || parent == c->mfc_parent)) {
1147
			found = true;
L
Linus Torvalds 已提交
1148
			break;
1149
		}
L
Linus Torvalds 已提交
1150 1151
	}

1152
	if (found) {
L
Linus Torvalds 已提交
1153 1154
		write_lock_bh(&mrt_lock);
		c->mfc_parent = mfc->mfcc_parent;
1155
		ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
L
Linus Torvalds 已提交
1156 1157 1158
		if (!mrtsock)
			c->mfc_flags |= MFC_STATIC;
		write_unlock_bh(&mrt_lock);
1159
		mroute_netlink_event(mrt, c, RTM_NEWROUTE);
L
Linus Torvalds 已提交
1160 1161 1162
		return 0;
	}

1163
	if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) &&
1164
	    !ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
L
Linus Torvalds 已提交
1165 1166
		return -EINVAL;

1167
	c = ipmr_cache_alloc();
1168
	if (!c)
L
Linus Torvalds 已提交
1169 1170
		return -ENOMEM;

J
Jianjun Kong 已提交
1171 1172 1173
	c->mfc_origin = mfc->mfcc_origin.s_addr;
	c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
	c->mfc_parent = mfc->mfcc_parent;
1174
	ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
L
Linus Torvalds 已提交
1175 1176 1177
	if (!mrtsock)
		c->mfc_flags |= MFC_STATIC;

1178
	list_add_rcu(&c->list, &mrt->mfc_cache_array[line]);
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183

	/*
	 *	Check to see if we resolved a queued list. If so we
	 *	need to send on the frames and tidy up.
	 */
1184
	found = false;
L
Linus Torvalds 已提交
1185
	spin_lock_bh(&mfc_unres_lock);
1186
	list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
1187
		if (uc->mfc_origin == c->mfc_origin &&
L
Linus Torvalds 已提交
1188
		    uc->mfc_mcastgrp == c->mfc_mcastgrp) {
1189
			list_del(&uc->list);
1190
			atomic_dec(&mrt->cache_resolve_queue_len);
1191
			found = true;
L
Linus Torvalds 已提交
1192 1193 1194
			break;
		}
	}
1195 1196
	if (list_empty(&mrt->mfc_unres_queue))
		del_timer(&mrt->ipmr_expire_timer);
L
Linus Torvalds 已提交
1197 1198
	spin_unlock_bh(&mfc_unres_lock);

1199
	if (found) {
1200
		ipmr_cache_resolve(net, mrt, uc, c);
1201
		ipmr_cache_free(uc);
L
Linus Torvalds 已提交
1202
	}
1203
	mroute_netlink_event(mrt, c, RTM_NEWROUTE);
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208 1209
	return 0;
}

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

1211
static void mroute_clean_tables(struct mr_table *mrt, bool all)
L
Linus Torvalds 已提交
1212 1213
{
	int i;
1214
	LIST_HEAD(list);
1215
	struct mfc_cache *c, *next;
1216

E
Eric Dumazet 已提交
1217 1218
	/* Shut down all active vif entries */

1219
	for (i = 0; i < mrt->maxvif; i++) {
1220 1221 1222
		if (!all && (mrt->vif_table[i].flags & VIFF_STATIC))
			continue;
		vif_delete(mrt, i, 0, &list);
L
Linus Torvalds 已提交
1223
	}
1224
	unregister_netdevice_many(&list);
L
Linus Torvalds 已提交
1225

E
Eric Dumazet 已提交
1226 1227
	/* Wipe the cache */

1228
	for (i = 0; i < MFC_LINES; i++) {
1229
		list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
1230
			if (!all && (c->mfc_flags & MFC_STATIC))
L
Linus Torvalds 已提交
1231
				continue;
1232
			list_del_rcu(&c->list);
1233
			mroute_netlink_event(mrt, c, RTM_DELROUTE);
1234
			ipmr_cache_free(c);
L
Linus Torvalds 已提交
1235 1236 1237
		}
	}

1238
	if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
L
Linus Torvalds 已提交
1239
		spin_lock_bh(&mfc_unres_lock);
1240
		list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
1241
			list_del(&c->list);
1242
			mroute_netlink_event(mrt, c, RTM_DELROUTE);
1243
			ipmr_destroy_unres(mrt, c);
L
Linus Torvalds 已提交
1244 1245 1246 1247 1248
		}
		spin_unlock_bh(&mfc_unres_lock);
	}
}

E
Eric Dumazet 已提交
1249 1250 1251
/* called from ip_ra_control(), before an RCU grace period,
 * we dont need to call synchronize_rcu() here
 */
L
Linus Torvalds 已提交
1252 1253
static void mrtsock_destruct(struct sock *sk)
{
1254
	struct net *net = sock_net(sk);
1255
	struct mr_table *mrt;
1256

L
Linus Torvalds 已提交
1257
	rtnl_lock();
1258
	ipmr_for_each_table(mrt, net) {
E
Eric Dumazet 已提交
1259
		if (sk == rtnl_dereference(mrt->mroute_sk)) {
1260
			IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
1261 1262 1263
			inet_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
						    NETCONFA_IFINDEX_ALL,
						    net->ipv4.devconf_all);
1264
			RCU_INIT_POINTER(mrt->mroute_sk, NULL);
1265
			mroute_clean_tables(mrt, false);
1266
		}
L
Linus Torvalds 已提交
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
	}
	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.
 */
1277

1278
int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
L
Linus Torvalds 已提交
1279
{
1280
	int ret, parent = 0;
L
Linus Torvalds 已提交
1281 1282
	struct vifctl vif;
	struct mfcctl mfc;
1283
	struct net *net = sock_net(sk);
1284 1285
	struct mr_table *mrt;

1286 1287 1288 1289
	if (sk->sk_type != SOCK_RAW ||
	    inet_sk(sk)->inet_num != IPPROTO_IGMP)
		return -EOPNOTSUPP;

1290
	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1291
	if (!mrt)
1292
		return -ENOENT;
1293

S
Stephen Hemminger 已提交
1294
	if (optname != MRT_INIT) {
1295
		if (sk != rcu_access_pointer(mrt->mroute_sk) &&
1296
		    !ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1297 1298 1299
			return -EACCES;
	}

S
Stephen Hemminger 已提交
1300 1301
	switch (optname) {
	case MRT_INIT:
J
Jianjun Kong 已提交
1302
		if (optlen != sizeof(int))
1303
			return -EINVAL;
L
Linus Torvalds 已提交
1304

S
Stephen Hemminger 已提交
1305
		rtnl_lock();
E
Eric Dumazet 已提交
1306
		if (rtnl_dereference(mrt->mroute_sk)) {
L
Linus Torvalds 已提交
1307
			rtnl_unlock();
S
Stephen Hemminger 已提交
1308 1309 1310 1311 1312
			return -EADDRINUSE;
		}

		ret = ip_ra_control(sk, 1, mrtsock_destruct);
		if (ret == 0) {
1313
			rcu_assign_pointer(mrt->mroute_sk, sk);
1314
			IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
1315 1316 1317
			inet_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
						    NETCONFA_IFINDEX_ALL,
						    net->ipv4.devconf_all);
S
Stephen Hemminger 已提交
1318 1319 1320 1321
		}
		rtnl_unlock();
		return ret;
	case MRT_DONE:
1322
		if (sk != rcu_access_pointer(mrt->mroute_sk))
S
Stephen Hemminger 已提交
1323 1324 1325 1326
			return -EACCES;
		return ip_ra_control(sk, 0, NULL);
	case MRT_ADD_VIF:
	case MRT_DEL_VIF:
J
Jianjun Kong 已提交
1327
		if (optlen != sizeof(vif))
S
Stephen Hemminger 已提交
1328
			return -EINVAL;
J
Jianjun Kong 已提交
1329
		if (copy_from_user(&vif, optval, sizeof(vif)))
S
Stephen Hemminger 已提交
1330 1331 1332 1333
			return -EFAULT;
		if (vif.vifc_vifi >= MAXVIFS)
			return -ENFILE;
		rtnl_lock();
J
Jianjun Kong 已提交
1334
		if (optname == MRT_ADD_VIF) {
E
Eric Dumazet 已提交
1335 1336
			ret = vif_add(net, mrt, &vif,
				      sk == rtnl_dereference(mrt->mroute_sk));
S
Stephen Hemminger 已提交
1337
		} else {
1338
			ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
S
Stephen Hemminger 已提交
1339 1340 1341
		}
		rtnl_unlock();
		return ret;
L
Linus Torvalds 已提交
1342 1343 1344 1345 1346

		/*
		 *	Manipulate the forwarding caches. These live
		 *	in a sort of kernel/user symbiosis.
		 */
S
Stephen Hemminger 已提交
1347 1348
	case MRT_ADD_MFC:
	case MRT_DEL_MFC:
1349 1350 1351
		parent = -1;
	case MRT_ADD_MFC_PROXY:
	case MRT_DEL_MFC_PROXY:
J
Jianjun Kong 已提交
1352
		if (optlen != sizeof(mfc))
S
Stephen Hemminger 已提交
1353
			return -EINVAL;
J
Jianjun Kong 已提交
1354
		if (copy_from_user(&mfc, optval, sizeof(mfc)))
S
Stephen Hemminger 已提交
1355
			return -EFAULT;
1356 1357
		if (parent == 0)
			parent = mfc.mfcc_parent;
S
Stephen Hemminger 已提交
1358
		rtnl_lock();
1359 1360
		if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY)
			ret = ipmr_mfc_delete(mrt, &mfc, parent);
S
Stephen Hemminger 已提交
1361
		else
E
Eric Dumazet 已提交
1362
			ret = ipmr_mfc_add(net, mrt, &mfc,
1363 1364
					   sk == rtnl_dereference(mrt->mroute_sk),
					   parent);
S
Stephen Hemminger 已提交
1365 1366
		rtnl_unlock();
		return ret;
L
Linus Torvalds 已提交
1367 1368 1369
		/*
		 *	Control PIM assert.
		 */
S
Stephen Hemminger 已提交
1370 1371 1372
	case MRT_ASSERT:
	{
		int v;
1373 1374
		if (optlen != sizeof(v))
			return -EINVAL;
E
Eric Dumazet 已提交
1375
		if (get_user(v, (int __user *)optval))
S
Stephen Hemminger 已提交
1376
			return -EFAULT;
1377
		mrt->mroute_do_assert = v;
S
Stephen Hemminger 已提交
1378 1379
		return 0;
	}
L
Linus Torvalds 已提交
1380
#ifdef CONFIG_IP_PIMSM
S
Stephen Hemminger 已提交
1381 1382
	case MRT_PIM:
	{
S
Stephen Hemminger 已提交
1383 1384
		int v;

1385 1386
		if (optlen != sizeof(v))
			return -EINVAL;
E
Eric Dumazet 已提交
1387
		if (get_user(v, (int __user *)optval))
S
Stephen Hemminger 已提交
1388
			return -EFAULT;
1389
		v = !!v;
S
Stephen Hemminger 已提交
1390

S
Stephen Hemminger 已提交
1391 1392
		rtnl_lock();
		ret = 0;
1393 1394 1395
		if (v != mrt->mroute_do_pim) {
			mrt->mroute_do_pim = v;
			mrt->mroute_do_assert = v;
L
Linus Torvalds 已提交
1396
		}
S
Stephen Hemminger 已提交
1397 1398 1399
		rtnl_unlock();
		return ret;
	}
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
#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;

1411 1412 1413 1414
		/* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
		if (v != RT_TABLE_DEFAULT && v >= 1000000000)
			return -EINVAL;

1415 1416
		rtnl_lock();
		ret = 0;
E
Eric Dumazet 已提交
1417 1418 1419 1420 1421
		if (sk == rtnl_dereference(mrt->mroute_sk)) {
			ret = -EBUSY;
		} else {
			if (!ipmr_new_table(net, v))
				ret = -ENOMEM;
1422 1423
			else
				raw_sk(sk)->ipmr_table = v;
E
Eric Dumazet 已提交
1424
		}
1425 1426 1427
		rtnl_unlock();
		return ret;
	}
L
Linus Torvalds 已提交
1428
#endif
S
Stephen Hemminger 已提交
1429 1430 1431 1432 1433 1434
	/*
	 *	Spurious command, or MRT_VERSION which you cannot
	 *	set.
	 */
	default:
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1435 1436 1437 1438 1439 1440
	}
}

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

J
Jianjun Kong 已提交
1442
int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
L
Linus Torvalds 已提交
1443 1444 1445
{
	int olr;
	int val;
1446
	struct net *net = sock_net(sk);
1447 1448
	struct mr_table *mrt;

1449 1450 1451 1452
	if (sk->sk_type != SOCK_RAW ||
	    inet_sk(sk)->inet_num != IPPROTO_IGMP)
		return -EOPNOTSUPP;

1453
	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1454
	if (!mrt)
1455
		return -ENOENT;
L
Linus Torvalds 已提交
1456

J
Jianjun Kong 已提交
1457
	if (optname != MRT_VERSION &&
L
Linus Torvalds 已提交
1458
#ifdef CONFIG_IP_PIMSM
E
Eric Dumazet 已提交
1459
	   optname != MRT_PIM &&
L
Linus Torvalds 已提交
1460
#endif
E
Eric Dumazet 已提交
1461
	   optname != MRT_ASSERT)
L
Linus Torvalds 已提交
1462 1463 1464 1465 1466 1467 1468 1469
		return -ENOPROTOOPT;

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

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

J
Jianjun Kong 已提交
1471
	if (put_user(olr, optlen))
L
Linus Torvalds 已提交
1472
		return -EFAULT;
J
Jianjun Kong 已提交
1473 1474
	if (optname == MRT_VERSION)
		val = 0x0305;
L
Linus Torvalds 已提交
1475
#ifdef CONFIG_IP_PIMSM
J
Jianjun Kong 已提交
1476
	else if (optname == MRT_PIM)
1477
		val = mrt->mroute_do_pim;
L
Linus Torvalds 已提交
1478 1479
#endif
	else
1480
		val = mrt->mroute_do_assert;
J
Jianjun Kong 已提交
1481
	if (copy_to_user(optval, &val, olr))
L
Linus Torvalds 已提交
1482 1483 1484 1485 1486 1487 1488
		return -EFAULT;
	return 0;
}

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

L
Linus Torvalds 已提交
1490 1491 1492 1493 1494 1495
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;
1496
	struct net *net = sock_net(sk);
1497 1498 1499
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1500
	if (!mrt)
1501
		return -ENOENT;
1502

S
Stephen Hemminger 已提交
1503 1504
	switch (cmd) {
	case SIOCGETVIFCNT:
J
Jianjun Kong 已提交
1505
		if (copy_from_user(&vr, arg, sizeof(vr)))
S
Stephen Hemminger 已提交
1506
			return -EFAULT;
1507
		if (vr.vifi >= mrt->maxvif)
S
Stephen Hemminger 已提交
1508 1509
			return -EINVAL;
		read_lock(&mrt_lock);
1510 1511
		vif = &mrt->vif_table[vr.vifi];
		if (VIF_EXISTS(mrt, vr.vifi)) {
J
Jianjun Kong 已提交
1512 1513 1514 1515
			vr.icount = vif->pkt_in;
			vr.ocount = vif->pkt_out;
			vr.ibytes = vif->bytes_in;
			vr.obytes = vif->bytes_out;
L
Linus Torvalds 已提交
1516 1517
			read_unlock(&mrt_lock);

J
Jianjun Kong 已提交
1518
			if (copy_to_user(arg, &vr, sizeof(vr)))
S
Stephen Hemminger 已提交
1519 1520 1521 1522 1523 1524
				return -EFAULT;
			return 0;
		}
		read_unlock(&mrt_lock);
		return -EADDRNOTAVAIL;
	case SIOCGETSGCNT:
J
Jianjun Kong 已提交
1525
		if (copy_from_user(&sr, arg, sizeof(sr)))
S
Stephen Hemminger 已提交
1526 1527
			return -EFAULT;

1528
		rcu_read_lock();
1529
		c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
S
Stephen Hemminger 已提交
1530 1531 1532 1533
		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;
1534
			rcu_read_unlock();
S
Stephen Hemminger 已提交
1535

J
Jianjun Kong 已提交
1536
			if (copy_to_user(arg, &sr, sizeof(sr)))
S
Stephen Hemminger 已提交
1537 1538 1539
				return -EFAULT;
			return 0;
		}
1540
		rcu_read_unlock();
S
Stephen Hemminger 已提交
1541 1542 1543
		return -EADDRNOTAVAIL;
	default:
		return -ENOIOCTLCMD;
L
Linus Torvalds 已提交
1544 1545 1546
	}
}

1547 1548 1549 1550 1551 1552 1553 1554 1555
#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;
};

1556 1557 1558 1559 1560 1561 1562 1563
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;
};

1564 1565
int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
{
1566
	struct compat_sioc_sg_req sr;
1567 1568
	struct compat_sioc_vif_req vr;
	struct vif_device *vif;
1569 1570 1571 1572 1573
	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);
1574
	if (!mrt)
1575 1576 1577
		return -ENOENT;

	switch (cmd) {
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
	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;
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
	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 已提交
1622 1623 1624

static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
{
1625
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1626
	struct net *net = dev_net(dev);
1627
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1628 1629
	struct vif_device *v;
	int ct;
1630

L
Linus Torvalds 已提交
1631 1632
	if (event != NETDEV_UNREGISTER)
		return NOTIFY_DONE;
1633 1634 1635 1636 1637

	ipmr_for_each_table(mrt, net) {
		v = &mrt->vif_table[0];
		for (ct = 0; ct < mrt->maxvif; ct++, v++) {
			if (v->dev == dev)
1638
				vif_delete(mrt, ct, 1, NULL);
1639
		}
L
Linus Torvalds 已提交
1640 1641 1642 1643 1644
	}
	return NOTIFY_DONE;
}


J
Jianjun Kong 已提交
1645
static struct notifier_block ip_mr_notifier = {
L
Linus Torvalds 已提交
1646 1647 1648 1649
	.notifier_call = ipmr_device_event,
};

/*
E
Eric Dumazet 已提交
1650
 *	Encapsulate a packet by attaching a valid IPIP header to it.
L
Linus Torvalds 已提交
1651 1652 1653
 *	This avoids tunnel drivers and other mess and gives us the speed so
 *	important for multicast video.
 */
1654

1655 1656
static void ip_encap(struct net *net, struct sk_buff *skb,
		     __be32 saddr, __be32 daddr)
L
Linus Torvalds 已提交
1657
{
1658
	struct iphdr *iph;
1659
	const struct iphdr *old_iph = ip_hdr(skb);
1660 1661

	skb_push(skb, sizeof(struct iphdr));
1662
	skb->transport_header = skb->network_header;
1663
	skb_reset_network_header(skb);
1664
	iph = ip_hdr(skb);
L
Linus Torvalds 已提交
1665

E
Eric Dumazet 已提交
1666
	iph->version	=	4;
1667 1668
	iph->tos	=	old_iph->tos;
	iph->ttl	=	old_iph->ttl;
L
Linus Torvalds 已提交
1669 1670 1671 1672 1673 1674
	iph->frag_off	=	0;
	iph->daddr	=	daddr;
	iph->saddr	=	saddr;
	iph->protocol	=	IPPROTO_IPIP;
	iph->ihl	=	5;
	iph->tot_len	=	htons(skb->len);
1675
	ip_select_ident(net, skb, NULL);
L
Linus Torvalds 已提交
1676 1677 1678 1679 1680 1681
	ip_send_check(iph);

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

1682 1683
static inline int ipmr_forward_finish(struct net *net, struct sock *sk,
				      struct sk_buff *skb)
L
Linus Torvalds 已提交
1684
{
E
Eric Dumazet 已提交
1685
	struct ip_options *opt = &(IPCB(skb)->opt);
L
Linus Torvalds 已提交
1686

1687 1688
	IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS);
	IP_ADD_STATS(net, IPSTATS_MIB_OUTOCTETS, skb->len);
L
Linus Torvalds 已提交
1689 1690 1691 1692

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

1693
	return dst_output(net, sk, skb);
L
Linus Torvalds 已提交
1694 1695 1696 1697 1698 1699
}

/*
 *	Processing handlers for ipmr_forward
 */

1700 1701
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 已提交
1702
{
1703
	const struct iphdr *iph = ip_hdr(skb);
1704
	struct vif_device *vif = &mrt->vif_table[vifi];
L
Linus Torvalds 已提交
1705 1706
	struct net_device *dev;
	struct rtable *rt;
1707
	struct flowi4 fl4;
L
Linus Torvalds 已提交
1708 1709
	int    encap = 0;

1710
	if (!vif->dev)
L
Linus Torvalds 已提交
1711 1712 1713 1714 1715
		goto out_free;

#ifdef CONFIG_IP_PIMSM
	if (vif->flags & VIFF_REGISTER) {
		vif->pkt_out++;
J
Jianjun Kong 已提交
1716
		vif->bytes_out += skb->len;
1717 1718
		vif->dev->stats.tx_bytes += skb->len;
		vif->dev->stats.tx_packets++;
1719
		ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
1720
		goto out_free;
L
Linus Torvalds 已提交
1721 1722 1723
	}
#endif

E
Eric Dumazet 已提交
1724
	if (vif->flags & VIFF_TUNNEL) {
1725
		rt = ip_route_output_ports(net, &fl4, NULL,
1726 1727 1728 1729
					   vif->remote, vif->local,
					   0, 0,
					   IPPROTO_IPIP,
					   RT_TOS(iph->tos), vif->link);
1730
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
1731 1732 1733
			goto out_free;
		encap = sizeof(struct iphdr);
	} else {
1734
		rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
1735 1736 1737
					   0, 0,
					   IPPROTO_IPIP,
					   RT_TOS(iph->tos), vif->link);
1738
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
1739 1740 1741
			goto out_free;
	}

1742
	dev = rt->dst.dev;
L
Linus Torvalds 已提交
1743

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

1750
		IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
L
Linus Torvalds 已提交
1751 1752 1753 1754
		ip_rt_put(rt);
		goto out_free;
	}

1755
	encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
L
Linus Torvalds 已提交
1756 1757

	if (skb_cow(skb, encap)) {
1758
		ip_rt_put(rt);
L
Linus Torvalds 已提交
1759 1760 1761 1762
		goto out_free;
	}

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

E
Eric Dumazet 已提交
1765
	skb_dst_drop(skb);
1766
	skb_dst_set(skb, &rt->dst);
1767
	ip_decrease_ttl(ip_hdr(skb));
L
Linus Torvalds 已提交
1768 1769

	/* FIXME: forward and output firewalls used to be called here.
E
Eric Dumazet 已提交
1770 1771
	 * What do we do with netfilter? -- RR
	 */
L
Linus Torvalds 已提交
1772
	if (vif->flags & VIFF_TUNNEL) {
1773
		ip_encap(net, skb, vif->local, vif->remote);
L
Linus Torvalds 已提交
1774
		/* FIXME: extra output firewall step used to be here. --RR */
1775 1776
		vif->dev->stats.tx_packets++;
		vif->dev->stats.tx_bytes += skb->len;
L
Linus Torvalds 已提交
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
	}

	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.
	 */
1792 1793
	NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
		net, NULL, skb, skb->dev, dev,
L
Linus Torvalds 已提交
1794 1795 1796 1797 1798 1799 1800
		ipmr_forward_finish);
	return;

out_free:
	kfree_skb(skb);
}

1801
static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
L
Linus Torvalds 已提交
1802 1803
{
	int ct;
1804 1805 1806

	for (ct = mrt->maxvif-1; ct >= 0; ct--) {
		if (mrt->vif_table[ct].dev == dev)
L
Linus Torvalds 已提交
1807 1808 1809 1810 1811 1812 1813
			break;
	}
	return ct;
}

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

1814 1815 1816
static void ip_mr_forward(struct net *net, struct mr_table *mrt,
			  struct sk_buff *skb, struct mfc_cache *cache,
			  int local)
L
Linus Torvalds 已提交
1817 1818 1819
{
	int psend = -1;
	int vif, ct;
1820
	int true_vifi = ipmr_find_vif(mrt, skb->dev);
L
Linus Torvalds 已提交
1821 1822 1823 1824 1825

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

1826
	if (cache->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) {
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837
		struct mfc_cache *cache_proxy;

		/* For an (*,G) entry, we only check that the incomming
		 * interface is part of the static tree.
		 */
		cache_proxy = ipmr_cache_find_any_parent(mrt, vif);
		if (cache_proxy &&
		    cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
			goto forward;
	}

L
Linus Torvalds 已提交
1838 1839 1840
	/*
	 * Wrong interface: drop packet and (maybe) send PIM assert.
	 */
1841
	if (mrt->vif_table[vif].dev != skb->dev) {
1842
		if (rt_is_output_route(skb_rtable(skb))) {
L
Linus Torvalds 已提交
1843
			/* It is our own packet, looped back.
E
Eric Dumazet 已提交
1844 1845 1846 1847 1848 1849 1850 1851 1852
			 * 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 已提交
1853 1854 1855 1856 1857 1858
			 */
			goto dont_forward;
		}

		cache->mfc_un.res.wrong_if++;

1859
		if (true_vifi >= 0 && mrt->mroute_do_assert &&
L
Linus Torvalds 已提交
1860
		    /* pimsm uses asserts, when switching from RPT to SPT,
E
Eric Dumazet 已提交
1861 1862 1863
		     * 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 已提交
1864
		     */
1865
		    (mrt->mroute_do_pim ||
1866
		     cache->mfc_un.res.ttls[true_vifi] < 255) &&
1867
		    time_after(jiffies,
L
Linus Torvalds 已提交
1868 1869
			       cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
			cache->mfc_un.res.last_assert = jiffies;
1870
			ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
L
Linus Torvalds 已提交
1871 1872 1873 1874
		}
		goto dont_forward;
	}

1875
forward:
1876 1877
	mrt->vif_table[vif].pkt_in++;
	mrt->vif_table[vif].bytes_in += skb->len;
L
Linus Torvalds 已提交
1878 1879 1880 1881

	/*
	 *	Forward the frame
	 */
1882 1883
	if (cache->mfc_origin == htonl(INADDR_ANY) &&
	    cache->mfc_mcastgrp == htonl(INADDR_ANY)) {
1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
		if (true_vifi >= 0 &&
		    true_vifi != cache->mfc_parent &&
		    ip_hdr(skb)->ttl >
				cache->mfc_un.res.ttls[cache->mfc_parent]) {
			/* It's an (*,*) entry and the packet is not coming from
			 * the upstream: forward the packet to the upstream
			 * only.
			 */
			psend = cache->mfc_parent;
			goto last_forward;
		}
		goto dont_forward;
	}
E
Eric Dumazet 已提交
1897 1898
	for (ct = cache->mfc_un.res.maxvif - 1;
	     ct >= cache->mfc_un.res.minvif; ct--) {
1899
		/* For (*,G) entry, don't forward to the incoming interface */
1900 1901
		if ((cache->mfc_origin != htonl(INADDR_ANY) ||
		     ct != true_vifi) &&
1902
		    ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
L
Linus Torvalds 已提交
1903 1904
			if (psend != -1) {
				struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
E
Eric Dumazet 已提交
1905

L
Linus Torvalds 已提交
1906
				if (skb2)
1907 1908
					ipmr_queue_xmit(net, mrt, skb2, cache,
							psend);
L
Linus Torvalds 已提交
1909
			}
J
Jianjun Kong 已提交
1910
			psend = ct;
L
Linus Torvalds 已提交
1911 1912
		}
	}
1913
last_forward:
L
Linus Torvalds 已提交
1914 1915 1916
	if (psend != -1) {
		if (local) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
E
Eric Dumazet 已提交
1917

L
Linus Torvalds 已提交
1918
			if (skb2)
1919
				ipmr_queue_xmit(net, mrt, skb2, cache, psend);
L
Linus Torvalds 已提交
1920
		} else {
1921
			ipmr_queue_xmit(net, mrt, skb, cache, psend);
1922
			return;
L
Linus Torvalds 已提交
1923 1924 1925 1926 1927 1928 1929 1930
		}
	}

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

1931
static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
1932
{
1933 1934
	struct rtable *rt = skb_rtable(skb);
	struct iphdr *iph = ip_hdr(skb);
D
David S. Miller 已提交
1935
	struct flowi4 fl4 = {
1936 1937
		.daddr = iph->daddr,
		.saddr = iph->saddr,
1938
		.flowi4_tos = RT_TOS(iph->tos),
D
David S. Miller 已提交
1939 1940 1941
		.flowi4_oif = (rt_is_output_route(rt) ?
			       skb->dev->ifindex : 0),
		.flowi4_iif = (rt_is_output_route(rt) ?
1942
			       LOOPBACK_IFINDEX :
D
David S. Miller 已提交
1943
			       skb->dev->ifindex),
1944
		.flowi4_mark = skb->mark,
1945 1946 1947 1948
	};
	struct mr_table *mrt;
	int err;

D
David S. Miller 已提交
1949
	err = ipmr_fib_lookup(net, &fl4, &mrt);
1950 1951 1952 1953
	if (err)
		return ERR_PTR(err);
	return mrt;
}
L
Linus Torvalds 已提交
1954 1955 1956

/*
 *	Multicast packets for forwarding arrive here
E
Eric Dumazet 已提交
1957
 *	Called with rcu_read_lock();
L
Linus Torvalds 已提交
1958 1959 1960 1961 1962
 */

int ip_mr_input(struct sk_buff *skb)
{
	struct mfc_cache *cache;
1963
	struct net *net = dev_net(skb->dev);
E
Eric Dumazet 已提交
1964
	int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1965
	struct mr_table *mrt;
L
Linus Torvalds 已提交
1966 1967

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

1973
	mrt = ipmr_rt_fib_lookup(net, skb);
1974 1975 1976
	if (IS_ERR(mrt)) {
		kfree_skb(skb);
		return PTR_ERR(mrt);
1977
	}
L
Linus Torvalds 已提交
1978
	if (!local) {
E
Eric Dumazet 已提交
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
		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 已提交
1997 1998 1999
		    }
	}

2000
	/* already under rcu_read_lock() */
2001
	cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
2002
	if (!cache) {
2003 2004 2005 2006 2007 2008
		int vif = ipmr_find_vif(mrt, skb->dev);

		if (vif >= 0)
			cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr,
						    vif);
	}
L
Linus Torvalds 已提交
2009 2010 2011 2012

	/*
	 *	No usable cache entry
	 */
2013
	if (!cache) {
L
Linus Torvalds 已提交
2014 2015 2016 2017 2018
		int vif;

		if (local) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
			ip_local_deliver(skb);
2019
			if (!skb2)
L
Linus Torvalds 已提交
2020 2021 2022 2023
				return -ENOBUFS;
			skb = skb2;
		}

2024
		read_lock(&mrt_lock);
2025
		vif = ipmr_find_vif(mrt, skb->dev);
L
Linus Torvalds 已提交
2026
		if (vif >= 0) {
2027
			int err2 = ipmr_cache_unresolved(mrt, vif, skb);
L
Linus Torvalds 已提交
2028 2029
			read_unlock(&mrt_lock);

2030
			return err2;
L
Linus Torvalds 已提交
2031 2032 2033 2034 2035 2036
		}
		read_unlock(&mrt_lock);
		kfree_skb(skb);
		return -ENODEV;
	}

2037
	read_lock(&mrt_lock);
2038
	ip_mr_forward(net, mrt, skb, cache, local);
L
Linus Torvalds 已提交
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052
	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 已提交
2053
#ifdef CONFIG_IP_PIMSM
2054
/* called with rcu_read_lock() */
2055 2056
static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
		     unsigned int pimlen)
L
Linus Torvalds 已提交
2057
{
I
Ilpo Järvinen 已提交
2058 2059
	struct net_device *reg_dev = NULL;
	struct iphdr *encap;
L
Linus Torvalds 已提交
2060

I
Ilpo Järvinen 已提交
2061
	encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
L
Linus Torvalds 已提交
2062
	/*
E
Eric Dumazet 已提交
2063 2064 2065 2066
	 * 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 已提交
2067
	 */
2068
	if (!ipv4_is_multicast(encap->daddr) ||
L
Linus Torvalds 已提交
2069
	    encap->tot_len == 0 ||
I
Ilpo Järvinen 已提交
2070 2071
	    ntohs(encap->tot_len) + pimlen > skb->len)
		return 1;
L
Linus Torvalds 已提交
2072 2073

	read_lock(&mrt_lock);
2074 2075
	if (mrt->mroute_reg_vif_num >= 0)
		reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
L
Linus Torvalds 已提交
2076 2077
	read_unlock(&mrt_lock);

2078
	if (!reg_dev)
I
Ilpo Järvinen 已提交
2079
		return 1;
L
Linus Torvalds 已提交
2080

2081
	skb->mac_header = skb->network_header;
2082
	skb_pull(skb, (u8 *)encap - skb->data);
2083
	skb_reset_network_header(skb);
L
Linus Torvalds 已提交
2084
	skb->protocol = htons(ETH_P_IP);
2085
	skb->ip_summed = CHECKSUM_NONE;
2086

2087
	skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
2088

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

2091
	return NET_RX_SUCCESS;
I
Ilpo Järvinen 已提交
2092 2093 2094 2095 2096 2097 2098 2099
}
#endif

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

E
Eric Dumazet 已提交
2100
int pim_rcv_v1(struct sk_buff *skb)
I
Ilpo Järvinen 已提交
2101 2102
{
	struct igmphdr *pim;
2103
	struct net *net = dev_net(skb->dev);
2104
	struct mr_table *mrt;
I
Ilpo Järvinen 已提交
2105 2106 2107 2108 2109 2110

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

	pim = igmp_hdr(skb);

2111
	mrt = ipmr_rt_fib_lookup(net, skb);
2112 2113
	if (IS_ERR(mrt))
		goto drop;
2114
	if (!mrt->mroute_do_pim ||
I
Ilpo Järvinen 已提交
2115 2116 2117
	    pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
		goto drop;

2118
	if (__pim_rcv(mrt, skb, sizeof(*pim))) {
I
Ilpo Järvinen 已提交
2119 2120 2121
drop:
		kfree_skb(skb);
	}
L
Linus Torvalds 已提交
2122 2123 2124 2125 2126
	return 0;
}
#endif

#ifdef CONFIG_IP_PIMSM_V2
E
Eric Dumazet 已提交
2127
static int pim_rcv(struct sk_buff *skb)
L
Linus Torvalds 已提交
2128 2129
{
	struct pimreghdr *pim;
2130 2131
	struct net *net = dev_net(skb->dev);
	struct mr_table *mrt;
L
Linus Torvalds 已提交
2132

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

2136
	pim = (struct pimreghdr *)skb_transport_header(skb);
E
Eric Dumazet 已提交
2137 2138
	if (pim->type != ((PIM_VERSION << 4) | (PIM_REGISTER)) ||
	    (pim->flags & PIM_NULL_REGISTER) ||
2139
	    (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
2140
	     csum_fold(skb_checksum(skb, 0, skb->len, 0))))
L
Linus Torvalds 已提交
2141 2142
		goto drop;

2143
	mrt = ipmr_rt_fib_lookup(net, skb);
2144 2145
	if (IS_ERR(mrt))
		goto drop;
2146
	if (__pim_rcv(mrt, skb, sizeof(*pim))) {
I
Ilpo Järvinen 已提交
2147 2148 2149
drop:
		kfree_skb(skb);
	}
L
Linus Torvalds 已提交
2150 2151 2152 2153
	return 0;
}
#endif

2154 2155
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
			      struct mfc_cache *c, struct rtmsg *rtm)
L
Linus Torvalds 已提交
2156 2157 2158
{
	int ct;
	struct rtnexthop *nhp;
T
Thomas Graf 已提交
2159
	struct nlattr *mp_attr;
2160
	struct rta_mfc_stats mfcs;
L
Linus Torvalds 已提交
2161

2162
	/* If cache is unresolved, don't try to parse IIF and OIF */
2163
	if (c->mfc_parent >= MAXVIFS)
2164 2165
		return -ENOENT;

T
Thomas Graf 已提交
2166 2167 2168
	if (VIF_EXISTS(mrt, c->mfc_parent) &&
	    nla_put_u32(skb, RTA_IIF, mrt->vif_table[c->mfc_parent].dev->ifindex) < 0)
		return -EMSGSIZE;
L
Linus Torvalds 已提交
2169

T
Thomas Graf 已提交
2170 2171
	if (!(mp_attr = nla_nest_start(skb, RTA_MULTIPATH)))
		return -EMSGSIZE;
L
Linus Torvalds 已提交
2172 2173

	for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2174
		if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
T
Thomas Graf 已提交
2175 2176 2177 2178 2179
			if (!(nhp = nla_reserve_nohdr(skb, sizeof(*nhp)))) {
				nla_nest_cancel(skb, mp_attr);
				return -EMSGSIZE;
			}

L
Linus Torvalds 已提交
2180 2181
			nhp->rtnh_flags = 0;
			nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2182
			nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
L
Linus Torvalds 已提交
2183 2184 2185
			nhp->rtnh_len = sizeof(*nhp);
		}
	}
T
Thomas Graf 已提交
2186 2187 2188

	nla_nest_end(skb, mp_attr);

2189 2190 2191 2192 2193 2194
	mfcs.mfcs_packets = c->mfc_un.res.pkt;
	mfcs.mfcs_bytes = c->mfc_un.res.bytes;
	mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
	if (nla_put(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs) < 0)
		return -EMSGSIZE;

L
Linus Torvalds 已提交
2195 2196 2197 2198
	rtm->rtm_type = RTN_MULTICAST;
	return 1;
}

2199 2200 2201
int ipmr_get_route(struct net *net, struct sk_buff *skb,
		   __be32 saddr, __be32 daddr,
		   struct rtmsg *rtm, int nowait)
L
Linus Torvalds 已提交
2202 2203
{
	struct mfc_cache *cache;
2204 2205
	struct mr_table *mrt;
	int err;
L
Linus Torvalds 已提交
2206

2207
	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2208
	if (!mrt)
2209 2210
		return -ENOENT;

2211
	rcu_read_lock();
2212
	cache = ipmr_cache_find(mrt, saddr, daddr);
2213
	if (!cache && skb->dev) {
2214
		int vif = ipmr_find_vif(mrt, skb->dev);
L
Linus Torvalds 已提交
2215

2216 2217 2218
		if (vif >= 0)
			cache = ipmr_cache_find_any(mrt, daddr, vif);
	}
2219
	if (!cache) {
2220
		struct sk_buff *skb2;
2221
		struct iphdr *iph;
L
Linus Torvalds 已提交
2222
		struct net_device *dev;
E
Eric Dumazet 已提交
2223
		int vif = -1;
L
Linus Torvalds 已提交
2224 2225

		if (nowait) {
2226
			rcu_read_unlock();
L
Linus Torvalds 已提交
2227 2228 2229 2230
			return -EAGAIN;
		}

		dev = skb->dev;
2231
		read_lock(&mrt_lock);
E
Eric Dumazet 已提交
2232 2233 2234
		if (dev)
			vif = ipmr_find_vif(mrt, dev);
		if (vif < 0) {
L
Linus Torvalds 已提交
2235
			read_unlock(&mrt_lock);
2236
			rcu_read_unlock();
L
Linus Torvalds 已提交
2237 2238
			return -ENODEV;
		}
2239 2240 2241
		skb2 = skb_clone(skb, GFP_ATOMIC);
		if (!skb2) {
			read_unlock(&mrt_lock);
2242
			rcu_read_unlock();
2243 2244 2245
			return -ENOMEM;
		}

2246 2247
		skb_push(skb2, sizeof(struct iphdr));
		skb_reset_network_header(skb2);
2248 2249
		iph = ip_hdr(skb2);
		iph->ihl = sizeof(struct iphdr) >> 2;
2250 2251
		iph->saddr = saddr;
		iph->daddr = daddr;
2252
		iph->version = 0;
2253
		err = ipmr_cache_unresolved(mrt, vif, skb2);
L
Linus Torvalds 已提交
2254
		read_unlock(&mrt_lock);
2255
		rcu_read_unlock();
L
Linus Torvalds 已提交
2256 2257 2258
		return err;
	}

2259 2260
	read_lock(&mrt_lock);
	if (!nowait && (rtm->rtm_flags & RTM_F_NOTIFY))
L
Linus Torvalds 已提交
2261
		cache->mfc_flags |= MFC_NOTIFY;
2262
	err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
L
Linus Torvalds 已提交
2263
	read_unlock(&mrt_lock);
2264
	rcu_read_unlock();
L
Linus Torvalds 已提交
2265 2266 2267
	return err;
}

2268
static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2269 2270
			    u32 portid, u32 seq, struct mfc_cache *c, int cmd,
			    int flags)
2271 2272 2273
{
	struct nlmsghdr *nlh;
	struct rtmsg *rtm;
2274
	int err;
2275

2276
	nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2277
	if (!nlh)
2278 2279 2280 2281 2282 2283 2284 2285
		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;
D
David S. Miller 已提交
2286 2287
	if (nla_put_u32(skb, RTA_TABLE, mrt->id))
		goto nla_put_failure;
2288 2289
	rtm->rtm_type     = RTN_MULTICAST;
	rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
2290 2291 2292 2293
	if (c->mfc_flags & MFC_STATIC)
		rtm->rtm_protocol = RTPROT_STATIC;
	else
		rtm->rtm_protocol = RTPROT_MROUTED;
2294 2295
	rtm->rtm_flags    = 0;

2296 2297
	if (nla_put_in_addr(skb, RTA_SRC, c->mfc_origin) ||
	    nla_put_in_addr(skb, RTA_DST, c->mfc_mcastgrp))
D
David S. Miller 已提交
2298
		goto nla_put_failure;
2299 2300 2301
	err = __ipmr_fill_mroute(mrt, skb, c, rtm);
	/* do not break the dump if cache is unresolved */
	if (err < 0 && err != -ENOENT)
2302 2303
		goto nla_put_failure;

2304 2305
	nlmsg_end(skb, nlh);
	return 0;
2306 2307 2308 2309 2310 2311

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

2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
static size_t mroute_msgsize(bool unresolved, int maxvif)
{
	size_t len =
		NLMSG_ALIGN(sizeof(struct rtmsg))
		+ nla_total_size(4)	/* RTA_TABLE */
		+ nla_total_size(4)	/* RTA_SRC */
		+ nla_total_size(4)	/* RTA_DST */
		;

	if (!unresolved)
		len = len
		      + nla_total_size(4)	/* RTA_IIF */
		      + nla_total_size(0)	/* RTA_MULTIPATH */
		      + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
						/* RTA_MFC_STATS */
		      + nla_total_size(sizeof(struct rta_mfc_stats))
		;

	return len;
}

static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
				 int cmd)
{
	struct net *net = read_pnet(&mrt->net);
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(mroute_msgsize(mfc->mfc_parent >= MAXVIFS, mrt->maxvif),
			GFP_ATOMIC);
2342
	if (!skb)
2343 2344
		goto errout;

2345
	err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
	if (err < 0)
		goto errout;

	rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC);
	return;

errout:
	kfree_skb(skb);
	if (err < 0)
		rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err);
}

2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370
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];

2371
	rcu_read_lock();
2372 2373 2374 2375 2376 2377
	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++) {
2378
			list_for_each_entry_rcu(mfc, &mrt->mfc_cache_array[h], list) {
2379 2380 2381
				if (e < s_e)
					goto next_entry;
				if (ipmr_fill_mroute(mrt, skb,
2382
						     NETLINK_CB(cb->skb).portid,
2383
						     cb->nlh->nlmsg_seq,
2384 2385
						     mfc, RTM_NEWROUTE,
						     NLM_F_MULTI) < 0)
2386 2387 2388 2389 2390 2391
					goto done;
next_entry:
				e++;
			}
			e = s_e = 0;
		}
2392 2393 2394 2395 2396 2397 2398
		spin_lock_bh(&mfc_unres_lock);
		list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
			if (e < s_e)
				goto next_entry2;
			if (ipmr_fill_mroute(mrt, skb,
					     NETLINK_CB(cb->skb).portid,
					     cb->nlh->nlmsg_seq,
2399 2400
					     mfc, RTM_NEWROUTE,
					     NLM_F_MULTI) < 0) {
2401 2402 2403 2404 2405 2406 2407 2408
				spin_unlock_bh(&mfc_unres_lock);
				goto done;
			}
next_entry2:
			e++;
		}
		spin_unlock_bh(&mfc_unres_lock);
		e = s_e = 0;
2409 2410 2411 2412 2413
		s_h = 0;
next_table:
		t++;
	}
done:
2414
	rcu_read_unlock();
2415 2416 2417 2418 2419 2420 2421 2422

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

	return skb->len;
}

2423
#ifdef CONFIG_PROC_FS
L
Linus Torvalds 已提交
2424
/*
E
Eric Dumazet 已提交
2425 2426
 *	The /proc interfaces to multicast routing :
 *	/proc/net/ip_mr_cache & /proc/net/ip_mr_vif
L
Linus Torvalds 已提交
2427 2428
 */
struct ipmr_vif_iter {
2429
	struct seq_net_private p;
2430
	struct mr_table *mrt;
L
Linus Torvalds 已提交
2431 2432 2433
	int ct;
};

2434 2435
static struct vif_device *ipmr_vif_seq_idx(struct net *net,
					   struct ipmr_vif_iter *iter,
L
Linus Torvalds 已提交
2436 2437
					   loff_t pos)
{
2438
	struct mr_table *mrt = iter->mrt;
2439 2440 2441

	for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
		if (!VIF_EXISTS(mrt, iter->ct))
L
Linus Torvalds 已提交
2442
			continue;
2443
		if (pos-- == 0)
2444
			return &mrt->vif_table[iter->ct];
L
Linus Torvalds 已提交
2445 2446 2447 2448 2449
	}
	return NULL;
}

static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
S
Stephen Hemminger 已提交
2450
	__acquires(mrt_lock)
L
Linus Torvalds 已提交
2451
{
2452
	struct ipmr_vif_iter *iter = seq->private;
2453
	struct net *net = seq_file_net(seq);
2454 2455 2456
	struct mr_table *mrt;

	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2457
	if (!mrt)
2458 2459 2460
		return ERR_PTR(-ENOENT);

	iter->mrt = mrt;
2461

L
Linus Torvalds 已提交
2462
	read_lock(&mrt_lock);
2463
	return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
L
Linus Torvalds 已提交
2464 2465 2466 2467 2468 2469
		: 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;
2470
	struct net *net = seq_file_net(seq);
2471
	struct mr_table *mrt = iter->mrt;
L
Linus Torvalds 已提交
2472 2473 2474

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

2477 2478
	while (++iter->ct < mrt->maxvif) {
		if (!VIF_EXISTS(mrt, iter->ct))
L
Linus Torvalds 已提交
2479
			continue;
2480
		return &mrt->vif_table[iter->ct];
L
Linus Torvalds 已提交
2481 2482 2483 2484 2485
	}
	return NULL;
}

static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
S
Stephen Hemminger 已提交
2486
	__releases(mrt_lock)
L
Linus Torvalds 已提交
2487 2488 2489 2490 2491 2492
{
	read_unlock(&mrt_lock);
}

static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
{
2493 2494
	struct ipmr_vif_iter *iter = seq->private;
	struct mr_table *mrt = iter->mrt;
2495

L
Linus Torvalds 已提交
2496
	if (v == SEQ_START_TOKEN) {
2497
		seq_puts(seq,
L
Linus Torvalds 已提交
2498 2499 2500 2501 2502 2503 2504
			 "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",
2505
			   vif - mrt->vif_table,
2506
			   name, vif->bytes_in, vif->pkt_in,
L
Linus Torvalds 已提交
2507 2508 2509 2510 2511 2512
			   vif->bytes_out, vif->pkt_out,
			   vif->flags, vif->local, vif->remote);
	}
	return 0;
}

2513
static const struct seq_operations ipmr_vif_seq_ops = {
L
Linus Torvalds 已提交
2514 2515 2516 2517 2518 2519 2520 2521
	.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)
{
2522 2523
	return seq_open_net(inode, file, &ipmr_vif_seq_ops,
			    sizeof(struct ipmr_vif_iter));
L
Linus Torvalds 已提交
2524 2525
}

2526
static const struct file_operations ipmr_vif_fops = {
L
Linus Torvalds 已提交
2527 2528 2529 2530
	.owner	 = THIS_MODULE,
	.open    = ipmr_vif_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
2531
	.release = seq_release_net,
L
Linus Torvalds 已提交
2532 2533 2534
};

struct ipmr_mfc_iter {
2535
	struct seq_net_private p;
2536
	struct mr_table *mrt;
2537
	struct list_head *cache;
L
Linus Torvalds 已提交
2538 2539 2540 2541
	int ct;
};


2542 2543
static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
					  struct ipmr_mfc_iter *it, loff_t pos)
L
Linus Torvalds 已提交
2544
{
2545
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2546 2547
	struct mfc_cache *mfc;

2548
	rcu_read_lock();
2549
	for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
2550
		it->cache = &mrt->mfc_cache_array[it->ct];
2551
		list_for_each_entry_rcu(mfc, it->cache, list)
2552
			if (pos-- == 0)
L
Linus Torvalds 已提交
2553
				return mfc;
2554
	}
2555
	rcu_read_unlock();
L
Linus Torvalds 已提交
2556 2557

	spin_lock_bh(&mfc_unres_lock);
2558
	it->cache = &mrt->mfc_unres_queue;
2559
	list_for_each_entry(mfc, it->cache, list)
2560
		if (pos-- == 0)
L
Linus Torvalds 已提交
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571
			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;
2572
	struct net *net = seq_file_net(seq);
2573
	struct mr_table *mrt;
2574

2575
	mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2576
	if (!mrt)
2577
		return ERR_PTR(-ENOENT);
2578

2579
	it->mrt = mrt;
L
Linus Torvalds 已提交
2580 2581
	it->cache = NULL;
	it->ct = 0;
2582
	return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
L
Linus Torvalds 已提交
2583 2584 2585 2586 2587 2588 2589
		: 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;
2590
	struct net *net = seq_file_net(seq);
2591
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2592 2593 2594 2595

	++*pos;

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

2598 2599
	if (mfc->list.next != it->cache)
		return list_entry(mfc->list.next, struct mfc_cache, list);
2600

2601
	if (it->cache == &mrt->mfc_unres_queue)
L
Linus Torvalds 已提交
2602 2603
		goto end_of_list;

2604
	BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
L
Linus Torvalds 已提交
2605 2606

	while (++it->ct < MFC_LINES) {
2607
		it->cache = &mrt->mfc_cache_array[it->ct];
2608 2609 2610
		if (list_empty(it->cache))
			continue;
		return list_first_entry(it->cache, struct mfc_cache, list);
L
Linus Torvalds 已提交
2611 2612 2613
	}

	/* exhausted cache_array, show unresolved */
2614
	rcu_read_unlock();
2615
	it->cache = &mrt->mfc_unres_queue;
L
Linus Torvalds 已提交
2616
	it->ct = 0;
2617

L
Linus Torvalds 已提交
2618
	spin_lock_bh(&mfc_unres_lock);
2619 2620
	if (!list_empty(it->cache))
		return list_first_entry(it->cache, struct mfc_cache, list);
L
Linus Torvalds 已提交
2621

E
Eric Dumazet 已提交
2622
end_of_list:
L
Linus Torvalds 已提交
2623 2624 2625 2626 2627 2628 2629 2630 2631
	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;
2632
	struct mr_table *mrt = it->mrt;
L
Linus Torvalds 已提交
2633

2634
	if (it->cache == &mrt->mfc_unres_queue)
L
Linus Torvalds 已提交
2635
		spin_unlock_bh(&mfc_unres_lock);
2636
	else if (it->cache == &mrt->mfc_cache_array[it->ct])
2637
		rcu_read_unlock();
L
Linus Torvalds 已提交
2638 2639 2640 2641 2642 2643 2644
}

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

	if (v == SEQ_START_TOKEN) {
2645
		seq_puts(seq,
L
Linus Torvalds 已提交
2646 2647 2648 2649
		 "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
	} else {
		const struct mfc_cache *mfc = v;
		const struct ipmr_mfc_iter *it = seq->private;
2650
		const struct mr_table *mrt = it->mrt;
2651

2652 2653 2654
		seq_printf(seq, "%08X %08X %-3hd",
			   (__force u32) mfc->mfc_mcastgrp,
			   (__force u32) mfc->mfc_origin,
2655
			   mfc->mfc_parent);
L
Linus Torvalds 已提交
2656

2657
		if (it->cache != &mrt->mfc_unres_queue) {
2658 2659 2660 2661
			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 已提交
2662
			for (n = mfc->mfc_un.res.minvif;
E
Eric Dumazet 已提交
2663
			     n < mfc->mfc_un.res.maxvif; n++) {
2664
				if (VIF_EXISTS(mrt, n) &&
2665 2666
				    mfc->mfc_un.res.ttls[n] < 255)
					seq_printf(seq,
2667
					   " %2d:%-3d",
L
Linus Torvalds 已提交
2668 2669
					   n, mfc->mfc_un.res.ttls[n]);
			}
2670 2671 2672 2673 2674
		} 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 已提交
2675 2676 2677 2678 2679 2680
		}
		seq_putc(seq, '\n');
	}
	return 0;
}

2681
static const struct seq_operations ipmr_mfc_seq_ops = {
L
Linus Torvalds 已提交
2682 2683 2684 2685 2686 2687 2688 2689
	.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)
{
2690 2691
	return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
			    sizeof(struct ipmr_mfc_iter));
L
Linus Torvalds 已提交
2692 2693
}

2694
static const struct file_operations ipmr_mfc_fops = {
L
Linus Torvalds 已提交
2695 2696 2697 2698
	.owner	 = THIS_MODULE,
	.open    = ipmr_mfc_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
2699
	.release = seq_release_net,
L
Linus Torvalds 已提交
2700
};
2701
#endif
L
Linus Torvalds 已提交
2702 2703

#ifdef CONFIG_IP_PIMSM_V2
2704
static const struct net_protocol pim_protocol = {
L
Linus Torvalds 已提交
2705
	.handler	=	pim_rcv,
T
Tom Goff 已提交
2706
	.netns_ok	=	1,
L
Linus Torvalds 已提交
2707 2708 2709 2710 2711 2712 2713
};
#endif


/*
 *	Setup for IP multicast routing
 */
2714 2715
static int __net_init ipmr_net_init(struct net *net)
{
2716
	int err;
2717

2718 2719
	err = ipmr_rules_init(net);
	if (err < 0)
2720
		goto fail;
2721 2722 2723

#ifdef CONFIG_PROC_FS
	err = -ENOMEM;
2724
	if (!proc_create("ip_mr_vif", 0, net->proc_net, &ipmr_vif_fops))
2725
		goto proc_vif_fail;
2726
	if (!proc_create("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_fops))
2727 2728
		goto proc_cache_fail;
#endif
2729 2730
	return 0;

2731 2732
#ifdef CONFIG_PROC_FS
proc_cache_fail:
2733
	remove_proc_entry("ip_mr_vif", net->proc_net);
2734
proc_vif_fail:
2735
	ipmr_rules_exit(net);
2736
#endif
2737 2738 2739 2740 2741 2742
fail:
	return err;
}

static void __net_exit ipmr_net_exit(struct net *net)
{
2743
#ifdef CONFIG_PROC_FS
2744 2745
	remove_proc_entry("ip_mr_cache", net->proc_net);
	remove_proc_entry("ip_mr_vif", net->proc_net);
2746
#endif
2747
	ipmr_rules_exit(net);
2748 2749 2750 2751 2752 2753
}

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

W
Wang Chen 已提交
2755
int __init ip_mr_init(void)
L
Linus Torvalds 已提交
2756
{
W
Wang Chen 已提交
2757 2758
	int err;

L
Linus Torvalds 已提交
2759 2760
	mrt_cachep = kmem_cache_create("ip_mrt_cache",
				       sizeof(struct mfc_cache),
2761
				       0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
2762
				       NULL);
W
Wang Chen 已提交
2763 2764 2765
	if (!mrt_cachep)
		return -ENOMEM;

2766 2767 2768 2769
	err = register_pernet_subsys(&ipmr_net_ops);
	if (err)
		goto reg_pernet_fail;

W
Wang Chen 已提交
2770 2771 2772
	err = register_netdevice_notifier(&ip_mr_notifier);
	if (err)
		goto reg_notif_fail;
T
Tom Goff 已提交
2773 2774
#ifdef CONFIG_IP_PIMSM_V2
	if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
J
Joe Perches 已提交
2775
		pr_err("%s: can't add PIM protocol\n", __func__);
T
Tom Goff 已提交
2776 2777 2778 2779
		err = -EAGAIN;
		goto add_proto_fail;
	}
#endif
2780 2781
	rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
		      NULL, ipmr_rtm_dumproute, NULL);
W
Wang Chen 已提交
2782
	return 0;
2783

T
Tom Goff 已提交
2784 2785 2786 2787
#ifdef CONFIG_IP_PIMSM_V2
add_proto_fail:
	unregister_netdevice_notifier(&ip_mr_notifier);
#endif
B
Benjamin Thery 已提交
2788
reg_notif_fail:
2789 2790
	unregister_pernet_subsys(&ipmr_net_ops);
reg_pernet_fail:
B
Benjamin Thery 已提交
2791
	kmem_cache_destroy(mrt_cachep);
W
Wang Chen 已提交
2792
	return err;
L
Linus Torvalds 已提交
2793
}