12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * IP multicast routing support for mrouted 3.6/3.8
41da177e4SLinus Torvalds *
5113aa838SAlan Cox * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
61da177e4SLinus Torvalds * Linux Consultancy and Custom Driver Development
71da177e4SLinus Torvalds *
81da177e4SLinus Torvalds * Fixes:
91da177e4SLinus Torvalds * Michael Chastain : Incorrect size of copying.
101da177e4SLinus Torvalds * Alan Cox : Added the cache manager code
111da177e4SLinus Torvalds * Alan Cox : Fixed the clone/copy bug and device race.
121da177e4SLinus Torvalds * Mike McLagan : Routing by source
131da177e4SLinus Torvalds * Malcolm Beattie : Buffer handling fixes.
141da177e4SLinus Torvalds * Alexey Kuznetsov : Double buffer free and other fixes.
151da177e4SLinus Torvalds * SVR Anand : Fixed several multicast bugs and problems.
161da177e4SLinus Torvalds * Alexey Kuznetsov : Status, optimisations and more.
171da177e4SLinus Torvalds * Brad Parker : Better behaviour on mrouted upcall
181da177e4SLinus Torvalds * overflow.
191da177e4SLinus Torvalds * Carlos Picoto : PIMv1 Support
201da177e4SLinus Torvalds * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
21f77f13e2SGilles Espinasse * Relax this requirement to work with older peers.
221da177e4SLinus Torvalds */
231da177e4SLinus Torvalds
247c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
251da177e4SLinus Torvalds #include <linux/types.h>
2608009a76SAlexey Dobriyan #include <linux/cache.h>
274fc268d2SRandy Dunlap #include <linux/capability.h>
281da177e4SLinus Torvalds #include <linux/errno.h>
291da177e4SLinus Torvalds #include <linux/mm.h>
301da177e4SLinus Torvalds #include <linux/kernel.h>
311da177e4SLinus Torvalds #include <linux/fcntl.h>
321da177e4SLinus Torvalds #include <linux/stat.h>
331da177e4SLinus Torvalds #include <linux/socket.h>
341da177e4SLinus Torvalds #include <linux/in.h>
351da177e4SLinus Torvalds #include <linux/inet.h>
361da177e4SLinus Torvalds #include <linux/netdevice.h>
371da177e4SLinus Torvalds #include <linux/inetdevice.h>
381da177e4SLinus Torvalds #include <linux/igmp.h>
391da177e4SLinus Torvalds #include <linux/proc_fs.h>
401da177e4SLinus Torvalds #include <linux/seq_file.h>
411da177e4SLinus Torvalds #include <linux/mroute.h>
421da177e4SLinus Torvalds #include <linux/init.h>
4346f25dffSKris Katterjohn #include <linux/if_ether.h>
445a0e3ad6STejun Heo #include <linux/slab.h>
45457c4cbcSEric W. Biederman #include <net/net_namespace.h>
461da177e4SLinus Torvalds #include <net/ip.h>
471da177e4SLinus Torvalds #include <net/protocol.h>
481da177e4SLinus Torvalds #include <linux/skbuff.h>
4914c85021SArnaldo Carvalho de Melo #include <net/route.h>
501da177e4SLinus Torvalds #include <net/icmp.h>
511da177e4SLinus Torvalds #include <net/udp.h>
521da177e4SLinus Torvalds #include <net/raw.h>
531da177e4SLinus Torvalds #include <linux/notifier.h>
541da177e4SLinus Torvalds #include <linux/if_arp.h>
551da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h>
56709b46e8SEric W. Biederman #include <linux/compat.h>
57bc3b2d7fSPaul Gortmaker #include <linux/export.h>
580eb71a9dSNeilBrown #include <linux/rhashtable.h>
59c5441932SPravin B Shelar #include <net/ip_tunnels.h>
601da177e4SLinus Torvalds #include <net/checksum.h>
61dc5fc579SArnaldo Carvalho de Melo #include <net/netlink.h>
62f0ad0860SPatrick McHardy #include <net/fib_rules.h>
63d67b8c61SNicolas Dichtel #include <linux/netconf.h>
643c618c1dSDavid Ahern #include <net/rtnh.h>
652bc9778bSIdo Schimmel #include <net/inet_dscp.h>
661da177e4SLinus Torvalds
675648451eSGustavo A. R. Silva #include <linux/nospec.h>
685648451eSGustavo A. R. Silva
69f0ad0860SPatrick McHardy struct ipmr_rule {
70f0ad0860SPatrick McHardy struct fib_rule common;
71f0ad0860SPatrick McHardy };
72f0ad0860SPatrick McHardy
73f0ad0860SPatrick McHardy struct ipmr_result {
74f0ad0860SPatrick McHardy struct mr_table *mrt;
75f0ad0860SPatrick McHardy };
76f0ad0860SPatrick McHardy
771da177e4SLinus Torvalds /* Big lock, protecting vif table, mrt cache and mroute socket state.
78a8cb16ddSEric Dumazet * Note that the changes are semaphored via rtnl_lock.
791da177e4SLinus Torvalds */
801da177e4SLinus Torvalds
813f55211eSEric Dumazet static DEFINE_SPINLOCK(mrt_lock);
821da177e4SLinus Torvalds
vif_dev_read(const struct vif_device * vif)83ebc31979SEric Dumazet static struct net_device *vif_dev_read(const struct vif_device *vif)
84ebc31979SEric Dumazet {
853f55211eSEric Dumazet return rcu_dereference(vif->dev);
86ebc31979SEric Dumazet }
87ebc31979SEric Dumazet
887ef8f65dSNikolay Aleksandrov /* Multicast router control variables */
891da177e4SLinus Torvalds
901da177e4SLinus Torvalds /* Special spinlock for queue of unresolved entries */
911da177e4SLinus Torvalds static DEFINE_SPINLOCK(mfc_unres_lock);
921da177e4SLinus Torvalds
931da177e4SLinus Torvalds /* We return to original Alan's scheme. Hash table of resolved
94a8cb16ddSEric Dumazet * entries is changed only in process context and protected
95a8cb16ddSEric Dumazet * with weak lock mrt_lock. Queue of unresolved entries is protected
96a8cb16ddSEric Dumazet * with strong spinlock mfc_unres_lock.
97a8cb16ddSEric Dumazet *
98a8cb16ddSEric Dumazet * In this case data path is free of exclusive locks at all.
991da177e4SLinus Torvalds */
1001da177e4SLinus Torvalds
10108009a76SAlexey Dobriyan static struct kmem_cache *mrt_cachep __ro_after_init;
1021da177e4SLinus Torvalds
103f0ad0860SPatrick McHardy static struct mr_table *ipmr_new_table(struct net *net, u32 id);
104acbb219dSFrancesco Ruggeri static void ipmr_free_table(struct mr_table *mrt);
105acbb219dSFrancesco Ruggeri
106c4854ec8SRami Rosen static void ip_mr_forward(struct net *net, struct mr_table *mrt,
1074b1f0d33SDonald Sharp struct net_device *dev, struct sk_buff *skb,
1084b1f0d33SDonald Sharp struct mfc_cache *cache, int local);
10964667988SEric Dumazet static int ipmr_cache_report(const struct mr_table *mrt,
1104feb88e5SBenjamin Thery struct sk_buff *pkt, vifi_t vifi, int assert);
1118cd3ac9fSNicolas Dichtel static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
1128cd3ac9fSNicolas Dichtel int cmd);
1130b490b51SEric Dumazet static void igmpmsg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt);
114ca8d4794SCallum Sinclair static void mroute_clean_tables(struct mr_table *mrt, int flags);
115e99e88a9SKees Cook static void ipmr_expire_process(struct timer_list *t);
1161da177e4SLinus Torvalds
117f0ad0860SPatrick McHardy #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
118f0ad0860SPatrick McHardy #define ipmr_for_each_table(mrt, net) \
119a14fbcd4SAmol Grover list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list, \
1207013908cSAmol Grover lockdep_rtnl_is_held() || \
1217013908cSAmol Grover list_empty(&net->ipv4.mr_tables))
122f0ad0860SPatrick McHardy
ipmr_mr_table_iter(struct net * net,struct mr_table * mrt)1237b0db857SYuval Mintz static struct mr_table *ipmr_mr_table_iter(struct net *net,
1247b0db857SYuval Mintz struct mr_table *mrt)
1257b0db857SYuval Mintz {
1267b0db857SYuval Mintz struct mr_table *ret;
1277b0db857SYuval Mintz
1287b0db857SYuval Mintz if (!mrt)
1297b0db857SYuval Mintz ret = list_entry_rcu(net->ipv4.mr_tables.next,
1307b0db857SYuval Mintz struct mr_table, list);
1317b0db857SYuval Mintz else
1327b0db857SYuval Mintz ret = list_entry_rcu(mrt->list.next,
1337b0db857SYuval Mintz struct mr_table, list);
1347b0db857SYuval Mintz
1357b0db857SYuval Mintz if (&ret->list == &net->ipv4.mr_tables)
1367b0db857SYuval Mintz return NULL;
1377b0db857SYuval Mintz return ret;
1387b0db857SYuval Mintz }
1397b0db857SYuval Mintz
ipmr_get_table(struct net * net,u32 id)140f0ad0860SPatrick McHardy static struct mr_table *ipmr_get_table(struct net *net, u32 id)
141f0ad0860SPatrick McHardy {
142f0ad0860SPatrick McHardy struct mr_table *mrt;
143f0ad0860SPatrick McHardy
144f0ad0860SPatrick McHardy ipmr_for_each_table(mrt, net) {
145f0ad0860SPatrick McHardy if (mrt->id == id)
146f0ad0860SPatrick McHardy return mrt;
147f0ad0860SPatrick McHardy }
148f0ad0860SPatrick McHardy return NULL;
149f0ad0860SPatrick McHardy }
150f0ad0860SPatrick McHardy
ipmr_fib_lookup(struct net * net,struct flowi4 * flp4,struct mr_table ** mrt)151da91981bSDavid S. Miller static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
152f0ad0860SPatrick McHardy struct mr_table **mrt)
153f0ad0860SPatrick McHardy {
154f0ad0860SPatrick McHardy int err;
15595f4a45dSHannes Frederic Sowa struct ipmr_result res;
15695f4a45dSHannes Frederic Sowa struct fib_lookup_arg arg = {
15795f4a45dSHannes Frederic Sowa .result = &res,
15895f4a45dSHannes Frederic Sowa .flags = FIB_LOOKUP_NOREF,
15995f4a45dSHannes Frederic Sowa };
160f0ad0860SPatrick McHardy
161e58e4159SDavid Ahern /* update flow if oif or iif point to device enslaved to l3mdev */
162e58e4159SDavid Ahern l3mdev_update_flow(net, flowi4_to_flowi(flp4));
163e58e4159SDavid Ahern
164da91981bSDavid S. Miller err = fib_rules_lookup(net->ipv4.mr_rules_ops,
165da91981bSDavid S. Miller flowi4_to_flowi(flp4), 0, &arg);
166f0ad0860SPatrick McHardy if (err < 0)
167f0ad0860SPatrick McHardy return err;
168f0ad0860SPatrick McHardy *mrt = res.mrt;
169f0ad0860SPatrick McHardy return 0;
170f0ad0860SPatrick McHardy }
171f0ad0860SPatrick McHardy
ipmr_rule_action(struct fib_rule * rule,struct flowi * flp,int flags,struct fib_lookup_arg * arg)172f0ad0860SPatrick McHardy static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
173f0ad0860SPatrick McHardy int flags, struct fib_lookup_arg *arg)
174f0ad0860SPatrick McHardy {
175f0ad0860SPatrick McHardy struct ipmr_result *res = arg->result;
176f0ad0860SPatrick McHardy struct mr_table *mrt;
177f0ad0860SPatrick McHardy
178f0ad0860SPatrick McHardy switch (rule->action) {
179f0ad0860SPatrick McHardy case FR_ACT_TO_TBL:
180f0ad0860SPatrick McHardy break;
181f0ad0860SPatrick McHardy case FR_ACT_UNREACHABLE:
182f0ad0860SPatrick McHardy return -ENETUNREACH;
183f0ad0860SPatrick McHardy case FR_ACT_PROHIBIT:
184f0ad0860SPatrick McHardy return -EACCES;
185f0ad0860SPatrick McHardy case FR_ACT_BLACKHOLE:
186f0ad0860SPatrick McHardy default:
187f0ad0860SPatrick McHardy return -EINVAL;
188f0ad0860SPatrick McHardy }
189f0ad0860SPatrick McHardy
190e58e4159SDavid Ahern arg->table = fib_rule_get_table(rule, arg);
191e58e4159SDavid Ahern
192e58e4159SDavid Ahern mrt = ipmr_get_table(rule->fr_net, arg->table);
19351456b29SIan Morris if (!mrt)
194f0ad0860SPatrick McHardy return -EAGAIN;
195f0ad0860SPatrick McHardy res->mrt = mrt;
196f0ad0860SPatrick McHardy return 0;
197f0ad0860SPatrick McHardy }
198f0ad0860SPatrick McHardy
ipmr_rule_match(struct fib_rule * rule,struct flowi * fl,int flags)199f0ad0860SPatrick McHardy static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
200f0ad0860SPatrick McHardy {
201f0ad0860SPatrick McHardy return 1;
202f0ad0860SPatrick McHardy }
203f0ad0860SPatrick McHardy
ipmr_rule_configure(struct fib_rule * rule,struct sk_buff * skb,struct fib_rule_hdr * frh,struct nlattr ** tb,struct netlink_ext_ack * extack)204f0ad0860SPatrick McHardy static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
205b16fb418SRoopa Prabhu struct fib_rule_hdr *frh, struct nlattr **tb,
206b16fb418SRoopa Prabhu struct netlink_ext_ack *extack)
207f0ad0860SPatrick McHardy {
208f0ad0860SPatrick McHardy return 0;
209f0ad0860SPatrick McHardy }
210f0ad0860SPatrick McHardy
ipmr_rule_compare(struct fib_rule * rule,struct fib_rule_hdr * frh,struct nlattr ** tb)211f0ad0860SPatrick McHardy static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
212f0ad0860SPatrick McHardy struct nlattr **tb)
213f0ad0860SPatrick McHardy {
214f0ad0860SPatrick McHardy return 1;
215f0ad0860SPatrick McHardy }
216f0ad0860SPatrick McHardy
ipmr_rule_fill(struct fib_rule * rule,struct sk_buff * skb,struct fib_rule_hdr * frh)217f0ad0860SPatrick McHardy static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
218f0ad0860SPatrick McHardy struct fib_rule_hdr *frh)
219f0ad0860SPatrick McHardy {
220f0ad0860SPatrick McHardy frh->dst_len = 0;
221f0ad0860SPatrick McHardy frh->src_len = 0;
222f0ad0860SPatrick McHardy frh->tos = 0;
223f0ad0860SPatrick McHardy return 0;
224f0ad0860SPatrick McHardy }
225f0ad0860SPatrick McHardy
22604a6f82cSAndi Kleen static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = {
22725239ceeSPatrick McHardy .family = RTNL_FAMILY_IPMR,
228f0ad0860SPatrick McHardy .rule_size = sizeof(struct ipmr_rule),
229f0ad0860SPatrick McHardy .addr_size = sizeof(u32),
230f0ad0860SPatrick McHardy .action = ipmr_rule_action,
231f0ad0860SPatrick McHardy .match = ipmr_rule_match,
232f0ad0860SPatrick McHardy .configure = ipmr_rule_configure,
233f0ad0860SPatrick McHardy .compare = ipmr_rule_compare,
234f0ad0860SPatrick McHardy .fill = ipmr_rule_fill,
235f0ad0860SPatrick McHardy .nlgroup = RTNLGRP_IPV4_RULE,
236f0ad0860SPatrick McHardy .owner = THIS_MODULE,
237f0ad0860SPatrick McHardy };
238f0ad0860SPatrick McHardy
ipmr_rules_init(struct net * net)239f0ad0860SPatrick McHardy static int __net_init ipmr_rules_init(struct net *net)
240f0ad0860SPatrick McHardy {
241f0ad0860SPatrick McHardy struct fib_rules_ops *ops;
242f0ad0860SPatrick McHardy struct mr_table *mrt;
243f0ad0860SPatrick McHardy int err;
244f0ad0860SPatrick McHardy
245f0ad0860SPatrick McHardy ops = fib_rules_register(&ipmr_rules_ops_template, net);
246f0ad0860SPatrick McHardy if (IS_ERR(ops))
247f0ad0860SPatrick McHardy return PTR_ERR(ops);
248f0ad0860SPatrick McHardy
249f0ad0860SPatrick McHardy INIT_LIST_HEAD(&net->ipv4.mr_tables);
250f0ad0860SPatrick McHardy
251f0ad0860SPatrick McHardy mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
2521113ebbcSNikolay Aleksandrov if (IS_ERR(mrt)) {
2531113ebbcSNikolay Aleksandrov err = PTR_ERR(mrt);
254f0ad0860SPatrick McHardy goto err1;
255f0ad0860SPatrick McHardy }
256f0ad0860SPatrick McHardy
257b4c1d4d9SZhengchao Shao err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT);
258f0ad0860SPatrick McHardy if (err < 0)
259f0ad0860SPatrick McHardy goto err2;
260f0ad0860SPatrick McHardy
261f0ad0860SPatrick McHardy net->ipv4.mr_rules_ops = ops;
262f0ad0860SPatrick McHardy return 0;
263f0ad0860SPatrick McHardy
264f0ad0860SPatrick McHardy err2:
2655611a006SEric Dumazet rtnl_lock();
266f243e5a7SWANG Cong ipmr_free_table(mrt);
2675611a006SEric Dumazet rtnl_unlock();
268f0ad0860SPatrick McHardy err1:
269f0ad0860SPatrick McHardy fib_rules_unregister(ops);
270f0ad0860SPatrick McHardy return err;
271f0ad0860SPatrick McHardy }
272f0ad0860SPatrick McHardy
ipmr_rules_exit(struct net * net)273f0ad0860SPatrick McHardy static void __net_exit ipmr_rules_exit(struct net *net)
274f0ad0860SPatrick McHardy {
275f0ad0860SPatrick McHardy struct mr_table *mrt, *next;
276f0ad0860SPatrick McHardy
277696e595fSEric Dumazet ASSERT_RTNL();
278035320d5SEric Dumazet list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
279035320d5SEric Dumazet list_del(&mrt->list);
280acbb219dSFrancesco Ruggeri ipmr_free_table(mrt);
281035320d5SEric Dumazet }
282f0ad0860SPatrick McHardy fib_rules_unregister(net->ipv4.mr_rules_ops);
283f0ad0860SPatrick McHardy }
2844d65b948SYotam Gigi
ipmr_rules_dump(struct net * net,struct notifier_block * nb,struct netlink_ext_ack * extack)285b7a59557SJiri Pirko static int ipmr_rules_dump(struct net *net, struct notifier_block *nb,
286b7a59557SJiri Pirko struct netlink_ext_ack *extack)
2874d65b948SYotam Gigi {
288b7a59557SJiri Pirko return fib_rules_dump(net, nb, RTNL_FAMILY_IPMR, extack);
2894d65b948SYotam Gigi }
2904d65b948SYotam Gigi
ipmr_rules_seq_read(struct net * net)2914d65b948SYotam Gigi static unsigned int ipmr_rules_seq_read(struct net *net)
2924d65b948SYotam Gigi {
2934d65b948SYotam Gigi return fib_rules_seq_read(net, RTNL_FAMILY_IPMR);
2944d65b948SYotam Gigi }
295478e4c2fSYotam Gigi
ipmr_rule_default(const struct fib_rule * rule)296478e4c2fSYotam Gigi bool ipmr_rule_default(const struct fib_rule *rule)
297478e4c2fSYotam Gigi {
298478e4c2fSYotam Gigi return fib_rule_matchall(rule) && rule->table == RT_TABLE_DEFAULT;
299478e4c2fSYotam Gigi }
300478e4c2fSYotam Gigi EXPORT_SYMBOL(ipmr_rule_default);
301f0ad0860SPatrick McHardy #else
302f0ad0860SPatrick McHardy #define ipmr_for_each_table(mrt, net) \
303f0ad0860SPatrick McHardy for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
304f0ad0860SPatrick McHardy
ipmr_mr_table_iter(struct net * net,struct mr_table * mrt)3057b0db857SYuval Mintz static struct mr_table *ipmr_mr_table_iter(struct net *net,
3067b0db857SYuval Mintz struct mr_table *mrt)
3077b0db857SYuval Mintz {
3087b0db857SYuval Mintz if (!mrt)
3097b0db857SYuval Mintz return net->ipv4.mrt;
3107b0db857SYuval Mintz return NULL;
3117b0db857SYuval Mintz }
3127b0db857SYuval Mintz
ipmr_get_table(struct net * net,u32 id)313f0ad0860SPatrick McHardy static struct mr_table *ipmr_get_table(struct net *net, u32 id)
314f0ad0860SPatrick McHardy {
315f0ad0860SPatrick McHardy return net->ipv4.mrt;
316f0ad0860SPatrick McHardy }
317f0ad0860SPatrick McHardy
ipmr_fib_lookup(struct net * net,struct flowi4 * flp4,struct mr_table ** mrt)318da91981bSDavid S. Miller static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
319f0ad0860SPatrick McHardy struct mr_table **mrt)
320f0ad0860SPatrick McHardy {
321f0ad0860SPatrick McHardy *mrt = net->ipv4.mrt;
322f0ad0860SPatrick McHardy return 0;
323f0ad0860SPatrick McHardy }
324f0ad0860SPatrick McHardy
ipmr_rules_init(struct net * net)325f0ad0860SPatrick McHardy static int __net_init ipmr_rules_init(struct net *net)
326f0ad0860SPatrick McHardy {
3271113ebbcSNikolay Aleksandrov struct mr_table *mrt;
3281113ebbcSNikolay Aleksandrov
3291113ebbcSNikolay Aleksandrov mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
3301113ebbcSNikolay Aleksandrov if (IS_ERR(mrt))
3311113ebbcSNikolay Aleksandrov return PTR_ERR(mrt);
3321113ebbcSNikolay Aleksandrov net->ipv4.mrt = mrt;
3331113ebbcSNikolay Aleksandrov return 0;
334f0ad0860SPatrick McHardy }
335f0ad0860SPatrick McHardy
ipmr_rules_exit(struct net * net)336f0ad0860SPatrick McHardy static void __net_exit ipmr_rules_exit(struct net *net)
337f0ad0860SPatrick McHardy {
338696e595fSEric Dumazet ASSERT_RTNL();
339acbb219dSFrancesco Ruggeri ipmr_free_table(net->ipv4.mrt);
340ed785309SWANG Cong net->ipv4.mrt = NULL;
341f0ad0860SPatrick McHardy }
3424d65b948SYotam Gigi
ipmr_rules_dump(struct net * net,struct notifier_block * nb,struct netlink_ext_ack * extack)343b7a59557SJiri Pirko static int ipmr_rules_dump(struct net *net, struct notifier_block *nb,
344b7a59557SJiri Pirko struct netlink_ext_ack *extack)
3454d65b948SYotam Gigi {
3464d65b948SYotam Gigi return 0;
3474d65b948SYotam Gigi }
3484d65b948SYotam Gigi
ipmr_rules_seq_read(struct net * net)3494d65b948SYotam Gigi static unsigned int ipmr_rules_seq_read(struct net *net)
3504d65b948SYotam Gigi {
3514d65b948SYotam Gigi return 0;
3524d65b948SYotam Gigi }
353478e4c2fSYotam Gigi
ipmr_rule_default(const struct fib_rule * rule)354478e4c2fSYotam Gigi bool ipmr_rule_default(const struct fib_rule *rule)
355478e4c2fSYotam Gigi {
356478e4c2fSYotam Gigi return true;
357478e4c2fSYotam Gigi }
358478e4c2fSYotam Gigi EXPORT_SYMBOL(ipmr_rule_default);
359f0ad0860SPatrick McHardy #endif
360f0ad0860SPatrick McHardy
ipmr_hash_cmp(struct rhashtable_compare_arg * arg,const void * ptr)3618fb472c0SNikolay Aleksandrov static inline int ipmr_hash_cmp(struct rhashtable_compare_arg *arg,
3628fb472c0SNikolay Aleksandrov const void *ptr)
3638fb472c0SNikolay Aleksandrov {
3648fb472c0SNikolay Aleksandrov const struct mfc_cache_cmp_arg *cmparg = arg->key;
3652e47eeceSYu Zhe const struct mfc_cache *c = ptr;
3668fb472c0SNikolay Aleksandrov
3678fb472c0SNikolay Aleksandrov return cmparg->mfc_mcastgrp != c->mfc_mcastgrp ||
3688fb472c0SNikolay Aleksandrov cmparg->mfc_origin != c->mfc_origin;
3698fb472c0SNikolay Aleksandrov }
3708fb472c0SNikolay Aleksandrov
3718fb472c0SNikolay Aleksandrov static const struct rhashtable_params ipmr_rht_params = {
372494fff56SYuval Mintz .head_offset = offsetof(struct mr_mfc, mnode),
3738fb472c0SNikolay Aleksandrov .key_offset = offsetof(struct mfc_cache, cmparg),
3748fb472c0SNikolay Aleksandrov .key_len = sizeof(struct mfc_cache_cmp_arg),
3758fb472c0SNikolay Aleksandrov .nelem_hint = 3,
3768fb472c0SNikolay Aleksandrov .obj_cmpfn = ipmr_hash_cmp,
3778fb472c0SNikolay Aleksandrov .automatic_shrinking = true,
3788fb472c0SNikolay Aleksandrov };
3798fb472c0SNikolay Aleksandrov
ipmr_new_table_set(struct mr_table * mrt,struct net * net)3800bbbf0e7SYuval Mintz static void ipmr_new_table_set(struct mr_table *mrt,
3810bbbf0e7SYuval Mintz struct net *net)
3820bbbf0e7SYuval Mintz {
3830bbbf0e7SYuval Mintz #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
3840bbbf0e7SYuval Mintz list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
3850bbbf0e7SYuval Mintz #endif
3860bbbf0e7SYuval Mintz }
3870bbbf0e7SYuval Mintz
388845c9a7aSYuval Mintz static struct mfc_cache_cmp_arg ipmr_mr_table_ops_cmparg_any = {
389845c9a7aSYuval Mintz .mfc_mcastgrp = htonl(INADDR_ANY),
390845c9a7aSYuval Mintz .mfc_origin = htonl(INADDR_ANY),
391845c9a7aSYuval Mintz };
392845c9a7aSYuval Mintz
393845c9a7aSYuval Mintz static struct mr_table_ops ipmr_mr_table_ops = {
394845c9a7aSYuval Mintz .rht_params = &ipmr_rht_params,
395845c9a7aSYuval Mintz .cmparg_any = &ipmr_mr_table_ops_cmparg_any,
396845c9a7aSYuval Mintz };
397845c9a7aSYuval Mintz
ipmr_new_table(struct net * net,u32 id)398f0ad0860SPatrick McHardy static struct mr_table *ipmr_new_table(struct net *net, u32 id)
399f0ad0860SPatrick McHardy {
400f0ad0860SPatrick McHardy struct mr_table *mrt;
401f0ad0860SPatrick McHardy
4021113ebbcSNikolay Aleksandrov /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
4031113ebbcSNikolay Aleksandrov if (id != RT_TABLE_DEFAULT && id >= 1000000000)
4041113ebbcSNikolay Aleksandrov return ERR_PTR(-EINVAL);
4051113ebbcSNikolay Aleksandrov
406f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, id);
40700db4124SIan Morris if (mrt)
408f0ad0860SPatrick McHardy return mrt;
409f0ad0860SPatrick McHardy
410845c9a7aSYuval Mintz return mr_table_alloc(net, id, &ipmr_mr_table_ops,
4110bbbf0e7SYuval Mintz ipmr_expire_process, ipmr_new_table_set);
412f0ad0860SPatrick McHardy }
4131da177e4SLinus Torvalds
ipmr_free_table(struct mr_table * mrt)414acbb219dSFrancesco Ruggeri static void ipmr_free_table(struct mr_table *mrt)
415acbb219dSFrancesco Ruggeri {
416292a089dSSteven Rostedt (Google) timer_shutdown_sync(&mrt->ipmr_expire_timer);
417ca8d4794SCallum Sinclair mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC |
418ca8d4794SCallum Sinclair MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC);
4198fb472c0SNikolay Aleksandrov rhltable_destroy(&mrt->mfc_hash);
420acbb219dSFrancesco Ruggeri kfree(mrt);
421acbb219dSFrancesco Ruggeri }
422acbb219dSFrancesco Ruggeri
4231da177e4SLinus Torvalds /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
4241da177e4SLinus Torvalds
425a0b47736SNikolay Aleksandrov /* Initialize ipmr pimreg/tunnel in_device */
ipmr_init_vif_indev(const struct net_device * dev)426a0b47736SNikolay Aleksandrov static bool ipmr_init_vif_indev(const struct net_device *dev)
427a0b47736SNikolay Aleksandrov {
428a0b47736SNikolay Aleksandrov struct in_device *in_dev;
429a0b47736SNikolay Aleksandrov
430a0b47736SNikolay Aleksandrov ASSERT_RTNL();
431a0b47736SNikolay Aleksandrov
432a0b47736SNikolay Aleksandrov in_dev = __in_dev_get_rtnl(dev);
433a0b47736SNikolay Aleksandrov if (!in_dev)
434a0b47736SNikolay Aleksandrov return false;
435a0b47736SNikolay Aleksandrov ipv4_devconf_setall(in_dev);
436a0b47736SNikolay Aleksandrov neigh_parms_data_state_setall(in_dev->arp_parms);
437a0b47736SNikolay Aleksandrov IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
438a0b47736SNikolay Aleksandrov
439a0b47736SNikolay Aleksandrov return true;
440a0b47736SNikolay Aleksandrov }
441a0b47736SNikolay Aleksandrov
ipmr_new_tunnel(struct net * net,struct vifctl * v)4427ef8f65dSNikolay Aleksandrov static struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
4431da177e4SLinus Torvalds {
444c384b8a7SChristoph Hellwig struct net_device *tunnel_dev, *new_dev;
445117aef12SAlexander Lobakin struct ip_tunnel_parm_kern p = { };
446c384b8a7SChristoph Hellwig int err;
4471da177e4SLinus Torvalds
448c384b8a7SChristoph Hellwig tunnel_dev = __dev_get_by_name(net, "tunl0");
449c384b8a7SChristoph Hellwig if (!tunnel_dev)
450c384b8a7SChristoph Hellwig goto out;
451c384b8a7SChristoph Hellwig
4521da177e4SLinus Torvalds p.iph.daddr = v->vifc_rmt_addr.s_addr;
4531da177e4SLinus Torvalds p.iph.saddr = v->vifc_lcl_addr.s_addr;
4541da177e4SLinus Torvalds p.iph.version = 4;
4551da177e4SLinus Torvalds p.iph.ihl = 5;
4561da177e4SLinus Torvalds p.iph.protocol = IPPROTO_IPIP;
4571da177e4SLinus Torvalds sprintf(p.name, "dvmrp%d", v->vifc_vifi);
4581da177e4SLinus Torvalds
459c7e36705SChristoph Hellwig if (!tunnel_dev->netdev_ops->ndo_tunnel_ctl)
460c384b8a7SChristoph Hellwig goto out;
461c7e36705SChristoph Hellwig err = tunnel_dev->netdev_ops->ndo_tunnel_ctl(tunnel_dev, &p,
462c384b8a7SChristoph Hellwig SIOCADDTUNNEL);
463c384b8a7SChristoph Hellwig if (err)
464c384b8a7SChristoph Hellwig goto out;
4651da177e4SLinus Torvalds
466c384b8a7SChristoph Hellwig new_dev = __dev_get_by_name(net, p.name);
467c384b8a7SChristoph Hellwig if (!new_dev)
468c384b8a7SChristoph Hellwig goto out;
4691da177e4SLinus Torvalds
470c384b8a7SChristoph Hellwig new_dev->flags |= IFF_MULTICAST;
471c384b8a7SChristoph Hellwig if (!ipmr_init_vif_indev(new_dev))
472c384b8a7SChristoph Hellwig goto out_unregister;
473c384b8a7SChristoph Hellwig if (dev_open(new_dev, NULL))
474c384b8a7SChristoph Hellwig goto out_unregister;
475c384b8a7SChristoph Hellwig dev_hold(new_dev);
476c1fd1182SChristoph Hellwig err = dev_set_allmulti(new_dev, 1);
477c1fd1182SChristoph Hellwig if (err) {
478c1fd1182SChristoph Hellwig dev_close(new_dev);
479c7e36705SChristoph Hellwig tunnel_dev->netdev_ops->ndo_tunnel_ctl(tunnel_dev, &p,
480c1fd1182SChristoph Hellwig SIOCDELTUNNEL);
481c1fd1182SChristoph Hellwig dev_put(new_dev);
482c1fd1182SChristoph Hellwig new_dev = ERR_PTR(err);
483c1fd1182SChristoph Hellwig }
484c384b8a7SChristoph Hellwig return new_dev;
485c384b8a7SChristoph Hellwig
486c384b8a7SChristoph Hellwig out_unregister:
487c384b8a7SChristoph Hellwig unregister_netdevice(new_dev);
488c384b8a7SChristoph Hellwig out:
489c1fd1182SChristoph Hellwig return ERR_PTR(-ENOBUFS);
4901da177e4SLinus Torvalds }
4911da177e4SLinus Torvalds
492c316c629SNikolay Aleksandrov #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
reg_vif_xmit(struct sk_buff * skb,struct net_device * dev)4936fef4c0cSStephen Hemminger static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
4941da177e4SLinus Torvalds {
4954feb88e5SBenjamin Thery struct net *net = dev_net(dev);
496f0ad0860SPatrick McHardy struct mr_table *mrt;
497da91981bSDavid S. Miller struct flowi4 fl4 = {
498da91981bSDavid S. Miller .flowi4_oif = dev->ifindex,
4996a662719SCong Wang .flowi4_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
500da91981bSDavid S. Miller .flowi4_mark = skb->mark,
501f0ad0860SPatrick McHardy };
502f0ad0860SPatrick McHardy int err;
503f0ad0860SPatrick McHardy
504da91981bSDavid S. Miller err = ipmr_fib_lookup(net, &fl4, &mrt);
505e40dbc51SBen Greear if (err < 0) {
506e40dbc51SBen Greear kfree_skb(skb);
507f0ad0860SPatrick McHardy return err;
508e40dbc51SBen Greear }
5094feb88e5SBenjamin Thery
510c4794d22SEric Dumazet DEV_STATS_ADD(dev, tx_bytes, skb->len);
511c4794d22SEric Dumazet DEV_STATS_INC(dev, tx_packets);
51264667988SEric Dumazet rcu_read_lock();
51364667988SEric Dumazet
51464667988SEric Dumazet /* Pairs with WRITE_ONCE() in vif_add() and vif_delete() */
51564667988SEric Dumazet ipmr_cache_report(mrt, skb, READ_ONCE(mrt->mroute_reg_vif_num),
51664667988SEric Dumazet IGMPMSG_WHOLEPKT);
51764667988SEric Dumazet
51864667988SEric Dumazet rcu_read_unlock();
5191da177e4SLinus Torvalds kfree_skb(skb);
5206ed10654SPatrick McHardy return NETDEV_TX_OK;
5211da177e4SLinus Torvalds }
5221da177e4SLinus Torvalds
reg_vif_get_iflink(const struct net_device * dev)523ee9b9596SNicolas Dichtel static int reg_vif_get_iflink(const struct net_device *dev)
524ee9b9596SNicolas Dichtel {
525ee9b9596SNicolas Dichtel return 0;
526ee9b9596SNicolas Dichtel }
527ee9b9596SNicolas Dichtel
528007c3838SStephen Hemminger static const struct net_device_ops reg_vif_netdev_ops = {
529007c3838SStephen Hemminger .ndo_start_xmit = reg_vif_xmit,
530ee9b9596SNicolas Dichtel .ndo_get_iflink = reg_vif_get_iflink,
531007c3838SStephen Hemminger };
532007c3838SStephen Hemminger
reg_vif_setup(struct net_device * dev)5331da177e4SLinus Torvalds static void reg_vif_setup(struct net_device *dev)
5341da177e4SLinus Torvalds {
5351da177e4SLinus Torvalds dev->type = ARPHRD_PIMREG;
53646f25dffSKris Katterjohn dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
5371da177e4SLinus Torvalds dev->flags = IFF_NOARP;
53870cb4a45SHimangi Saraogi dev->netdev_ops = ®_vif_netdev_ops;
539cf124db5SDavid S. Miller dev->needs_free_netdev = true;
54005c1280aSAlexander Lobakin dev->netns_local = true;
5411da177e4SLinus Torvalds }
5421da177e4SLinus Torvalds
ipmr_reg_vif(struct net * net,struct mr_table * mrt)543f0ad0860SPatrick McHardy static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
5441da177e4SLinus Torvalds {
5451da177e4SLinus Torvalds struct net_device *dev;
546f0ad0860SPatrick McHardy char name[IFNAMSIZ];
5471da177e4SLinus Torvalds
548f0ad0860SPatrick McHardy if (mrt->id == RT_TABLE_DEFAULT)
549f0ad0860SPatrick McHardy sprintf(name, "pimreg");
550f0ad0860SPatrick McHardy else
551f0ad0860SPatrick McHardy sprintf(name, "pimreg%u", mrt->id);
552f0ad0860SPatrick McHardy
553c835a677STom Gundersen dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
5541da177e4SLinus Torvalds
55551456b29SIan Morris if (!dev)
5561da177e4SLinus Torvalds return NULL;
5571da177e4SLinus Torvalds
558403dbb97STom Goff dev_net_set(dev, net);
559403dbb97STom Goff
5601da177e4SLinus Torvalds if (register_netdevice(dev)) {
5611da177e4SLinus Torvalds free_netdev(dev);
5621da177e4SLinus Torvalds return NULL;
5631da177e4SLinus Torvalds }
5641da177e4SLinus Torvalds
565a0b47736SNikolay Aleksandrov if (!ipmr_init_vif_indev(dev))
5661da177e4SLinus Torvalds goto failure;
56700f54e68SPetr Machata if (dev_open(dev, NULL))
5681da177e4SLinus Torvalds goto failure;
5691da177e4SLinus Torvalds
5707dc00c82SWang Chen dev_hold(dev);
5717dc00c82SWang Chen
5721da177e4SLinus Torvalds return dev;
5731da177e4SLinus Torvalds
5741da177e4SLinus Torvalds failure:
5751da177e4SLinus Torvalds unregister_netdevice(dev);
5761da177e4SLinus Torvalds return NULL;
5771da177e4SLinus Torvalds }
578c316c629SNikolay Aleksandrov
579c316c629SNikolay Aleksandrov /* called with rcu_read_lock() */
__pim_rcv(struct mr_table * mrt,struct sk_buff * skb,unsigned int pimlen)580c316c629SNikolay Aleksandrov static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
581c316c629SNikolay Aleksandrov unsigned int pimlen)
582c316c629SNikolay Aleksandrov {
583c316c629SNikolay Aleksandrov struct net_device *reg_dev = NULL;
584c316c629SNikolay Aleksandrov struct iphdr *encap;
585121fefc6SEric Dumazet int vif_num;
586c316c629SNikolay Aleksandrov
587c316c629SNikolay Aleksandrov encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
5887ef8f65dSNikolay Aleksandrov /* Check that:
589c316c629SNikolay Aleksandrov * a. packet is really sent to a multicast group
590c316c629SNikolay Aleksandrov * b. packet is not a NULL-REGISTER
591c316c629SNikolay Aleksandrov * c. packet is not truncated
592c316c629SNikolay Aleksandrov */
593c316c629SNikolay Aleksandrov if (!ipv4_is_multicast(encap->daddr) ||
594c316c629SNikolay Aleksandrov encap->tot_len == 0 ||
595c316c629SNikolay Aleksandrov ntohs(encap->tot_len) + pimlen > skb->len)
596c316c629SNikolay Aleksandrov return 1;
597c316c629SNikolay Aleksandrov
598121fefc6SEric Dumazet /* Pairs with WRITE_ONCE() in vif_add()/vid_delete() */
599121fefc6SEric Dumazet vif_num = READ_ONCE(mrt->mroute_reg_vif_num);
600121fefc6SEric Dumazet if (vif_num >= 0)
601121fefc6SEric Dumazet reg_dev = vif_dev_read(&mrt->vif_table[vif_num]);
602c316c629SNikolay Aleksandrov if (!reg_dev)
603c316c629SNikolay Aleksandrov return 1;
604c316c629SNikolay Aleksandrov
605c316c629SNikolay Aleksandrov skb->mac_header = skb->network_header;
606c316c629SNikolay Aleksandrov skb_pull(skb, (u8 *)encap - skb->data);
607c316c629SNikolay Aleksandrov skb_reset_network_header(skb);
608c316c629SNikolay Aleksandrov skb->protocol = htons(ETH_P_IP);
609c316c629SNikolay Aleksandrov skb->ip_summed = CHECKSUM_NONE;
610c316c629SNikolay Aleksandrov
611c316c629SNikolay Aleksandrov skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
612c316c629SNikolay Aleksandrov
613c316c629SNikolay Aleksandrov netif_rx(skb);
614c316c629SNikolay Aleksandrov
615c316c629SNikolay Aleksandrov return NET_RX_SUCCESS;
616c316c629SNikolay Aleksandrov }
617c316c629SNikolay Aleksandrov #else
ipmr_reg_vif(struct net * net,struct mr_table * mrt)618c316c629SNikolay Aleksandrov static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
619c316c629SNikolay Aleksandrov {
620c316c629SNikolay Aleksandrov return NULL;
621c316c629SNikolay Aleksandrov }
6221da177e4SLinus Torvalds #endif
6231da177e4SLinus Torvalds
call_ipmr_vif_entry_notifiers(struct net * net,enum fib_event_type event_type,struct vif_device * vif,struct net_device * vif_dev,vifi_t vif_index,u32 tb_id)624b362053aSYotam Gigi static int call_ipmr_vif_entry_notifiers(struct net *net,
625b362053aSYotam Gigi enum fib_event_type event_type,
626b362053aSYotam Gigi struct vif_device *vif,
627ebc31979SEric Dumazet struct net_device *vif_dev,
628b362053aSYotam Gigi vifi_t vif_index, u32 tb_id)
629b362053aSYotam Gigi {
630bc67a0daSYuval Mintz return mr_call_vif_notifiers(net, RTNL_FAMILY_IPMR, event_type,
631ebc31979SEric Dumazet vif, vif_dev, vif_index, tb_id,
632bc67a0daSYuval Mintz &net->ipv4.ipmr_seq);
633b362053aSYotam Gigi }
634b362053aSYotam Gigi
call_ipmr_mfc_entry_notifiers(struct net * net,enum fib_event_type event_type,struct mfc_cache * mfc,u32 tb_id)635b362053aSYotam Gigi static int call_ipmr_mfc_entry_notifiers(struct net *net,
636b362053aSYotam Gigi enum fib_event_type event_type,
637b362053aSYotam Gigi struct mfc_cache *mfc, u32 tb_id)
638b362053aSYotam Gigi {
63954c4cad9SYuval Mintz return mr_call_mfc_notifiers(net, RTNL_FAMILY_IPMR, event_type,
64054c4cad9SYuval Mintz &mfc->_c, tb_id, &net->ipv4.ipmr_seq);
641b362053aSYotam Gigi }
642b362053aSYotam Gigi
6432c53040fSBen Hutchings /**
6442c53040fSBen Hutchings * vif_delete - Delete a VIF entry
6453628e3cbSAndrew Lunn * @mrt: Table to delete from
6463628e3cbSAndrew Lunn * @vifi: VIF identifier to delete
6477dc00c82SWang Chen * @notify: Set to 1, if the caller is a notifier_call
6483628e3cbSAndrew Lunn * @head: if unregistering the VIF, place it on this queue
6491da177e4SLinus Torvalds */
vif_delete(struct mr_table * mrt,int vifi,int notify,struct list_head * head)6500c12295aSPatrick McHardy static int vif_delete(struct mr_table *mrt, int vifi, int notify,
651d17fa6faSEric Dumazet struct list_head *head)
6521da177e4SLinus Torvalds {
653b362053aSYotam Gigi struct net *net = read_pnet(&mrt->net);
6541da177e4SLinus Torvalds struct vif_device *v;
6551da177e4SLinus Torvalds struct net_device *dev;
6561da177e4SLinus Torvalds struct in_device *in_dev;
6571da177e4SLinus Torvalds
6580c12295aSPatrick McHardy if (vifi < 0 || vifi >= mrt->maxvif)
6591da177e4SLinus Torvalds return -EADDRNOTAVAIL;
6601da177e4SLinus Torvalds
6610c12295aSPatrick McHardy v = &mrt->vif_table[vifi];
6621da177e4SLinus Torvalds
663ebc31979SEric Dumazet dev = rtnl_dereference(v->dev);
664ebc31979SEric Dumazet if (!dev)
665ebc31979SEric Dumazet return -EADDRNOTAVAIL;
666b362053aSYotam Gigi
6673f55211eSEric Dumazet spin_lock(&mrt_lock);
668ebc31979SEric Dumazet call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_DEL, v, dev,
669ebc31979SEric Dumazet vifi, mrt->id);
670ebc31979SEric Dumazet RCU_INIT_POINTER(v->dev, NULL);
6711da177e4SLinus Torvalds
67264667988SEric Dumazet if (vifi == mrt->mroute_reg_vif_num) {
67364667988SEric Dumazet /* Pairs with READ_ONCE() in ipmr_cache_report() and reg_vif_xmit() */
67464667988SEric Dumazet WRITE_ONCE(mrt->mroute_reg_vif_num, -1);
67564667988SEric Dumazet }
6760c12295aSPatrick McHardy if (vifi + 1 == mrt->maxvif) {
6771da177e4SLinus Torvalds int tmp;
678a8cb16ddSEric Dumazet
6791da177e4SLinus Torvalds for (tmp = vifi - 1; tmp >= 0; tmp--) {
6800c12295aSPatrick McHardy if (VIF_EXISTS(mrt, tmp))
6811da177e4SLinus Torvalds break;
6821da177e4SLinus Torvalds }
6839094db4bSEric Dumazet WRITE_ONCE(mrt->maxvif, tmp + 1);
6841da177e4SLinus Torvalds }
6851da177e4SLinus Torvalds
6863f55211eSEric Dumazet spin_unlock(&mrt_lock);
6871da177e4SLinus Torvalds
6881da177e4SLinus Torvalds dev_set_allmulti(dev, -1);
6891da177e4SLinus Torvalds
690a8cb16ddSEric Dumazet in_dev = __in_dev_get_rtnl(dev);
691a8cb16ddSEric Dumazet if (in_dev) {
69242f811b8SHerbert Xu IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
6933b022865SDavid Ahern inet_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
694d67b8c61SNicolas Dichtel NETCONFA_MC_FORWARDING,
695d67b8c61SNicolas Dichtel dev->ifindex, &in_dev->cnf);
6961da177e4SLinus Torvalds ip_rt_multicast_event(in_dev);
6971da177e4SLinus Torvalds }
6981da177e4SLinus Torvalds
6997dc00c82SWang Chen if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
700d17fa6faSEric Dumazet unregister_netdevice_queue(dev, head);
7011da177e4SLinus Torvalds
702d62607c3SJakub Kicinski netdev_put(dev, &v->dev_tracker);
7031da177e4SLinus Torvalds return 0;
7041da177e4SLinus Torvalds }
7051da177e4SLinus Torvalds
ipmr_cache_free_rcu(struct rcu_head * head)706a8c9486bSEric Dumazet static void ipmr_cache_free_rcu(struct rcu_head *head)
707a8c9486bSEric Dumazet {
708494fff56SYuval Mintz struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
709a8c9486bSEric Dumazet
710494fff56SYuval Mintz kmem_cache_free(mrt_cachep, (struct mfc_cache *)c);
711a8c9486bSEric Dumazet }
712a8c9486bSEric Dumazet
ipmr_cache_free(struct mfc_cache * c)7138c13af2aSYuval Mintz static void ipmr_cache_free(struct mfc_cache *c)
7145c0a66f5SBenjamin Thery {
715494fff56SYuval Mintz call_rcu(&c->_c.rcu, ipmr_cache_free_rcu);
7165c0a66f5SBenjamin Thery }
7175c0a66f5SBenjamin Thery
7181da177e4SLinus Torvalds /* Destroy an unresolved cache entry, killing queued skbs
719a8cb16ddSEric Dumazet * and reporting error to netlink readers.
7201da177e4SLinus Torvalds */
ipmr_destroy_unres(struct mr_table * mrt,struct mfc_cache * c)7210c12295aSPatrick McHardy static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
7221da177e4SLinus Torvalds {
7238de53dfbSPatrick McHardy struct net *net = read_pnet(&mrt->net);
7241da177e4SLinus Torvalds struct sk_buff *skb;
7259ef1d4c7SPatrick McHardy struct nlmsgerr *e;
7261da177e4SLinus Torvalds
7270c12295aSPatrick McHardy atomic_dec(&mrt->cache_resolve_queue_len);
7281da177e4SLinus Torvalds
729494fff56SYuval Mintz while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved))) {
730eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->version == 0) {
731af72868bSJohannes Berg struct nlmsghdr *nlh = skb_pull(skb,
732af72868bSJohannes Berg sizeof(struct iphdr));
7331da177e4SLinus Torvalds nlh->nlmsg_type = NLMSG_ERROR;
734573ce260SHong zhi guo nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
7351da177e4SLinus Torvalds skb_trim(skb, nlh->nlmsg_len);
736573ce260SHong zhi guo e = nlmsg_data(nlh);
7379ef1d4c7SPatrick McHardy e->error = -ETIMEDOUT;
7389ef1d4c7SPatrick McHardy memset(&e->msg, 0, sizeof(e->msg));
7392942e900SThomas Graf
74015e47304SEric W. Biederman rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
741a8cb16ddSEric Dumazet } else {
7421da177e4SLinus Torvalds kfree_skb(skb);
7431da177e4SLinus Torvalds }
744a8cb16ddSEric Dumazet }
7451da177e4SLinus Torvalds
7465c0a66f5SBenjamin Thery ipmr_cache_free(c);
7471da177e4SLinus Torvalds }
7481da177e4SLinus Torvalds
749e258beb2SPatrick McHardy /* Timer process for the unresolved queue. */
ipmr_expire_process(struct timer_list * t)750e99e88a9SKees Cook static void ipmr_expire_process(struct timer_list *t)
7511da177e4SLinus Torvalds {
752e99e88a9SKees Cook struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
753494fff56SYuval Mintz struct mr_mfc *c, *next;
7541da177e4SLinus Torvalds unsigned long expires;
755494fff56SYuval Mintz unsigned long now;
7561da177e4SLinus Torvalds
7571da177e4SLinus Torvalds if (!spin_trylock(&mfc_unres_lock)) {
7580c12295aSPatrick McHardy mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
7591da177e4SLinus Torvalds return;
7601da177e4SLinus Torvalds }
7611da177e4SLinus Torvalds
7620c12295aSPatrick McHardy if (list_empty(&mrt->mfc_unres_queue))
7631da177e4SLinus Torvalds goto out;
7641da177e4SLinus Torvalds
7651da177e4SLinus Torvalds now = jiffies;
7661da177e4SLinus Torvalds expires = 10*HZ;
7671da177e4SLinus Torvalds
7680c12295aSPatrick McHardy list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
7691da177e4SLinus Torvalds if (time_after(c->mfc_un.unres.expires, now)) {
7701da177e4SLinus Torvalds unsigned long interval = c->mfc_un.unres.expires - now;
7711da177e4SLinus Torvalds if (interval < expires)
7721da177e4SLinus Torvalds expires = interval;
7731da177e4SLinus Torvalds continue;
7741da177e4SLinus Torvalds }
7751da177e4SLinus Torvalds
776862465f2SPatrick McHardy list_del(&c->list);
777494fff56SYuval Mintz mroute_netlink_event(mrt, (struct mfc_cache *)c, RTM_DELROUTE);
778494fff56SYuval Mintz ipmr_destroy_unres(mrt, (struct mfc_cache *)c);
7791da177e4SLinus Torvalds }
7801da177e4SLinus Torvalds
7810c12295aSPatrick McHardy if (!list_empty(&mrt->mfc_unres_queue))
7820c12295aSPatrick McHardy mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
7831da177e4SLinus Torvalds
7841da177e4SLinus Torvalds out:
7851da177e4SLinus Torvalds spin_unlock(&mfc_unres_lock);
7861da177e4SLinus Torvalds }
7871da177e4SLinus Torvalds
7883f55211eSEric Dumazet /* Fill oifs list. It is called under locked mrt_lock. */
ipmr_update_thresholds(struct mr_table * mrt,struct mr_mfc * cache,unsigned char * ttls)789494fff56SYuval Mintz static void ipmr_update_thresholds(struct mr_table *mrt, struct mr_mfc *cache,
790d658f8a0SPatrick McHardy unsigned char *ttls)
7911da177e4SLinus Torvalds {
7921da177e4SLinus Torvalds int vifi;
7931da177e4SLinus Torvalds
7941da177e4SLinus Torvalds cache->mfc_un.res.minvif = MAXVIFS;
7951da177e4SLinus Torvalds cache->mfc_un.res.maxvif = 0;
7961da177e4SLinus Torvalds memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
7971da177e4SLinus Torvalds
7980c12295aSPatrick McHardy for (vifi = 0; vifi < mrt->maxvif; vifi++) {
7990c12295aSPatrick McHardy if (VIF_EXISTS(mrt, vifi) &&
800cf958ae3SBenjamin Thery ttls[vifi] && ttls[vifi] < 255) {
8011da177e4SLinus Torvalds cache->mfc_un.res.ttls[vifi] = ttls[vifi];
8021da177e4SLinus Torvalds if (cache->mfc_un.res.minvif > vifi)
8031da177e4SLinus Torvalds cache->mfc_un.res.minvif = vifi;
8041da177e4SLinus Torvalds if (cache->mfc_un.res.maxvif <= vifi)
8051da177e4SLinus Torvalds cache->mfc_un.res.maxvif = vifi + 1;
8061da177e4SLinus Torvalds }
8071da177e4SLinus Torvalds }
80890b5ca17SNikolay Aleksandrov cache->mfc_un.res.lastuse = jiffies;
8091da177e4SLinus Torvalds }
8101da177e4SLinus Torvalds
vif_add(struct net * net,struct mr_table * mrt,struct vifctl * vifc,int mrtsock)8110c12295aSPatrick McHardy static int vif_add(struct net *net, struct mr_table *mrt,
8120c12295aSPatrick McHardy struct vifctl *vifc, int mrtsock)
8131da177e4SLinus Torvalds {
814bccb3025SFlorian Fainelli struct netdev_phys_item_id ppid = { };
8151da177e4SLinus Torvalds int vifi = vifc->vifc_vifi;
8160c12295aSPatrick McHardy struct vif_device *v = &mrt->vif_table[vifi];
8171da177e4SLinus Torvalds struct net_device *dev;
8181da177e4SLinus Torvalds struct in_device *in_dev;
819d607032dSWang Chen int err;
8201da177e4SLinus Torvalds
8211da177e4SLinus Torvalds /* Is vif busy ? */
8220c12295aSPatrick McHardy if (VIF_EXISTS(mrt, vifi))
8231da177e4SLinus Torvalds return -EADDRINUSE;
8241da177e4SLinus Torvalds
8251da177e4SLinus Torvalds switch (vifc->vifc_flags) {
8261da177e4SLinus Torvalds case VIFF_REGISTER:
8271973a4eaSNikolay Aleksandrov if (!ipmr_pimsm_enabled())
828c316c629SNikolay Aleksandrov return -EINVAL;
829c316c629SNikolay Aleksandrov /* Special Purpose VIF in PIM
8301da177e4SLinus Torvalds * All the packets will be sent to the daemon
8311da177e4SLinus Torvalds */
8320c12295aSPatrick McHardy if (mrt->mroute_reg_vif_num >= 0)
8331da177e4SLinus Torvalds return -EADDRINUSE;
834f0ad0860SPatrick McHardy dev = ipmr_reg_vif(net, mrt);
8351da177e4SLinus Torvalds if (!dev)
8361da177e4SLinus Torvalds return -ENOBUFS;
837d607032dSWang Chen err = dev_set_allmulti(dev, 1);
838d607032dSWang Chen if (err) {
839d607032dSWang Chen unregister_netdevice(dev);
8407dc00c82SWang Chen dev_put(dev);
841d607032dSWang Chen return err;
842d607032dSWang Chen }
8431da177e4SLinus Torvalds break;
8441da177e4SLinus Torvalds case VIFF_TUNNEL:
8454feb88e5SBenjamin Thery dev = ipmr_new_tunnel(net, vifc);
846c1fd1182SChristoph Hellwig if (IS_ERR(dev))
847c1fd1182SChristoph Hellwig return PTR_ERR(dev);
8481da177e4SLinus Torvalds break;
849ee5e81f0SIlia K case VIFF_USE_IFINDEX:
8501da177e4SLinus Torvalds case 0:
851ee5e81f0SIlia K if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
852ee5e81f0SIlia K dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
85351456b29SIan Morris if (dev && !__in_dev_get_rtnl(dev)) {
854ee5e81f0SIlia K dev_put(dev);
855ee5e81f0SIlia K return -EADDRNOTAVAIL;
856ee5e81f0SIlia K }
857a8cb16ddSEric Dumazet } else {
8584feb88e5SBenjamin Thery dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
859a8cb16ddSEric Dumazet }
8601da177e4SLinus Torvalds if (!dev)
8611da177e4SLinus Torvalds return -EADDRNOTAVAIL;
862d607032dSWang Chen err = dev_set_allmulti(dev, 1);
8637dc00c82SWang Chen if (err) {
8647dc00c82SWang Chen dev_put(dev);
865d607032dSWang Chen return err;
8667dc00c82SWang Chen }
8671da177e4SLinus Torvalds break;
8681da177e4SLinus Torvalds default:
8691da177e4SLinus Torvalds return -EINVAL;
8701da177e4SLinus Torvalds }
8711da177e4SLinus Torvalds
872a8cb16ddSEric Dumazet in_dev = __in_dev_get_rtnl(dev);
873a8cb16ddSEric Dumazet if (!in_dev) {
874d0490cfdSDan Carpenter dev_put(dev);
8751da177e4SLinus Torvalds return -EADDRNOTAVAIL;
876d0490cfdSDan Carpenter }
87742f811b8SHerbert Xu IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
8783b022865SDavid Ahern inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_MC_FORWARDING,
8793b022865SDavid Ahern dev->ifindex, &in_dev->cnf);
8801da177e4SLinus Torvalds ip_rt_multicast_event(in_dev);
8811da177e4SLinus Torvalds
882a8cb16ddSEric Dumazet /* Fill in the VIF structures */
8836853f21fSYuval Mintz vif_device_init(v, dev, vifc->vifc_rate_limit,
8846853f21fSYuval Mintz vifc->vifc_threshold,
8856853f21fSYuval Mintz vifc->vifc_flags | (!mrtsock ? VIFF_STATIC : 0),
8866853f21fSYuval Mintz (VIFF_TUNNEL | VIFF_REGISTER));
887a8cb16ddSEric Dumazet
888bccb3025SFlorian Fainelli err = dev_get_port_parent_id(dev, &ppid, true);
889bccb3025SFlorian Fainelli if (err == 0) {
890bccb3025SFlorian Fainelli memcpy(v->dev_parent_id.id, ppid.id, ppid.id_len);
891bccb3025SFlorian Fainelli v->dev_parent_id.id_len = ppid.id_len;
8925d8b3e69SYotam Gigi } else {
8935d8b3e69SYotam Gigi v->dev_parent_id.id_len = 0;
8945d8b3e69SYotam Gigi }
8956853f21fSYuval Mintz
8961da177e4SLinus Torvalds v->local = vifc->vifc_lcl_addr.s_addr;
8971da177e4SLinus Torvalds v->remote = vifc->vifc_rmt_addr.s_addr;
8981da177e4SLinus Torvalds
8991da177e4SLinus Torvalds /* And finish update writing critical data */
9003f55211eSEric Dumazet spin_lock(&mrt_lock);
901ebc31979SEric Dumazet rcu_assign_pointer(v->dev, dev);
90242120a86SEric Dumazet netdev_tracker_alloc(dev, &v->dev_tracker, GFP_ATOMIC);
90364667988SEric Dumazet if (v->flags & VIFF_REGISTER) {
90464667988SEric Dumazet /* Pairs with READ_ONCE() in ipmr_cache_report() and reg_vif_xmit() */
90564667988SEric Dumazet WRITE_ONCE(mrt->mroute_reg_vif_num, vifi);
90664667988SEric Dumazet }
9070c12295aSPatrick McHardy if (vifi+1 > mrt->maxvif)
9089094db4bSEric Dumazet WRITE_ONCE(mrt->maxvif, vifi + 1);
9093f55211eSEric Dumazet spin_unlock(&mrt_lock);
910ebc31979SEric Dumazet call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD, v, dev,
911ebc31979SEric Dumazet vifi, mrt->id);
9121da177e4SLinus Torvalds return 0;
9131da177e4SLinus Torvalds }
9141da177e4SLinus Torvalds
915a8c9486bSEric Dumazet /* called with rcu_read_lock() */
ipmr_cache_find(struct mr_table * mrt,__be32 origin,__be32 mcastgrp)9160c12295aSPatrick McHardy static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
9174feb88e5SBenjamin Thery __be32 origin,
9184feb88e5SBenjamin Thery __be32 mcastgrp)
9191da177e4SLinus Torvalds {
9208fb472c0SNikolay Aleksandrov struct mfc_cache_cmp_arg arg = {
9218fb472c0SNikolay Aleksandrov .mfc_mcastgrp = mcastgrp,
9228fb472c0SNikolay Aleksandrov .mfc_origin = origin
9238fb472c0SNikolay Aleksandrov };
9241da177e4SLinus Torvalds
925845c9a7aSYuval Mintz return mr_mfc_find(mrt, &arg);
926660b26dcSNicolas Dichtel }
927660b26dcSNicolas Dichtel
928660b26dcSNicolas Dichtel /* Look for a (*,G) entry */
ipmr_cache_find_any(struct mr_table * mrt,__be32 mcastgrp,int vifi)929660b26dcSNicolas Dichtel static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt,
930660b26dcSNicolas Dichtel __be32 mcastgrp, int vifi)
931660b26dcSNicolas Dichtel {
9328fb472c0SNikolay Aleksandrov struct mfc_cache_cmp_arg arg = {
9338fb472c0SNikolay Aleksandrov .mfc_mcastgrp = mcastgrp,
9348fb472c0SNikolay Aleksandrov .mfc_origin = htonl(INADDR_ANY)
9358fb472c0SNikolay Aleksandrov };
936660b26dcSNicolas Dichtel
937360eb5daSNicolas Dichtel if (mcastgrp == htonl(INADDR_ANY))
938845c9a7aSYuval Mintz return mr_mfc_find_any_parent(mrt, vifi);
939845c9a7aSYuval Mintz return mr_mfc_find_any(mrt, vifi, &arg);
940660b26dcSNicolas Dichtel }
941660b26dcSNicolas Dichtel
9428fb472c0SNikolay Aleksandrov /* Look for a (S,G,iif) entry if parent != -1 */
ipmr_cache_find_parent(struct mr_table * mrt,__be32 origin,__be32 mcastgrp,int parent)9438fb472c0SNikolay Aleksandrov static struct mfc_cache *ipmr_cache_find_parent(struct mr_table *mrt,
9448fb472c0SNikolay Aleksandrov __be32 origin, __be32 mcastgrp,
9458fb472c0SNikolay Aleksandrov int parent)
9468fb472c0SNikolay Aleksandrov {
9478fb472c0SNikolay Aleksandrov struct mfc_cache_cmp_arg arg = {
9488fb472c0SNikolay Aleksandrov .mfc_mcastgrp = mcastgrp,
9498fb472c0SNikolay Aleksandrov .mfc_origin = origin,
9508fb472c0SNikolay Aleksandrov };
9518fb472c0SNikolay Aleksandrov
952845c9a7aSYuval Mintz return mr_mfc_find_parent(mrt, &arg, parent);
9538fb472c0SNikolay Aleksandrov }
9548fb472c0SNikolay Aleksandrov
9557ef8f65dSNikolay Aleksandrov /* Allocate a multicast cache entry */
ipmr_cache_alloc(void)956d658f8a0SPatrick McHardy static struct mfc_cache *ipmr_cache_alloc(void)
9571da177e4SLinus Torvalds {
958c3762229SRobert P. J. Day struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
959a8c9486bSEric Dumazet
96070a0dec4STom Goff if (c) {
961494fff56SYuval Mintz c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
962494fff56SYuval Mintz c->_c.mfc_un.res.minvif = MAXVIFS;
9638c13af2aSYuval Mintz c->_c.free = ipmr_cache_free_rcu;
964494fff56SYuval Mintz refcount_set(&c->_c.mfc_un.res.refcount, 1);
96570a0dec4STom Goff }
9661da177e4SLinus Torvalds return c;
9671da177e4SLinus Torvalds }
9681da177e4SLinus Torvalds
ipmr_cache_alloc_unres(void)969d658f8a0SPatrick McHardy static struct mfc_cache *ipmr_cache_alloc_unres(void)
9701da177e4SLinus Torvalds {
971c3762229SRobert P. J. Day struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
972a8c9486bSEric Dumazet
973a8c9486bSEric Dumazet if (c) {
974494fff56SYuval Mintz skb_queue_head_init(&c->_c.mfc_un.unres.unresolved);
975494fff56SYuval Mintz c->_c.mfc_un.unres.expires = jiffies + 10 * HZ;
976a8c9486bSEric Dumazet }
9771da177e4SLinus Torvalds return c;
9781da177e4SLinus Torvalds }
9791da177e4SLinus Torvalds
9807ef8f65dSNikolay Aleksandrov /* A cache entry has gone into a resolved state from queued */
ipmr_cache_resolve(struct net * net,struct mr_table * mrt,struct mfc_cache * uc,struct mfc_cache * c)9810c12295aSPatrick McHardy static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
9820c12295aSPatrick McHardy struct mfc_cache *uc, struct mfc_cache *c)
9831da177e4SLinus Torvalds {
9841da177e4SLinus Torvalds struct sk_buff *skb;
9859ef1d4c7SPatrick McHardy struct nlmsgerr *e;
9861da177e4SLinus Torvalds
987a8cb16ddSEric Dumazet /* Play the pending entries through our router */
988494fff56SYuval Mintz while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) {
989eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->version == 0) {
990af72868bSJohannes Berg struct nlmsghdr *nlh = skb_pull(skb,
991af72868bSJohannes Berg sizeof(struct iphdr));
9921da177e4SLinus Torvalds
9937b0db857SYuval Mintz if (mr_fill_mroute(mrt, skb, &c->_c,
994494fff56SYuval Mintz nlmsg_data(nlh)) > 0) {
995a8cb16ddSEric Dumazet nlh->nlmsg_len = skb_tail_pointer(skb) -
996a8cb16ddSEric Dumazet (u8 *)nlh;
9971da177e4SLinus Torvalds } else {
9981da177e4SLinus Torvalds nlh->nlmsg_type = NLMSG_ERROR;
999573ce260SHong zhi guo nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
10001da177e4SLinus Torvalds skb_trim(skb, nlh->nlmsg_len);
1001573ce260SHong zhi guo e = nlmsg_data(nlh);
10029ef1d4c7SPatrick McHardy e->error = -EMSGSIZE;
10039ef1d4c7SPatrick McHardy memset(&e->msg, 0, sizeof(e->msg));
10041da177e4SLinus Torvalds }
10052942e900SThomas Graf
100615e47304SEric W. Biederman rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1007a8cb16ddSEric Dumazet } else {
1008b07a9b26SIdo Schimmel rcu_read_lock();
10094b1f0d33SDonald Sharp ip_mr_forward(net, mrt, skb->dev, skb, c, 0);
1010b07a9b26SIdo Schimmel rcu_read_unlock();
10111da177e4SLinus Torvalds }
10121da177e4SLinus Torvalds }
1013a8cb16ddSEric Dumazet }
10141da177e4SLinus Torvalds
10155a645dd8SJulien Gomes /* Bounce a cache query up to mrouted and netlink.
10161da177e4SLinus Torvalds *
101764667988SEric Dumazet * Called under rcu_read_lock().
10181da177e4SLinus Torvalds */
ipmr_cache_report(const struct mr_table * mrt,struct sk_buff * pkt,vifi_t vifi,int assert)101964667988SEric Dumazet static int ipmr_cache_report(const struct mr_table *mrt,
10204feb88e5SBenjamin Thery struct sk_buff *pkt, vifi_t vifi, int assert)
10211da177e4SLinus Torvalds {
1022c9bdd4b5SArnaldo Carvalho de Melo const int ihl = ip_hdrlen(pkt);
1023c316c629SNikolay Aleksandrov struct sock *mroute_sk;
10241da177e4SLinus Torvalds struct igmphdr *igmp;
10251da177e4SLinus Torvalds struct igmpmsg *msg;
1026c316c629SNikolay Aleksandrov struct sk_buff *skb;
10271da177e4SLinus Torvalds int ret;
10281da177e4SLinus Torvalds
1029bb740365SLeone Fernando mroute_sk = rcu_dereference(mrt->mroute_sk);
1030bb740365SLeone Fernando if (!mroute_sk)
1031bb740365SLeone Fernando return -EINVAL;
1032bb740365SLeone Fernando
1033c921c207SNikolay Aleksandrov if (assert == IGMPMSG_WHOLEPKT || assert == IGMPMSG_WRVIFWHOLE)
10341da177e4SLinus Torvalds skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
10351da177e4SLinus Torvalds else
10361da177e4SLinus Torvalds skb = alloc_skb(128, GFP_ATOMIC);
10371da177e4SLinus Torvalds
10381da177e4SLinus Torvalds if (!skb)
10391da177e4SLinus Torvalds return -ENOBUFS;
10401da177e4SLinus Torvalds
1041c921c207SNikolay Aleksandrov if (assert == IGMPMSG_WHOLEPKT || assert == IGMPMSG_WRVIFWHOLE) {
10421da177e4SLinus Torvalds /* Ugly, but we have no choice with this interface.
1043a8cb16ddSEric Dumazet * Duplicate old header, fix ihl, length etc.
1044a8cb16ddSEric Dumazet * And all this only to mangle msg->im_msgtype and
1045a8cb16ddSEric Dumazet * to set msg->im_mbz to "mbz" :-)
10461da177e4SLinus Torvalds */
1047878c8145SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct iphdr));
1048878c8145SArnaldo Carvalho de Melo skb_reset_network_header(skb);
1049badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
10500272ffc4SArnaldo Carvalho de Melo msg = (struct igmpmsg *)skb_network_header(skb);
1051d56f90a7SArnaldo Carvalho de Melo memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
1052c921c207SNikolay Aleksandrov msg->im_msgtype = assert;
10531da177e4SLinus Torvalds msg->im_mbz = 0;
1054c8715a8eSPaul Davey if (assert == IGMPMSG_WRVIFWHOLE) {
1055c921c207SNikolay Aleksandrov msg->im_vif = vifi;
1056c8715a8eSPaul Davey msg->im_vif_hi = vifi >> 8;
1057c8715a8eSPaul Davey } else {
105864667988SEric Dumazet /* Pairs with WRITE_ONCE() in vif_add() and vif_delete() */
105964667988SEric Dumazet int vif_num = READ_ONCE(mrt->mroute_reg_vif_num);
106064667988SEric Dumazet
106164667988SEric Dumazet msg->im_vif = vif_num;
106264667988SEric Dumazet msg->im_vif_hi = vif_num >> 8;
1063c8715a8eSPaul Davey }
1064eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
1065eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
1066eddc9ec5SArnaldo Carvalho de Melo sizeof(struct iphdr));
1067c316c629SNikolay Aleksandrov } else {
1068a8cb16ddSEric Dumazet /* Copy the IP header */
106930f3a40fSCong Wang skb_set_network_header(skb, skb->len);
1070ddc7b8e3SArnaldo Carvalho de Melo skb_put(skb, ihl);
107127d7ff46SArnaldo Carvalho de Melo skb_copy_to_linear_data(skb, pkt->data, ihl);
1072c316c629SNikolay Aleksandrov /* Flag to the kernel this is a route add */
1073c316c629SNikolay Aleksandrov ip_hdr(skb)->protocol = 0;
1074eddc9ec5SArnaldo Carvalho de Melo msg = (struct igmpmsg *)skb_network_header(skb);
10751da177e4SLinus Torvalds msg->im_vif = vifi;
1076c8715a8eSPaul Davey msg->im_vif_hi = vifi >> 8;
1077e622502cSNicolas Dichtel ipv4_pktinfo_prepare(mroute_sk, pkt, false);
1078bb740365SLeone Fernando memcpy(skb->cb, pkt->cb, sizeof(skb->cb));
1079a8cb16ddSEric Dumazet /* Add our header */
10804df864c1SJohannes Berg igmp = skb_put(skb, sizeof(struct igmphdr));
1081c316c629SNikolay Aleksandrov igmp->type = assert;
10821da177e4SLinus Torvalds msg->im_msgtype = assert;
10831da177e4SLinus Torvalds igmp->code = 0;
1084eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
1085b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header;
10861da177e4SLinus Torvalds }
10871da177e4SLinus Torvalds
10885a645dd8SJulien Gomes igmpmsg_netlink_event(mrt, skb);
10895a645dd8SJulien Gomes
1090a8cb16ddSEric Dumazet /* Deliver to mrouted */
10914c968709SEric Dumazet ret = sock_queue_rcv_skb(mroute_sk, skb);
109264667988SEric Dumazet
109370a269e6SBenjamin Thery if (ret < 0) {
1094e87cc472SJoe Perches net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
10951da177e4SLinus Torvalds kfree_skb(skb);
10961da177e4SLinus Torvalds }
10971da177e4SLinus Torvalds
10981da177e4SLinus Torvalds return ret;
10991da177e4SLinus Torvalds }
11001da177e4SLinus Torvalds
11017ef8f65dSNikolay Aleksandrov /* Queue a packet for resolution. It gets locked cache entry! */
110264667988SEric Dumazet /* Called under rcu_read_lock() */
ipmr_cache_unresolved(struct mr_table * mrt,vifi_t vifi,struct sk_buff * skb,struct net_device * dev)11037ef8f65dSNikolay Aleksandrov static int ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi,
11044b1f0d33SDonald Sharp struct sk_buff *skb, struct net_device *dev)
11051da177e4SLinus Torvalds {
11068fb472c0SNikolay Aleksandrov const struct iphdr *iph = ip_hdr(skb);
11078fb472c0SNikolay Aleksandrov struct mfc_cache *c;
1108862465f2SPatrick McHardy bool found = false;
11091da177e4SLinus Torvalds int err;
11101da177e4SLinus Torvalds
11111da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock);
1112494fff56SYuval Mintz list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
1113e258beb2SPatrick McHardy if (c->mfc_mcastgrp == iph->daddr &&
1114862465f2SPatrick McHardy c->mfc_origin == iph->saddr) {
1115862465f2SPatrick McHardy found = true;
11161da177e4SLinus Torvalds break;
11171da177e4SLinus Torvalds }
1118862465f2SPatrick McHardy }
11191da177e4SLinus Torvalds
1120862465f2SPatrick McHardy if (!found) {
1121a8cb16ddSEric Dumazet /* Create a new entry if allowable */
11220079ad8eSHangbin Liu c = ipmr_cache_alloc_unres();
11230079ad8eSHangbin Liu if (!c) {
11241da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock);
11251da177e4SLinus Torvalds
11261da177e4SLinus Torvalds kfree_skb(skb);
11271da177e4SLinus Torvalds return -ENOBUFS;
11281da177e4SLinus Torvalds }
11291da177e4SLinus Torvalds
1130a8cb16ddSEric Dumazet /* Fill in the new cache entry */
1131494fff56SYuval Mintz c->_c.mfc_parent = -1;
1132eddc9ec5SArnaldo Carvalho de Melo c->mfc_origin = iph->saddr;
1133eddc9ec5SArnaldo Carvalho de Melo c->mfc_mcastgrp = iph->daddr;
11341da177e4SLinus Torvalds
1135a8cb16ddSEric Dumazet /* Reflect first query at mrouted. */
11360c12295aSPatrick McHardy err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
1137494fff56SYuval Mintz
11384feb88e5SBenjamin Thery if (err < 0) {
11391da177e4SLinus Torvalds /* If the report failed throw the cache entry
11401da177e4SLinus Torvalds out - Brad Parker
11411da177e4SLinus Torvalds */
11421da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock);
11431da177e4SLinus Torvalds
11445c0a66f5SBenjamin Thery ipmr_cache_free(c);
11451da177e4SLinus Torvalds kfree_skb(skb);
11461da177e4SLinus Torvalds return err;
11471da177e4SLinus Torvalds }
11481da177e4SLinus Torvalds
11490c12295aSPatrick McHardy atomic_inc(&mrt->cache_resolve_queue_len);
1150494fff56SYuval Mintz list_add(&c->_c.list, &mrt->mfc_unres_queue);
11518cd3ac9fSNicolas Dichtel mroute_netlink_event(mrt, c, RTM_NEWROUTE);
11521da177e4SLinus Torvalds
1153278554bdSDavid S. Miller if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
1154494fff56SYuval Mintz mod_timer(&mrt->ipmr_expire_timer,
1155494fff56SYuval Mintz c->_c.mfc_un.unres.expires);
11561da177e4SLinus Torvalds }
11571da177e4SLinus Torvalds
1158a8cb16ddSEric Dumazet /* See if we can append the packet */
1159494fff56SYuval Mintz if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
11601da177e4SLinus Torvalds kfree_skb(skb);
11611da177e4SLinus Torvalds err = -ENOBUFS;
11621da177e4SLinus Torvalds } else {
11634b1f0d33SDonald Sharp if (dev) {
11644b1f0d33SDonald Sharp skb->dev = dev;
11654b1f0d33SDonald Sharp skb->skb_iif = dev->ifindex;
11664b1f0d33SDonald Sharp }
1167494fff56SYuval Mintz skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
11681da177e4SLinus Torvalds err = 0;
11691da177e4SLinus Torvalds }
11701da177e4SLinus Torvalds
11711da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock);
11721da177e4SLinus Torvalds return err;
11731da177e4SLinus Torvalds }
11741da177e4SLinus Torvalds
11757ef8f65dSNikolay Aleksandrov /* MFC cache manipulation by user space mroute daemon */
11761da177e4SLinus Torvalds
ipmr_mfc_delete(struct mr_table * mrt,struct mfcctl * mfc,int parent)1177660b26dcSNicolas Dichtel static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent)
11781da177e4SLinus Torvalds {
1179b362053aSYotam Gigi struct net *net = read_pnet(&mrt->net);
11808fb472c0SNikolay Aleksandrov struct mfc_cache *c;
11811da177e4SLinus Torvalds
11828fb472c0SNikolay Aleksandrov /* The entries are added/deleted only under RTNL */
11838fb472c0SNikolay Aleksandrov rcu_read_lock();
11848fb472c0SNikolay Aleksandrov c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
11858fb472c0SNikolay Aleksandrov mfc->mfcc_mcastgrp.s_addr, parent);
11868fb472c0SNikolay Aleksandrov rcu_read_unlock();
11878fb472c0SNikolay Aleksandrov if (!c)
11888fb472c0SNikolay Aleksandrov return -ENOENT;
1189494fff56SYuval Mintz rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ipmr_rht_params);
1190494fff56SYuval Mintz list_del_rcu(&c->_c.list);
1191b362053aSYotam Gigi call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, c, mrt->id);
11928cd3ac9fSNicolas Dichtel mroute_netlink_event(mrt, c, RTM_DELROUTE);
11938c13af2aSYuval Mintz mr_cache_put(&c->_c);
11948fb472c0SNikolay Aleksandrov
11951da177e4SLinus Torvalds return 0;
11961da177e4SLinus Torvalds }
11971da177e4SLinus Torvalds
ipmr_mfc_add(struct net * net,struct mr_table * mrt,struct mfcctl * mfc,int mrtsock,int parent)11980c12295aSPatrick McHardy static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
1199660b26dcSNicolas Dichtel struct mfcctl *mfc, int mrtsock, int parent)
12001da177e4SLinus Torvalds {
1201862465f2SPatrick McHardy struct mfc_cache *uc, *c;
1202494fff56SYuval Mintz struct mr_mfc *_uc;
12038fb472c0SNikolay Aleksandrov bool found;
12048fb472c0SNikolay Aleksandrov int ret;
12051da177e4SLinus Torvalds
1206a50436f2SPatrick McHardy if (mfc->mfcc_parent >= MAXVIFS)
1207a50436f2SPatrick McHardy return -ENFILE;
1208a50436f2SPatrick McHardy
12098fb472c0SNikolay Aleksandrov /* The entries are added/deleted only under RTNL */
12108fb472c0SNikolay Aleksandrov rcu_read_lock();
12118fb472c0SNikolay Aleksandrov c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
12128fb472c0SNikolay Aleksandrov mfc->mfcc_mcastgrp.s_addr, parent);
12138fb472c0SNikolay Aleksandrov rcu_read_unlock();
12148fb472c0SNikolay Aleksandrov if (c) {
12153f55211eSEric Dumazet spin_lock(&mrt_lock);
1216494fff56SYuval Mintz c->_c.mfc_parent = mfc->mfcc_parent;
1217494fff56SYuval Mintz ipmr_update_thresholds(mrt, &c->_c, mfc->mfcc_ttls);
12181da177e4SLinus Torvalds if (!mrtsock)
1219494fff56SYuval Mintz c->_c.mfc_flags |= MFC_STATIC;
12203f55211eSEric Dumazet spin_unlock(&mrt_lock);
1221b362053aSYotam Gigi call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE, c,
1222b362053aSYotam Gigi mrt->id);
12238cd3ac9fSNicolas Dichtel mroute_netlink_event(mrt, c, RTM_NEWROUTE);
12241da177e4SLinus Torvalds return 0;
12251da177e4SLinus Torvalds }
12261da177e4SLinus Torvalds
1227360eb5daSNicolas Dichtel if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) &&
1228660b26dcSNicolas Dichtel !ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
12291da177e4SLinus Torvalds return -EINVAL;
12301da177e4SLinus Torvalds
1231d658f8a0SPatrick McHardy c = ipmr_cache_alloc();
123251456b29SIan Morris if (!c)
12331da177e4SLinus Torvalds return -ENOMEM;
12341da177e4SLinus Torvalds
12351da177e4SLinus Torvalds c->mfc_origin = mfc->mfcc_origin.s_addr;
12361da177e4SLinus Torvalds c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
1237494fff56SYuval Mintz c->_c.mfc_parent = mfc->mfcc_parent;
1238494fff56SYuval Mintz ipmr_update_thresholds(mrt, &c->_c, mfc->mfcc_ttls);
12391da177e4SLinus Torvalds if (!mrtsock)
1240494fff56SYuval Mintz c->_c.mfc_flags |= MFC_STATIC;
12411da177e4SLinus Torvalds
1242494fff56SYuval Mintz ret = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
12438fb472c0SNikolay Aleksandrov ipmr_rht_params);
12448fb472c0SNikolay Aleksandrov if (ret) {
12458fb472c0SNikolay Aleksandrov pr_err("ipmr: rhtable insert error %d\n", ret);
12468fb472c0SNikolay Aleksandrov ipmr_cache_free(c);
12478fb472c0SNikolay Aleksandrov return ret;
12488fb472c0SNikolay Aleksandrov }
1249494fff56SYuval Mintz list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
12507ef8f65dSNikolay Aleksandrov /* Check to see if we resolved a queued list. If so we
12511da177e4SLinus Torvalds * need to send on the frames and tidy up.
12521da177e4SLinus Torvalds */
1253b0ebb739SPatrick McHardy found = false;
12541da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock);
1255494fff56SYuval Mintz list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
1256494fff56SYuval Mintz uc = (struct mfc_cache *)_uc;
1257e258beb2SPatrick McHardy if (uc->mfc_origin == c->mfc_origin &&
12581da177e4SLinus Torvalds uc->mfc_mcastgrp == c->mfc_mcastgrp) {
1259494fff56SYuval Mintz list_del(&_uc->list);
12600c12295aSPatrick McHardy atomic_dec(&mrt->cache_resolve_queue_len);
1261b0ebb739SPatrick McHardy found = true;
12621da177e4SLinus Torvalds break;
12631da177e4SLinus Torvalds }
12641da177e4SLinus Torvalds }
12650c12295aSPatrick McHardy if (list_empty(&mrt->mfc_unres_queue))
12660c12295aSPatrick McHardy del_timer(&mrt->ipmr_expire_timer);
12671da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock);
12681da177e4SLinus Torvalds
1269b0ebb739SPatrick McHardy if (found) {
12700c12295aSPatrick McHardy ipmr_cache_resolve(net, mrt, uc, c);
12715c0a66f5SBenjamin Thery ipmr_cache_free(uc);
12721da177e4SLinus Torvalds }
1273b362053aSYotam Gigi call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD, c, mrt->id);
12748cd3ac9fSNicolas Dichtel mroute_netlink_event(mrt, c, RTM_NEWROUTE);
12751da177e4SLinus Torvalds return 0;
12761da177e4SLinus Torvalds }
12771da177e4SLinus Torvalds
12787ef8f65dSNikolay Aleksandrov /* Close the multicast socket, and clear the vif tables etc */
mroute_clean_tables(struct mr_table * mrt,int flags)1279ca8d4794SCallum Sinclair static void mroute_clean_tables(struct mr_table *mrt, int flags)
12801da177e4SLinus Torvalds {
1281b362053aSYotam Gigi struct net *net = read_pnet(&mrt->net);
1282494fff56SYuval Mintz struct mr_mfc *c, *tmp;
1283494fff56SYuval Mintz struct mfc_cache *cache;
1284d17fa6faSEric Dumazet LIST_HEAD(list);
12858fb472c0SNikolay Aleksandrov int i;
12861da177e4SLinus Torvalds
1287a8cb16ddSEric Dumazet /* Shut down all active vif entries */
1288ca8d4794SCallum Sinclair if (flags & (MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC)) {
12890c12295aSPatrick McHardy for (i = 0; i < mrt->maxvif; i++) {
1290ca8d4794SCallum Sinclair if (((mrt->vif_table[i].flags & VIFF_STATIC) &&
1291ca8d4794SCallum Sinclair !(flags & MRT_FLUSH_VIFS_STATIC)) ||
1292ca8d4794SCallum Sinclair (!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT_FLUSH_VIFS)))
12930e615e96SNikolay Aleksandrov continue;
12940c12295aSPatrick McHardy vif_delete(mrt, i, 0, &list);
12951da177e4SLinus Torvalds }
1296d17fa6faSEric Dumazet unregister_netdevice_many(&list);
1297ca8d4794SCallum Sinclair }
12981da177e4SLinus Torvalds
1299a8cb16ddSEric Dumazet /* Wipe the cache */
1300ca8d4794SCallum Sinclair if (flags & (MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC)) {
13018fb472c0SNikolay Aleksandrov list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1302ca8d4794SCallum Sinclair if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT_FLUSH_MFC_STATIC)) ||
1303ca8d4794SCallum Sinclair (!(c->mfc_flags & MFC_STATIC) && !(flags & MRT_FLUSH_MFC)))
13041da177e4SLinus Torvalds continue;
13058fb472c0SNikolay Aleksandrov rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params);
1306a8c9486bSEric Dumazet list_del_rcu(&c->list);
1307494fff56SYuval Mintz cache = (struct mfc_cache *)c;
1308494fff56SYuval Mintz call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, cache,
1309b362053aSYotam Gigi mrt->id);
1310494fff56SYuval Mintz mroute_netlink_event(mrt, cache, RTM_DELROUTE);
13118c13af2aSYuval Mintz mr_cache_put(c);
13121da177e4SLinus Torvalds }
1313ca8d4794SCallum Sinclair }
13141da177e4SLinus Torvalds
1315ca8d4794SCallum Sinclair if (flags & MRT_FLUSH_MFC) {
13160c12295aSPatrick McHardy if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
13171da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock);
13188fb472c0SNikolay Aleksandrov list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
1319862465f2SPatrick McHardy list_del(&c->list);
1320494fff56SYuval Mintz cache = (struct mfc_cache *)c;
1321494fff56SYuval Mintz mroute_netlink_event(mrt, cache, RTM_DELROUTE);
1322494fff56SYuval Mintz ipmr_destroy_unres(mrt, cache);
13231da177e4SLinus Torvalds }
13241da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock);
13251da177e4SLinus Torvalds }
13261da177e4SLinus Torvalds }
1327ca8d4794SCallum Sinclair }
13281da177e4SLinus Torvalds
13294c968709SEric Dumazet /* called from ip_ra_control(), before an RCU grace period,
1330974d8f86SZheng Yongjun * we don't need to call synchronize_rcu() here
13314c968709SEric Dumazet */
mrtsock_destruct(struct sock * sk)13321da177e4SLinus Torvalds static void mrtsock_destruct(struct sock *sk)
13331da177e4SLinus Torvalds {
13344feb88e5SBenjamin Thery struct net *net = sock_net(sk);
1335f0ad0860SPatrick McHardy struct mr_table *mrt;
13364feb88e5SBenjamin Thery
1337128aaa98SKirill Tkhai rtnl_lock();
1338f0ad0860SPatrick McHardy ipmr_for_each_table(mrt, net) {
13394c968709SEric Dumazet if (sk == rtnl_dereference(mrt->mroute_sk)) {
13404feb88e5SBenjamin Thery IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
13413b022865SDavid Ahern inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
13423b022865SDavid Ahern NETCONFA_MC_FORWARDING,
1343d67b8c61SNicolas Dichtel NETCONFA_IFINDEX_ALL,
1344d67b8c61SNicolas Dichtel net->ipv4.devconf_all);
1345a9b3cd7fSStephen Hemminger RCU_INIT_POINTER(mrt->mroute_sk, NULL);
1346ca8d4794SCallum Sinclair mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_MFC);
13471da177e4SLinus Torvalds }
13481da177e4SLinus Torvalds }
1349128aaa98SKirill Tkhai rtnl_unlock();
13501da177e4SLinus Torvalds }
13511da177e4SLinus Torvalds
13527ef8f65dSNikolay Aleksandrov /* Socket options and virtual interface manipulation. The whole
13531da177e4SLinus Torvalds * virtual interface system is a complete heap, but unfortunately
13541da177e4SLinus Torvalds * that's how BSD mrouted happens to think. Maybe one day with a proper
13551da177e4SLinus Torvalds * MOSPF/PIM router set up we can clean this up.
13561da177e4SLinus Torvalds */
13571da177e4SLinus Torvalds
ip_mroute_setsockopt(struct sock * sk,int optname,sockptr_t optval,unsigned int optlen)135801ccb5b4SChristoph Hellwig int ip_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval,
135929e97d21SNikolay Aleksandrov unsigned int optlen)
13601da177e4SLinus Torvalds {
136129e97d21SNikolay Aleksandrov struct net *net = sock_net(sk);
136229e97d21SNikolay Aleksandrov int val, ret = 0, parent = 0;
136329e97d21SNikolay Aleksandrov struct mr_table *mrt;
13641da177e4SLinus Torvalds struct vifctl vif;
13651da177e4SLinus Torvalds struct mfcctl mfc;
1366c921c207SNikolay Aleksandrov bool do_wrvifwhole;
136729e97d21SNikolay Aleksandrov u32 uval;
1368f0ad0860SPatrick McHardy
136929e97d21SNikolay Aleksandrov /* There's one exception to the lock - MRT_DONE which needs to unlock */
137029e97d21SNikolay Aleksandrov rtnl_lock();
13715e1859fbSEric Dumazet if (sk->sk_type != SOCK_RAW ||
137229e97d21SNikolay Aleksandrov inet_sk(sk)->inet_num != IPPROTO_IGMP) {
137329e97d21SNikolay Aleksandrov ret = -EOPNOTSUPP;
137429e97d21SNikolay Aleksandrov goto out_unlock;
137529e97d21SNikolay Aleksandrov }
13765e1859fbSEric Dumazet
1377f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
137829e97d21SNikolay Aleksandrov if (!mrt) {
137929e97d21SNikolay Aleksandrov ret = -ENOENT;
138029e97d21SNikolay Aleksandrov goto out_unlock;
138129e97d21SNikolay Aleksandrov }
1382132adf54SStephen Hemminger if (optname != MRT_INIT) {
138333d480ceSEric Dumazet if (sk != rcu_access_pointer(mrt->mroute_sk) &&
138429e97d21SNikolay Aleksandrov !ns_capable(net->user_ns, CAP_NET_ADMIN)) {
138529e97d21SNikolay Aleksandrov ret = -EACCES;
138629e97d21SNikolay Aleksandrov goto out_unlock;
138729e97d21SNikolay Aleksandrov }
13881da177e4SLinus Torvalds }
13891da177e4SLinus Torvalds
1390132adf54SStephen Hemminger switch (optname) {
13911da177e4SLinus Torvalds case MRT_INIT:
139242e6b89cSNikolay Aleksandrov if (optlen != sizeof(int)) {
139329e97d21SNikolay Aleksandrov ret = -EINVAL;
139429e97d21SNikolay Aleksandrov break;
139542e6b89cSNikolay Aleksandrov }
139642e6b89cSNikolay Aleksandrov if (rtnl_dereference(mrt->mroute_sk)) {
139742e6b89cSNikolay Aleksandrov ret = -EADDRINUSE;
139842e6b89cSNikolay Aleksandrov break;
139942e6b89cSNikolay Aleksandrov }
14001da177e4SLinus Torvalds
14011da177e4SLinus Torvalds ret = ip_ra_control(sk, 1, mrtsock_destruct);
14021da177e4SLinus Torvalds if (ret == 0) {
1403cf778b00SEric Dumazet rcu_assign_pointer(mrt->mroute_sk, sk);
14044feb88e5SBenjamin Thery IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
14053b022865SDavid Ahern inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
14063b022865SDavid Ahern NETCONFA_MC_FORWARDING,
1407d67b8c61SNicolas Dichtel NETCONFA_IFINDEX_ALL,
1408d67b8c61SNicolas Dichtel net->ipv4.devconf_all);
14091da177e4SLinus Torvalds }
141029e97d21SNikolay Aleksandrov break;
14111da177e4SLinus Torvalds case MRT_DONE:
141229e97d21SNikolay Aleksandrov if (sk != rcu_access_pointer(mrt->mroute_sk)) {
141329e97d21SNikolay Aleksandrov ret = -EACCES;
141429e97d21SNikolay Aleksandrov } else {
1415128aaa98SKirill Tkhai /* We need to unlock here because mrtsock_destruct takes
1416128aaa98SKirill Tkhai * care of rtnl itself and we can't change that due to
1417128aaa98SKirill Tkhai * the IP_ROUTER_ALERT setsockopt which runs without it.
1418128aaa98SKirill Tkhai */
1419128aaa98SKirill Tkhai rtnl_unlock();
142029e97d21SNikolay Aleksandrov ret = ip_ra_control(sk, 0, NULL);
1421128aaa98SKirill Tkhai goto out;
142229e97d21SNikolay Aleksandrov }
142329e97d21SNikolay Aleksandrov break;
14241da177e4SLinus Torvalds case MRT_ADD_VIF:
14251da177e4SLinus Torvalds case MRT_DEL_VIF:
142629e97d21SNikolay Aleksandrov if (optlen != sizeof(vif)) {
142729e97d21SNikolay Aleksandrov ret = -EINVAL;
142829e97d21SNikolay Aleksandrov break;
142929e97d21SNikolay Aleksandrov }
143001ccb5b4SChristoph Hellwig if (copy_from_sockptr(&vif, optval, sizeof(vif))) {
143129e97d21SNikolay Aleksandrov ret = -EFAULT;
143229e97d21SNikolay Aleksandrov break;
143329e97d21SNikolay Aleksandrov }
143429e97d21SNikolay Aleksandrov if (vif.vifc_vifi >= MAXVIFS) {
143529e97d21SNikolay Aleksandrov ret = -ENFILE;
143629e97d21SNikolay Aleksandrov break;
143729e97d21SNikolay Aleksandrov }
14381da177e4SLinus Torvalds if (optname == MRT_ADD_VIF) {
14394c968709SEric Dumazet ret = vif_add(net, mrt, &vif,
14404c968709SEric Dumazet sk == rtnl_dereference(mrt->mroute_sk));
14411da177e4SLinus Torvalds } else {
14420c12295aSPatrick McHardy ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
14431da177e4SLinus Torvalds }
144429e97d21SNikolay Aleksandrov break;
14457ef8f65dSNikolay Aleksandrov /* Manipulate the forwarding caches. These live
14461da177e4SLinus Torvalds * in a sort of kernel/user symbiosis.
14471da177e4SLinus Torvalds */
14481da177e4SLinus Torvalds case MRT_ADD_MFC:
14491da177e4SLinus Torvalds case MRT_DEL_MFC:
1450660b26dcSNicolas Dichtel parent = -1;
1451a8eceea8SJoe Perches fallthrough;
1452660b26dcSNicolas Dichtel case MRT_ADD_MFC_PROXY:
1453660b26dcSNicolas Dichtel case MRT_DEL_MFC_PROXY:
145429e97d21SNikolay Aleksandrov if (optlen != sizeof(mfc)) {
145529e97d21SNikolay Aleksandrov ret = -EINVAL;
145629e97d21SNikolay Aleksandrov break;
145729e97d21SNikolay Aleksandrov }
145873cb1193SIdo Schimmel if (copy_from_sockptr(&mfc, optval, sizeof(mfc))) {
145929e97d21SNikolay Aleksandrov ret = -EFAULT;
146029e97d21SNikolay Aleksandrov break;
146129e97d21SNikolay Aleksandrov }
1462660b26dcSNicolas Dichtel if (parent == 0)
1463660b26dcSNicolas Dichtel parent = mfc.mfcc_parent;
1464660b26dcSNicolas Dichtel if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY)
1465660b26dcSNicolas Dichtel ret = ipmr_mfc_delete(mrt, &mfc, parent);
14661da177e4SLinus Torvalds else
14674c968709SEric Dumazet ret = ipmr_mfc_add(net, mrt, &mfc,
1468660b26dcSNicolas Dichtel sk == rtnl_dereference(mrt->mroute_sk),
1469660b26dcSNicolas Dichtel parent);
147029e97d21SNikolay Aleksandrov break;
1471ca8d4794SCallum Sinclair case MRT_FLUSH:
1472ca8d4794SCallum Sinclair if (optlen != sizeof(val)) {
1473ca8d4794SCallum Sinclair ret = -EINVAL;
1474ca8d4794SCallum Sinclair break;
1475ca8d4794SCallum Sinclair }
147601ccb5b4SChristoph Hellwig if (copy_from_sockptr(&val, optval, sizeof(val))) {
1477ca8d4794SCallum Sinclair ret = -EFAULT;
1478ca8d4794SCallum Sinclair break;
1479ca8d4794SCallum Sinclair }
1480ca8d4794SCallum Sinclair mroute_clean_tables(mrt, val);
1481ca8d4794SCallum Sinclair break;
14827ef8f65dSNikolay Aleksandrov /* Control PIM assert. */
14831da177e4SLinus Torvalds case MRT_ASSERT:
148429e97d21SNikolay Aleksandrov if (optlen != sizeof(val)) {
148529e97d21SNikolay Aleksandrov ret = -EINVAL;
148629e97d21SNikolay Aleksandrov break;
14871da177e4SLinus Torvalds }
148801ccb5b4SChristoph Hellwig if (copy_from_sockptr(&val, optval, sizeof(val))) {
148929e97d21SNikolay Aleksandrov ret = -EFAULT;
149029e97d21SNikolay Aleksandrov break;
149129e97d21SNikolay Aleksandrov }
149229e97d21SNikolay Aleksandrov mrt->mroute_do_assert = val;
149329e97d21SNikolay Aleksandrov break;
14941da177e4SLinus Torvalds case MRT_PIM:
14951973a4eaSNikolay Aleksandrov if (!ipmr_pimsm_enabled()) {
149629e97d21SNikolay Aleksandrov ret = -ENOPROTOOPT;
149729e97d21SNikolay Aleksandrov break;
14981da177e4SLinus Torvalds }
149929e97d21SNikolay Aleksandrov if (optlen != sizeof(val)) {
150029e97d21SNikolay Aleksandrov ret = -EINVAL;
150129e97d21SNikolay Aleksandrov break;
15021da177e4SLinus Torvalds }
150301ccb5b4SChristoph Hellwig if (copy_from_sockptr(&val, optval, sizeof(val))) {
150429e97d21SNikolay Aleksandrov ret = -EFAULT;
150529e97d21SNikolay Aleksandrov break;
150629e97d21SNikolay Aleksandrov }
150729e97d21SNikolay Aleksandrov
1508c921c207SNikolay Aleksandrov do_wrvifwhole = (val == IGMPMSG_WRVIFWHOLE);
150929e97d21SNikolay Aleksandrov val = !!val;
151029e97d21SNikolay Aleksandrov if (val != mrt->mroute_do_pim) {
151129e97d21SNikolay Aleksandrov mrt->mroute_do_pim = val;
151229e97d21SNikolay Aleksandrov mrt->mroute_do_assert = val;
1513c921c207SNikolay Aleksandrov mrt->mroute_do_wrvifwhole = do_wrvifwhole;
151429e97d21SNikolay Aleksandrov }
151529e97d21SNikolay Aleksandrov break;
1516f0ad0860SPatrick McHardy case MRT_TABLE:
151729e97d21SNikolay Aleksandrov if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES)) {
151829e97d21SNikolay Aleksandrov ret = -ENOPROTOOPT;
151929e97d21SNikolay Aleksandrov break;
152029e97d21SNikolay Aleksandrov }
152129e97d21SNikolay Aleksandrov if (optlen != sizeof(uval)) {
152229e97d21SNikolay Aleksandrov ret = -EINVAL;
152329e97d21SNikolay Aleksandrov break;
152429e97d21SNikolay Aleksandrov }
152501ccb5b4SChristoph Hellwig if (copy_from_sockptr(&uval, optval, sizeof(uval))) {
152629e97d21SNikolay Aleksandrov ret = -EFAULT;
152729e97d21SNikolay Aleksandrov break;
152829e97d21SNikolay Aleksandrov }
1529f0ad0860SPatrick McHardy
15304c968709SEric Dumazet if (sk == rtnl_dereference(mrt->mroute_sk)) {
15314c968709SEric Dumazet ret = -EBUSY;
15324c968709SEric Dumazet } else {
153329e97d21SNikolay Aleksandrov mrt = ipmr_new_table(net, uval);
15341113ebbcSNikolay Aleksandrov if (IS_ERR(mrt))
15351113ebbcSNikolay Aleksandrov ret = PTR_ERR(mrt);
15365e1859fbSEric Dumazet else
153729e97d21SNikolay Aleksandrov raw_sk(sk)->ipmr_table = uval;
15384c968709SEric Dumazet }
153929e97d21SNikolay Aleksandrov break;
15407ef8f65dSNikolay Aleksandrov /* Spurious command, or MRT_VERSION which you cannot set. */
15411da177e4SLinus Torvalds default:
154229e97d21SNikolay Aleksandrov ret = -ENOPROTOOPT;
15431da177e4SLinus Torvalds }
154429e97d21SNikolay Aleksandrov out_unlock:
154529e97d21SNikolay Aleksandrov rtnl_unlock();
1546128aaa98SKirill Tkhai out:
154729e97d21SNikolay Aleksandrov return ret;
15481da177e4SLinus Torvalds }
15491da177e4SLinus Torvalds
1550e1d001faSBreno Leitao /* Execute if this ioctl is a special mroute ioctl */
ipmr_sk_ioctl(struct sock * sk,unsigned int cmd,void __user * arg)1551e1d001faSBreno Leitao int ipmr_sk_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1552e1d001faSBreno Leitao {
1553e1d001faSBreno Leitao switch (cmd) {
1554e1d001faSBreno Leitao /* These userspace buffers will be consumed by ipmr_ioctl() */
1555e1d001faSBreno Leitao case SIOCGETVIFCNT: {
1556e1d001faSBreno Leitao struct sioc_vif_req buffer;
1557e1d001faSBreno Leitao
1558e1d001faSBreno Leitao return sock_ioctl_inout(sk, cmd, arg, &buffer,
1559e1d001faSBreno Leitao sizeof(buffer));
1560e1d001faSBreno Leitao }
1561e1d001faSBreno Leitao case SIOCGETSGCNT: {
1562e1d001faSBreno Leitao struct sioc_sg_req buffer;
1563e1d001faSBreno Leitao
1564e1d001faSBreno Leitao return sock_ioctl_inout(sk, cmd, arg, &buffer,
1565e1d001faSBreno Leitao sizeof(buffer));
1566e1d001faSBreno Leitao }
1567e1d001faSBreno Leitao }
1568e1d001faSBreno Leitao /* return code > 0 means that the ioctl was not executed */
1569e1d001faSBreno Leitao return 1;
1570e1d001faSBreno Leitao }
1571e1d001faSBreno Leitao
15727ef8f65dSNikolay Aleksandrov /* Getsock opt support for the multicast routing system. */
ip_mroute_getsockopt(struct sock * sk,int optname,sockptr_t optval,sockptr_t optlen)1573728f064cSMartin KaFai Lau int ip_mroute_getsockopt(struct sock *sk, int optname, sockptr_t optval,
1574728f064cSMartin KaFai Lau sockptr_t optlen)
15751da177e4SLinus Torvalds {
15761da177e4SLinus Torvalds int olr;
15771da177e4SLinus Torvalds int val;
15784feb88e5SBenjamin Thery struct net *net = sock_net(sk);
1579f0ad0860SPatrick McHardy struct mr_table *mrt;
1580f0ad0860SPatrick McHardy
15815e1859fbSEric Dumazet if (sk->sk_type != SOCK_RAW ||
15825e1859fbSEric Dumazet inet_sk(sk)->inet_num != IPPROTO_IGMP)
15835e1859fbSEric Dumazet return -EOPNOTSUPP;
15845e1859fbSEric Dumazet
1585f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
158651456b29SIan Morris if (!mrt)
1587f0ad0860SPatrick McHardy return -ENOENT;
15881da177e4SLinus Torvalds
1589fe9ef3ceSNikolay Aleksandrov switch (optname) {
1590fe9ef3ceSNikolay Aleksandrov case MRT_VERSION:
15911da177e4SLinus Torvalds val = 0x0305;
1592fe9ef3ceSNikolay Aleksandrov break;
1593fe9ef3ceSNikolay Aleksandrov case MRT_PIM:
15941973a4eaSNikolay Aleksandrov if (!ipmr_pimsm_enabled())
1595c316c629SNikolay Aleksandrov return -ENOPROTOOPT;
15960c12295aSPatrick McHardy val = mrt->mroute_do_pim;
1597fe9ef3ceSNikolay Aleksandrov break;
1598fe9ef3ceSNikolay Aleksandrov case MRT_ASSERT:
15990c12295aSPatrick McHardy val = mrt->mroute_do_assert;
1600fe9ef3ceSNikolay Aleksandrov break;
1601fe9ef3ceSNikolay Aleksandrov default:
1602fe9ef3ceSNikolay Aleksandrov return -ENOPROTOOPT;
1603c316c629SNikolay Aleksandrov }
1604fe9ef3ceSNikolay Aleksandrov
1605728f064cSMartin KaFai Lau if (copy_from_sockptr(&olr, optlen, sizeof(int)))
1606fe9ef3ceSNikolay Aleksandrov return -EFAULT;
1607fe9ef3ceSNikolay Aleksandrov if (olr < 0)
1608fe9ef3ceSNikolay Aleksandrov return -EINVAL;
16095c3be3e0SGavrilov Ilia
16105c3be3e0SGavrilov Ilia olr = min_t(unsigned int, olr, sizeof(int));
16115c3be3e0SGavrilov Ilia
1612728f064cSMartin KaFai Lau if (copy_to_sockptr(optlen, &olr, sizeof(int)))
1613fe9ef3ceSNikolay Aleksandrov return -EFAULT;
1614728f064cSMartin KaFai Lau if (copy_to_sockptr(optval, &val, olr))
16151da177e4SLinus Torvalds return -EFAULT;
16161da177e4SLinus Torvalds return 0;
16171da177e4SLinus Torvalds }
16181da177e4SLinus Torvalds
16197ef8f65dSNikolay Aleksandrov /* The IP multicast ioctl support routines. */
ipmr_ioctl(struct sock * sk,int cmd,void * arg)1620e1d001faSBreno Leitao int ipmr_ioctl(struct sock *sk, int cmd, void *arg)
16211da177e4SLinus Torvalds {
16221da177e4SLinus Torvalds struct vif_device *vif;
16231da177e4SLinus Torvalds struct mfc_cache *c;
16244feb88e5SBenjamin Thery struct net *net = sock_net(sk);
1625e1d001faSBreno Leitao struct sioc_vif_req *vr;
1626e1d001faSBreno Leitao struct sioc_sg_req *sr;
1627f0ad0860SPatrick McHardy struct mr_table *mrt;
1628f0ad0860SPatrick McHardy
1629f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
163051456b29SIan Morris if (!mrt)
1631f0ad0860SPatrick McHardy return -ENOENT;
16321da177e4SLinus Torvalds
1633132adf54SStephen Hemminger switch (cmd) {
16341da177e4SLinus Torvalds case SIOCGETVIFCNT:
1635e1d001faSBreno Leitao vr = (struct sioc_vif_req *)arg;
1636e1d001faSBreno Leitao if (vr->vifi >= mrt->maxvif)
16371da177e4SLinus Torvalds return -EINVAL;
1638e1d001faSBreno Leitao vr->vifi = array_index_nospec(vr->vifi, mrt->maxvif);
1639559260fdSEric Dumazet rcu_read_lock();
1640e1d001faSBreno Leitao vif = &mrt->vif_table[vr->vifi];
1641e1d001faSBreno Leitao if (VIF_EXISTS(mrt, vr->vifi)) {
1642e1d001faSBreno Leitao vr->icount = READ_ONCE(vif->pkt_in);
1643e1d001faSBreno Leitao vr->ocount = READ_ONCE(vif->pkt_out);
1644e1d001faSBreno Leitao vr->ibytes = READ_ONCE(vif->bytes_in);
1645e1d001faSBreno Leitao vr->obytes = READ_ONCE(vif->bytes_out);
1646559260fdSEric Dumazet rcu_read_unlock();
16471da177e4SLinus Torvalds
16481da177e4SLinus Torvalds return 0;
16491da177e4SLinus Torvalds }
1650559260fdSEric Dumazet rcu_read_unlock();
16511da177e4SLinus Torvalds return -EADDRNOTAVAIL;
16521da177e4SLinus Torvalds case SIOCGETSGCNT:
1653e1d001faSBreno Leitao sr = (struct sioc_sg_req *)arg;
16541da177e4SLinus Torvalds
1655a8c9486bSEric Dumazet rcu_read_lock();
1656e1d001faSBreno Leitao c = ipmr_cache_find(mrt, sr->src.s_addr, sr->grp.s_addr);
16571da177e4SLinus Torvalds if (c) {
1658e1d001faSBreno Leitao sr->pktcnt = c->_c.mfc_un.res.pkt;
1659e1d001faSBreno Leitao sr->bytecnt = c->_c.mfc_un.res.bytes;
1660e1d001faSBreno Leitao sr->wrong_if = c->_c.mfc_un.res.wrong_if;
1661a8c9486bSEric Dumazet rcu_read_unlock();
16621da177e4SLinus Torvalds return 0;
16631da177e4SLinus Torvalds }
1664a8c9486bSEric Dumazet rcu_read_unlock();
16651da177e4SLinus Torvalds return -EADDRNOTAVAIL;
16661da177e4SLinus Torvalds default:
16671da177e4SLinus Torvalds return -ENOIOCTLCMD;
16681da177e4SLinus Torvalds }
16691da177e4SLinus Torvalds }
16701da177e4SLinus Torvalds
1671709b46e8SEric W. Biederman #ifdef CONFIG_COMPAT
1672709b46e8SEric W. Biederman struct compat_sioc_sg_req {
1673709b46e8SEric W. Biederman struct in_addr src;
1674709b46e8SEric W. Biederman struct in_addr grp;
1675709b46e8SEric W. Biederman compat_ulong_t pktcnt;
1676709b46e8SEric W. Biederman compat_ulong_t bytecnt;
1677709b46e8SEric W. Biederman compat_ulong_t wrong_if;
1678709b46e8SEric W. Biederman };
1679709b46e8SEric W. Biederman
1680ca6b8bb0SDavid S. Miller struct compat_sioc_vif_req {
1681ca6b8bb0SDavid S. Miller vifi_t vifi; /* Which iface */
1682ca6b8bb0SDavid S. Miller compat_ulong_t icount;
1683ca6b8bb0SDavid S. Miller compat_ulong_t ocount;
1684ca6b8bb0SDavid S. Miller compat_ulong_t ibytes;
1685ca6b8bb0SDavid S. Miller compat_ulong_t obytes;
1686ca6b8bb0SDavid S. Miller };
1687ca6b8bb0SDavid S. Miller
ipmr_compat_ioctl(struct sock * sk,unsigned int cmd,void __user * arg)1688709b46e8SEric W. Biederman int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1689709b46e8SEric W. Biederman {
16900033d5adSDavid S. Miller struct compat_sioc_sg_req sr;
1691ca6b8bb0SDavid S. Miller struct compat_sioc_vif_req vr;
1692ca6b8bb0SDavid S. Miller struct vif_device *vif;
1693709b46e8SEric W. Biederman struct mfc_cache *c;
1694709b46e8SEric W. Biederman struct net *net = sock_net(sk);
1695709b46e8SEric W. Biederman struct mr_table *mrt;
1696709b46e8SEric W. Biederman
1697709b46e8SEric W. Biederman mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
169851456b29SIan Morris if (!mrt)
1699709b46e8SEric W. Biederman return -ENOENT;
1700709b46e8SEric W. Biederman
1701709b46e8SEric W. Biederman switch (cmd) {
1702ca6b8bb0SDavid S. Miller case SIOCGETVIFCNT:
1703ca6b8bb0SDavid S. Miller if (copy_from_user(&vr, arg, sizeof(vr)))
1704ca6b8bb0SDavid S. Miller return -EFAULT;
1705ca6b8bb0SDavid S. Miller if (vr.vifi >= mrt->maxvif)
1706ca6b8bb0SDavid S. Miller return -EINVAL;
17075648451eSGustavo A. R. Silva vr.vifi = array_index_nospec(vr.vifi, mrt->maxvif);
1708559260fdSEric Dumazet rcu_read_lock();
1709ca6b8bb0SDavid S. Miller vif = &mrt->vif_table[vr.vifi];
1710ca6b8bb0SDavid S. Miller if (VIF_EXISTS(mrt, vr.vifi)) {
1711559260fdSEric Dumazet vr.icount = READ_ONCE(vif->pkt_in);
1712559260fdSEric Dumazet vr.ocount = READ_ONCE(vif->pkt_out);
1713559260fdSEric Dumazet vr.ibytes = READ_ONCE(vif->bytes_in);
1714559260fdSEric Dumazet vr.obytes = READ_ONCE(vif->bytes_out);
1715559260fdSEric Dumazet rcu_read_unlock();
1716ca6b8bb0SDavid S. Miller
1717ca6b8bb0SDavid S. Miller if (copy_to_user(arg, &vr, sizeof(vr)))
1718ca6b8bb0SDavid S. Miller return -EFAULT;
1719ca6b8bb0SDavid S. Miller return 0;
1720ca6b8bb0SDavid S. Miller }
1721559260fdSEric Dumazet rcu_read_unlock();
1722ca6b8bb0SDavid S. Miller return -EADDRNOTAVAIL;
1723709b46e8SEric W. Biederman case SIOCGETSGCNT:
1724709b46e8SEric W. Biederman if (copy_from_user(&sr, arg, sizeof(sr)))
1725709b46e8SEric W. Biederman return -EFAULT;
1726709b46e8SEric W. Biederman
1727709b46e8SEric W. Biederman rcu_read_lock();
1728709b46e8SEric W. Biederman c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
1729709b46e8SEric W. Biederman if (c) {
1730494fff56SYuval Mintz sr.pktcnt = c->_c.mfc_un.res.pkt;
1731494fff56SYuval Mintz sr.bytecnt = c->_c.mfc_un.res.bytes;
1732494fff56SYuval Mintz sr.wrong_if = c->_c.mfc_un.res.wrong_if;
1733709b46e8SEric W. Biederman rcu_read_unlock();
1734709b46e8SEric W. Biederman
1735709b46e8SEric W. Biederman if (copy_to_user(arg, &sr, sizeof(sr)))
1736709b46e8SEric W. Biederman return -EFAULT;
1737709b46e8SEric W. Biederman return 0;
1738709b46e8SEric W. Biederman }
1739709b46e8SEric W. Biederman rcu_read_unlock();
1740709b46e8SEric W. Biederman return -EADDRNOTAVAIL;
1741709b46e8SEric W. Biederman default:
1742709b46e8SEric W. Biederman return -ENOIOCTLCMD;
1743709b46e8SEric W. Biederman }
1744709b46e8SEric W. Biederman }
1745709b46e8SEric W. Biederman #endif
1746709b46e8SEric W. Biederman
ipmr_device_event(struct notifier_block * this,unsigned long event,void * ptr)17471da177e4SLinus Torvalds static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
17481da177e4SLinus Torvalds {
1749351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr);
17504feb88e5SBenjamin Thery struct net *net = dev_net(dev);
1751f0ad0860SPatrick McHardy struct mr_table *mrt;
17521da177e4SLinus Torvalds struct vif_device *v;
17531da177e4SLinus Torvalds int ct;
1754e9dc8653SEric W. Biederman
17551da177e4SLinus Torvalds if (event != NETDEV_UNREGISTER)
17561da177e4SLinus Torvalds return NOTIFY_DONE;
1757f0ad0860SPatrick McHardy
1758f0ad0860SPatrick McHardy ipmr_for_each_table(mrt, net) {
17590c12295aSPatrick McHardy v = &mrt->vif_table[0];
17600c12295aSPatrick McHardy for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1761ebc31979SEric Dumazet if (rcu_access_pointer(v->dev) == dev)
1762e92036a6SRongQing.Li vif_delete(mrt, ct, 1, NULL);
17631da177e4SLinus Torvalds }
17641da177e4SLinus Torvalds }
17651da177e4SLinus Torvalds return NOTIFY_DONE;
17661da177e4SLinus Torvalds }
17671da177e4SLinus Torvalds
17681da177e4SLinus Torvalds static struct notifier_block ip_mr_notifier = {
17691da177e4SLinus Torvalds .notifier_call = ipmr_device_event,
17701da177e4SLinus Torvalds };
17711da177e4SLinus Torvalds
17727ef8f65dSNikolay Aleksandrov /* Encapsulate a packet by attaching a valid IPIP header to it.
17731da177e4SLinus Torvalds * This avoids tunnel drivers and other mess and gives us the speed so
17741da177e4SLinus Torvalds * important for multicast video.
17751da177e4SLinus Torvalds */
ip_encap(struct net * net,struct sk_buff * skb,__be32 saddr,__be32 daddr)1776b6a7719aSHannes Frederic Sowa static void ip_encap(struct net *net, struct sk_buff *skb,
1777b6a7719aSHannes Frederic Sowa __be32 saddr, __be32 daddr)
17781da177e4SLinus Torvalds {
17798856dfa3SArnaldo Carvalho de Melo struct iphdr *iph;
1780b71d1d42SEric Dumazet const struct iphdr *old_iph = ip_hdr(skb);
17818856dfa3SArnaldo Carvalho de Melo
17828856dfa3SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct iphdr));
1783b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header;
17848856dfa3SArnaldo Carvalho de Melo skb_reset_network_header(skb);
1785eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb);
17861da177e4SLinus Torvalds
17871da177e4SLinus Torvalds iph->version = 4;
1788e023dd64SArnaldo Carvalho de Melo iph->tos = old_iph->tos;
1789e023dd64SArnaldo Carvalho de Melo iph->ttl = old_iph->ttl;
17901da177e4SLinus Torvalds iph->frag_off = 0;
17911da177e4SLinus Torvalds iph->daddr = daddr;
17921da177e4SLinus Torvalds iph->saddr = saddr;
17931da177e4SLinus Torvalds iph->protocol = IPPROTO_IPIP;
17941da177e4SLinus Torvalds iph->ihl = 5;
17951da177e4SLinus Torvalds iph->tot_len = htons(skb->len);
1796b6a7719aSHannes Frederic Sowa ip_select_ident(net, skb, NULL);
17971da177e4SLinus Torvalds ip_send_check(iph);
17981da177e4SLinus Torvalds
17991da177e4SLinus Torvalds memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1800895b5c9fSFlorian Westphal nf_reset_ct(skb);
18011da177e4SLinus Torvalds }
18021da177e4SLinus Torvalds
ipmr_forward_finish(struct net * net,struct sock * sk,struct sk_buff * skb)18030c4b51f0SEric W. Biederman static inline int ipmr_forward_finish(struct net *net, struct sock *sk,
18040c4b51f0SEric W. Biederman struct sk_buff *skb)
18051da177e4SLinus Torvalds {
18061da177e4SLinus Torvalds struct ip_options *opt = &(IPCB(skb)->opt);
18071da177e4SLinus Torvalds
180873186df8SDavid S. Miller IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS);
18091da177e4SLinus Torvalds
18101da177e4SLinus Torvalds if (unlikely(opt->optlen))
18111da177e4SLinus Torvalds ip_forward_options(skb);
18121da177e4SLinus Torvalds
181313206b6bSEric W. Biederman return dst_output(net, sk, skb);
18141da177e4SLinus Torvalds }
18151da177e4SLinus Torvalds
1816a5bc9294SYotam Gigi #ifdef CONFIG_NET_SWITCHDEV
ipmr_forward_offloaded(struct sk_buff * skb,struct mr_table * mrt,int in_vifi,int out_vifi)1817a5bc9294SYotam Gigi static bool ipmr_forward_offloaded(struct sk_buff *skb, struct mr_table *mrt,
1818a5bc9294SYotam Gigi int in_vifi, int out_vifi)
1819a5bc9294SYotam Gigi {
1820a5bc9294SYotam Gigi struct vif_device *out_vif = &mrt->vif_table[out_vifi];
1821a5bc9294SYotam Gigi struct vif_device *in_vif = &mrt->vif_table[in_vifi];
1822a5bc9294SYotam Gigi
1823875e8939SIdo Schimmel if (!skb->offload_l3_fwd_mark)
1824a5bc9294SYotam Gigi return false;
1825a5bc9294SYotam Gigi if (!out_vif->dev_parent_id.id_len || !in_vif->dev_parent_id.id_len)
1826a5bc9294SYotam Gigi return false;
1827a5bc9294SYotam Gigi return netdev_phys_item_id_same(&out_vif->dev_parent_id,
1828a5bc9294SYotam Gigi &in_vif->dev_parent_id);
1829a5bc9294SYotam Gigi }
1830a5bc9294SYotam Gigi #else
ipmr_forward_offloaded(struct sk_buff * skb,struct mr_table * mrt,int in_vifi,int out_vifi)1831a5bc9294SYotam Gigi static bool ipmr_forward_offloaded(struct sk_buff *skb, struct mr_table *mrt,
1832a5bc9294SYotam Gigi int in_vifi, int out_vifi)
1833a5bc9294SYotam Gigi {
1834a5bc9294SYotam Gigi return false;
1835a5bc9294SYotam Gigi }
1836a5bc9294SYotam Gigi #endif
1837a5bc9294SYotam Gigi
18384eadb882SEric Dumazet /* Processing handlers for ipmr_forward, under rcu_read_lock() */
18391da177e4SLinus Torvalds
ipmr_queue_xmit(struct net * net,struct mr_table * mrt,int in_vifi,struct sk_buff * skb,int vifi)18400c12295aSPatrick McHardy static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
18416e0735d1SDavid Ahern int in_vifi, struct sk_buff *skb, int vifi)
18421da177e4SLinus Torvalds {
1843eddc9ec5SArnaldo Carvalho de Melo const struct iphdr *iph = ip_hdr(skb);
18440c12295aSPatrick McHardy struct vif_device *vif = &mrt->vif_table[vifi];
1845ebc31979SEric Dumazet struct net_device *vif_dev;
18461da177e4SLinus Torvalds struct net_device *dev;
18471da177e4SLinus Torvalds struct rtable *rt;
184831e4543dSDavid S. Miller struct flowi4 fl4;
18491da177e4SLinus Torvalds int encap = 0;
18501da177e4SLinus Torvalds
1851ebc31979SEric Dumazet vif_dev = vif_dev_read(vif);
1852ebc31979SEric Dumazet if (!vif_dev)
18531da177e4SLinus Torvalds goto out_free;
18541da177e4SLinus Torvalds
18551da177e4SLinus Torvalds if (vif->flags & VIFF_REGISTER) {
1856559260fdSEric Dumazet WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
1857559260fdSEric Dumazet WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
1858c4794d22SEric Dumazet DEV_STATS_ADD(vif_dev, tx_bytes, skb->len);
1859c4794d22SEric Dumazet DEV_STATS_INC(vif_dev, tx_packets);
18600c12295aSPatrick McHardy ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
186169ebbf58SIlpo Järvinen goto out_free;
18621da177e4SLinus Torvalds }
18631da177e4SLinus Torvalds
1864a5bc9294SYotam Gigi if (ipmr_forward_offloaded(skb, mrt, in_vifi, vifi))
1865a5bc9294SYotam Gigi goto out_free;
1866a5bc9294SYotam Gigi
18671da177e4SLinus Torvalds if (vif->flags & VIFF_TUNNEL) {
186831e4543dSDavid S. Miller rt = ip_route_output_ports(net, &fl4, NULL,
186978fbfd8aSDavid S. Miller vif->remote, vif->local,
187078fbfd8aSDavid S. Miller 0, 0,
187178fbfd8aSDavid S. Miller IPPROTO_IPIP,
1872*97edbbaaSIdo Schimmel iph->tos & INET_DSCP_MASK, vif->link);
1873b23dd4feSDavid S. Miller if (IS_ERR(rt))
18741da177e4SLinus Torvalds goto out_free;
18751da177e4SLinus Torvalds encap = sizeof(struct iphdr);
18761da177e4SLinus Torvalds } else {
187731e4543dSDavid S. Miller rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
187878fbfd8aSDavid S. Miller 0, 0,
187978fbfd8aSDavid S. Miller IPPROTO_IPIP,
1880*97edbbaaSIdo Schimmel iph->tos & INET_DSCP_MASK, vif->link);
1881b23dd4feSDavid S. Miller if (IS_ERR(rt))
18821da177e4SLinus Torvalds goto out_free;
18831da177e4SLinus Torvalds }
18841da177e4SLinus Torvalds
1885d8d1f30bSChangli Gao dev = rt->dst.dev;
18861da177e4SLinus Torvalds
1887d8d1f30bSChangli Gao if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
18881da177e4SLinus Torvalds /* Do not fragment multicasts. Alas, IPv4 does not
1889a8cb16ddSEric Dumazet * allow to send ICMP, so that packets will disappear
1890a8cb16ddSEric Dumazet * to blackhole.
18911da177e4SLinus Torvalds */
189273186df8SDavid S. Miller IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
18931da177e4SLinus Torvalds ip_rt_put(rt);
18941da177e4SLinus Torvalds goto out_free;
18951da177e4SLinus Torvalds }
18961da177e4SLinus Torvalds
1897d8d1f30bSChangli Gao encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
18981da177e4SLinus Torvalds
18991da177e4SLinus Torvalds if (skb_cow(skb, encap)) {
19001da177e4SLinus Torvalds ip_rt_put(rt);
19011da177e4SLinus Torvalds goto out_free;
19021da177e4SLinus Torvalds }
19031da177e4SLinus Torvalds
1904559260fdSEric Dumazet WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
1905559260fdSEric Dumazet WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
19061da177e4SLinus Torvalds
1907adf30907SEric Dumazet skb_dst_drop(skb);
1908d8d1f30bSChangli Gao skb_dst_set(skb, &rt->dst);
1909eddc9ec5SArnaldo Carvalho de Melo ip_decrease_ttl(ip_hdr(skb));
19101da177e4SLinus Torvalds
19111da177e4SLinus Torvalds /* FIXME: forward and output firewalls used to be called here.
1912a8cb16ddSEric Dumazet * What do we do with netfilter? -- RR
1913a8cb16ddSEric Dumazet */
19141da177e4SLinus Torvalds if (vif->flags & VIFF_TUNNEL) {
1915b6a7719aSHannes Frederic Sowa ip_encap(net, skb, vif->local, vif->remote);
19161da177e4SLinus Torvalds /* FIXME: extra output firewall step used to be here. --RR */
1917c4794d22SEric Dumazet DEV_STATS_INC(vif_dev, tx_packets);
1918c4794d22SEric Dumazet DEV_STATS_ADD(vif_dev, tx_bytes, skb->len);
19191da177e4SLinus Torvalds }
19201da177e4SLinus Torvalds
19219ee6c5dcSLance Richardson IPCB(skb)->flags |= IPSKB_FORWARDED;
19221da177e4SLinus Torvalds
19237ef8f65dSNikolay Aleksandrov /* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
19241da177e4SLinus Torvalds * not only before forwarding, but after forwarding on all output
19251da177e4SLinus Torvalds * interfaces. It is clear, if mrouter runs a multicasting
19261da177e4SLinus Torvalds * program, it should receive packets not depending to what interface
19271da177e4SLinus Torvalds * program is joined.
19281da177e4SLinus Torvalds * If we will not make it, the program will have to join on all
19291da177e4SLinus Torvalds * interfaces. On the other hand, multihoming host (or router, but
19301da177e4SLinus Torvalds * not mrouter) cannot join to more than one interface - it will
19311da177e4SLinus Torvalds * result in receiving multiple packets.
19321da177e4SLinus Torvalds */
193329a26a56SEric W. Biederman NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
193429a26a56SEric W. Biederman net, NULL, skb, skb->dev, dev,
19351da177e4SLinus Torvalds ipmr_forward_finish);
19361da177e4SLinus Torvalds return;
19371da177e4SLinus Torvalds
19381da177e4SLinus Torvalds out_free:
19391da177e4SLinus Torvalds kfree_skb(skb);
19401da177e4SLinus Torvalds }
19411da177e4SLinus Torvalds
19429094db4bSEric Dumazet /* Called with mrt_lock or rcu_read_lock() */
ipmr_find_vif(const struct mr_table * mrt,struct net_device * dev)19439094db4bSEric Dumazet static int ipmr_find_vif(const struct mr_table *mrt, struct net_device *dev)
19441da177e4SLinus Torvalds {
19451da177e4SLinus Torvalds int ct;
19469094db4bSEric Dumazet /* Pairs with WRITE_ONCE() in vif_delete()/vif_add() */
19479094db4bSEric Dumazet for (ct = READ_ONCE(mrt->maxvif) - 1; ct >= 0; ct--) {
1948ebc31979SEric Dumazet if (rcu_access_pointer(mrt->vif_table[ct].dev) == dev)
19491da177e4SLinus Torvalds break;
19501da177e4SLinus Torvalds }
19511da177e4SLinus Torvalds return ct;
19521da177e4SLinus Torvalds }
19531da177e4SLinus Torvalds
19541da177e4SLinus Torvalds /* "local" means that we should preserve one skb (for local delivery) */
19554eadb882SEric Dumazet /* Called uner rcu_read_lock() */
ip_mr_forward(struct net * net,struct mr_table * mrt,struct net_device * dev,struct sk_buff * skb,struct mfc_cache * c,int local)1956c4854ec8SRami Rosen static void ip_mr_forward(struct net *net, struct mr_table *mrt,
19574b1f0d33SDonald Sharp struct net_device *dev, struct sk_buff *skb,
1958494fff56SYuval Mintz struct mfc_cache *c, int local)
19591da177e4SLinus Torvalds {
19604b1f0d33SDonald Sharp int true_vifi = ipmr_find_vif(mrt, dev);
19611da177e4SLinus Torvalds int psend = -1;
19621da177e4SLinus Torvalds int vif, ct;
19631da177e4SLinus Torvalds
1964494fff56SYuval Mintz vif = c->_c.mfc_parent;
1965494fff56SYuval Mintz c->_c.mfc_un.res.pkt++;
1966494fff56SYuval Mintz c->_c.mfc_un.res.bytes += skb->len;
1967494fff56SYuval Mintz c->_c.mfc_un.res.lastuse = jiffies;
19681da177e4SLinus Torvalds
1969494fff56SYuval Mintz if (c->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) {
1970660b26dcSNicolas Dichtel struct mfc_cache *cache_proxy;
1971660b26dcSNicolas Dichtel
1972974d8f86SZheng Yongjun /* For an (*,G) entry, we only check that the incoming
1973660b26dcSNicolas Dichtel * interface is part of the static tree.
1974660b26dcSNicolas Dichtel */
1975845c9a7aSYuval Mintz cache_proxy = mr_mfc_find_any_parent(mrt, vif);
1976660b26dcSNicolas Dichtel if (cache_proxy &&
1977494fff56SYuval Mintz cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255)
1978660b26dcSNicolas Dichtel goto forward;
1979660b26dcSNicolas Dichtel }
1980660b26dcSNicolas Dichtel
19817ef8f65dSNikolay Aleksandrov /* Wrong interface: drop packet and (maybe) send PIM assert. */
1982ebc31979SEric Dumazet if (rcu_access_pointer(mrt->vif_table[vif].dev) != dev) {
1983c7537967SDavid S. Miller if (rt_is_output_route(skb_rtable(skb))) {
19841da177e4SLinus Torvalds /* It is our own packet, looped back.
1985a8cb16ddSEric Dumazet * Very complicated situation...
1986a8cb16ddSEric Dumazet *
1987a8cb16ddSEric Dumazet * The best workaround until routing daemons will be
1988a8cb16ddSEric Dumazet * fixed is not to redistribute packet, if it was
1989a8cb16ddSEric Dumazet * send through wrong interface. It means, that
1990a8cb16ddSEric Dumazet * multicast applications WILL NOT work for
1991a8cb16ddSEric Dumazet * (S,G), which have default multicast route pointing
1992a8cb16ddSEric Dumazet * to wrong oif. In any case, it is not a good
1993a8cb16ddSEric Dumazet * idea to use multicasting applications on router.
19941da177e4SLinus Torvalds */
19951da177e4SLinus Torvalds goto dont_forward;
19961da177e4SLinus Torvalds }
19971da177e4SLinus Torvalds
1998494fff56SYuval Mintz c->_c.mfc_un.res.wrong_if++;
19991da177e4SLinus Torvalds
20000c12295aSPatrick McHardy if (true_vifi >= 0 && mrt->mroute_do_assert &&
20011da177e4SLinus Torvalds /* pimsm uses asserts, when switching from RPT to SPT,
2002a8cb16ddSEric Dumazet * so that we cannot check that packet arrived on an oif.
2003a8cb16ddSEric Dumazet * It is bad, but otherwise we would need to move pretty
2004a8cb16ddSEric Dumazet * large chunk of pimd to kernel. Ough... --ANK
20051da177e4SLinus Torvalds */
20060c12295aSPatrick McHardy (mrt->mroute_do_pim ||
2007494fff56SYuval Mintz c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
20081da177e4SLinus Torvalds time_after(jiffies,
2009494fff56SYuval Mintz c->_c.mfc_un.res.last_assert +
2010494fff56SYuval Mintz MFC_ASSERT_THRESH)) {
2011494fff56SYuval Mintz c->_c.mfc_un.res.last_assert = jiffies;
20120c12295aSPatrick McHardy ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
2013c921c207SNikolay Aleksandrov if (mrt->mroute_do_wrvifwhole)
2014c921c207SNikolay Aleksandrov ipmr_cache_report(mrt, skb, true_vifi,
2015c921c207SNikolay Aleksandrov IGMPMSG_WRVIFWHOLE);
20161da177e4SLinus Torvalds }
20171da177e4SLinus Torvalds goto dont_forward;
20181da177e4SLinus Torvalds }
20191da177e4SLinus Torvalds
2020660b26dcSNicolas Dichtel forward:
2021559260fdSEric Dumazet WRITE_ONCE(mrt->vif_table[vif].pkt_in,
2022559260fdSEric Dumazet mrt->vif_table[vif].pkt_in + 1);
2023559260fdSEric Dumazet WRITE_ONCE(mrt->vif_table[vif].bytes_in,
2024559260fdSEric Dumazet mrt->vif_table[vif].bytes_in + skb->len);
20251da177e4SLinus Torvalds
20267ef8f65dSNikolay Aleksandrov /* Forward the frame */
2027494fff56SYuval Mintz if (c->mfc_origin == htonl(INADDR_ANY) &&
2028494fff56SYuval Mintz c->mfc_mcastgrp == htonl(INADDR_ANY)) {
2029660b26dcSNicolas Dichtel if (true_vifi >= 0 &&
2030494fff56SYuval Mintz true_vifi != c->_c.mfc_parent &&
2031660b26dcSNicolas Dichtel ip_hdr(skb)->ttl >
2032494fff56SYuval Mintz c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
2033660b26dcSNicolas Dichtel /* It's an (*,*) entry and the packet is not coming from
2034660b26dcSNicolas Dichtel * the upstream: forward the packet to the upstream
2035660b26dcSNicolas Dichtel * only.
2036660b26dcSNicolas Dichtel */
2037494fff56SYuval Mintz psend = c->_c.mfc_parent;
2038660b26dcSNicolas Dichtel goto last_forward;
2039660b26dcSNicolas Dichtel }
2040660b26dcSNicolas Dichtel goto dont_forward;
2041660b26dcSNicolas Dichtel }
2042494fff56SYuval Mintz for (ct = c->_c.mfc_un.res.maxvif - 1;
2043494fff56SYuval Mintz ct >= c->_c.mfc_un.res.minvif; ct--) {
2044660b26dcSNicolas Dichtel /* For (*,G) entry, don't forward to the incoming interface */
2045494fff56SYuval Mintz if ((c->mfc_origin != htonl(INADDR_ANY) ||
2046360eb5daSNicolas Dichtel ct != true_vifi) &&
2047494fff56SYuval Mintz ip_hdr(skb)->ttl > c->_c.mfc_un.res.ttls[ct]) {
20481da177e4SLinus Torvalds if (psend != -1) {
20491da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2050a8cb16ddSEric Dumazet
20511da177e4SLinus Torvalds if (skb2)
2052a5bc9294SYotam Gigi ipmr_queue_xmit(net, mrt, true_vifi,
20536e0735d1SDavid Ahern skb2, psend);
20541da177e4SLinus Torvalds }
20551da177e4SLinus Torvalds psend = ct;
20561da177e4SLinus Torvalds }
20571da177e4SLinus Torvalds }
2058660b26dcSNicolas Dichtel last_forward:
20591da177e4SLinus Torvalds if (psend != -1) {
20601da177e4SLinus Torvalds if (local) {
20611da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2062a8cb16ddSEric Dumazet
20631da177e4SLinus Torvalds if (skb2)
2064a5bc9294SYotam Gigi ipmr_queue_xmit(net, mrt, true_vifi, skb2,
20656e0735d1SDavid Ahern psend);
20661da177e4SLinus Torvalds } else {
20676e0735d1SDavid Ahern ipmr_queue_xmit(net, mrt, true_vifi, skb, psend);
2068c4854ec8SRami Rosen return;
20691da177e4SLinus Torvalds }
20701da177e4SLinus Torvalds }
20711da177e4SLinus Torvalds
20721da177e4SLinus Torvalds dont_forward:
20731da177e4SLinus Torvalds if (!local)
20741da177e4SLinus Torvalds kfree_skb(skb);
20751da177e4SLinus Torvalds }
20761da177e4SLinus Torvalds
ipmr_rt_fib_lookup(struct net * net,struct sk_buff * skb)2077417da66fSDavid S. Miller static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
2078ee3f1aafSDavid S. Miller {
2079417da66fSDavid S. Miller struct rtable *rt = skb_rtable(skb);
2080417da66fSDavid S. Miller struct iphdr *iph = ip_hdr(skb);
2081da91981bSDavid S. Miller struct flowi4 fl4 = {
2082417da66fSDavid S. Miller .daddr = iph->daddr,
2083417da66fSDavid S. Miller .saddr = iph->saddr,
20842bc9778bSIdo Schimmel .flowi4_tos = iph->tos & INET_DSCP_MASK,
20854fd551d7SDavid S. Miller .flowi4_oif = (rt_is_output_route(rt) ?
20864fd551d7SDavid S. Miller skb->dev->ifindex : 0),
20874fd551d7SDavid S. Miller .flowi4_iif = (rt_is_output_route(rt) ?
20881fb9489bSPavel Emelyanov LOOPBACK_IFINDEX :
20894fd551d7SDavid S. Miller skb->dev->ifindex),
2090b4869889SDavid Miller .flowi4_mark = skb->mark,
2091ee3f1aafSDavid S. Miller };
2092ee3f1aafSDavid S. Miller struct mr_table *mrt;
2093ee3f1aafSDavid S. Miller int err;
2094ee3f1aafSDavid S. Miller
2095da91981bSDavid S. Miller err = ipmr_fib_lookup(net, &fl4, &mrt);
2096ee3f1aafSDavid S. Miller if (err)
2097ee3f1aafSDavid S. Miller return ERR_PTR(err);
2098ee3f1aafSDavid S. Miller return mrt;
2099ee3f1aafSDavid S. Miller }
21001da177e4SLinus Torvalds
21017ef8f65dSNikolay Aleksandrov /* Multicast packets for forwarding arrive here
21024c968709SEric Dumazet * Called with rcu_read_lock();
21031da177e4SLinus Torvalds */
ip_mr_input(struct sk_buff * skb)21041da177e4SLinus Torvalds int ip_mr_input(struct sk_buff *skb)
21051da177e4SLinus Torvalds {
21061da177e4SLinus Torvalds struct mfc_cache *cache;
21074feb88e5SBenjamin Thery struct net *net = dev_net(skb->dev);
2108511c3f92SEric Dumazet int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
2109f0ad0860SPatrick McHardy struct mr_table *mrt;
2110bcfc7d33SThomas Winter struct net_device *dev;
2111bcfc7d33SThomas Winter
2112bcfc7d33SThomas Winter /* skb->dev passed in is the loX master dev for vrfs.
2113bcfc7d33SThomas Winter * As there are no vifs associated with loopback devices,
2114bcfc7d33SThomas Winter * get the proper interface that does have a vif associated with it.
2115bcfc7d33SThomas Winter */
2116bcfc7d33SThomas Winter dev = skb->dev;
2117bcfc7d33SThomas Winter if (netif_is_l3_master(skb->dev)) {
2118bcfc7d33SThomas Winter dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2119bcfc7d33SThomas Winter if (!dev) {
2120bcfc7d33SThomas Winter kfree_skb(skb);
2121bcfc7d33SThomas Winter return -ENODEV;
2122bcfc7d33SThomas Winter }
2123bcfc7d33SThomas Winter }
21241da177e4SLinus Torvalds
21251da177e4SLinus Torvalds /* Packet is looped back after forward, it should not be
2126a8cb16ddSEric Dumazet * forwarded second time, but still can be delivered locally.
21271da177e4SLinus Torvalds */
21281da177e4SLinus Torvalds if (IPCB(skb)->flags & IPSKB_FORWARDED)
21291da177e4SLinus Torvalds goto dont_forward;
21301da177e4SLinus Torvalds
2131417da66fSDavid S. Miller mrt = ipmr_rt_fib_lookup(net, skb);
2132ee3f1aafSDavid S. Miller if (IS_ERR(mrt)) {
2133e40dbc51SBen Greear kfree_skb(skb);
2134ee3f1aafSDavid S. Miller return PTR_ERR(mrt);
21355e2b61f7SDavid S. Miller }
21361da177e4SLinus Torvalds if (!local) {
21371da177e4SLinus Torvalds if (IPCB(skb)->opt.router_alert) {
21381da177e4SLinus Torvalds if (ip_call_ra_chain(skb))
21391da177e4SLinus Torvalds return 0;
2140eddc9ec5SArnaldo Carvalho de Melo } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) {
21411da177e4SLinus Torvalds /* IGMPv1 (and broken IGMPv2 implementations sort of
21424c968709SEric Dumazet * Cisco IOS <= 11.2(8)) do not put router alert
21434c968709SEric Dumazet * option to IGMP packets destined to routable
21444c968709SEric Dumazet * groups. It is very bad, because it means
21454c968709SEric Dumazet * that we can forward NO IGMP messages.
21461da177e4SLinus Torvalds */
21474c968709SEric Dumazet struct sock *mroute_sk;
21484c968709SEric Dumazet
21494c968709SEric Dumazet mroute_sk = rcu_dereference(mrt->mroute_sk);
21504c968709SEric Dumazet if (mroute_sk) {
2151895b5c9fSFlorian Westphal nf_reset_ct(skb);
21524c968709SEric Dumazet raw_rcv(mroute_sk, skb);
21531da177e4SLinus Torvalds return 0;
21541da177e4SLinus Torvalds }
21551da177e4SLinus Torvalds }
21561da177e4SLinus Torvalds }
21571da177e4SLinus Torvalds
2158a8c9486bSEric Dumazet /* already under rcu_read_lock() */
21590c12295aSPatrick McHardy cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
216051456b29SIan Morris if (!cache) {
2161bcfc7d33SThomas Winter int vif = ipmr_find_vif(mrt, dev);
2162660b26dcSNicolas Dichtel
2163660b26dcSNicolas Dichtel if (vif >= 0)
2164660b26dcSNicolas Dichtel cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr,
2165660b26dcSNicolas Dichtel vif);
2166660b26dcSNicolas Dichtel }
21671da177e4SLinus Torvalds
21687ef8f65dSNikolay Aleksandrov /* No usable cache entry */
216951456b29SIan Morris if (!cache) {
21701da177e4SLinus Torvalds int vif;
21711da177e4SLinus Torvalds
21721da177e4SLinus Torvalds if (local) {
21731da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
21741da177e4SLinus Torvalds ip_local_deliver(skb);
217551456b29SIan Morris if (!skb2)
21761da177e4SLinus Torvalds return -ENOBUFS;
21771da177e4SLinus Torvalds skb = skb2;
21781da177e4SLinus Torvalds }
21791da177e4SLinus Torvalds
2180bcfc7d33SThomas Winter vif = ipmr_find_vif(mrt, dev);
21819094db4bSEric Dumazet if (vif >= 0)
21829094db4bSEric Dumazet return ipmr_cache_unresolved(mrt, vif, skb, dev);
21831da177e4SLinus Torvalds kfree_skb(skb);
21841da177e4SLinus Torvalds return -ENODEV;
21851da177e4SLinus Torvalds }
21861da177e4SLinus Torvalds
21874b1f0d33SDonald Sharp ip_mr_forward(net, mrt, dev, skb, cache, local);
21881da177e4SLinus Torvalds
21891da177e4SLinus Torvalds if (local)
21901da177e4SLinus Torvalds return ip_local_deliver(skb);
21911da177e4SLinus Torvalds
21921da177e4SLinus Torvalds return 0;
21931da177e4SLinus Torvalds
21941da177e4SLinus Torvalds dont_forward:
21951da177e4SLinus Torvalds if (local)
21961da177e4SLinus Torvalds return ip_local_deliver(skb);
21971da177e4SLinus Torvalds kfree_skb(skb);
21981da177e4SLinus Torvalds return 0;
21991da177e4SLinus Torvalds }
22001da177e4SLinus Torvalds
2201b1879204SIlpo Järvinen #ifdef CONFIG_IP_PIMSM_V1
22027ef8f65dSNikolay Aleksandrov /* Handle IGMP messages of PIMv1 */
pim_rcv_v1(struct sk_buff * skb)2203b1879204SIlpo Järvinen int pim_rcv_v1(struct sk_buff *skb)
2204b1879204SIlpo Järvinen {
2205b1879204SIlpo Järvinen struct igmphdr *pim;
22064feb88e5SBenjamin Thery struct net *net = dev_net(skb->dev);
2207f0ad0860SPatrick McHardy struct mr_table *mrt;
2208b1879204SIlpo Järvinen
2209b1879204SIlpo Järvinen if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
2210b1879204SIlpo Järvinen goto drop;
2211b1879204SIlpo Järvinen
2212b1879204SIlpo Järvinen pim = igmp_hdr(skb);
2213b1879204SIlpo Järvinen
2214417da66fSDavid S. Miller mrt = ipmr_rt_fib_lookup(net, skb);
2215ee3f1aafSDavid S. Miller if (IS_ERR(mrt))
2216f0ad0860SPatrick McHardy goto drop;
22170c12295aSPatrick McHardy if (!mrt->mroute_do_pim ||
2218b1879204SIlpo Järvinen pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
2219b1879204SIlpo Järvinen goto drop;
2220b1879204SIlpo Järvinen
2221f0ad0860SPatrick McHardy if (__pim_rcv(mrt, skb, sizeof(*pim))) {
22221da177e4SLinus Torvalds drop:
22231da177e4SLinus Torvalds kfree_skb(skb);
2224b1879204SIlpo Järvinen }
22251da177e4SLinus Torvalds return 0;
22261da177e4SLinus Torvalds }
22271da177e4SLinus Torvalds #endif
22281da177e4SLinus Torvalds
22291da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2
pim_rcv(struct sk_buff * skb)22301da177e4SLinus Torvalds static int pim_rcv(struct sk_buff *skb)
22311da177e4SLinus Torvalds {
22321da177e4SLinus Torvalds struct pimreghdr *pim;
2233f0ad0860SPatrick McHardy struct net *net = dev_net(skb->dev);
2234f0ad0860SPatrick McHardy struct mr_table *mrt;
22351da177e4SLinus Torvalds
2236b1879204SIlpo Järvinen if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
22371da177e4SLinus Torvalds goto drop;
22381da177e4SLinus Torvalds
22399c70220bSArnaldo Carvalho de Melo pim = (struct pimreghdr *)skb_transport_header(skb);
224056245caeSNikolay Aleksandrov if (pim->type != ((PIM_VERSION << 4) | (PIM_TYPE_REGISTER)) ||
22411da177e4SLinus Torvalds (pim->flags & PIM_NULL_REGISTER) ||
22421da177e4SLinus Torvalds (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
2243d3bc23e7SAl Viro csum_fold(skb_checksum(skb, 0, skb->len, 0))))
22441da177e4SLinus Torvalds goto drop;
22451da177e4SLinus Torvalds
2246417da66fSDavid S. Miller mrt = ipmr_rt_fib_lookup(net, skb);
2247ee3f1aafSDavid S. Miller if (IS_ERR(mrt))
2248f0ad0860SPatrick McHardy goto drop;
2249f0ad0860SPatrick McHardy if (__pim_rcv(mrt, skb, sizeof(*pim))) {
22501da177e4SLinus Torvalds drop:
22511da177e4SLinus Torvalds kfree_skb(skb);
2252b1879204SIlpo Järvinen }
22531da177e4SLinus Torvalds return 0;
22541da177e4SLinus Torvalds }
22551da177e4SLinus Torvalds #endif
22561da177e4SLinus Torvalds
ipmr_get_route(struct net * net,struct sk_buff * skb,__be32 saddr,__be32 daddr,struct rtmsg * rtm,u32 portid)22579a1b9496SDavid S. Miller int ipmr_get_route(struct net *net, struct sk_buff *skb,
22589a1b9496SDavid S. Miller __be32 saddr, __be32 daddr,
22599f09eaeaSDavid Ahern struct rtmsg *rtm, u32 portid)
22601da177e4SLinus Torvalds {
22611da177e4SLinus Torvalds struct mfc_cache *cache;
22629a1b9496SDavid S. Miller struct mr_table *mrt;
22639a1b9496SDavid S. Miller int err;
22641da177e4SLinus Torvalds
2265f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
226651456b29SIan Morris if (!mrt)
2267f0ad0860SPatrick McHardy return -ENOENT;
2268f0ad0860SPatrick McHardy
2269a8c9486bSEric Dumazet rcu_read_lock();
22709a1b9496SDavid S. Miller cache = ipmr_cache_find(mrt, saddr, daddr);
227151456b29SIan Morris if (!cache && skb->dev) {
2272660b26dcSNicolas Dichtel int vif = ipmr_find_vif(mrt, skb->dev);
22731da177e4SLinus Torvalds
2274660b26dcSNicolas Dichtel if (vif >= 0)
2275660b26dcSNicolas Dichtel cache = ipmr_cache_find_any(mrt, daddr, vif);
2276660b26dcSNicolas Dichtel }
227751456b29SIan Morris if (!cache) {
227872287490SAlexey Kuznetsov struct sk_buff *skb2;
2279eddc9ec5SArnaldo Carvalho de Melo struct iphdr *iph;
22801da177e4SLinus Torvalds struct net_device *dev;
2281a8cb16ddSEric Dumazet int vif = -1;
22821da177e4SLinus Torvalds
22831da177e4SLinus Torvalds dev = skb->dev;
2284a8cb16ddSEric Dumazet if (dev)
2285a8cb16ddSEric Dumazet vif = ipmr_find_vif(mrt, dev);
2286a8cb16ddSEric Dumazet if (vif < 0) {
2287a8c9486bSEric Dumazet rcu_read_unlock();
22881da177e4SLinus Torvalds return -ENODEV;
22891da177e4SLinus Torvalds }
22907901cd97SGuillaume Nault
22917901cd97SGuillaume Nault skb2 = skb_realloc_headroom(skb, sizeof(struct iphdr));
229272287490SAlexey Kuznetsov if (!skb2) {
2293a8c9486bSEric Dumazet rcu_read_unlock();
229472287490SAlexey Kuznetsov return -ENOMEM;
229572287490SAlexey Kuznetsov }
229672287490SAlexey Kuznetsov
22972cf75070SNikolay Aleksandrov NETLINK_CB(skb2).portid = portid;
2298e2d1bca7SArnaldo Carvalho de Melo skb_push(skb2, sizeof(struct iphdr));
2299e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(skb2);
2300eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb2);
2301eddc9ec5SArnaldo Carvalho de Melo iph->ihl = sizeof(struct iphdr) >> 2;
23029a1b9496SDavid S. Miller iph->saddr = saddr;
23039a1b9496SDavid S. Miller iph->daddr = daddr;
2304eddc9ec5SArnaldo Carvalho de Melo iph->version = 0;
23054b1f0d33SDonald Sharp err = ipmr_cache_unresolved(mrt, vif, skb2, dev);
2306a8c9486bSEric Dumazet rcu_read_unlock();
23071da177e4SLinus Torvalds return err;
23081da177e4SLinus Torvalds }
23091da177e4SLinus Torvalds
23107b0db857SYuval Mintz err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
2311a8c9486bSEric Dumazet rcu_read_unlock();
23121da177e4SLinus Torvalds return err;
23131da177e4SLinus Torvalds }
23141da177e4SLinus Torvalds
ipmr_fill_mroute(struct mr_table * mrt,struct sk_buff * skb,u32 portid,u32 seq,struct mfc_cache * c,int cmd,int flags)2315cb6a4e46SPatrick McHardy static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
231665886f43SNicolas Dichtel u32 portid, u32 seq, struct mfc_cache *c, int cmd,
231765886f43SNicolas Dichtel int flags)
2318cb6a4e46SPatrick McHardy {
2319cb6a4e46SPatrick McHardy struct nlmsghdr *nlh;
2320cb6a4e46SPatrick McHardy struct rtmsg *rtm;
23211eb99af5SNicolas Dichtel int err;
2322cb6a4e46SPatrick McHardy
232365886f43SNicolas Dichtel nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
232451456b29SIan Morris if (!nlh)
2325cb6a4e46SPatrick McHardy return -EMSGSIZE;
2326cb6a4e46SPatrick McHardy
2327cb6a4e46SPatrick McHardy rtm = nlmsg_data(nlh);
2328cb6a4e46SPatrick McHardy rtm->rtm_family = RTNL_FAMILY_IPMR;
2329cb6a4e46SPatrick McHardy rtm->rtm_dst_len = 32;
2330cb6a4e46SPatrick McHardy rtm->rtm_src_len = 32;
2331cb6a4e46SPatrick McHardy rtm->rtm_tos = 0;
2332cb6a4e46SPatrick McHardy rtm->rtm_table = mrt->id;
2333f3756b79SDavid S. Miller if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2334f3756b79SDavid S. Miller goto nla_put_failure;
2335cb6a4e46SPatrick McHardy rtm->rtm_type = RTN_MULTICAST;
2336cb6a4e46SPatrick McHardy rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2337494fff56SYuval Mintz if (c->_c.mfc_flags & MFC_STATIC)
23389a68ac72SNicolas Dichtel rtm->rtm_protocol = RTPROT_STATIC;
23399a68ac72SNicolas Dichtel else
23409a68ac72SNicolas Dichtel rtm->rtm_protocol = RTPROT_MROUTED;
2341cb6a4e46SPatrick McHardy rtm->rtm_flags = 0;
2342cb6a4e46SPatrick McHardy
2343930345eaSJiri Benc if (nla_put_in_addr(skb, RTA_SRC, c->mfc_origin) ||
2344930345eaSJiri Benc nla_put_in_addr(skb, RTA_DST, c->mfc_mcastgrp))
2345f3756b79SDavid S. Miller goto nla_put_failure;
23467b0db857SYuval Mintz err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
23471eb99af5SNicolas Dichtel /* do not break the dump if cache is unresolved */
23481eb99af5SNicolas Dichtel if (err < 0 && err != -ENOENT)
2349cb6a4e46SPatrick McHardy goto nla_put_failure;
2350cb6a4e46SPatrick McHardy
2351053c095aSJohannes Berg nlmsg_end(skb, nlh);
2352053c095aSJohannes Berg return 0;
2353cb6a4e46SPatrick McHardy
2354cb6a4e46SPatrick McHardy nla_put_failure:
2355cb6a4e46SPatrick McHardy nlmsg_cancel(skb, nlh);
2356cb6a4e46SPatrick McHardy return -EMSGSIZE;
2357cb6a4e46SPatrick McHardy }
2358cb6a4e46SPatrick McHardy
_ipmr_fill_mroute(struct mr_table * mrt,struct sk_buff * skb,u32 portid,u32 seq,struct mr_mfc * c,int cmd,int flags)23597b0db857SYuval Mintz static int _ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
23607b0db857SYuval Mintz u32 portid, u32 seq, struct mr_mfc *c, int cmd,
23617b0db857SYuval Mintz int flags)
23627b0db857SYuval Mintz {
23637b0db857SYuval Mintz return ipmr_fill_mroute(mrt, skb, portid, seq, (struct mfc_cache *)c,
23647b0db857SYuval Mintz cmd, flags);
23657b0db857SYuval Mintz }
23667b0db857SYuval Mintz
mroute_msgsize(bool unresolved,int maxvif)23678cd3ac9fSNicolas Dichtel static size_t mroute_msgsize(bool unresolved, int maxvif)
23688cd3ac9fSNicolas Dichtel {
23698cd3ac9fSNicolas Dichtel size_t len =
23708cd3ac9fSNicolas Dichtel NLMSG_ALIGN(sizeof(struct rtmsg))
23718cd3ac9fSNicolas Dichtel + nla_total_size(4) /* RTA_TABLE */
23728cd3ac9fSNicolas Dichtel + nla_total_size(4) /* RTA_SRC */
23738cd3ac9fSNicolas Dichtel + nla_total_size(4) /* RTA_DST */
23748cd3ac9fSNicolas Dichtel ;
23758cd3ac9fSNicolas Dichtel
23768cd3ac9fSNicolas Dichtel if (!unresolved)
23778cd3ac9fSNicolas Dichtel len = len
23788cd3ac9fSNicolas Dichtel + nla_total_size(4) /* RTA_IIF */
23798cd3ac9fSNicolas Dichtel + nla_total_size(0) /* RTA_MULTIPATH */
23808cd3ac9fSNicolas Dichtel + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
23818cd3ac9fSNicolas Dichtel /* RTA_MFC_STATS */
2382a9a08042SNicolas Dichtel + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
23838cd3ac9fSNicolas Dichtel ;
23848cd3ac9fSNicolas Dichtel
23858cd3ac9fSNicolas Dichtel return len;
23868cd3ac9fSNicolas Dichtel }
23878cd3ac9fSNicolas Dichtel
mroute_netlink_event(struct mr_table * mrt,struct mfc_cache * mfc,int cmd)23888cd3ac9fSNicolas Dichtel static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
23898cd3ac9fSNicolas Dichtel int cmd)
23908cd3ac9fSNicolas Dichtel {
23918cd3ac9fSNicolas Dichtel struct net *net = read_pnet(&mrt->net);
23928cd3ac9fSNicolas Dichtel struct sk_buff *skb;
23938cd3ac9fSNicolas Dichtel int err = -ENOBUFS;
23948cd3ac9fSNicolas Dichtel
2395494fff56SYuval Mintz skb = nlmsg_new(mroute_msgsize(mfc->_c.mfc_parent >= MAXVIFS,
2396494fff56SYuval Mintz mrt->maxvif),
23978cd3ac9fSNicolas Dichtel GFP_ATOMIC);
239851456b29SIan Morris if (!skb)
23998cd3ac9fSNicolas Dichtel goto errout;
24008cd3ac9fSNicolas Dichtel
240165886f43SNicolas Dichtel err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
24028cd3ac9fSNicolas Dichtel if (err < 0)
24038cd3ac9fSNicolas Dichtel goto errout;
24048cd3ac9fSNicolas Dichtel
24058cd3ac9fSNicolas Dichtel rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC);
24068cd3ac9fSNicolas Dichtel return;
24078cd3ac9fSNicolas Dichtel
24088cd3ac9fSNicolas Dichtel errout:
24098cd3ac9fSNicolas Dichtel kfree_skb(skb);
24108cd3ac9fSNicolas Dichtel rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err);
24118cd3ac9fSNicolas Dichtel }
24128cd3ac9fSNicolas Dichtel
igmpmsg_netlink_msgsize(size_t payloadlen)24135a645dd8SJulien Gomes static size_t igmpmsg_netlink_msgsize(size_t payloadlen)
24145a645dd8SJulien Gomes {
24155a645dd8SJulien Gomes size_t len =
24165a645dd8SJulien Gomes NLMSG_ALIGN(sizeof(struct rtgenmsg))
24175a645dd8SJulien Gomes + nla_total_size(1) /* IPMRA_CREPORT_MSGTYPE */
24185a645dd8SJulien Gomes + nla_total_size(4) /* IPMRA_CREPORT_VIF_ID */
24195a645dd8SJulien Gomes + nla_total_size(4) /* IPMRA_CREPORT_SRC_ADDR */
24205a645dd8SJulien Gomes + nla_total_size(4) /* IPMRA_CREPORT_DST_ADDR */
2421501cb008SPaul Davey + nla_total_size(4) /* IPMRA_CREPORT_TABLE */
24225a645dd8SJulien Gomes /* IPMRA_CREPORT_PKT */
24235a645dd8SJulien Gomes + nla_total_size(payloadlen)
24245a645dd8SJulien Gomes ;
24255a645dd8SJulien Gomes
24265a645dd8SJulien Gomes return len;
24275a645dd8SJulien Gomes }
24285a645dd8SJulien Gomes
igmpmsg_netlink_event(const struct mr_table * mrt,struct sk_buff * pkt)24290b490b51SEric Dumazet static void igmpmsg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt)
24305a645dd8SJulien Gomes {
24315a645dd8SJulien Gomes struct net *net = read_pnet(&mrt->net);
24325a645dd8SJulien Gomes struct nlmsghdr *nlh;
24335a645dd8SJulien Gomes struct rtgenmsg *rtgenm;
24345a645dd8SJulien Gomes struct igmpmsg *msg;
24355a645dd8SJulien Gomes struct sk_buff *skb;
24365a645dd8SJulien Gomes struct nlattr *nla;
24375a645dd8SJulien Gomes int payloadlen;
24385a645dd8SJulien Gomes
24395a645dd8SJulien Gomes payloadlen = pkt->len - sizeof(struct igmpmsg);
24405a645dd8SJulien Gomes msg = (struct igmpmsg *)skb_network_header(pkt);
24415a645dd8SJulien Gomes
24425a645dd8SJulien Gomes skb = nlmsg_new(igmpmsg_netlink_msgsize(payloadlen), GFP_ATOMIC);
24435a645dd8SJulien Gomes if (!skb)
24445a645dd8SJulien Gomes goto errout;
24455a645dd8SJulien Gomes
24465a645dd8SJulien Gomes nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
24475a645dd8SJulien Gomes sizeof(struct rtgenmsg), 0);
24485a645dd8SJulien Gomes if (!nlh)
24495a645dd8SJulien Gomes goto errout;
24505a645dd8SJulien Gomes rtgenm = nlmsg_data(nlh);
24515a645dd8SJulien Gomes rtgenm->rtgen_family = RTNL_FAMILY_IPMR;
24525a645dd8SJulien Gomes if (nla_put_u8(skb, IPMRA_CREPORT_MSGTYPE, msg->im_msgtype) ||
2453bb82067cSPaul Davey nla_put_u32(skb, IPMRA_CREPORT_VIF_ID, msg->im_vif | (msg->im_vif_hi << 8)) ||
24545a645dd8SJulien Gomes nla_put_in_addr(skb, IPMRA_CREPORT_SRC_ADDR,
24555a645dd8SJulien Gomes msg->im_src.s_addr) ||
24565a645dd8SJulien Gomes nla_put_in_addr(skb, IPMRA_CREPORT_DST_ADDR,
2457501cb008SPaul Davey msg->im_dst.s_addr) ||
2458501cb008SPaul Davey nla_put_u32(skb, IPMRA_CREPORT_TABLE, mrt->id))
24595a645dd8SJulien Gomes goto nla_put_failure;
24605a645dd8SJulien Gomes
24615a645dd8SJulien Gomes nla = nla_reserve(skb, IPMRA_CREPORT_PKT, payloadlen);
24625a645dd8SJulien Gomes if (!nla || skb_copy_bits(pkt, sizeof(struct igmpmsg),
24635a645dd8SJulien Gomes nla_data(nla), payloadlen))
24645a645dd8SJulien Gomes goto nla_put_failure;
24655a645dd8SJulien Gomes
24665a645dd8SJulien Gomes nlmsg_end(skb, nlh);
24675a645dd8SJulien Gomes
24685a645dd8SJulien Gomes rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE_R, NULL, GFP_ATOMIC);
24695a645dd8SJulien Gomes return;
24705a645dd8SJulien Gomes
24715a645dd8SJulien Gomes nla_put_failure:
24725a645dd8SJulien Gomes nlmsg_cancel(skb, nlh);
24735a645dd8SJulien Gomes errout:
24745a645dd8SJulien Gomes kfree_skb(skb);
24755a645dd8SJulien Gomes rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE_R, -ENOBUFS);
24765a645dd8SJulien Gomes }
24775a645dd8SJulien Gomes
ipmr_rtm_valid_getroute_req(struct sk_buff * skb,const struct nlmsghdr * nlh,struct nlattr ** tb,struct netlink_ext_ack * extack)2478d0440029SJakub Kicinski static int ipmr_rtm_valid_getroute_req(struct sk_buff *skb,
2479d0440029SJakub Kicinski const struct nlmsghdr *nlh,
2480d0440029SJakub Kicinski struct nlattr **tb,
2481d0440029SJakub Kicinski struct netlink_ext_ack *extack)
2482d0440029SJakub Kicinski {
2483d0440029SJakub Kicinski struct rtmsg *rtm;
2484d0440029SJakub Kicinski int i, err;
2485d0440029SJakub Kicinski
2486d0440029SJakub Kicinski if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm))) {
2487d0440029SJakub Kicinski NL_SET_ERR_MSG(extack, "ipv4: Invalid header for multicast route get request");
2488d0440029SJakub Kicinski return -EINVAL;
2489d0440029SJakub Kicinski }
2490d0440029SJakub Kicinski
2491d0440029SJakub Kicinski if (!netlink_strict_get_check(skb))
24928cb08174SJohannes Berg return nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX,
2493d0440029SJakub Kicinski rtm_ipv4_policy, extack);
2494d0440029SJakub Kicinski
2495d0440029SJakub Kicinski rtm = nlmsg_data(nlh);
2496d0440029SJakub Kicinski if ((rtm->rtm_src_len && rtm->rtm_src_len != 32) ||
2497d0440029SJakub Kicinski (rtm->rtm_dst_len && rtm->rtm_dst_len != 32) ||
2498d0440029SJakub Kicinski rtm->rtm_tos || rtm->rtm_table || rtm->rtm_protocol ||
2499d0440029SJakub Kicinski rtm->rtm_scope || rtm->rtm_type || rtm->rtm_flags) {
2500d0440029SJakub Kicinski NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for multicast route get request");
2501d0440029SJakub Kicinski return -EINVAL;
2502d0440029SJakub Kicinski }
2503d0440029SJakub Kicinski
25048cb08174SJohannes Berg err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX,
2505d0440029SJakub Kicinski rtm_ipv4_policy, extack);
2506d0440029SJakub Kicinski if (err)
2507d0440029SJakub Kicinski return err;
2508d0440029SJakub Kicinski
2509d0440029SJakub Kicinski if ((tb[RTA_SRC] && !rtm->rtm_src_len) ||
2510d0440029SJakub Kicinski (tb[RTA_DST] && !rtm->rtm_dst_len)) {
2511d0440029SJakub Kicinski NL_SET_ERR_MSG(extack, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4");
2512d0440029SJakub Kicinski return -EINVAL;
2513d0440029SJakub Kicinski }
2514d0440029SJakub Kicinski
2515d0440029SJakub Kicinski for (i = 0; i <= RTA_MAX; i++) {
2516d0440029SJakub Kicinski if (!tb[i])
2517d0440029SJakub Kicinski continue;
2518d0440029SJakub Kicinski
2519d0440029SJakub Kicinski switch (i) {
2520d0440029SJakub Kicinski case RTA_SRC:
2521d0440029SJakub Kicinski case RTA_DST:
2522d0440029SJakub Kicinski case RTA_TABLE:
2523d0440029SJakub Kicinski break;
2524d0440029SJakub Kicinski default:
2525d0440029SJakub Kicinski NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in multicast route get request");
2526d0440029SJakub Kicinski return -EINVAL;
2527d0440029SJakub Kicinski }
2528d0440029SJakub Kicinski }
2529d0440029SJakub Kicinski
2530d0440029SJakub Kicinski return 0;
2531d0440029SJakub Kicinski }
2532d0440029SJakub Kicinski
ipmr_rtm_getroute(struct sk_buff * in_skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack)25334f75ba69SDonald Sharp static int ipmr_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
25344f75ba69SDonald Sharp struct netlink_ext_ack *extack)
25354f75ba69SDonald Sharp {
25364f75ba69SDonald Sharp struct net *net = sock_net(in_skb->sk);
25374f75ba69SDonald Sharp struct nlattr *tb[RTA_MAX + 1];
25384f75ba69SDonald Sharp struct sk_buff *skb = NULL;
25394f75ba69SDonald Sharp struct mfc_cache *cache;
25404f75ba69SDonald Sharp struct mr_table *mrt;
25414f75ba69SDonald Sharp __be32 src, grp;
25424f75ba69SDonald Sharp u32 tableid;
25434f75ba69SDonald Sharp int err;
25444f75ba69SDonald Sharp
2545d0440029SJakub Kicinski err = ipmr_rtm_valid_getroute_req(in_skb, nlh, tb, extack);
25464f75ba69SDonald Sharp if (err < 0)
25474f75ba69SDonald Sharp goto errout;
25484f75ba69SDonald Sharp
25494f75ba69SDonald Sharp src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
25504f75ba69SDonald Sharp grp = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
25514f75ba69SDonald Sharp tableid = tb[RTA_TABLE] ? nla_get_u32(tb[RTA_TABLE]) : 0;
25524f75ba69SDonald Sharp
25534f75ba69SDonald Sharp mrt = ipmr_get_table(net, tableid ? tableid : RT_TABLE_DEFAULT);
25542e3d232eSDan Carpenter if (!mrt) {
25552e3d232eSDan Carpenter err = -ENOENT;
25564f75ba69SDonald Sharp goto errout_free;
25574f75ba69SDonald Sharp }
25584f75ba69SDonald Sharp
25594f75ba69SDonald Sharp /* entries are added/deleted only under RTNL */
25604f75ba69SDonald Sharp rcu_read_lock();
25614f75ba69SDonald Sharp cache = ipmr_cache_find(mrt, src, grp);
25624f75ba69SDonald Sharp rcu_read_unlock();
25634f75ba69SDonald Sharp if (!cache) {
25644f75ba69SDonald Sharp err = -ENOENT;
25654f75ba69SDonald Sharp goto errout_free;
25664f75ba69SDonald Sharp }
25674f75ba69SDonald Sharp
25684f75ba69SDonald Sharp skb = nlmsg_new(mroute_msgsize(false, mrt->maxvif), GFP_KERNEL);
25694f75ba69SDonald Sharp if (!skb) {
25704f75ba69SDonald Sharp err = -ENOBUFS;
25714f75ba69SDonald Sharp goto errout_free;
25724f75ba69SDonald Sharp }
25734f75ba69SDonald Sharp
25744f75ba69SDonald Sharp err = ipmr_fill_mroute(mrt, skb, NETLINK_CB(in_skb).portid,
25754f75ba69SDonald Sharp nlh->nlmsg_seq, cache,
25764f75ba69SDonald Sharp RTM_NEWROUTE, 0);
25774f75ba69SDonald Sharp if (err < 0)
25784f75ba69SDonald Sharp goto errout_free;
25794f75ba69SDonald Sharp
25804f75ba69SDonald Sharp err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
25814f75ba69SDonald Sharp
25824f75ba69SDonald Sharp errout:
25834f75ba69SDonald Sharp return err;
25844f75ba69SDonald Sharp
25854f75ba69SDonald Sharp errout_free:
25864f75ba69SDonald Sharp kfree_skb(skb);
25874f75ba69SDonald Sharp goto errout;
25884f75ba69SDonald Sharp }
25894f75ba69SDonald Sharp
ipmr_rtm_dumproute(struct sk_buff * skb,struct netlink_callback * cb)2590cb6a4e46SPatrick McHardy static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2591cb6a4e46SPatrick McHardy {
259222e36ea9SEric Dumazet struct fib_dump_filter filter = {
259322e36ea9SEric Dumazet .rtnl_held = true,
259422e36ea9SEric Dumazet };
25954724676dSDavid Ahern int err;
25964724676dSDavid Ahern
2597cb167893SDavid Ahern if (cb->strict_check) {
25984724676dSDavid Ahern err = ip_valid_fib_dump_req(sock_net(skb->sk), cb->nlh,
2599effe6792SDavid Ahern &filter, cb);
2600e8ba330aSDavid Ahern if (err < 0)
2601e8ba330aSDavid Ahern return err;
2602e8ba330aSDavid Ahern }
2603e8ba330aSDavid Ahern
2604cb167893SDavid Ahern if (filter.table_id) {
2605cb167893SDavid Ahern struct mr_table *mrt;
2606cb167893SDavid Ahern
2607cb167893SDavid Ahern mrt = ipmr_get_table(sock_net(skb->sk), filter.table_id);
2608cb167893SDavid Ahern if (!mrt) {
260941b4bd98SSabrina Dubroca if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IPMR)
2610ae677bbbSDavid Ahern return skb->len;
2611ae677bbbSDavid Ahern
2612cb167893SDavid Ahern NL_SET_ERR_MSG(cb->extack, "ipv4: MR table does not exist");
2613cb167893SDavid Ahern return -ENOENT;
2614cb167893SDavid Ahern }
2615cb167893SDavid Ahern err = mr_table_dump(mrt, skb, cb, _ipmr_fill_mroute,
2616cb167893SDavid Ahern &mfc_unres_lock, &filter);
2617cb167893SDavid Ahern return skb->len ? : err;
2618cb167893SDavid Ahern }
2619cb167893SDavid Ahern
26207b0db857SYuval Mintz return mr_rtm_dumproute(skb, cb, ipmr_mr_table_iter,
2621cb167893SDavid Ahern _ipmr_fill_mroute, &mfc_unres_lock, &filter);
2622cb6a4e46SPatrick McHardy }
2623cb6a4e46SPatrick McHardy
2624ccbb0aa6SNikolay Aleksandrov static const struct nla_policy rtm_ipmr_policy[RTA_MAX + 1] = {
2625ccbb0aa6SNikolay Aleksandrov [RTA_SRC] = { .type = NLA_U32 },
2626ccbb0aa6SNikolay Aleksandrov [RTA_DST] = { .type = NLA_U32 },
2627ccbb0aa6SNikolay Aleksandrov [RTA_IIF] = { .type = NLA_U32 },
2628ccbb0aa6SNikolay Aleksandrov [RTA_TABLE] = { .type = NLA_U32 },
2629ccbb0aa6SNikolay Aleksandrov [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2630ccbb0aa6SNikolay Aleksandrov };
2631ccbb0aa6SNikolay Aleksandrov
ipmr_rtm_validate_proto(unsigned char rtm_protocol)2632ccbb0aa6SNikolay Aleksandrov static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol)
2633ccbb0aa6SNikolay Aleksandrov {
2634ccbb0aa6SNikolay Aleksandrov switch (rtm_protocol) {
2635ccbb0aa6SNikolay Aleksandrov case RTPROT_STATIC:
2636ccbb0aa6SNikolay Aleksandrov case RTPROT_MROUTED:
2637ccbb0aa6SNikolay Aleksandrov return true;
2638ccbb0aa6SNikolay Aleksandrov }
2639ccbb0aa6SNikolay Aleksandrov return false;
2640ccbb0aa6SNikolay Aleksandrov }
2641ccbb0aa6SNikolay Aleksandrov
ipmr_nla_get_ttls(const struct nlattr * nla,struct mfcctl * mfcc)2642ccbb0aa6SNikolay Aleksandrov static int ipmr_nla_get_ttls(const struct nlattr *nla, struct mfcctl *mfcc)
2643ccbb0aa6SNikolay Aleksandrov {
2644ccbb0aa6SNikolay Aleksandrov struct rtnexthop *rtnh = nla_data(nla);
2645ccbb0aa6SNikolay Aleksandrov int remaining = nla_len(nla), vifi = 0;
2646ccbb0aa6SNikolay Aleksandrov
2647ccbb0aa6SNikolay Aleksandrov while (rtnh_ok(rtnh, remaining)) {
2648ccbb0aa6SNikolay Aleksandrov mfcc->mfcc_ttls[vifi] = rtnh->rtnh_hops;
2649ccbb0aa6SNikolay Aleksandrov if (++vifi == MAXVIFS)
2650ccbb0aa6SNikolay Aleksandrov break;
2651ccbb0aa6SNikolay Aleksandrov rtnh = rtnh_next(rtnh, &remaining);
2652ccbb0aa6SNikolay Aleksandrov }
2653ccbb0aa6SNikolay Aleksandrov
2654ccbb0aa6SNikolay Aleksandrov return remaining > 0 ? -EINVAL : vifi;
2655ccbb0aa6SNikolay Aleksandrov }
2656ccbb0aa6SNikolay Aleksandrov
2657ccbb0aa6SNikolay Aleksandrov /* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */
rtm_to_ipmr_mfcc(struct net * net,struct nlmsghdr * nlh,struct mfcctl * mfcc,int * mrtsock,struct mr_table ** mrtret,struct netlink_ext_ack * extack)2658ccbb0aa6SNikolay Aleksandrov static int rtm_to_ipmr_mfcc(struct net *net, struct nlmsghdr *nlh,
2659ccbb0aa6SNikolay Aleksandrov struct mfcctl *mfcc, int *mrtsock,
2660c21ef3e3SDavid Ahern struct mr_table **mrtret,
2661c21ef3e3SDavid Ahern struct netlink_ext_ack *extack)
2662ccbb0aa6SNikolay Aleksandrov {
2663ccbb0aa6SNikolay Aleksandrov struct net_device *dev = NULL;
2664ccbb0aa6SNikolay Aleksandrov u32 tblid = RT_TABLE_DEFAULT;
2665ccbb0aa6SNikolay Aleksandrov struct mr_table *mrt;
2666ccbb0aa6SNikolay Aleksandrov struct nlattr *attr;
2667ccbb0aa6SNikolay Aleksandrov struct rtmsg *rtm;
2668ccbb0aa6SNikolay Aleksandrov int ret, rem;
2669ccbb0aa6SNikolay Aleksandrov
26708cb08174SJohannes Berg ret = nlmsg_validate_deprecated(nlh, sizeof(*rtm), RTA_MAX,
26718cb08174SJohannes Berg rtm_ipmr_policy, extack);
2672ccbb0aa6SNikolay Aleksandrov if (ret < 0)
2673ccbb0aa6SNikolay Aleksandrov goto out;
2674ccbb0aa6SNikolay Aleksandrov rtm = nlmsg_data(nlh);
2675ccbb0aa6SNikolay Aleksandrov
2676ccbb0aa6SNikolay Aleksandrov ret = -EINVAL;
2677ccbb0aa6SNikolay Aleksandrov if (rtm->rtm_family != RTNL_FAMILY_IPMR || rtm->rtm_dst_len != 32 ||
2678ccbb0aa6SNikolay Aleksandrov rtm->rtm_type != RTN_MULTICAST ||
2679ccbb0aa6SNikolay Aleksandrov rtm->rtm_scope != RT_SCOPE_UNIVERSE ||
2680ccbb0aa6SNikolay Aleksandrov !ipmr_rtm_validate_proto(rtm->rtm_protocol))
2681ccbb0aa6SNikolay Aleksandrov goto out;
2682ccbb0aa6SNikolay Aleksandrov
2683ccbb0aa6SNikolay Aleksandrov memset(mfcc, 0, sizeof(*mfcc));
2684ccbb0aa6SNikolay Aleksandrov mfcc->mfcc_parent = -1;
2685ccbb0aa6SNikolay Aleksandrov ret = 0;
2686ccbb0aa6SNikolay Aleksandrov nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), rem) {
2687ccbb0aa6SNikolay Aleksandrov switch (nla_type(attr)) {
2688ccbb0aa6SNikolay Aleksandrov case RTA_SRC:
2689ccbb0aa6SNikolay Aleksandrov mfcc->mfcc_origin.s_addr = nla_get_be32(attr);
2690ccbb0aa6SNikolay Aleksandrov break;
2691ccbb0aa6SNikolay Aleksandrov case RTA_DST:
2692ccbb0aa6SNikolay Aleksandrov mfcc->mfcc_mcastgrp.s_addr = nla_get_be32(attr);
2693ccbb0aa6SNikolay Aleksandrov break;
2694ccbb0aa6SNikolay Aleksandrov case RTA_IIF:
2695ccbb0aa6SNikolay Aleksandrov dev = __dev_get_by_index(net, nla_get_u32(attr));
2696ccbb0aa6SNikolay Aleksandrov if (!dev) {
2697ccbb0aa6SNikolay Aleksandrov ret = -ENODEV;
2698ccbb0aa6SNikolay Aleksandrov goto out;
2699ccbb0aa6SNikolay Aleksandrov }
2700ccbb0aa6SNikolay Aleksandrov break;
2701ccbb0aa6SNikolay Aleksandrov case RTA_MULTIPATH:
2702ccbb0aa6SNikolay Aleksandrov if (ipmr_nla_get_ttls(attr, mfcc) < 0) {
2703ccbb0aa6SNikolay Aleksandrov ret = -EINVAL;
2704ccbb0aa6SNikolay Aleksandrov goto out;
2705ccbb0aa6SNikolay Aleksandrov }
2706ccbb0aa6SNikolay Aleksandrov break;
2707ccbb0aa6SNikolay Aleksandrov case RTA_PREFSRC:
2708ccbb0aa6SNikolay Aleksandrov ret = 1;
2709ccbb0aa6SNikolay Aleksandrov break;
2710ccbb0aa6SNikolay Aleksandrov case RTA_TABLE:
2711ccbb0aa6SNikolay Aleksandrov tblid = nla_get_u32(attr);
2712ccbb0aa6SNikolay Aleksandrov break;
2713ccbb0aa6SNikolay Aleksandrov }
2714ccbb0aa6SNikolay Aleksandrov }
2715ccbb0aa6SNikolay Aleksandrov mrt = ipmr_get_table(net, tblid);
2716ccbb0aa6SNikolay Aleksandrov if (!mrt) {
2717ccbb0aa6SNikolay Aleksandrov ret = -ENOENT;
2718ccbb0aa6SNikolay Aleksandrov goto out;
2719ccbb0aa6SNikolay Aleksandrov }
2720ccbb0aa6SNikolay Aleksandrov *mrtret = mrt;
2721ccbb0aa6SNikolay Aleksandrov *mrtsock = rtm->rtm_protocol == RTPROT_MROUTED ? 1 : 0;
2722ccbb0aa6SNikolay Aleksandrov if (dev)
2723ccbb0aa6SNikolay Aleksandrov mfcc->mfcc_parent = ipmr_find_vif(mrt, dev);
2724ccbb0aa6SNikolay Aleksandrov
2725ccbb0aa6SNikolay Aleksandrov out:
2726ccbb0aa6SNikolay Aleksandrov return ret;
2727ccbb0aa6SNikolay Aleksandrov }
2728ccbb0aa6SNikolay Aleksandrov
2729ccbb0aa6SNikolay Aleksandrov /* takes care of both newroute and delroute */
ipmr_rtm_route(struct sk_buff * skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack)2730c21ef3e3SDavid Ahern static int ipmr_rtm_route(struct sk_buff *skb, struct nlmsghdr *nlh,
2731c21ef3e3SDavid Ahern struct netlink_ext_ack *extack)
2732ccbb0aa6SNikolay Aleksandrov {
2733ccbb0aa6SNikolay Aleksandrov struct net *net = sock_net(skb->sk);
2734ccbb0aa6SNikolay Aleksandrov int ret, mrtsock, parent;
2735ccbb0aa6SNikolay Aleksandrov struct mr_table *tbl;
2736ccbb0aa6SNikolay Aleksandrov struct mfcctl mfcc;
2737ccbb0aa6SNikolay Aleksandrov
2738ccbb0aa6SNikolay Aleksandrov mrtsock = 0;
2739ccbb0aa6SNikolay Aleksandrov tbl = NULL;
2740c21ef3e3SDavid Ahern ret = rtm_to_ipmr_mfcc(net, nlh, &mfcc, &mrtsock, &tbl, extack);
2741ccbb0aa6SNikolay Aleksandrov if (ret < 0)
2742ccbb0aa6SNikolay Aleksandrov return ret;
2743ccbb0aa6SNikolay Aleksandrov
2744ccbb0aa6SNikolay Aleksandrov parent = ret ? mfcc.mfcc_parent : -1;
2745ccbb0aa6SNikolay Aleksandrov if (nlh->nlmsg_type == RTM_NEWROUTE)
2746ccbb0aa6SNikolay Aleksandrov return ipmr_mfc_add(net, tbl, &mfcc, mrtsock, parent);
2747ccbb0aa6SNikolay Aleksandrov else
2748ccbb0aa6SNikolay Aleksandrov return ipmr_mfc_delete(tbl, &mfcc, parent);
2749ccbb0aa6SNikolay Aleksandrov }
2750ccbb0aa6SNikolay Aleksandrov
ipmr_fill_table(struct mr_table * mrt,struct sk_buff * skb)2751772c344dSNikolay Aleksandrov static bool ipmr_fill_table(struct mr_table *mrt, struct sk_buff *skb)
2752772c344dSNikolay Aleksandrov {
2753772c344dSNikolay Aleksandrov u32 queue_len = atomic_read(&mrt->cache_resolve_queue_len);
2754772c344dSNikolay Aleksandrov
2755772c344dSNikolay Aleksandrov if (nla_put_u32(skb, IPMRA_TABLE_ID, mrt->id) ||
2756772c344dSNikolay Aleksandrov nla_put_u32(skb, IPMRA_TABLE_CACHE_RES_QUEUE_LEN, queue_len) ||
2757772c344dSNikolay Aleksandrov nla_put_s32(skb, IPMRA_TABLE_MROUTE_REG_VIF_NUM,
2758772c344dSNikolay Aleksandrov mrt->mroute_reg_vif_num) ||
2759772c344dSNikolay Aleksandrov nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_ASSERT,
2760772c344dSNikolay Aleksandrov mrt->mroute_do_assert) ||
2761c921c207SNikolay Aleksandrov nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_PIM, mrt->mroute_do_pim) ||
2762c921c207SNikolay Aleksandrov nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_WRVIFWHOLE,
2763c921c207SNikolay Aleksandrov mrt->mroute_do_wrvifwhole))
2764772c344dSNikolay Aleksandrov return false;
2765772c344dSNikolay Aleksandrov
2766772c344dSNikolay Aleksandrov return true;
2767772c344dSNikolay Aleksandrov }
2768772c344dSNikolay Aleksandrov
ipmr_fill_vif(struct mr_table * mrt,u32 vifid,struct sk_buff * skb)2769772c344dSNikolay Aleksandrov static bool ipmr_fill_vif(struct mr_table *mrt, u32 vifid, struct sk_buff *skb)
2770772c344dSNikolay Aleksandrov {
2771ebc31979SEric Dumazet struct net_device *vif_dev;
2772772c344dSNikolay Aleksandrov struct nlattr *vif_nest;
2773772c344dSNikolay Aleksandrov struct vif_device *vif;
2774772c344dSNikolay Aleksandrov
2775ebc31979SEric Dumazet vif = &mrt->vif_table[vifid];
27760fcae3c8SEric Dumazet vif_dev = rtnl_dereference(vif->dev);
2777772c344dSNikolay Aleksandrov /* if the VIF doesn't exist just continue */
2778ebc31979SEric Dumazet if (!vif_dev)
2779772c344dSNikolay Aleksandrov return true;
2780772c344dSNikolay Aleksandrov
2781ae0be8deSMichal Kubecek vif_nest = nla_nest_start_noflag(skb, IPMRA_VIF);
2782772c344dSNikolay Aleksandrov if (!vif_nest)
2783772c344dSNikolay Aleksandrov return false;
2784ebc31979SEric Dumazet
2785ebc31979SEric Dumazet if (nla_put_u32(skb, IPMRA_VIFA_IFINDEX, vif_dev->ifindex) ||
2786772c344dSNikolay Aleksandrov nla_put_u32(skb, IPMRA_VIFA_VIF_ID, vifid) ||
2787772c344dSNikolay Aleksandrov nla_put_u16(skb, IPMRA_VIFA_FLAGS, vif->flags) ||
2788772c344dSNikolay Aleksandrov nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_IN, vif->bytes_in,
2789772c344dSNikolay Aleksandrov IPMRA_VIFA_PAD) ||
2790772c344dSNikolay Aleksandrov nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_OUT, vif->bytes_out,
2791772c344dSNikolay Aleksandrov IPMRA_VIFA_PAD) ||
2792772c344dSNikolay Aleksandrov nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_IN, vif->pkt_in,
2793772c344dSNikolay Aleksandrov IPMRA_VIFA_PAD) ||
2794772c344dSNikolay Aleksandrov nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_OUT, vif->pkt_out,
2795772c344dSNikolay Aleksandrov IPMRA_VIFA_PAD) ||
2796772c344dSNikolay Aleksandrov nla_put_be32(skb, IPMRA_VIFA_LOCAL_ADDR, vif->local) ||
2797772c344dSNikolay Aleksandrov nla_put_be32(skb, IPMRA_VIFA_REMOTE_ADDR, vif->remote)) {
2798772c344dSNikolay Aleksandrov nla_nest_cancel(skb, vif_nest);
2799772c344dSNikolay Aleksandrov return false;
2800772c344dSNikolay Aleksandrov }
2801772c344dSNikolay Aleksandrov nla_nest_end(skb, vif_nest);
2802772c344dSNikolay Aleksandrov
2803772c344dSNikolay Aleksandrov return true;
2804772c344dSNikolay Aleksandrov }
2805772c344dSNikolay Aleksandrov
ipmr_valid_dumplink(const struct nlmsghdr * nlh,struct netlink_ext_ack * extack)280614fc5bb2SDavid Ahern static int ipmr_valid_dumplink(const struct nlmsghdr *nlh,
280714fc5bb2SDavid Ahern struct netlink_ext_ack *extack)
280814fc5bb2SDavid Ahern {
280914fc5bb2SDavid Ahern struct ifinfomsg *ifm;
281014fc5bb2SDavid Ahern
281114fc5bb2SDavid Ahern if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
281214fc5bb2SDavid Ahern NL_SET_ERR_MSG(extack, "ipv4: Invalid header for ipmr link dump");
281314fc5bb2SDavid Ahern return -EINVAL;
281414fc5bb2SDavid Ahern }
281514fc5bb2SDavid Ahern
281614fc5bb2SDavid Ahern if (nlmsg_attrlen(nlh, sizeof(*ifm))) {
281714fc5bb2SDavid Ahern NL_SET_ERR_MSG(extack, "Invalid data after header in ipmr link dump");
281814fc5bb2SDavid Ahern return -EINVAL;
281914fc5bb2SDavid Ahern }
282014fc5bb2SDavid Ahern
282114fc5bb2SDavid Ahern ifm = nlmsg_data(nlh);
282214fc5bb2SDavid Ahern if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
282314fc5bb2SDavid Ahern ifm->ifi_change || ifm->ifi_index) {
282414fc5bb2SDavid Ahern NL_SET_ERR_MSG(extack, "Invalid values in header for ipmr link dump request");
282514fc5bb2SDavid Ahern return -EINVAL;
282614fc5bb2SDavid Ahern }
282714fc5bb2SDavid Ahern
282814fc5bb2SDavid Ahern return 0;
282914fc5bb2SDavid Ahern }
283014fc5bb2SDavid Ahern
ipmr_rtm_dumplink(struct sk_buff * skb,struct netlink_callback * cb)2831772c344dSNikolay Aleksandrov static int ipmr_rtm_dumplink(struct sk_buff *skb, struct netlink_callback *cb)
2832772c344dSNikolay Aleksandrov {
2833772c344dSNikolay Aleksandrov struct net *net = sock_net(skb->sk);
2834772c344dSNikolay Aleksandrov struct nlmsghdr *nlh = NULL;
2835772c344dSNikolay Aleksandrov unsigned int t = 0, s_t;
2836772c344dSNikolay Aleksandrov unsigned int e = 0, s_e;
2837772c344dSNikolay Aleksandrov struct mr_table *mrt;
2838772c344dSNikolay Aleksandrov
283914fc5bb2SDavid Ahern if (cb->strict_check) {
284014fc5bb2SDavid Ahern int err = ipmr_valid_dumplink(cb->nlh, cb->extack);
284114fc5bb2SDavid Ahern
284214fc5bb2SDavid Ahern if (err < 0)
284314fc5bb2SDavid Ahern return err;
284414fc5bb2SDavid Ahern }
284514fc5bb2SDavid Ahern
2846772c344dSNikolay Aleksandrov s_t = cb->args[0];
2847772c344dSNikolay Aleksandrov s_e = cb->args[1];
2848772c344dSNikolay Aleksandrov
2849772c344dSNikolay Aleksandrov ipmr_for_each_table(mrt, net) {
2850772c344dSNikolay Aleksandrov struct nlattr *vifs, *af;
2851772c344dSNikolay Aleksandrov struct ifinfomsg *hdr;
2852772c344dSNikolay Aleksandrov u32 i;
2853772c344dSNikolay Aleksandrov
2854772c344dSNikolay Aleksandrov if (t < s_t)
2855772c344dSNikolay Aleksandrov goto skip_table;
2856772c344dSNikolay Aleksandrov nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
2857772c344dSNikolay Aleksandrov cb->nlh->nlmsg_seq, RTM_NEWLINK,
2858772c344dSNikolay Aleksandrov sizeof(*hdr), NLM_F_MULTI);
2859772c344dSNikolay Aleksandrov if (!nlh)
2860772c344dSNikolay Aleksandrov break;
2861772c344dSNikolay Aleksandrov
2862772c344dSNikolay Aleksandrov hdr = nlmsg_data(nlh);
2863772c344dSNikolay Aleksandrov memset(hdr, 0, sizeof(*hdr));
2864772c344dSNikolay Aleksandrov hdr->ifi_family = RTNL_FAMILY_IPMR;
2865772c344dSNikolay Aleksandrov
2866ae0be8deSMichal Kubecek af = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
2867772c344dSNikolay Aleksandrov if (!af) {
2868772c344dSNikolay Aleksandrov nlmsg_cancel(skb, nlh);
2869772c344dSNikolay Aleksandrov goto out;
2870772c344dSNikolay Aleksandrov }
2871772c344dSNikolay Aleksandrov
2872772c344dSNikolay Aleksandrov if (!ipmr_fill_table(mrt, skb)) {
2873772c344dSNikolay Aleksandrov nlmsg_cancel(skb, nlh);
2874772c344dSNikolay Aleksandrov goto out;
2875772c344dSNikolay Aleksandrov }
2876772c344dSNikolay Aleksandrov
2877ae0be8deSMichal Kubecek vifs = nla_nest_start_noflag(skb, IPMRA_TABLE_VIFS);
2878772c344dSNikolay Aleksandrov if (!vifs) {
2879772c344dSNikolay Aleksandrov nla_nest_end(skb, af);
2880772c344dSNikolay Aleksandrov nlmsg_end(skb, nlh);
2881772c344dSNikolay Aleksandrov goto out;
2882772c344dSNikolay Aleksandrov }
2883772c344dSNikolay Aleksandrov for (i = 0; i < mrt->maxvif; i++) {
2884772c344dSNikolay Aleksandrov if (e < s_e)
2885772c344dSNikolay Aleksandrov goto skip_entry;
2886772c344dSNikolay Aleksandrov if (!ipmr_fill_vif(mrt, i, skb)) {
2887772c344dSNikolay Aleksandrov nla_nest_end(skb, vifs);
2888772c344dSNikolay Aleksandrov nla_nest_end(skb, af);
2889772c344dSNikolay Aleksandrov nlmsg_end(skb, nlh);
2890772c344dSNikolay Aleksandrov goto out;
2891772c344dSNikolay Aleksandrov }
2892772c344dSNikolay Aleksandrov skip_entry:
2893772c344dSNikolay Aleksandrov e++;
2894772c344dSNikolay Aleksandrov }
2895772c344dSNikolay Aleksandrov s_e = 0;
2896772c344dSNikolay Aleksandrov e = 0;
2897772c344dSNikolay Aleksandrov nla_nest_end(skb, vifs);
2898772c344dSNikolay Aleksandrov nla_nest_end(skb, af);
2899772c344dSNikolay Aleksandrov nlmsg_end(skb, nlh);
2900772c344dSNikolay Aleksandrov skip_table:
2901772c344dSNikolay Aleksandrov t++;
2902772c344dSNikolay Aleksandrov }
2903772c344dSNikolay Aleksandrov
2904772c344dSNikolay Aleksandrov out:
2905772c344dSNikolay Aleksandrov cb->args[1] = e;
2906772c344dSNikolay Aleksandrov cb->args[0] = t;
2907772c344dSNikolay Aleksandrov
2908772c344dSNikolay Aleksandrov return skb->len;
2909772c344dSNikolay Aleksandrov }
2910772c344dSNikolay Aleksandrov
29111da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
29127ef8f65dSNikolay Aleksandrov /* The /proc interfaces to multicast routing :
2913a8cb16ddSEric Dumazet * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
29141da177e4SLinus Torvalds */
29151da177e4SLinus Torvalds
ipmr_vif_seq_start(struct seq_file * seq,loff_t * pos)29161da177e4SLinus Torvalds static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
2917b96ef16dSEric Dumazet __acquires(RCU)
29181da177e4SLinus Torvalds {
29193feda6b4SYuval Mintz struct mr_vif_iter *iter = seq->private;
2920f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq);
2921f0ad0860SPatrick McHardy struct mr_table *mrt;
2922f0ad0860SPatrick McHardy
2923f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
292451456b29SIan Morris if (!mrt)
2925f0ad0860SPatrick McHardy return ERR_PTR(-ENOENT);
2926f0ad0860SPatrick McHardy
2927f0ad0860SPatrick McHardy iter->mrt = mrt;
2928f6bb4514SBenjamin Thery
2929b96ef16dSEric Dumazet rcu_read_lock();
29303feda6b4SYuval Mintz return mr_vif_seq_start(seq, pos);
29311da177e4SLinus Torvalds }
29321da177e4SLinus Torvalds
ipmr_vif_seq_stop(struct seq_file * seq,void * v)29331da177e4SLinus Torvalds static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
2934b96ef16dSEric Dumazet __releases(RCU)
29351da177e4SLinus Torvalds {
2936b96ef16dSEric Dumazet rcu_read_unlock();
29371da177e4SLinus Torvalds }
29381da177e4SLinus Torvalds
ipmr_vif_seq_show(struct seq_file * seq,void * v)29391da177e4SLinus Torvalds static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
29401da177e4SLinus Torvalds {
29413feda6b4SYuval Mintz struct mr_vif_iter *iter = seq->private;
2942f0ad0860SPatrick McHardy struct mr_table *mrt = iter->mrt;
2943f6bb4514SBenjamin Thery
29441da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) {
29451da177e4SLinus Torvalds seq_puts(seq,
29461da177e4SLinus Torvalds "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
29471da177e4SLinus Torvalds } else {
29481da177e4SLinus Torvalds const struct vif_device *vif = v;
2949ebc31979SEric Dumazet const struct net_device *vif_dev;
2950ebc31979SEric Dumazet const char *name;
29511da177e4SLinus Torvalds
2952ebc31979SEric Dumazet vif_dev = vif_dev_read(vif);
2953ebc31979SEric Dumazet name = vif_dev ? vif_dev->name : "none";
29541da177e4SLinus Torvalds seq_printf(seq,
295591e6dd82SJames Hogan "%2td %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
29560c12295aSPatrick McHardy vif - mrt->vif_table,
29571da177e4SLinus Torvalds name, vif->bytes_in, vif->pkt_in,
29581da177e4SLinus Torvalds vif->bytes_out, vif->pkt_out,
29591da177e4SLinus Torvalds vif->flags, vif->local, vif->remote);
29601da177e4SLinus Torvalds }
29611da177e4SLinus Torvalds return 0;
29621da177e4SLinus Torvalds }
29631da177e4SLinus Torvalds
2964f690808eSStephen Hemminger static const struct seq_operations ipmr_vif_seq_ops = {
29651da177e4SLinus Torvalds .start = ipmr_vif_seq_start,
29663feda6b4SYuval Mintz .next = mr_vif_seq_next,
29671da177e4SLinus Torvalds .stop = ipmr_vif_seq_stop,
29681da177e4SLinus Torvalds .show = ipmr_vif_seq_show,
29691da177e4SLinus Torvalds };
29701da177e4SLinus Torvalds
ipmr_mfc_seq_start(struct seq_file * seq,loff_t * pos)29711da177e4SLinus Torvalds static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
29721da177e4SLinus Torvalds {
2973f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq);
2974f0ad0860SPatrick McHardy struct mr_table *mrt;
2975f6bb4514SBenjamin Thery
2976f0ad0860SPatrick McHardy mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
297751456b29SIan Morris if (!mrt)
2978f0ad0860SPatrick McHardy return ERR_PTR(-ENOENT);
2979f0ad0860SPatrick McHardy
2980c8d61968SYuval Mintz return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
29811da177e4SLinus Torvalds }
29821da177e4SLinus Torvalds
ipmr_mfc_seq_show(struct seq_file * seq,void * v)29831da177e4SLinus Torvalds static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
29841da177e4SLinus Torvalds {
29851da177e4SLinus Torvalds int n;
29861da177e4SLinus Torvalds
29871da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) {
29881da177e4SLinus Torvalds seq_puts(seq,
29891da177e4SLinus Torvalds "Group Origin Iif Pkts Bytes Wrong Oifs\n");
29901da177e4SLinus Torvalds } else {
29911da177e4SLinus Torvalds const struct mfc_cache *mfc = v;
2992c8d61968SYuval Mintz const struct mr_mfc_iter *it = seq->private;
2993f0ad0860SPatrick McHardy const struct mr_table *mrt = it->mrt;
29941da177e4SLinus Torvalds
29950eae88f3SEric Dumazet seq_printf(seq, "%08X %08X %-3hd",
29960eae88f3SEric Dumazet (__force u32) mfc->mfc_mcastgrp,
29970eae88f3SEric Dumazet (__force u32) mfc->mfc_origin,
2998494fff56SYuval Mintz mfc->_c.mfc_parent);
29991ea472e2SBenjamin Thery
30000c12295aSPatrick McHardy if (it->cache != &mrt->mfc_unres_queue) {
30011ea472e2SBenjamin Thery seq_printf(seq, " %8lu %8lu %8lu",
3002494fff56SYuval Mintz mfc->_c.mfc_un.res.pkt,
3003494fff56SYuval Mintz mfc->_c.mfc_un.res.bytes,
3004494fff56SYuval Mintz mfc->_c.mfc_un.res.wrong_if);
3005494fff56SYuval Mintz for (n = mfc->_c.mfc_un.res.minvif;
3006494fff56SYuval Mintz n < mfc->_c.mfc_un.res.maxvif; n++) {
30070c12295aSPatrick McHardy if (VIF_EXISTS(mrt, n) &&
3008494fff56SYuval Mintz mfc->_c.mfc_un.res.ttls[n] < 255)
30091da177e4SLinus Torvalds seq_printf(seq,
30101da177e4SLinus Torvalds " %2d:%-3d",
3011494fff56SYuval Mintz n, mfc->_c.mfc_un.res.ttls[n]);
30121da177e4SLinus Torvalds }
30131ea472e2SBenjamin Thery } else {
30141ea472e2SBenjamin Thery /* unresolved mfc_caches don't contain
30151ea472e2SBenjamin Thery * pkt, bytes and wrong_if values
30161ea472e2SBenjamin Thery */
30171ea472e2SBenjamin Thery seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
30181da177e4SLinus Torvalds }
30191da177e4SLinus Torvalds seq_putc(seq, '\n');
30201da177e4SLinus Torvalds }
30211da177e4SLinus Torvalds return 0;
30221da177e4SLinus Torvalds }
30231da177e4SLinus Torvalds
3024f690808eSStephen Hemminger static const struct seq_operations ipmr_mfc_seq_ops = {
30251da177e4SLinus Torvalds .start = ipmr_mfc_seq_start,
3026c8d61968SYuval Mintz .next = mr_mfc_seq_next,
3027c8d61968SYuval Mintz .stop = mr_mfc_seq_stop,
30281da177e4SLinus Torvalds .show = ipmr_mfc_seq_show,
30291da177e4SLinus Torvalds };
30301da177e4SLinus Torvalds #endif
30311da177e4SLinus Torvalds
30321da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2
303332613090SAlexey Dobriyan static const struct net_protocol pim_protocol = {
30341da177e4SLinus Torvalds .handler = pim_rcv,
30351da177e4SLinus Torvalds };
30361da177e4SLinus Torvalds #endif
30371da177e4SLinus Torvalds
ipmr_seq_read(struct net * net)30384d65b948SYotam Gigi static unsigned int ipmr_seq_read(struct net *net)
30394d65b948SYotam Gigi {
30404d65b948SYotam Gigi ASSERT_RTNL();
30414d65b948SYotam Gigi
30424d65b948SYotam Gigi return net->ipv4.ipmr_seq + ipmr_rules_seq_read(net);
30434d65b948SYotam Gigi }
30444d65b948SYotam Gigi
ipmr_dump(struct net * net,struct notifier_block * nb,struct netlink_ext_ack * extack)3045b7a59557SJiri Pirko static int ipmr_dump(struct net *net, struct notifier_block *nb,
3046b7a59557SJiri Pirko struct netlink_ext_ack *extack)
30474d65b948SYotam Gigi {
3048cdc9f944SYuval Mintz return mr_dump(net, nb, RTNL_FAMILY_IPMR, ipmr_rules_dump,
3049194366b2SEric Dumazet ipmr_mr_table_iter, extack);
30504d65b948SYotam Gigi }
30514d65b948SYotam Gigi
30524d65b948SYotam Gigi static const struct fib_notifier_ops ipmr_notifier_ops_template = {
30534d65b948SYotam Gigi .family = RTNL_FAMILY_IPMR,
30544d65b948SYotam Gigi .fib_seq_read = ipmr_seq_read,
30554d65b948SYotam Gigi .fib_dump = ipmr_dump,
30564d65b948SYotam Gigi .owner = THIS_MODULE,
30574d65b948SYotam Gigi };
30584d65b948SYotam Gigi
ipmr_notifier_init(struct net * net)3059ef739d8aSColin Ian King static int __net_init ipmr_notifier_init(struct net *net)
30604d65b948SYotam Gigi {
30614d65b948SYotam Gigi struct fib_notifier_ops *ops;
30624d65b948SYotam Gigi
30634d65b948SYotam Gigi net->ipv4.ipmr_seq = 0;
30644d65b948SYotam Gigi
30654d65b948SYotam Gigi ops = fib_notifier_ops_register(&ipmr_notifier_ops_template, net);
30664d65b948SYotam Gigi if (IS_ERR(ops))
30674d65b948SYotam Gigi return PTR_ERR(ops);
30684d65b948SYotam Gigi net->ipv4.ipmr_notifier_ops = ops;
30694d65b948SYotam Gigi
30704d65b948SYotam Gigi return 0;
30714d65b948SYotam Gigi }
30724d65b948SYotam Gigi
ipmr_notifier_exit(struct net * net)30734d65b948SYotam Gigi static void __net_exit ipmr_notifier_exit(struct net *net)
30744d65b948SYotam Gigi {
30754d65b948SYotam Gigi fib_notifier_ops_unregister(net->ipv4.ipmr_notifier_ops);
30764d65b948SYotam Gigi net->ipv4.ipmr_notifier_ops = NULL;
30774d65b948SYotam Gigi }
30784d65b948SYotam Gigi
30797ef8f65dSNikolay Aleksandrov /* Setup for IP multicast routing */
ipmr_net_init(struct net * net)3080cf958ae3SBenjamin Thery static int __net_init ipmr_net_init(struct net *net)
3081cf958ae3SBenjamin Thery {
3082f0ad0860SPatrick McHardy int err;
3083cf958ae3SBenjamin Thery
30844d65b948SYotam Gigi err = ipmr_notifier_init(net);
30854d65b948SYotam Gigi if (err)
30864d65b948SYotam Gigi goto ipmr_notifier_fail;
30874d65b948SYotam Gigi
3088f0ad0860SPatrick McHardy err = ipmr_rules_init(net);
3089f0ad0860SPatrick McHardy if (err < 0)
30904d65b948SYotam Gigi goto ipmr_rules_fail;
3091f6bb4514SBenjamin Thery
3092f6bb4514SBenjamin Thery #ifdef CONFIG_PROC_FS
3093f6bb4514SBenjamin Thery err = -ENOMEM;
3094c3506372SChristoph Hellwig if (!proc_create_net("ip_mr_vif", 0, net->proc_net, &ipmr_vif_seq_ops,
3095c3506372SChristoph Hellwig sizeof(struct mr_vif_iter)))
3096f6bb4514SBenjamin Thery goto proc_vif_fail;
3097c3506372SChristoph Hellwig if (!proc_create_net("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
3098c3506372SChristoph Hellwig sizeof(struct mr_mfc_iter)))
3099f6bb4514SBenjamin Thery goto proc_cache_fail;
3100f6bb4514SBenjamin Thery #endif
31012bb8b26cSBenjamin Thery return 0;
31022bb8b26cSBenjamin Thery
3103f6bb4514SBenjamin Thery #ifdef CONFIG_PROC_FS
3104f6bb4514SBenjamin Thery proc_cache_fail:
3105ece31ffdSGao feng remove_proc_entry("ip_mr_vif", net->proc_net);
3106f6bb4514SBenjamin Thery proc_vif_fail:
3107696e595fSEric Dumazet rtnl_lock();
3108f0ad0860SPatrick McHardy ipmr_rules_exit(net);
3109696e595fSEric Dumazet rtnl_unlock();
3110f6bb4514SBenjamin Thery #endif
31114d65b948SYotam Gigi ipmr_rules_fail:
31124d65b948SYotam Gigi ipmr_notifier_exit(net);
31134d65b948SYotam Gigi ipmr_notifier_fail:
3114cf958ae3SBenjamin Thery return err;
3115cf958ae3SBenjamin Thery }
3116cf958ae3SBenjamin Thery
ipmr_net_exit(struct net * net)3117cf958ae3SBenjamin Thery static void __net_exit ipmr_net_exit(struct net *net)
3118cf958ae3SBenjamin Thery {
3119f6bb4514SBenjamin Thery #ifdef CONFIG_PROC_FS
3120ece31ffdSGao feng remove_proc_entry("ip_mr_cache", net->proc_net);
3121ece31ffdSGao feng remove_proc_entry("ip_mr_vif", net->proc_net);
3122f6bb4514SBenjamin Thery #endif
31234d65b948SYotam Gigi ipmr_notifier_exit(net);
3124696e595fSEric Dumazet }
3125696e595fSEric Dumazet
ipmr_net_exit_batch(struct list_head * net_list)3126696e595fSEric Dumazet static void __net_exit ipmr_net_exit_batch(struct list_head *net_list)
3127696e595fSEric Dumazet {
3128696e595fSEric Dumazet struct net *net;
3129696e595fSEric Dumazet
3130696e595fSEric Dumazet rtnl_lock();
3131696e595fSEric Dumazet list_for_each_entry(net, net_list, exit_list)
3132f0ad0860SPatrick McHardy ipmr_rules_exit(net);
3133696e595fSEric Dumazet rtnl_unlock();
3134cf958ae3SBenjamin Thery }
3135cf958ae3SBenjamin Thery
3136cf958ae3SBenjamin Thery static struct pernet_operations ipmr_net_ops = {
3137cf958ae3SBenjamin Thery .init = ipmr_net_init,
3138cf958ae3SBenjamin Thery .exit = ipmr_net_exit,
3139696e595fSEric Dumazet .exit_batch = ipmr_net_exit_batch,
3140cf958ae3SBenjamin Thery };
31411da177e4SLinus Torvalds
ip_mr_init(void)314203d2f897SWang Chen int __init ip_mr_init(void)
31431da177e4SLinus Torvalds {
314403d2f897SWang Chen int err;
314503d2f897SWang Chen
3146eec70af2SKunwu Chan mrt_cachep = KMEM_CACHE(mfc_cache, SLAB_HWCACHE_ALIGN | SLAB_PANIC);
314703d2f897SWang Chen
3148cf958ae3SBenjamin Thery err = register_pernet_subsys(&ipmr_net_ops);
3149cf958ae3SBenjamin Thery if (err)
3150cf958ae3SBenjamin Thery goto reg_pernet_fail;
3151cf958ae3SBenjamin Thery
315203d2f897SWang Chen err = register_netdevice_notifier(&ip_mr_notifier);
315303d2f897SWang Chen if (err)
315403d2f897SWang Chen goto reg_notif_fail;
3155403dbb97STom Goff #ifdef CONFIG_IP_PIMSM_V2
3156403dbb97STom Goff if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
3157058bd4d2SJoe Perches pr_err("%s: can't add PIM protocol\n", __func__);
3158403dbb97STom Goff err = -EAGAIN;
3159403dbb97STom Goff goto add_proto_fail;
3160403dbb97STom Goff }
3161403dbb97STom Goff #endif
3162c7ac8679SGreg Rose rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
3163b97bac64SFlorian Westphal ipmr_rtm_getroute, ipmr_rtm_dumproute, 0);
3164ccbb0aa6SNikolay Aleksandrov rtnl_register(RTNL_FAMILY_IPMR, RTM_NEWROUTE,
3165b97bac64SFlorian Westphal ipmr_rtm_route, NULL, 0);
3166ccbb0aa6SNikolay Aleksandrov rtnl_register(RTNL_FAMILY_IPMR, RTM_DELROUTE,
3167b97bac64SFlorian Westphal ipmr_rtm_route, NULL, 0);
3168772c344dSNikolay Aleksandrov
3169772c344dSNikolay Aleksandrov rtnl_register(RTNL_FAMILY_IPMR, RTM_GETLINK,
3170b97bac64SFlorian Westphal NULL, ipmr_rtm_dumplink, 0);
317103d2f897SWang Chen return 0;
3172f6bb4514SBenjamin Thery
3173403dbb97STom Goff #ifdef CONFIG_IP_PIMSM_V2
3174403dbb97STom Goff add_proto_fail:
3175403dbb97STom Goff unregister_netdevice_notifier(&ip_mr_notifier);
3176403dbb97STom Goff #endif
3177c3e38896SBenjamin Thery reg_notif_fail:
3178cf958ae3SBenjamin Thery unregister_pernet_subsys(&ipmr_net_ops);
3179cf958ae3SBenjamin Thery reg_pernet_fail:
3180c3e38896SBenjamin Thery kmem_cache_destroy(mrt_cachep);
318103d2f897SWang Chen return err;
31821da177e4SLinus Torvalds }
3183