~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv6/ip6mr.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *      Linux IPv6 multicast routing support for BSD pim6sd
  3  *      Based on net/ipv4/ipmr.c.
  4  *
  5  *      (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
  6  *              LSIIT Laboratory, Strasbourg, France
  7  *      (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
  8  *              6WIND, Paris, France
  9  *      Copyright (C)2007,2008 USAGI/WIDE Project
 10  *              YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
 11  *
 12  *      This program is free software; you can redistribute it and/or
 13  *      modify it under the terms of the GNU General Public License
 14  *      as published by the Free Software Foundation; either version
 15  *      2 of the License, or (at your option) any later version.
 16  *
 17  */
 18 
 19 #include <linux/uaccess.h>
 20 #include <linux/types.h>
 21 #include <linux/sched.h>
 22 #include <linux/errno.h>
 23 #include <linux/timer.h>
 24 #include <linux/mm.h>
 25 #include <linux/kernel.h>
 26 #include <linux/fcntl.h>
 27 #include <linux/stat.h>
 28 #include <linux/socket.h>
 29 #include <linux/inet.h>
 30 #include <linux/netdevice.h>
 31 #include <linux/inetdevice.h>
 32 #include <linux/proc_fs.h>
 33 #include <linux/seq_file.h>
 34 #include <linux/init.h>
 35 #include <linux/slab.h>
 36 #include <linux/compat.h>
 37 #include <net/protocol.h>
 38 #include <linux/skbuff.h>
 39 #include <net/sock.h>
 40 #include <net/raw.h>
 41 #include <linux/notifier.h>
 42 #include <linux/if_arp.h>
 43 #include <net/checksum.h>
 44 #include <net/netlink.h>
 45 #include <net/fib_rules.h>
 46 
 47 #include <net/ipv6.h>
 48 #include <net/ip6_route.h>
 49 #include <linux/mroute6.h>
 50 #include <linux/pim.h>
 51 #include <net/addrconf.h>
 52 #include <linux/netfilter_ipv6.h>
 53 #include <linux/export.h>
 54 #include <net/ip6_checksum.h>
 55 #include <linux/netconf.h>
 56 
 57 struct mr6_table {
 58         struct list_head        list;
 59         possible_net_t          net;
 60         u32                     id;
 61         struct sock             *mroute6_sk;
 62         struct timer_list       ipmr_expire_timer;
 63         struct list_head        mfc6_unres_queue;
 64         struct list_head        mfc6_cache_array[MFC6_LINES];
 65         struct mif_device       vif6_table[MAXMIFS];
 66         int                     maxvif;
 67         atomic_t                cache_resolve_queue_len;
 68         bool                    mroute_do_assert;
 69         bool                    mroute_do_pim;
 70 #ifdef CONFIG_IPV6_PIMSM_V2
 71         int                     mroute_reg_vif_num;
 72 #endif
 73 };
 74 
 75 struct ip6mr_rule {
 76         struct fib_rule         common;
 77 };
 78 
 79 struct ip6mr_result {
 80         struct mr6_table        *mrt;
 81 };
 82 
 83 /* Big lock, protecting vif table, mrt cache and mroute socket state.
 84    Note that the changes are semaphored via rtnl_lock.
 85  */
 86 
 87 static DEFINE_RWLOCK(mrt_lock);
 88 
 89 /*
 90  *      Multicast router control variables
 91  */
 92 
 93 #define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
 94 
 95 /* Special spinlock for queue of unresolved entries */
 96 static DEFINE_SPINLOCK(mfc_unres_lock);
 97 
 98 /* We return to original Alan's scheme. Hash table of resolved
 99    entries is changed only in process context and protected
100    with weak lock mrt_lock. Queue of unresolved entries is protected
101    with strong spinlock mfc_unres_lock.
102 
103    In this case data path is free of exclusive locks at all.
104  */
105 
106 static struct kmem_cache *mrt_cachep __read_mostly;
107 
108 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
109 static void ip6mr_free_table(struct mr6_table *mrt);
110 
111 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
112                            struct sk_buff *skb, struct mfc6_cache *cache);
113 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
114                               mifi_t mifi, int assert);
115 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
116                                struct mfc6_cache *c, struct rtmsg *rtm);
117 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
118                               int cmd);
119 static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt);
120 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
121                                struct netlink_callback *cb);
122 static void mroute_clean_tables(struct mr6_table *mrt, bool all);
123 static void ipmr_expire_process(unsigned long arg);
124 
125 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
126 #define ip6mr_for_each_table(mrt, net) \
127         list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
128 
129 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
130 {
131         struct mr6_table *mrt;
132 
133         ip6mr_for_each_table(mrt, net) {
134                 if (mrt->id == id)
135                         return mrt;
136         }
137         return NULL;
138 }
139 
140 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
141                             struct mr6_table **mrt)
142 {
143         int err;
144         struct ip6mr_result res;
145         struct fib_lookup_arg arg = {
146                 .result = &res,
147                 .flags = FIB_LOOKUP_NOREF,
148         };
149 
150         err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
151                                flowi6_to_flowi(flp6), 0, &arg);
152         if (err < 0)
153                 return err;
154         *mrt = res.mrt;
155         return 0;
156 }
157 
158 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
159                              int flags, struct fib_lookup_arg *arg)
160 {
161         struct ip6mr_result *res = arg->result;
162         struct mr6_table *mrt;
163 
164         switch (rule->action) {
165         case FR_ACT_TO_TBL:
166                 break;
167         case FR_ACT_UNREACHABLE:
168                 return -ENETUNREACH;
169         case FR_ACT_PROHIBIT:
170                 return -EACCES;
171         case FR_ACT_BLACKHOLE:
172         default:
173                 return -EINVAL;
174         }
175 
176         mrt = ip6mr_get_table(rule->fr_net, rule->table);
177         if (!mrt)
178                 return -EAGAIN;
179         res->mrt = mrt;
180         return 0;
181 }
182 
183 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
184 {
185         return 1;
186 }
187 
188 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
189         FRA_GENERIC_POLICY,
190 };
191 
192 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
193                                 struct fib_rule_hdr *frh, struct nlattr **tb)
194 {
195         return 0;
196 }
197 
198 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
199                               struct nlattr **tb)
200 {
201         return 1;
202 }
203 
204 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
205                            struct fib_rule_hdr *frh)
206 {
207         frh->dst_len = 0;
208         frh->src_len = 0;
209         frh->tos     = 0;
210         return 0;
211 }
212 
213 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
214         .family         = RTNL_FAMILY_IP6MR,
215         .rule_size      = sizeof(struct ip6mr_rule),
216         .addr_size      = sizeof(struct in6_addr),
217         .action         = ip6mr_rule_action,
218         .match          = ip6mr_rule_match,
219         .configure      = ip6mr_rule_configure,
220         .compare        = ip6mr_rule_compare,
221         .fill           = ip6mr_rule_fill,
222         .nlgroup        = RTNLGRP_IPV6_RULE,
223         .policy         = ip6mr_rule_policy,
224         .owner          = THIS_MODULE,
225 };
226 
227 static int __net_init ip6mr_rules_init(struct net *net)
228 {
229         struct fib_rules_ops *ops;
230         struct mr6_table *mrt;
231         int err;
232 
233         ops = fib_rules_register(&ip6mr_rules_ops_template, net);
234         if (IS_ERR(ops))
235                 return PTR_ERR(ops);
236 
237         INIT_LIST_HEAD(&net->ipv6.mr6_tables);
238 
239         mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
240         if (!mrt) {
241                 err = -ENOMEM;
242                 goto err1;
243         }
244 
245         err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
246         if (err < 0)
247                 goto err2;
248 
249         net->ipv6.mr6_rules_ops = ops;
250         return 0;
251 
252 err2:
253         ip6mr_free_table(mrt);
254 err1:
255         fib_rules_unregister(ops);
256         return err;
257 }
258 
259 static void __net_exit ip6mr_rules_exit(struct net *net)
260 {
261         struct mr6_table *mrt, *next;
262 
263         rtnl_lock();
264         list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
265                 list_del(&mrt->list);
266                 ip6mr_free_table(mrt);
267         }
268         fib_rules_unregister(net->ipv6.mr6_rules_ops);
269         rtnl_unlock();
270 }
271 #else
272 #define ip6mr_for_each_table(mrt, net) \
273         for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
274 
275 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
276 {
277         return net->ipv6.mrt6;
278 }
279 
280 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
281                             struct mr6_table **mrt)
282 {
283         *mrt = net->ipv6.mrt6;
284         return 0;
285 }
286 
287 static int __net_init ip6mr_rules_init(struct net *net)
288 {
289         net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
290         return net->ipv6.mrt6 ? 0 : -ENOMEM;
291 }
292 
293 static void __net_exit ip6mr_rules_exit(struct net *net)
294 {
295         rtnl_lock();
296         ip6mr_free_table(net->ipv6.mrt6);
297         net->ipv6.mrt6 = NULL;
298         rtnl_unlock();
299 }
300 #endif
301 
302 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
303 {
304         struct mr6_table *mrt;
305         unsigned int i;
306 
307         mrt = ip6mr_get_table(net, id);
308         if (mrt)
309                 return mrt;
310 
311         mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
312         if (!mrt)
313                 return NULL;
314         mrt->id = id;
315         write_pnet(&mrt->net, net);
316 
317         /* Forwarding cache */
318         for (i = 0; i < MFC6_LINES; i++)
319                 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
320 
321         INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
322 
323         setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
324                     (unsigned long)mrt);
325 
326 #ifdef CONFIG_IPV6_PIMSM_V2
327         mrt->mroute_reg_vif_num = -1;
328 #endif
329 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
330         list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
331 #endif
332         return mrt;
333 }
334 
335 static void ip6mr_free_table(struct mr6_table *mrt)
336 {
337         del_timer_sync(&mrt->ipmr_expire_timer);
338         mroute_clean_tables(mrt, true);
339         kfree(mrt);
340 }
341 
342 #ifdef CONFIG_PROC_FS
343 
344 struct ipmr_mfc_iter {
345         struct seq_net_private p;
346         struct mr6_table *mrt;
347         struct list_head *cache;
348         int ct;
349 };
350 
351 
352 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
353                                            struct ipmr_mfc_iter *it, loff_t pos)
354 {
355         struct mr6_table *mrt = it->mrt;
356         struct mfc6_cache *mfc;
357 
358         read_lock(&mrt_lock);
359         for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
360                 it->cache = &mrt->mfc6_cache_array[it->ct];
361                 list_for_each_entry(mfc, it->cache, list)
362                         if (pos-- == 0)
363                                 return mfc;
364         }
365         read_unlock(&mrt_lock);
366 
367         spin_lock_bh(&mfc_unres_lock);
368         it->cache = &mrt->mfc6_unres_queue;
369         list_for_each_entry(mfc, it->cache, list)
370                 if (pos-- == 0)
371                         return mfc;
372         spin_unlock_bh(&mfc_unres_lock);
373 
374         it->cache = NULL;
375         return NULL;
376 }
377 
378 /*
379  *      The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
380  */
381 
382 struct ipmr_vif_iter {
383         struct seq_net_private p;
384         struct mr6_table *mrt;
385         int ct;
386 };
387 
388 static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
389                                             struct ipmr_vif_iter *iter,
390                                             loff_t pos)
391 {
392         struct mr6_table *mrt = iter->mrt;
393 
394         for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
395                 if (!MIF_EXISTS(mrt, iter->ct))
396                         continue;
397                 if (pos-- == 0)
398                         return &mrt->vif6_table[iter->ct];
399         }
400         return NULL;
401 }
402 
403 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
404         __acquires(mrt_lock)
405 {
406         struct ipmr_vif_iter *iter = seq->private;
407         struct net *net = seq_file_net(seq);
408         struct mr6_table *mrt;
409 
410         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
411         if (!mrt)
412                 return ERR_PTR(-ENOENT);
413 
414         iter->mrt = mrt;
415 
416         read_lock(&mrt_lock);
417         return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
418                 : SEQ_START_TOKEN;
419 }
420 
421 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
422 {
423         struct ipmr_vif_iter *iter = seq->private;
424         struct net *net = seq_file_net(seq);
425         struct mr6_table *mrt = iter->mrt;
426 
427         ++*pos;
428         if (v == SEQ_START_TOKEN)
429                 return ip6mr_vif_seq_idx(net, iter, 0);
430 
431         while (++iter->ct < mrt->maxvif) {
432                 if (!MIF_EXISTS(mrt, iter->ct))
433                         continue;
434                 return &mrt->vif6_table[iter->ct];
435         }
436         return NULL;
437 }
438 
439 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
440         __releases(mrt_lock)
441 {
442         read_unlock(&mrt_lock);
443 }
444 
445 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
446 {
447         struct ipmr_vif_iter *iter = seq->private;
448         struct mr6_table *mrt = iter->mrt;
449 
450         if (v == SEQ_START_TOKEN) {
451                 seq_puts(seq,
452                          "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags\n");
453         } else {
454                 const struct mif_device *vif = v;
455                 const char *name = vif->dev ? vif->dev->name : "none";
456 
457                 seq_printf(seq,
458                            "%2td %-10s %8ld %7ld  %8ld %7ld %05X\n",
459                            vif - mrt->vif6_table,
460                            name, vif->bytes_in, vif->pkt_in,
461                            vif->bytes_out, vif->pkt_out,
462                            vif->flags);
463         }
464         return 0;
465 }
466 
467 static const struct seq_operations ip6mr_vif_seq_ops = {
468         .start = ip6mr_vif_seq_start,
469         .next  = ip6mr_vif_seq_next,
470         .stop  = ip6mr_vif_seq_stop,
471         .show  = ip6mr_vif_seq_show,
472 };
473 
474 static int ip6mr_vif_open(struct inode *inode, struct file *file)
475 {
476         return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
477                             sizeof(struct ipmr_vif_iter));
478 }
479 
480 static const struct file_operations ip6mr_vif_fops = {
481         .owner   = THIS_MODULE,
482         .open    = ip6mr_vif_open,
483         .read    = seq_read,
484         .llseek  = seq_lseek,
485         .release = seq_release_net,
486 };
487 
488 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
489 {
490         struct ipmr_mfc_iter *it = seq->private;
491         struct net *net = seq_file_net(seq);
492         struct mr6_table *mrt;
493 
494         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
495         if (!mrt)
496                 return ERR_PTR(-ENOENT);
497 
498         it->mrt = mrt;
499         return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
500                 : SEQ_START_TOKEN;
501 }
502 
503 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
504 {
505         struct mfc6_cache *mfc = v;
506         struct ipmr_mfc_iter *it = seq->private;
507         struct net *net = seq_file_net(seq);
508         struct mr6_table *mrt = it->mrt;
509 
510         ++*pos;
511 
512         if (v == SEQ_START_TOKEN)
513                 return ipmr_mfc_seq_idx(net, seq->private, 0);
514 
515         if (mfc->list.next != it->cache)
516                 return list_entry(mfc->list.next, struct mfc6_cache, list);
517 
518         if (it->cache == &mrt->mfc6_unres_queue)
519                 goto end_of_list;
520 
521         BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
522 
523         while (++it->ct < MFC6_LINES) {
524                 it->cache = &mrt->mfc6_cache_array[it->ct];
525                 if (list_empty(it->cache))
526                         continue;
527                 return list_first_entry(it->cache, struct mfc6_cache, list);
528         }
529 
530         /* exhausted cache_array, show unresolved */
531         read_unlock(&mrt_lock);
532         it->cache = &mrt->mfc6_unres_queue;
533         it->ct = 0;
534 
535         spin_lock_bh(&mfc_unres_lock);
536         if (!list_empty(it->cache))
537                 return list_first_entry(it->cache, struct mfc6_cache, list);
538 
539  end_of_list:
540         spin_unlock_bh(&mfc_unres_lock);
541         it->cache = NULL;
542 
543         return NULL;
544 }
545 
546 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
547 {
548         struct ipmr_mfc_iter *it = seq->private;
549         struct mr6_table *mrt = it->mrt;
550 
551         if (it->cache == &mrt->mfc6_unres_queue)
552                 spin_unlock_bh(&mfc_unres_lock);
553         else if (it->cache == &mrt->mfc6_cache_array[it->ct])
554                 read_unlock(&mrt_lock);
555 }
556 
557 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
558 {
559         int n;
560 
561         if (v == SEQ_START_TOKEN) {
562                 seq_puts(seq,
563                          "Group                            "
564                          "Origin                           "
565                          "Iif      Pkts  Bytes     Wrong  Oifs\n");
566         } else {
567                 const struct mfc6_cache *mfc = v;
568                 const struct ipmr_mfc_iter *it = seq->private;
569                 struct mr6_table *mrt = it->mrt;
570 
571                 seq_printf(seq, "%pI6 %pI6 %-3hd",
572                            &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
573                            mfc->mf6c_parent);
574 
575                 if (it->cache != &mrt->mfc6_unres_queue) {
576                         seq_printf(seq, " %8lu %8lu %8lu",
577                                    mfc->mfc_un.res.pkt,
578                                    mfc->mfc_un.res.bytes,
579                                    mfc->mfc_un.res.wrong_if);
580                         for (n = mfc->mfc_un.res.minvif;
581                              n < mfc->mfc_un.res.maxvif; n++) {
582                                 if (MIF_EXISTS(mrt, n) &&
583                                     mfc->mfc_un.res.ttls[n] < 255)
584                                         seq_printf(seq,
585                                                    " %2d:%-3d",
586                                                    n, mfc->mfc_un.res.ttls[n]);
587                         }
588                 } else {
589                         /* unresolved mfc_caches don't contain
590                          * pkt, bytes and wrong_if values
591                          */
592                         seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
593                 }
594                 seq_putc(seq, '\n');
595         }
596         return 0;
597 }
598 
599 static const struct seq_operations ipmr_mfc_seq_ops = {
600         .start = ipmr_mfc_seq_start,
601         .next  = ipmr_mfc_seq_next,
602         .stop  = ipmr_mfc_seq_stop,
603         .show  = ipmr_mfc_seq_show,
604 };
605 
606 static int ipmr_mfc_open(struct inode *inode, struct file *file)
607 {
608         return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
609                             sizeof(struct ipmr_mfc_iter));
610 }
611 
612 static const struct file_operations ip6mr_mfc_fops = {
613         .owner   = THIS_MODULE,
614         .open    = ipmr_mfc_open,
615         .read    = seq_read,
616         .llseek  = seq_lseek,
617         .release = seq_release_net,
618 };
619 #endif
620 
621 #ifdef CONFIG_IPV6_PIMSM_V2
622 
623 static int pim6_rcv(struct sk_buff *skb)
624 {
625         struct pimreghdr *pim;
626         struct ipv6hdr   *encap;
627         struct net_device  *reg_dev = NULL;
628         struct net *net = dev_net(skb->dev);
629         struct mr6_table *mrt;
630         struct flowi6 fl6 = {
631                 .flowi6_iif     = skb->dev->ifindex,
632                 .flowi6_mark    = skb->mark,
633         };
634         int reg_vif_num;
635 
636         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
637                 goto drop;
638 
639         pim = (struct pimreghdr *)skb_transport_header(skb);
640         if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
641             (pim->flags & PIM_NULL_REGISTER) ||
642             (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
643                              sizeof(*pim), IPPROTO_PIM,
644                              csum_partial((void *)pim, sizeof(*pim), 0)) &&
645              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
646                 goto drop;
647 
648         /* check if the inner packet is destined to mcast group */
649         encap = (struct ipv6hdr *)(skb_transport_header(skb) +
650                                    sizeof(*pim));
651 
652         if (!ipv6_addr_is_multicast(&encap->daddr) ||
653             encap->payload_len == 0 ||
654             ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
655                 goto drop;
656 
657         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
658                 goto drop;
659         reg_vif_num = mrt->mroute_reg_vif_num;
660 
661         read_lock(&mrt_lock);
662         if (reg_vif_num >= 0)
663                 reg_dev = mrt->vif6_table[reg_vif_num].dev;
664         if (reg_dev)
665                 dev_hold(reg_dev);
666         read_unlock(&mrt_lock);
667 
668         if (!reg_dev)
669                 goto drop;
670 
671         skb->mac_header = skb->network_header;
672         skb_pull(skb, (u8 *)encap - skb->data);
673         skb_reset_network_header(skb);
674         skb->protocol = htons(ETH_P_IPV6);
675         skb->ip_summed = CHECKSUM_NONE;
676 
677         skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
678 
679         netif_rx(skb);
680 
681         dev_put(reg_dev);
682         return 0;
683  drop:
684         kfree_skb(skb);
685         return 0;
686 }
687 
688 static const struct inet6_protocol pim6_protocol = {
689         .handler        =       pim6_rcv,
690 };
691 
692 /* Service routines creating virtual interfaces: PIMREG */
693 
694 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
695                                       struct net_device *dev)
696 {
697         struct net *net = dev_net(dev);
698         struct mr6_table *mrt;
699         struct flowi6 fl6 = {
700                 .flowi6_oif     = dev->ifindex,
701                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
702                 .flowi6_mark    = skb->mark,
703         };
704         int err;
705 
706         err = ip6mr_fib_lookup(net, &fl6, &mrt);
707         if (err < 0) {
708                 kfree_skb(skb);
709                 return err;
710         }
711 
712         read_lock(&mrt_lock);
713         dev->stats.tx_bytes += skb->len;
714         dev->stats.tx_packets++;
715         ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
716         read_unlock(&mrt_lock);
717         kfree_skb(skb);
718         return NETDEV_TX_OK;
719 }
720 
721 static int reg_vif_get_iflink(const struct net_device *dev)
722 {
723         return 0;
724 }
725 
726 static const struct net_device_ops reg_vif_netdev_ops = {
727         .ndo_start_xmit = reg_vif_xmit,
728         .ndo_get_iflink = reg_vif_get_iflink,
729 };
730 
731 static void reg_vif_setup(struct net_device *dev)
732 {
733         dev->type               = ARPHRD_PIMREG;
734         dev->mtu                = 1500 - sizeof(struct ipv6hdr) - 8;
735         dev->flags              = IFF_NOARP;
736         dev->netdev_ops         = &reg_vif_netdev_ops;
737         dev->needs_free_netdev  = true;
738         dev->features           |= NETIF_F_NETNS_LOCAL;
739 }
740 
741 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
742 {
743         struct net_device *dev;
744         char name[IFNAMSIZ];
745 
746         if (mrt->id == RT6_TABLE_DFLT)
747                 sprintf(name, "pim6reg");
748         else
749                 sprintf(name, "pim6reg%u", mrt->id);
750 
751         dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
752         if (!dev)
753                 return NULL;
754 
755         dev_net_set(dev, net);
756 
757         if (register_netdevice(dev)) {
758                 free_netdev(dev);
759                 return NULL;
760         }
761 
762         if (dev_open(dev))
763                 goto failure;
764 
765         dev_hold(dev);
766         return dev;
767 
768 failure:
769         unregister_netdevice(dev);
770         return NULL;
771 }
772 #endif
773 
774 /*
775  *      Delete a VIF entry
776  */
777 
778 static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
779                        struct list_head *head)
780 {
781         struct mif_device *v;
782         struct net_device *dev;
783         struct inet6_dev *in6_dev;
784 
785         if (vifi < 0 || vifi >= mrt->maxvif)
786                 return -EADDRNOTAVAIL;
787 
788         v = &mrt->vif6_table[vifi];
789 
790         write_lock_bh(&mrt_lock);
791         dev = v->dev;
792         v->dev = NULL;
793 
794         if (!dev) {
795                 write_unlock_bh(&mrt_lock);
796                 return -EADDRNOTAVAIL;
797         }
798 
799 #ifdef CONFIG_IPV6_PIMSM_V2
800         if (vifi == mrt->mroute_reg_vif_num)
801                 mrt->mroute_reg_vif_num = -1;
802 #endif
803 
804         if (vifi + 1 == mrt->maxvif) {
805                 int tmp;
806                 for (tmp = vifi - 1; tmp >= 0; tmp--) {
807                         if (MIF_EXISTS(mrt, tmp))
808                                 break;
809                 }
810                 mrt->maxvif = tmp + 1;
811         }
812 
813         write_unlock_bh(&mrt_lock);
814 
815         dev_set_allmulti(dev, -1);
816 
817         in6_dev = __in6_dev_get(dev);
818         if (in6_dev) {
819                 in6_dev->cnf.mc_forwarding--;
820                 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
821                                              NETCONFA_MC_FORWARDING,
822                                              dev->ifindex, &in6_dev->cnf);
823         }
824 
825         if ((v->flags & MIFF_REGISTER) && !notify)
826                 unregister_netdevice_queue(dev, head);
827 
828         dev_put(dev);
829         return 0;
830 }
831 
832 static inline void ip6mr_cache_free(struct mfc6_cache *c)
833 {
834         kmem_cache_free(mrt_cachep, c);
835 }
836 
837 /* Destroy an unresolved cache entry, killing queued skbs
838    and reporting error to netlink readers.
839  */
840 
841 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
842 {
843         struct net *net = read_pnet(&mrt->net);
844         struct sk_buff *skb;
845 
846         atomic_dec(&mrt->cache_resolve_queue_len);
847 
848         while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
849                 if (ipv6_hdr(skb)->version == 0) {
850                         struct nlmsghdr *nlh = skb_pull(skb,
851                                                         sizeof(struct ipv6hdr));
852                         nlh->nlmsg_type = NLMSG_ERROR;
853                         nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
854                         skb_trim(skb, nlh->nlmsg_len);
855                         ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
856                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
857                 } else
858                         kfree_skb(skb);
859         }
860 
861         ip6mr_cache_free(c);
862 }
863 
864 
865 /* Timer process for all the unresolved queue. */
866 
867 static void ipmr_do_expire_process(struct mr6_table *mrt)
868 {
869         unsigned long now = jiffies;
870         unsigned long expires = 10 * HZ;
871         struct mfc6_cache *c, *next;
872 
873         list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
874                 if (time_after(c->mfc_un.unres.expires, now)) {
875                         /* not yet... */
876                         unsigned long interval = c->mfc_un.unres.expires - now;
877                         if (interval < expires)
878                                 expires = interval;
879                         continue;
880                 }
881 
882                 list_del(&c->list);
883                 mr6_netlink_event(mrt, c, RTM_DELROUTE);
884                 ip6mr_destroy_unres(mrt, c);
885         }
886 
887         if (!list_empty(&mrt->mfc6_unres_queue))
888                 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
889 }
890 
891 static void ipmr_expire_process(unsigned long arg)
892 {
893         struct mr6_table *mrt = (struct mr6_table *)arg;
894 
895         if (!spin_trylock(&mfc_unres_lock)) {
896                 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
897                 return;
898         }
899 
900         if (!list_empty(&mrt->mfc6_unres_queue))
901                 ipmr_do_expire_process(mrt);
902 
903         spin_unlock(&mfc_unres_lock);
904 }
905 
906 /* Fill oifs list. It is called under write locked mrt_lock. */
907 
908 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
909                                     unsigned char *ttls)
910 {
911         int vifi;
912 
913         cache->mfc_un.res.minvif = MAXMIFS;
914         cache->mfc_un.res.maxvif = 0;
915         memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
916 
917         for (vifi = 0; vifi < mrt->maxvif; vifi++) {
918                 if (MIF_EXISTS(mrt, vifi) &&
919                     ttls[vifi] && ttls[vifi] < 255) {
920                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
921                         if (cache->mfc_un.res.minvif > vifi)
922                                 cache->mfc_un.res.minvif = vifi;
923                         if (cache->mfc_un.res.maxvif <= vifi)
924                                 cache->mfc_un.res.maxvif = vifi + 1;
925                 }
926         }
927         cache->mfc_un.res.lastuse = jiffies;
928 }
929 
930 static int mif6_add(struct net *net, struct mr6_table *mrt,
931                     struct mif6ctl *vifc, int mrtsock)
932 {
933         int vifi = vifc->mif6c_mifi;
934         struct mif_device *v = &mrt->vif6_table[vifi];
935         struct net_device *dev;
936         struct inet6_dev *in6_dev;
937         int err;
938 
939         /* Is vif busy ? */
940         if (MIF_EXISTS(mrt, vifi))
941                 return -EADDRINUSE;
942 
943         switch (vifc->mif6c_flags) {
944 #ifdef CONFIG_IPV6_PIMSM_V2
945         case MIFF_REGISTER:
946                 /*
947                  * Special Purpose VIF in PIM
948                  * All the packets will be sent to the daemon
949                  */
950                 if (mrt->mroute_reg_vif_num >= 0)
951                         return -EADDRINUSE;
952                 dev = ip6mr_reg_vif(net, mrt);
953                 if (!dev)
954                         return -ENOBUFS;
955                 err = dev_set_allmulti(dev, 1);
956                 if (err) {
957                         unregister_netdevice(dev);
958                         dev_put(dev);
959                         return err;
960                 }
961                 break;
962 #endif
963         case 0:
964                 dev = dev_get_by_index(net, vifc->mif6c_pifi);
965                 if (!dev)
966                         return -EADDRNOTAVAIL;
967                 err = dev_set_allmulti(dev, 1);
968                 if (err) {
969                         dev_put(dev);
970                         return err;
971                 }
972                 break;
973         default:
974                 return -EINVAL;
975         }
976 
977         in6_dev = __in6_dev_get(dev);
978         if (in6_dev) {
979                 in6_dev->cnf.mc_forwarding++;
980                 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
981                                              NETCONFA_MC_FORWARDING,
982                                              dev->ifindex, &in6_dev->cnf);
983         }
984 
985         /*
986          *      Fill in the VIF structures
987          */
988         v->rate_limit = vifc->vifc_rate_limit;
989         v->flags = vifc->mif6c_flags;
990         if (!mrtsock)
991                 v->flags |= VIFF_STATIC;
992         v->threshold = vifc->vifc_threshold;
993         v->bytes_in = 0;
994         v->bytes_out = 0;
995         v->pkt_in = 0;
996         v->pkt_out = 0;
997         v->link = dev->ifindex;
998         if (v->flags & MIFF_REGISTER)
999                 v->link = dev_get_iflink(dev);
1000 
1001         /* And finish update writing critical data */
1002         write_lock_bh(&mrt_lock);
1003         v->dev = dev;
1004 #ifdef CONFIG_IPV6_PIMSM_V2
1005         if (v->flags & MIFF_REGISTER)
1006                 mrt->mroute_reg_vif_num = vifi;
1007 #endif
1008         if (vifi + 1 > mrt->maxvif)
1009                 mrt->maxvif = vifi + 1;
1010         write_unlock_bh(&mrt_lock);
1011         return 0;
1012 }
1013 
1014 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1015                                            const struct in6_addr *origin,
1016                                            const struct in6_addr *mcastgrp)
1017 {
1018         int line = MFC6_HASH(mcastgrp, origin);
1019         struct mfc6_cache *c;
1020 
1021         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1022                 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1023                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1024                         return c;
1025         }
1026         return NULL;
1027 }
1028 
1029 /* Look for a (*,*,oif) entry */
1030 static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1031                                                       mifi_t mifi)
1032 {
1033         int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1034         struct mfc6_cache *c;
1035 
1036         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1037                 if (ipv6_addr_any(&c->mf6c_origin) &&
1038                     ipv6_addr_any(&c->mf6c_mcastgrp) &&
1039                     (c->mfc_un.res.ttls[mifi] < 255))
1040                         return c;
1041 
1042         return NULL;
1043 }
1044 
1045 /* Look for a (*,G) entry */
1046 static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1047                                                struct in6_addr *mcastgrp,
1048                                                mifi_t mifi)
1049 {
1050         int line = MFC6_HASH(mcastgrp, &in6addr_any);
1051         struct mfc6_cache *c, *proxy;
1052 
1053         if (ipv6_addr_any(mcastgrp))
1054                 goto skip;
1055 
1056         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1057                 if (ipv6_addr_any(&c->mf6c_origin) &&
1058                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1059                         if (c->mfc_un.res.ttls[mifi] < 255)
1060                                 return c;
1061 
1062                         /* It's ok if the mifi is part of the static tree */
1063                         proxy = ip6mr_cache_find_any_parent(mrt,
1064                                                             c->mf6c_parent);
1065                         if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1066                                 return c;
1067                 }
1068 
1069 skip:
1070         return ip6mr_cache_find_any_parent(mrt, mifi);
1071 }
1072 
1073 /*
1074  *      Allocate a multicast cache entry
1075  */
1076 static struct mfc6_cache *ip6mr_cache_alloc(void)
1077 {
1078         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1079         if (!c)
1080                 return NULL;
1081         c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
1082         c->mfc_un.res.minvif = MAXMIFS;
1083         return c;
1084 }
1085 
1086 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1087 {
1088         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1089         if (!c)
1090                 return NULL;
1091         skb_queue_head_init(&c->mfc_un.unres.unresolved);
1092         c->mfc_un.unres.expires = jiffies + 10 * HZ;
1093         return c;
1094 }
1095 
1096 /*
1097  *      A cache entry has gone into a resolved state from queued
1098  */
1099 
1100 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1101                                 struct mfc6_cache *uc, struct mfc6_cache *c)
1102 {
1103         struct sk_buff *skb;
1104 
1105         /*
1106          *      Play the pending entries through our router
1107          */
1108 
1109         while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1110                 if (ipv6_hdr(skb)->version == 0) {
1111                         struct nlmsghdr *nlh = skb_pull(skb,
1112                                                         sizeof(struct ipv6hdr));
1113 
1114                         if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1115                                 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1116                         } else {
1117                                 nlh->nlmsg_type = NLMSG_ERROR;
1118                                 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1119                                 skb_trim(skb, nlh->nlmsg_len);
1120                                 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1121                         }
1122                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1123                 } else
1124                         ip6_mr_forward(net, mrt, skb, c);
1125         }
1126 }
1127 
1128 /*
1129  *      Bounce a cache query up to pim6sd and netlink.
1130  *
1131  *      Called under mrt_lock.
1132  */
1133 
1134 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1135                               mifi_t mifi, int assert)
1136 {
1137         struct sk_buff *skb;
1138         struct mrt6msg *msg;
1139         int ret;
1140 
1141 #ifdef CONFIG_IPV6_PIMSM_V2
1142         if (assert == MRT6MSG_WHOLEPKT)
1143                 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1144                                                 +sizeof(*msg));
1145         else
1146 #endif
1147                 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1148 
1149         if (!skb)
1150                 return -ENOBUFS;
1151 
1152         /* I suppose that internal messages
1153          * do not require checksums */
1154 
1155         skb->ip_summed = CHECKSUM_UNNECESSARY;
1156 
1157 #ifdef CONFIG_IPV6_PIMSM_V2
1158         if (assert == MRT6MSG_WHOLEPKT) {
1159                 /* Ugly, but we have no choice with this interface.
1160                    Duplicate old header, fix length etc.
1161                    And all this only to mangle msg->im6_msgtype and
1162                    to set msg->im6_mbz to "mbz" :-)
1163                  */
1164                 skb_push(skb, -skb_network_offset(pkt));
1165 
1166                 skb_push(skb, sizeof(*msg));
1167                 skb_reset_transport_header(skb);
1168                 msg = (struct mrt6msg *)skb_transport_header(skb);
1169                 msg->im6_mbz = 0;
1170                 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1171                 msg->im6_mif = mrt->mroute_reg_vif_num;
1172                 msg->im6_pad = 0;
1173                 msg->im6_src = ipv6_hdr(pkt)->saddr;
1174                 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1175 
1176                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1177         } else
1178 #endif
1179         {
1180         /*
1181          *      Copy the IP header
1182          */
1183 
1184         skb_put(skb, sizeof(struct ipv6hdr));
1185         skb_reset_network_header(skb);
1186         skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1187 
1188         /*
1189          *      Add our header
1190          */
1191         skb_put(skb, sizeof(*msg));
1192         skb_reset_transport_header(skb);
1193         msg = (struct mrt6msg *)skb_transport_header(skb);
1194 
1195         msg->im6_mbz = 0;
1196         msg->im6_msgtype = assert;
1197         msg->im6_mif = mifi;
1198         msg->im6_pad = 0;
1199         msg->im6_src = ipv6_hdr(pkt)->saddr;
1200         msg->im6_dst = ipv6_hdr(pkt)->daddr;
1201 
1202         skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1203         skb->ip_summed = CHECKSUM_UNNECESSARY;
1204         }
1205 
1206         if (!mrt->mroute6_sk) {
1207                 kfree_skb(skb);
1208                 return -EINVAL;
1209         }
1210 
1211         mrt6msg_netlink_event(mrt, skb);
1212 
1213         /*
1214          *      Deliver to user space multicast routing algorithms
1215          */
1216         ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1217         if (ret < 0) {
1218                 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1219                 kfree_skb(skb);
1220         }
1221 
1222         return ret;
1223 }
1224 
1225 /*
1226  *      Queue a packet for resolution. It gets locked cache entry!
1227  */
1228 
1229 static int
1230 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1231 {
1232         bool found = false;
1233         int err;
1234         struct mfc6_cache *c;
1235 
1236         spin_lock_bh(&mfc_unres_lock);
1237         list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1238                 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1239                     ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1240                         found = true;
1241                         break;
1242                 }
1243         }
1244 
1245         if (!found) {
1246                 /*
1247                  *      Create a new entry if allowable
1248                  */
1249 
1250                 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1251                     (c = ip6mr_cache_alloc_unres()) == NULL) {
1252                         spin_unlock_bh(&mfc_unres_lock);
1253 
1254                         kfree_skb(skb);
1255                         return -ENOBUFS;
1256                 }
1257 
1258                 /*
1259                  *      Fill in the new cache entry
1260                  */
1261                 c->mf6c_parent = -1;
1262                 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1263                 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1264 
1265                 /*
1266                  *      Reflect first query at pim6sd
1267                  */
1268                 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1269                 if (err < 0) {
1270                         /* If the report failed throw the cache entry
1271                            out - Brad Parker
1272                          */
1273                         spin_unlock_bh(&mfc_unres_lock);
1274 
1275                         ip6mr_cache_free(c);
1276                         kfree_skb(skb);
1277                         return err;
1278                 }
1279 
1280                 atomic_inc(&mrt->cache_resolve_queue_len);
1281                 list_add(&c->list, &mrt->mfc6_unres_queue);
1282                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1283 
1284                 ipmr_do_expire_process(mrt);
1285         }
1286 
1287         /*
1288          *      See if we can append the packet
1289          */
1290         if (c->mfc_un.unres.unresolved.qlen > 3) {
1291                 kfree_skb(skb);
1292                 err = -ENOBUFS;
1293         } else {
1294                 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1295                 err = 0;
1296         }
1297 
1298         spin_unlock_bh(&mfc_unres_lock);
1299         return err;
1300 }
1301 
1302 /*
1303  *      MFC6 cache manipulation by user space
1304  */
1305 
1306 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1307                             int parent)
1308 {
1309         int line;
1310         struct mfc6_cache *c, *next;
1311 
1312         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1313 
1314         list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1315                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1316                     ipv6_addr_equal(&c->mf6c_mcastgrp,
1317                                     &mfc->mf6cc_mcastgrp.sin6_addr) &&
1318                     (parent == -1 || parent == c->mf6c_parent)) {
1319                         write_lock_bh(&mrt_lock);
1320                         list_del(&c->list);
1321                         write_unlock_bh(&mrt_lock);
1322 
1323                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1324                         ip6mr_cache_free(c);
1325                         return 0;
1326                 }
1327         }
1328         return -ENOENT;
1329 }
1330 
1331 static int ip6mr_device_event(struct notifier_block *this,
1332                               unsigned long event, void *ptr)
1333 {
1334         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1335         struct net *net = dev_net(dev);
1336         struct mr6_table *mrt;
1337         struct mif_device *v;
1338         int ct;
1339 
1340         if (event != NETDEV_UNREGISTER)
1341                 return NOTIFY_DONE;
1342 
1343         ip6mr_for_each_table(mrt, net) {
1344                 v = &mrt->vif6_table[0];
1345                 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1346                         if (v->dev == dev)
1347                                 mif6_delete(mrt, ct, 1, NULL);
1348                 }
1349         }
1350 
1351         return NOTIFY_DONE;
1352 }
1353 
1354 static struct notifier_block ip6_mr_notifier = {
1355         .notifier_call = ip6mr_device_event
1356 };
1357 
1358 /*
1359  *      Setup for IP multicast routing
1360  */
1361 
1362 static int __net_init ip6mr_net_init(struct net *net)
1363 {
1364         int err;
1365 
1366         err = ip6mr_rules_init(net);
1367         if (err < 0)
1368                 goto fail;
1369 
1370 #ifdef CONFIG_PROC_FS
1371         err = -ENOMEM;
1372         if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1373                 goto proc_vif_fail;
1374         if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1375                 goto proc_cache_fail;
1376 #endif
1377 
1378         return 0;
1379 
1380 #ifdef CONFIG_PROC_FS
1381 proc_cache_fail:
1382         remove_proc_entry("ip6_mr_vif", net->proc_net);
1383 proc_vif_fail:
1384         ip6mr_rules_exit(net);
1385 #endif
1386 fail:
1387         return err;
1388 }
1389 
1390 static void __net_exit ip6mr_net_exit(struct net *net)
1391 {
1392 #ifdef CONFIG_PROC_FS
1393         remove_proc_entry("ip6_mr_cache", net->proc_net);
1394         remove_proc_entry("ip6_mr_vif", net->proc_net);
1395 #endif
1396         ip6mr_rules_exit(net);
1397 }
1398 
1399 static struct pernet_operations ip6mr_net_ops = {
1400         .init = ip6mr_net_init,
1401         .exit = ip6mr_net_exit,
1402 };
1403 
1404 int __init ip6_mr_init(void)
1405 {
1406         int err;
1407 
1408         mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1409                                        sizeof(struct mfc6_cache),
1410                                        0, SLAB_HWCACHE_ALIGN,
1411                                        NULL);
1412         if (!mrt_cachep)
1413                 return -ENOMEM;
1414 
1415         err = register_pernet_subsys(&ip6mr_net_ops);
1416         if (err)
1417                 goto reg_pernet_fail;
1418 
1419         err = register_netdevice_notifier(&ip6_mr_notifier);
1420         if (err)
1421                 goto reg_notif_fail;
1422 #ifdef CONFIG_IPV6_PIMSM_V2
1423         if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1424                 pr_err("%s: can't add PIM protocol\n", __func__);
1425                 err = -EAGAIN;
1426                 goto add_proto_fail;
1427         }
1428 #endif
1429         rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1430                       ip6mr_rtm_dumproute, NULL);
1431         return 0;
1432 #ifdef CONFIG_IPV6_PIMSM_V2
1433 add_proto_fail:
1434         unregister_netdevice_notifier(&ip6_mr_notifier);
1435 #endif
1436 reg_notif_fail:
1437         unregister_pernet_subsys(&ip6mr_net_ops);
1438 reg_pernet_fail:
1439         kmem_cache_destroy(mrt_cachep);
1440         return err;
1441 }
1442 
1443 void ip6_mr_cleanup(void)
1444 {
1445         rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1446 #ifdef CONFIG_IPV6_PIMSM_V2
1447         inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1448 #endif
1449         unregister_netdevice_notifier(&ip6_mr_notifier);
1450         unregister_pernet_subsys(&ip6mr_net_ops);
1451         kmem_cache_destroy(mrt_cachep);
1452 }
1453 
1454 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1455                          struct mf6cctl *mfc, int mrtsock, int parent)
1456 {
1457         bool found = false;
1458         int line;
1459         struct mfc6_cache *uc, *c;
1460         unsigned char ttls[MAXMIFS];
1461         int i;
1462 
1463         if (mfc->mf6cc_parent >= MAXMIFS)
1464                 return -ENFILE;
1465 
1466         memset(ttls, 255, MAXMIFS);
1467         for (i = 0; i < MAXMIFS; i++) {
1468                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1469                         ttls[i] = 1;
1470 
1471         }
1472 
1473         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1474 
1475         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1476                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1477                     ipv6_addr_equal(&c->mf6c_mcastgrp,
1478                                     &mfc->mf6cc_mcastgrp.sin6_addr) &&
1479                     (parent == -1 || parent == mfc->mf6cc_parent)) {
1480                         found = true;
1481                         break;
1482                 }
1483         }
1484 
1485         if (found) {
1486                 write_lock_bh(&mrt_lock);
1487                 c->mf6c_parent = mfc->mf6cc_parent;
1488                 ip6mr_update_thresholds(mrt, c, ttls);
1489                 if (!mrtsock)
1490                         c->mfc_flags |= MFC_STATIC;
1491                 write_unlock_bh(&mrt_lock);
1492                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1493                 return 0;
1494         }
1495 
1496         if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1497             !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1498                 return -EINVAL;
1499 
1500         c = ip6mr_cache_alloc();
1501         if (!c)
1502                 return -ENOMEM;
1503 
1504         c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1505         c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1506         c->mf6c_parent = mfc->mf6cc_parent;
1507         ip6mr_update_thresholds(mrt, c, ttls);
1508         if (!mrtsock)
1509                 c->mfc_flags |= MFC_STATIC;
1510 
1511         write_lock_bh(&mrt_lock);
1512         list_add(&c->list, &mrt->mfc6_cache_array[line]);
1513         write_unlock_bh(&mrt_lock);
1514 
1515         /*
1516          *      Check to see if we resolved a queued list. If so we
1517          *      need to send on the frames and tidy up.
1518          */
1519         found = false;
1520         spin_lock_bh(&mfc_unres_lock);
1521         list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1522                 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1523                     ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1524                         list_del(&uc->list);
1525                         atomic_dec(&mrt->cache_resolve_queue_len);
1526                         found = true;
1527                         break;
1528                 }
1529         }
1530         if (list_empty(&mrt->mfc6_unres_queue))
1531                 del_timer(&mrt->ipmr_expire_timer);
1532         spin_unlock_bh(&mfc_unres_lock);
1533 
1534         if (found) {
1535                 ip6mr_cache_resolve(net, mrt, uc, c);
1536                 ip6mr_cache_free(uc);
1537         }
1538         mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1539         return 0;
1540 }
1541 
1542 /*
1543  *      Close the multicast socket, and clear the vif tables etc
1544  */
1545 
1546 static void mroute_clean_tables(struct mr6_table *mrt, bool all)
1547 {
1548         int i;
1549         LIST_HEAD(list);
1550         struct mfc6_cache *c, *next;
1551 
1552         /*
1553          *      Shut down all active vif entries
1554          */
1555         for (i = 0; i < mrt->maxvif; i++) {
1556                 if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
1557                         continue;
1558                 mif6_delete(mrt, i, 0, &list);
1559         }
1560         unregister_netdevice_many(&list);
1561 
1562         /*
1563          *      Wipe the cache
1564          */
1565         for (i = 0; i < MFC6_LINES; i++) {
1566                 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1567                         if (!all && (c->mfc_flags & MFC_STATIC))
1568                                 continue;
1569                         write_lock_bh(&mrt_lock);
1570                         list_del(&c->list);
1571                         write_unlock_bh(&mrt_lock);
1572 
1573                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1574                         ip6mr_cache_free(c);
1575                 }
1576         }
1577 
1578         if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1579                 spin_lock_bh(&mfc_unres_lock);
1580                 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1581                         list_del(&c->list);
1582                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1583                         ip6mr_destroy_unres(mrt, c);
1584                 }
1585                 spin_unlock_bh(&mfc_unres_lock);
1586         }
1587 }
1588 
1589 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1590 {
1591         int err = 0;
1592         struct net *net = sock_net(sk);
1593 
1594         rtnl_lock();
1595         write_lock_bh(&mrt_lock);
1596         if (likely(mrt->mroute6_sk == NULL)) {
1597                 mrt->mroute6_sk = sk;
1598                 net->ipv6.devconf_all->mc_forwarding++;
1599         } else {
1600                 err = -EADDRINUSE;
1601         }
1602         write_unlock_bh(&mrt_lock);
1603 
1604         if (!err)
1605                 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1606                                              NETCONFA_MC_FORWARDING,
1607                                              NETCONFA_IFINDEX_ALL,
1608                                              net->ipv6.devconf_all);
1609         rtnl_unlock();
1610 
1611         return err;
1612 }
1613 
1614 int ip6mr_sk_done(struct sock *sk)
1615 {
1616         int err = -EACCES;
1617         struct net *net = sock_net(sk);
1618         struct mr6_table *mrt;
1619 
1620         rtnl_lock();
1621         ip6mr_for_each_table(mrt, net) {
1622                 if (sk == mrt->mroute6_sk) {
1623                         write_lock_bh(&mrt_lock);
1624                         mrt->mroute6_sk = NULL;
1625                         net->ipv6.devconf_all->mc_forwarding--;
1626                         write_unlock_bh(&mrt_lock);
1627                         inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1628                                                      NETCONFA_MC_FORWARDING,
1629                                                      NETCONFA_IFINDEX_ALL,
1630                                                      net->ipv6.devconf_all);
1631 
1632                         mroute_clean_tables(mrt, false);
1633                         err = 0;
1634                         break;
1635                 }
1636         }
1637         rtnl_unlock();
1638 
1639         return err;
1640 }
1641 
1642 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1643 {
1644         struct mr6_table *mrt;
1645         struct flowi6 fl6 = {
1646                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
1647                 .flowi6_oif     = skb->dev->ifindex,
1648                 .flowi6_mark    = skb->mark,
1649         };
1650 
1651         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1652                 return NULL;
1653 
1654         return mrt->mroute6_sk;
1655 }
1656 
1657 /*
1658  *      Socket options and virtual interface manipulation. The whole
1659  *      virtual interface system is a complete heap, but unfortunately
1660  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1661  *      MOSPF/PIM router set up we can clean this up.
1662  */
1663 
1664 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1665 {
1666         int ret, parent = 0;
1667         struct mif6ctl vif;
1668         struct mf6cctl mfc;
1669         mifi_t mifi;
1670         struct net *net = sock_net(sk);
1671         struct mr6_table *mrt;
1672 
1673         if (sk->sk_type != SOCK_RAW ||
1674             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1675                 return -EOPNOTSUPP;
1676 
1677         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1678         if (!mrt)
1679                 return -ENOENT;
1680 
1681         if (optname != MRT6_INIT) {
1682                 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1683                         return -EACCES;
1684         }
1685 
1686         switch (optname) {
1687         case MRT6_INIT:
1688                 if (optlen < sizeof(int))
1689                         return -EINVAL;
1690 
1691                 return ip6mr_sk_init(mrt, sk);
1692 
1693         case MRT6_DONE:
1694                 return ip6mr_sk_done(sk);
1695 
1696         case MRT6_ADD_MIF:
1697                 if (optlen < sizeof(vif))
1698                         return -EINVAL;
1699                 if (copy_from_user(&vif, optval, sizeof(vif)))
1700                         return -EFAULT;
1701                 if (vif.mif6c_mifi >= MAXMIFS)
1702                         return -ENFILE;
1703                 rtnl_lock();
1704                 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1705                 rtnl_unlock();
1706                 return ret;
1707 
1708         case MRT6_DEL_MIF:
1709                 if (optlen < sizeof(mifi_t))
1710                         return -EINVAL;
1711                 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1712                         return -EFAULT;
1713                 rtnl_lock();
1714                 ret = mif6_delete(mrt, mifi, 0, NULL);
1715                 rtnl_unlock();
1716                 return ret;
1717 
1718         /*
1719          *      Manipulate the forwarding caches. These live
1720          *      in a sort of kernel/user symbiosis.
1721          */
1722         case MRT6_ADD_MFC:
1723         case MRT6_DEL_MFC:
1724                 parent = -1;
1725         case MRT6_ADD_MFC_PROXY:
1726         case MRT6_DEL_MFC_PROXY:
1727                 if (optlen < sizeof(mfc))
1728                         return -EINVAL;
1729                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1730                         return -EFAULT;
1731                 if (parent == 0)
1732                         parent = mfc.mf6cc_parent;
1733                 rtnl_lock();
1734                 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1735                         ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1736                 else
1737                         ret = ip6mr_mfc_add(net, mrt, &mfc,
1738                                             sk == mrt->mroute6_sk, parent);
1739                 rtnl_unlock();
1740                 return ret;
1741 
1742         /*
1743          *      Control PIM assert (to activate pim will activate assert)
1744          */
1745         case MRT6_ASSERT:
1746         {
1747                 int v;
1748 
1749                 if (optlen != sizeof(v))
1750                         return -EINVAL;
1751                 if (get_user(v, (int __user *)optval))
1752                         return -EFAULT;
1753                 mrt->mroute_do_assert = v;
1754                 return 0;
1755         }
1756 
1757 #ifdef CONFIG_IPV6_PIMSM_V2
1758         case MRT6_PIM:
1759         {
1760                 int v;
1761 
1762                 if (optlen != sizeof(v))
1763                         return -EINVAL;
1764                 if (get_user(v, (int __user *)optval))
1765                         return -EFAULT;
1766                 v = !!v;
1767                 rtnl_lock();
1768                 ret = 0;
1769                 if (v != mrt->mroute_do_pim) {
1770                         mrt->mroute_do_pim = v;
1771                         mrt->mroute_do_assert = v;
1772                 }
1773                 rtnl_unlock();
1774                 return ret;
1775         }
1776 
1777 #endif
1778 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1779         case MRT6_TABLE:
1780         {
1781                 u32 v;
1782 
1783                 if (optlen != sizeof(u32))
1784                         return -EINVAL;
1785                 if (get_user(v, (u32 __user *)optval))
1786                         return -EFAULT;
1787                 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1788                 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1789                         return -EINVAL;
1790                 if (sk == mrt->mroute6_sk)
1791                         return -EBUSY;
1792 
1793                 rtnl_lock();
1794                 ret = 0;
1795                 if (!ip6mr_new_table(net, v))
1796                         ret = -ENOMEM;
1797                 raw6_sk(sk)->ip6mr_table = v;
1798                 rtnl_unlock();
1799                 return ret;
1800         }
1801 #endif
1802         /*
1803          *      Spurious command, or MRT6_VERSION which you cannot
1804          *      set.
1805          */
1806         default:
1807                 return -ENOPROTOOPT;
1808         }
1809 }
1810 
1811 /*
1812  *      Getsock opt support for the multicast routing system.
1813  */
1814 
1815 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1816                           int __user *optlen)
1817 {
1818         int olr;
1819         int val;
1820         struct net *net = sock_net(sk);
1821         struct mr6_table *mrt;
1822 
1823         if (sk->sk_type != SOCK_RAW ||
1824             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1825                 return -EOPNOTSUPP;
1826 
1827         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1828         if (!mrt)
1829                 return -ENOENT;
1830 
1831         switch (optname) {
1832         case MRT6_VERSION:
1833                 val = 0x0305;
1834                 break;
1835 #ifdef CONFIG_IPV6_PIMSM_V2
1836         case MRT6_PIM:
1837                 val = mrt->mroute_do_pim;
1838                 break;
1839 #endif
1840         case MRT6_ASSERT:
1841                 val = mrt->mroute_do_assert;
1842                 break;
1843         default:
1844                 return -ENOPROTOOPT;
1845         }
1846 
1847         if (get_user(olr, optlen))
1848                 return -EFAULT;
1849 
1850         olr = min_t(int, olr, sizeof(int));
1851         if (olr < 0)
1852                 return -EINVAL;
1853 
1854         if (put_user(olr, optlen))
1855                 return -EFAULT;
1856         if (copy_to_user(optval, &val, olr))
1857                 return -EFAULT;
1858         return 0;
1859 }
1860 
1861 /*
1862  *      The IP multicast ioctl support routines.
1863  */
1864 
1865 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1866 {
1867         struct sioc_sg_req6 sr;
1868         struct sioc_mif_req6 vr;
1869         struct mif_device *vif;
1870         struct mfc6_cache *c;
1871         struct net *net = sock_net(sk);
1872         struct mr6_table *mrt;
1873 
1874         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1875         if (!mrt)
1876                 return -ENOENT;
1877 
1878         switch (cmd) {
1879         case SIOCGETMIFCNT_IN6:
1880                 if (copy_from_user(&vr, arg, sizeof(vr)))
1881                         return -EFAULT;
1882                 if (vr.mifi >= mrt->maxvif)
1883                         return -EINVAL;
1884                 read_lock(&mrt_lock);
1885                 vif = &mrt->vif6_table[vr.mifi];
1886                 if (MIF_EXISTS(mrt, vr.mifi)) {
1887                         vr.icount = vif->pkt_in;
1888                         vr.ocount = vif->pkt_out;
1889                         vr.ibytes = vif->bytes_in;
1890                         vr.obytes = vif->bytes_out;
1891                         read_unlock(&mrt_lock);
1892 
1893                         if (copy_to_user(arg, &vr, sizeof(vr)))
1894                                 return -EFAULT;
1895                         return 0;
1896                 }
1897                 read_unlock(&mrt_lock);
1898                 return -EADDRNOTAVAIL;
1899         case SIOCGETSGCNT_IN6:
1900                 if (copy_from_user(&sr, arg, sizeof(sr)))
1901                         return -EFAULT;
1902 
1903                 read_lock(&mrt_lock);
1904                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1905                 if (c) {
1906                         sr.pktcnt = c->mfc_un.res.pkt;
1907                         sr.bytecnt = c->mfc_un.res.bytes;
1908                         sr.wrong_if = c->mfc_un.res.wrong_if;
1909                         read_unlock(&mrt_lock);
1910 
1911                         if (copy_to_user(arg, &sr, sizeof(sr)))
1912                                 return -EFAULT;
1913                         return 0;
1914                 }
1915                 read_unlock(&mrt_lock);
1916                 return -EADDRNOTAVAIL;
1917         default:
1918                 return -ENOIOCTLCMD;
1919         }
1920 }
1921 
1922 #ifdef CONFIG_COMPAT
1923 struct compat_sioc_sg_req6 {
1924         struct sockaddr_in6 src;
1925         struct sockaddr_in6 grp;
1926         compat_ulong_t pktcnt;
1927         compat_ulong_t bytecnt;
1928         compat_ulong_t wrong_if;
1929 };
1930 
1931 struct compat_sioc_mif_req6 {
1932         mifi_t  mifi;
1933         compat_ulong_t icount;
1934         compat_ulong_t ocount;
1935         compat_ulong_t ibytes;
1936         compat_ulong_t obytes;
1937 };
1938 
1939 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1940 {
1941         struct compat_sioc_sg_req6 sr;
1942         struct compat_sioc_mif_req6 vr;
1943         struct mif_device *vif;
1944         struct mfc6_cache *c;
1945         struct net *net = sock_net(sk);
1946         struct mr6_table *mrt;
1947 
1948         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1949         if (!mrt)
1950                 return -ENOENT;
1951 
1952         switch (cmd) {
1953         case SIOCGETMIFCNT_IN6:
1954                 if (copy_from_user(&vr, arg, sizeof(vr)))
1955                         return -EFAULT;
1956                 if (vr.mifi >= mrt->maxvif)
1957                         return -EINVAL;
1958                 read_lock(&mrt_lock);
1959                 vif = &mrt->vif6_table[vr.mifi];
1960                 if (MIF_EXISTS(mrt, vr.mifi)) {
1961                         vr.icount = vif->pkt_in;
1962                         vr.ocount = vif->pkt_out;
1963                         vr.ibytes = vif->bytes_in;
1964                         vr.obytes = vif->bytes_out;
1965                         read_unlock(&mrt_lock);
1966 
1967                         if (copy_to_user(arg, &vr, sizeof(vr)))
1968                                 return -EFAULT;
1969                         return 0;
1970                 }
1971                 read_unlock(&mrt_lock);
1972                 return -EADDRNOTAVAIL;
1973         case SIOCGETSGCNT_IN6:
1974                 if (copy_from_user(&sr, arg, sizeof(sr)))
1975                         return -EFAULT;
1976 
1977                 read_lock(&mrt_lock);
1978                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1979                 if (c) {
1980                         sr.pktcnt = c->mfc_un.res.pkt;
1981                         sr.bytecnt = c->mfc_un.res.bytes;
1982                         sr.wrong_if = c->mfc_un.res.wrong_if;
1983                         read_unlock(&mrt_lock);
1984 
1985                         if (copy_to_user(arg, &sr, sizeof(sr)))
1986                                 return -EFAULT;
1987                         return 0;
1988                 }
1989                 read_unlock(&mrt_lock);
1990                 return -EADDRNOTAVAIL;
1991         default:
1992                 return -ENOIOCTLCMD;
1993         }
1994 }
1995 #endif
1996 
1997 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
1998 {
1999         __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2000                         IPSTATS_MIB_OUTFORWDATAGRAMS);
2001         __IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2002                         IPSTATS_MIB_OUTOCTETS, skb->len);
2003         return dst_output(net, sk, skb);
2004 }
2005 
2006 /*
2007  *      Processing handlers for ip6mr_forward
2008  */
2009 
2010 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2011                           struct sk_buff *skb, struct mfc6_cache *c, int vifi)
2012 {
2013         struct ipv6hdr *ipv6h;
2014         struct mif_device *vif = &mrt->vif6_table[vifi];
2015         struct net_device *dev;
2016         struct dst_entry *dst;
2017         struct flowi6 fl6;
2018 
2019         if (!vif->dev)
2020                 goto out_free;
2021 
2022 #ifdef CONFIG_IPV6_PIMSM_V2
2023         if (vif->flags & MIFF_REGISTER) {
2024                 vif->pkt_out++;
2025                 vif->bytes_out += skb->len;
2026                 vif->dev->stats.tx_bytes += skb->len;
2027                 vif->dev->stats.tx_packets++;
2028                 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2029                 goto out_free;
2030         }
2031 #endif
2032 
2033         ipv6h = ipv6_hdr(skb);
2034 
2035         fl6 = (struct flowi6) {
2036                 .flowi6_oif = vif->link,
2037                 .daddr = ipv6h->daddr,
2038         };
2039 
2040         dst = ip6_route_output(net, NULL, &fl6);
2041         if (dst->error) {
2042                 dst_release(dst);
2043                 goto out_free;
2044         }
2045 
2046         skb_dst_drop(skb);
2047         skb_dst_set(skb, dst);
2048 
2049         /*
2050          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2051          * not only before forwarding, but after forwarding on all output
2052          * interfaces. It is clear, if mrouter runs a multicasting
2053          * program, it should receive packets not depending to what interface
2054          * program is joined.
2055          * If we will not make it, the program will have to join on all
2056          * interfaces. On the other hand, multihoming host (or router, but
2057          * not mrouter) cannot join to more than one interface - it will
2058          * result in receiving multiple packets.
2059          */
2060         dev = vif->dev;
2061         skb->dev = dev;
2062         vif->pkt_out++;
2063         vif->bytes_out += skb->len;
2064 
2065         /* We are about to write */
2066         /* XXX: extension headers? */
2067         if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2068                 goto out_free;
2069 
2070         ipv6h = ipv6_hdr(skb);
2071         ipv6h->hop_limit--;
2072 
2073         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2074 
2075         return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2076                        net, NULL, skb, skb->dev, dev,
2077                        ip6mr_forward2_finish);
2078 
2079 out_free:
2080         kfree_skb(skb);
2081         return 0;
2082 }
2083 
2084 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2085 {
2086         int ct;
2087 
2088         for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2089                 if (mrt->vif6_table[ct].dev == dev)
2090                         break;
2091         }
2092         return ct;
2093 }
2094 
2095 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2096                            struct sk_buff *skb, struct mfc6_cache *cache)
2097 {
2098         int psend = -1;
2099         int vif, ct;
2100         int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2101 
2102         vif = cache->mf6c_parent;
2103         cache->mfc_un.res.pkt++;
2104         cache->mfc_un.res.bytes += skb->len;
2105         cache->mfc_un.res.lastuse = jiffies;
2106 
2107         if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2108                 struct mfc6_cache *cache_proxy;
2109 
2110                 /* For an (*,G) entry, we only check that the incoming
2111                  * interface is part of the static tree.
2112                  */
2113                 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2114                 if (cache_proxy &&
2115                     cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2116                         goto forward;
2117         }
2118 
2119         /*
2120          * Wrong interface: drop packet and (maybe) send PIM assert.
2121          */
2122         if (mrt->vif6_table[vif].dev != skb->dev) {
2123                 cache->mfc_un.res.wrong_if++;
2124 
2125                 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2126                     /* pimsm uses asserts, when switching from RPT to SPT,
2127                        so that we cannot check that packet arrived on an oif.
2128                        It is bad, but otherwise we would need to move pretty
2129                        large chunk of pimd to kernel. Ough... --ANK
2130                      */
2131                     (mrt->mroute_do_pim ||
2132                      cache->mfc_un.res.ttls[true_vifi] < 255) &&
2133                     time_after(jiffies,
2134                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2135                         cache->mfc_un.res.last_assert = jiffies;
2136                         ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2137                 }
2138                 goto dont_forward;
2139         }
2140 
2141 forward:
2142         mrt->vif6_table[vif].pkt_in++;
2143         mrt->vif6_table[vif].bytes_in += skb->len;
2144 
2145         /*
2146          *      Forward the frame
2147          */
2148         if (ipv6_addr_any(&cache->mf6c_origin) &&
2149             ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2150                 if (true_vifi >= 0 &&
2151                     true_vifi != cache->mf6c_parent &&
2152                     ipv6_hdr(skb)->hop_limit >
2153                                 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2154                         /* It's an (*,*) entry and the packet is not coming from
2155                          * the upstream: forward the packet to the upstream
2156                          * only.
2157                          */
2158                         psend = cache->mf6c_parent;
2159                         goto last_forward;
2160                 }
2161                 goto dont_forward;
2162         }
2163         for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2164                 /* For (*,G) entry, don't forward to the incoming interface */
2165                 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2166                     ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2167                         if (psend != -1) {
2168                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2169                                 if (skb2)
2170                                         ip6mr_forward2(net, mrt, skb2, cache, psend);
2171                         }
2172                         psend = ct;
2173                 }
2174         }
2175 last_forward:
2176         if (psend != -1) {
2177                 ip6mr_forward2(net, mrt, skb, cache, psend);
2178                 return;
2179         }
2180 
2181 dont_forward:
2182         kfree_skb(skb);
2183 }
2184 
2185 
2186 /*
2187  *      Multicast packets for forwarding arrive here
2188  */
2189 
2190 int ip6_mr_input(struct sk_buff *skb)
2191 {
2192         struct mfc6_cache *cache;
2193         struct net *net = dev_net(skb->dev);
2194         struct mr6_table *mrt;
2195         struct flowi6 fl6 = {
2196                 .flowi6_iif     = skb->dev->ifindex,
2197                 .flowi6_mark    = skb->mark,
2198         };
2199         int err;
2200 
2201         err = ip6mr_fib_lookup(net, &fl6, &mrt);
2202         if (err < 0) {
2203                 kfree_skb(skb);
2204                 return err;
2205         }
2206 
2207         read_lock(&mrt_lock);
2208         cache = ip6mr_cache_find(mrt,
2209                                  &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2210         if (!cache) {
2211                 int vif = ip6mr_find_vif(mrt, skb->dev);
2212 
2213                 if (vif >= 0)
2214                         cache = ip6mr_cache_find_any(mrt,
2215                                                      &ipv6_hdr(skb)->daddr,
2216                                                      vif);
2217         }
2218 
2219         /*
2220          *      No usable cache entry
2221          */
2222         if (!cache) {
2223                 int vif;
2224 
2225                 vif = ip6mr_find_vif(mrt, skb->dev);
2226                 if (vif >= 0) {
2227                         int err = ip6mr_cache_unresolved(mrt, vif, skb);
2228                         read_unlock(&mrt_lock);
2229 
2230                         return err;
2231                 }
2232                 read_unlock(&mrt_lock);
2233                 kfree_skb(skb);
2234                 return -ENODEV;
2235         }
2236 
2237         ip6_mr_forward(net, mrt, skb, cache);
2238 
2239         read_unlock(&mrt_lock);
2240 
2241         return 0;
2242 }
2243 
2244 
2245 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2246                                struct mfc6_cache *c, struct rtmsg *rtm)
2247 {
2248         struct rta_mfc_stats mfcs;
2249         struct nlattr *mp_attr;
2250         struct rtnexthop *nhp;
2251         unsigned long lastuse;
2252         int ct;
2253 
2254         /* If cache is unresolved, don't try to parse IIF and OIF */
2255         if (c->mf6c_parent >= MAXMIFS) {
2256                 rtm->rtm_flags |= RTNH_F_UNRESOLVED;
2257                 return -ENOENT;
2258         }
2259 
2260         if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2261             nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2262                 return -EMSGSIZE;
2263         mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2264         if (!mp_attr)
2265                 return -EMSGSIZE;
2266 
2267         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2268                 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2269                         nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2270                         if (!nhp) {
2271                                 nla_nest_cancel(skb, mp_attr);
2272                                 return -EMSGSIZE;
2273                         }
2274 
2275                         nhp->rtnh_flags = 0;
2276                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2277                         nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2278                         nhp->rtnh_len = sizeof(*nhp);
2279                 }
2280         }
2281 
2282         nla_nest_end(skb, mp_attr);
2283 
2284         lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2285         lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2286 
2287         mfcs.mfcs_packets = c->mfc_un.res.pkt;
2288         mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2289         mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2290         if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
2291             nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
2292                               RTA_PAD))
2293                 return -EMSGSIZE;
2294 
2295         rtm->rtm_type = RTN_MULTICAST;
2296         return 1;
2297 }
2298 
2299 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2300                     u32 portid)
2301 {
2302         int err;
2303         struct mr6_table *mrt;
2304         struct mfc6_cache *cache;
2305         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2306 
2307         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2308         if (!mrt)
2309                 return -ENOENT;
2310 
2311         read_lock(&mrt_lock);
2312         cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2313         if (!cache && skb->dev) {
2314                 int vif = ip6mr_find_vif(mrt, skb->dev);
2315 
2316                 if (vif >= 0)
2317                         cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2318                                                      vif);
2319         }
2320 
2321         if (!cache) {
2322                 struct sk_buff *skb2;
2323                 struct ipv6hdr *iph;
2324                 struct net_device *dev;
2325                 int vif;
2326 
2327                 dev = skb->dev;
2328                 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2329                         read_unlock(&mrt_lock);
2330                         return -ENODEV;
2331                 }
2332 
2333                 /* really correct? */
2334                 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2335                 if (!skb2) {
2336                         read_unlock(&mrt_lock);
2337                         return -ENOMEM;
2338                 }
2339 
2340                 NETLINK_CB(skb2).portid = portid;
2341                 skb_reset_transport_header(skb2);
2342 
2343                 skb_put(skb2, sizeof(struct ipv6hdr));
2344                 skb_reset_network_header(skb2);
2345 
2346                 iph = ipv6_hdr(skb2);
2347                 iph->version = 0;
2348                 iph->priority = 0;
2349                 iph->flow_lbl[0] = 0;
2350                 iph->flow_lbl[1] = 0;
2351                 iph->flow_lbl[2] = 0;
2352                 iph->payload_len = 0;
2353                 iph->nexthdr = IPPROTO_NONE;
2354                 iph->hop_limit = 0;
2355                 iph->saddr = rt->rt6i_src.addr;
2356                 iph->daddr = rt->rt6i_dst.addr;
2357 
2358                 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2359                 read_unlock(&mrt_lock);
2360 
2361                 return err;
2362         }
2363 
2364         if (rtm->rtm_flags & RTM_F_NOTIFY)
2365                 cache->mfc_flags |= MFC_NOTIFY;
2366 
2367         err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2368         read_unlock(&mrt_lock);
2369         return err;
2370 }
2371 
2372 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2373                              u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2374                              int flags)
2375 {
2376         struct nlmsghdr *nlh;
2377         struct rtmsg *rtm;
2378         int err;
2379 
2380         nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2381         if (!nlh)
2382                 return -EMSGSIZE;
2383 
2384         rtm = nlmsg_data(nlh);
2385         rtm->rtm_family   = RTNL_FAMILY_IP6MR;
2386         rtm->rtm_dst_len  = 128;
2387         rtm->rtm_src_len  = 128;
2388         rtm->rtm_tos      = 0;
2389         rtm->rtm_table    = mrt->id;
2390         if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2391                 goto nla_put_failure;
2392         rtm->rtm_type = RTN_MULTICAST;
2393         rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
2394         if (c->mfc_flags & MFC_STATIC)
2395                 rtm->rtm_protocol = RTPROT_STATIC;
2396         else
2397                 rtm->rtm_protocol = RTPROT_MROUTED;
2398         rtm->rtm_flags    = 0;
2399 
2400         if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2401             nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2402                 goto nla_put_failure;
2403         err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2404         /* do not break the dump if cache is unresolved */
2405         if (err < 0 && err != -ENOENT)
2406                 goto nla_put_failure;
2407 
2408         nlmsg_end(skb, nlh);
2409         return 0;
2410 
2411 nla_put_failure:
2412         nlmsg_cancel(skb, nlh);
2413         return -EMSGSIZE;
2414 }
2415 
2416 static int mr6_msgsize(bool unresolved, int maxvif)
2417 {
2418         size_t len =
2419                 NLMSG_ALIGN(sizeof(struct rtmsg))
2420                 + nla_total_size(4)     /* RTA_TABLE */
2421                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_SRC */
2422                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_DST */
2423                 ;
2424 
2425         if (!unresolved)
2426                 len = len
2427                       + nla_total_size(4)       /* RTA_IIF */
2428                       + nla_total_size(0)       /* RTA_MULTIPATH */
2429                       + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2430                                                 /* RTA_MFC_STATS */
2431                       + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2432                 ;
2433 
2434         return len;
2435 }
2436 
2437 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2438                               int cmd)
2439 {
2440         struct net *net = read_pnet(&mrt->net);
2441         struct sk_buff *skb;
2442         int err = -ENOBUFS;
2443 
2444         skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2445                         GFP_ATOMIC);
2446         if (!skb)
2447                 goto errout;
2448 
2449         err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2450         if (err < 0)
2451                 goto errout;
2452 
2453         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2454         return;
2455 
2456 errout:
2457         kfree_skb(skb);
2458         if (err < 0)
2459                 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2460 }
2461 
2462 static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2463 {
2464         size_t len =
2465                 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2466                 + nla_total_size(1)     /* IP6MRA_CREPORT_MSGTYPE */
2467                 + nla_total_size(4)     /* IP6MRA_CREPORT_MIF_ID */
2468                                         /* IP6MRA_CREPORT_SRC_ADDR */
2469                 + nla_total_size(sizeof(struct in6_addr))
2470                                         /* IP6MRA_CREPORT_DST_ADDR */
2471                 + nla_total_size(sizeof(struct in6_addr))
2472                                         /* IP6MRA_CREPORT_PKT */
2473                 + nla_total_size(payloadlen)
2474                 ;
2475 
2476         return len;
2477 }
2478 
2479 static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt)
2480 {
2481         struct net *net = read_pnet(&mrt->net);
2482         struct nlmsghdr *nlh;
2483         struct rtgenmsg *rtgenm;
2484         struct mrt6msg *msg;
2485         struct sk_buff *skb;
2486         struct nlattr *nla;
2487         int payloadlen;
2488 
2489         payloadlen = pkt->len - sizeof(struct mrt6msg);
2490         msg = (struct mrt6msg *)skb_transport_header(pkt);
2491 
2492         skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2493         if (!skb)
2494                 goto errout;
2495 
2496         nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2497                         sizeof(struct rtgenmsg), 0);
2498         if (!nlh)
2499                 goto errout;
2500         rtgenm = nlmsg_data(nlh);
2501         rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2502         if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2503             nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2504             nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2505                              &msg->im6_src) ||
2506             nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2507                              &msg->im6_dst))
2508                 goto nla_put_failure;
2509 
2510         nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2511         if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2512                                   nla_data(nla), payloadlen))
2513                 goto nla_put_failure;
2514 
2515         nlmsg_end(skb, nlh);
2516 
2517         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2518         return;
2519 
2520 nla_put_failure:
2521         nlmsg_cancel(skb, nlh);
2522 errout:
2523         kfree_skb(skb);
2524         rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2525 }
2526 
2527 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2528 {
2529         struct net *net = sock_net(skb->sk);
2530         struct mr6_table *mrt;
2531         struct mfc6_cache *mfc;
2532         unsigned int t = 0, s_t;
2533         unsigned int h = 0, s_h;
2534         unsigned int e = 0, s_e;
2535 
2536         s_t = cb->args[0];
2537         s_h = cb->args[1];
2538         s_e = cb->args[2];
2539 
2540         read_lock(&mrt_lock);
2541         ip6mr_for_each_table(mrt, net) {
2542                 if (t < s_t)
2543                         goto next_table;
2544                 if (t > s_t)
2545                         s_h = 0;
2546                 for (h = s_h; h < MFC6_LINES; h++) {
2547                         list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2548                                 if (e < s_e)
2549                                         goto next_entry;
2550                                 if (ip6mr_fill_mroute(mrt, skb,
2551                                                       NETLINK_CB(cb->skb).portid,
2552                                                       cb->nlh->nlmsg_seq,
2553                                                       mfc, RTM_NEWROUTE,
2554                                                       NLM_F_MULTI) < 0)
2555                                         goto done;
2556 next_entry:
2557                                 e++;
2558                         }
2559                         e = s_e = 0;
2560                 }
2561                 spin_lock_bh(&mfc_unres_lock);
2562                 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2563                         if (e < s_e)
2564                                 goto next_entry2;
2565                         if (ip6mr_fill_mroute(mrt, skb,
2566                                               NETLINK_CB(cb->skb).portid,
2567                                               cb->nlh->nlmsg_seq,
2568                                               mfc, RTM_NEWROUTE,
2569                                               NLM_F_MULTI) < 0) {
2570                                 spin_unlock_bh(&mfc_unres_lock);
2571                                 goto done;
2572                         }
2573 next_entry2:
2574                         e++;
2575                 }
2576                 spin_unlock_bh(&mfc_unres_lock);
2577                 e = s_e = 0;
2578                 s_h = 0;
2579 next_table:
2580                 t++;
2581         }
2582 done:
2583         read_unlock(&mrt_lock);
2584 
2585         cb->args[2] = e;
2586         cb->args[1] = h;
2587         cb->args[0] = t;
2588 
2589         return skb->len;
2590 }
2591 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp