net: seq_operations should be const
[linux-2.6.git] / net / ipv6 / ip6mr.c
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 <asm/system.h>
20 #include <asm/uaccess.h>
21 #include <linux/types.h>
22 #include <linux/sched.h>
23 #include <linux/errno.h>
24 #include <linux/timer.h>
25 #include <linux/mm.h>
26 #include <linux/kernel.h>
27 #include <linux/fcntl.h>
28 #include <linux/stat.h>
29 #include <linux/socket.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/inetdevice.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #include <linux/init.h>
36 #include <net/protocol.h>
37 #include <linux/skbuff.h>
38 #include <net/sock.h>
39 #include <net/raw.h>
40 #include <linux/notifier.h>
41 #include <linux/if_arp.h>
42 #include <net/checksum.h>
43 #include <net/netlink.h>
44
45 #include <net/ipv6.h>
46 #include <net/ip6_route.h>
47 #include <linux/mroute6.h>
48 #include <linux/pim.h>
49 #include <net/addrconf.h>
50 #include <linux/netfilter_ipv6.h>
51 #include <net/ip6_checksum.h>
52
53 /* Big lock, protecting vif table, mrt cache and mroute socket state.
54    Note that the changes are semaphored via rtnl_lock.
55  */
56
57 static DEFINE_RWLOCK(mrt_lock);
58
59 /*
60  *      Multicast router control variables
61  */
62
63 #define MIF_EXISTS(_net, _idx) ((_net)->ipv6.vif6_table[_idx].dev != NULL)
64
65 static struct mfc6_cache *mfc_unres_queue;              /* Queue of unresolved entries */
66
67 /* Special spinlock for queue of unresolved entries */
68 static DEFINE_SPINLOCK(mfc_unres_lock);
69
70 /* We return to original Alan's scheme. Hash table of resolved
71    entries is changed only in process context and protected
72    with weak lock mrt_lock. Queue of unresolved entries is protected
73    with strong spinlock mfc_unres_lock.
74
75    In this case data path is free of exclusive locks at all.
76  */
77
78 static struct kmem_cache *mrt_cachep __read_mostly;
79
80 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache);
81 static int ip6mr_cache_report(struct net *net, struct sk_buff *pkt,
82                               mifi_t mifi, int assert);
83 static int ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm);
84 static void mroute_clean_tables(struct net *net);
85
86 #ifdef CONFIG_IPV6_PIMSM_V2
87 static struct inet6_protocol pim6_protocol;
88 #endif
89
90 static struct timer_list ipmr_expire_timer;
91
92
93 #ifdef CONFIG_PROC_FS
94
95 struct ipmr_mfc_iter {
96         struct seq_net_private p;
97         struct mfc6_cache **cache;
98         int ct;
99 };
100
101
102 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
103                                            struct ipmr_mfc_iter *it, loff_t pos)
104 {
105         struct mfc6_cache *mfc;
106
107         it->cache = net->ipv6.mfc6_cache_array;
108         read_lock(&mrt_lock);
109         for (it->ct = 0; it->ct < MFC6_LINES; it->ct++)
110                 for (mfc = net->ipv6.mfc6_cache_array[it->ct];
111                      mfc; mfc = mfc->next)
112                         if (pos-- == 0)
113                                 return mfc;
114         read_unlock(&mrt_lock);
115
116         it->cache = &mfc_unres_queue;
117         spin_lock_bh(&mfc_unres_lock);
118         for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
119                 if (net_eq(mfc6_net(mfc), net) &&
120                     pos-- == 0)
121                         return mfc;
122         spin_unlock_bh(&mfc_unres_lock);
123
124         it->cache = NULL;
125         return NULL;
126 }
127
128
129
130
131 /*
132  *      The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
133  */
134
135 struct ipmr_vif_iter {
136         struct seq_net_private p;
137         int ct;
138 };
139
140 static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
141                                             struct ipmr_vif_iter *iter,
142                                             loff_t pos)
143 {
144         for (iter->ct = 0; iter->ct < net->ipv6.maxvif; ++iter->ct) {
145                 if (!MIF_EXISTS(net, iter->ct))
146                         continue;
147                 if (pos-- == 0)
148                         return &net->ipv6.vif6_table[iter->ct];
149         }
150         return NULL;
151 }
152
153 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
154         __acquires(mrt_lock)
155 {
156         struct net *net = seq_file_net(seq);
157
158         read_lock(&mrt_lock);
159         return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
160                 : SEQ_START_TOKEN;
161 }
162
163 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
164 {
165         struct ipmr_vif_iter *iter = seq->private;
166         struct net *net = seq_file_net(seq);
167
168         ++*pos;
169         if (v == SEQ_START_TOKEN)
170                 return ip6mr_vif_seq_idx(net, iter, 0);
171
172         while (++iter->ct < net->ipv6.maxvif) {
173                 if (!MIF_EXISTS(net, iter->ct))
174                         continue;
175                 return &net->ipv6.vif6_table[iter->ct];
176         }
177         return NULL;
178 }
179
180 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
181         __releases(mrt_lock)
182 {
183         read_unlock(&mrt_lock);
184 }
185
186 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
187 {
188         struct net *net = seq_file_net(seq);
189
190         if (v == SEQ_START_TOKEN) {
191                 seq_puts(seq,
192                          "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags\n");
193         } else {
194                 const struct mif_device *vif = v;
195                 const char *name = vif->dev ? vif->dev->name : "none";
196
197                 seq_printf(seq,
198                            "%2td %-10s %8ld %7ld  %8ld %7ld %05X\n",
199                            vif - net->ipv6.vif6_table,
200                            name, vif->bytes_in, vif->pkt_in,
201                            vif->bytes_out, vif->pkt_out,
202                            vif->flags);
203         }
204         return 0;
205 }
206
207 static const struct seq_operations ip6mr_vif_seq_ops = {
208         .start = ip6mr_vif_seq_start,
209         .next  = ip6mr_vif_seq_next,
210         .stop  = ip6mr_vif_seq_stop,
211         .show  = ip6mr_vif_seq_show,
212 };
213
214 static int ip6mr_vif_open(struct inode *inode, struct file *file)
215 {
216         return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
217                             sizeof(struct ipmr_vif_iter));
218 }
219
220 static struct file_operations ip6mr_vif_fops = {
221         .owner   = THIS_MODULE,
222         .open    = ip6mr_vif_open,
223         .read    = seq_read,
224         .llseek  = seq_lseek,
225         .release = seq_release_net,
226 };
227
228 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
229 {
230         struct net *net = seq_file_net(seq);
231
232         return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
233                 : SEQ_START_TOKEN;
234 }
235
236 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
237 {
238         struct mfc6_cache *mfc = v;
239         struct ipmr_mfc_iter *it = seq->private;
240         struct net *net = seq_file_net(seq);
241
242         ++*pos;
243
244         if (v == SEQ_START_TOKEN)
245                 return ipmr_mfc_seq_idx(net, seq->private, 0);
246
247         if (mfc->next)
248                 return mfc->next;
249
250         if (it->cache == &mfc_unres_queue)
251                 goto end_of_list;
252
253         BUG_ON(it->cache != net->ipv6.mfc6_cache_array);
254
255         while (++it->ct < MFC6_LINES) {
256                 mfc = net->ipv6.mfc6_cache_array[it->ct];
257                 if (mfc)
258                         return mfc;
259         }
260
261         /* exhausted cache_array, show unresolved */
262         read_unlock(&mrt_lock);
263         it->cache = &mfc_unres_queue;
264         it->ct = 0;
265
266         spin_lock_bh(&mfc_unres_lock);
267         mfc = mfc_unres_queue;
268         if (mfc)
269                 return mfc;
270
271  end_of_list:
272         spin_unlock_bh(&mfc_unres_lock);
273         it->cache = NULL;
274
275         return NULL;
276 }
277
278 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
279 {
280         struct ipmr_mfc_iter *it = seq->private;
281         struct net *net = seq_file_net(seq);
282
283         if (it->cache == &mfc_unres_queue)
284                 spin_unlock_bh(&mfc_unres_lock);
285         else if (it->cache == net->ipv6.mfc6_cache_array)
286                 read_unlock(&mrt_lock);
287 }
288
289 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
290 {
291         int n;
292         struct net *net = seq_file_net(seq);
293
294         if (v == SEQ_START_TOKEN) {
295                 seq_puts(seq,
296                          "Group                            "
297                          "Origin                           "
298                          "Iif      Pkts  Bytes     Wrong  Oifs\n");
299         } else {
300                 const struct mfc6_cache *mfc = v;
301                 const struct ipmr_mfc_iter *it = seq->private;
302
303                 seq_printf(seq, "%pI6 %pI6 %-3hd",
304                            &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
305                            mfc->mf6c_parent);
306
307                 if (it->cache != &mfc_unres_queue) {
308                         seq_printf(seq, " %8lu %8lu %8lu",
309                                    mfc->mfc_un.res.pkt,
310                                    mfc->mfc_un.res.bytes,
311                                    mfc->mfc_un.res.wrong_if);
312                         for (n = mfc->mfc_un.res.minvif;
313                              n < mfc->mfc_un.res.maxvif; n++) {
314                                 if (MIF_EXISTS(net, n) &&
315                                     mfc->mfc_un.res.ttls[n] < 255)
316                                         seq_printf(seq,
317                                                    " %2d:%-3d",
318                                                    n, mfc->mfc_un.res.ttls[n]);
319                         }
320                 } else {
321                         /* unresolved mfc_caches don't contain
322                          * pkt, bytes and wrong_if values
323                          */
324                         seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
325                 }
326                 seq_putc(seq, '\n');
327         }
328         return 0;
329 }
330
331 static struct seq_operations ipmr_mfc_seq_ops = {
332         .start = ipmr_mfc_seq_start,
333         .next  = ipmr_mfc_seq_next,
334         .stop  = ipmr_mfc_seq_stop,
335         .show  = ipmr_mfc_seq_show,
336 };
337
338 static int ipmr_mfc_open(struct inode *inode, struct file *file)
339 {
340         return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
341                             sizeof(struct ipmr_mfc_iter));
342 }
343
344 static struct file_operations ip6mr_mfc_fops = {
345         .owner   = THIS_MODULE,
346         .open    = ipmr_mfc_open,
347         .read    = seq_read,
348         .llseek  = seq_lseek,
349         .release = seq_release_net,
350 };
351 #endif
352
353 #ifdef CONFIG_IPV6_PIMSM_V2
354
355 static int pim6_rcv(struct sk_buff *skb)
356 {
357         struct pimreghdr *pim;
358         struct ipv6hdr   *encap;
359         struct net_device  *reg_dev = NULL;
360         struct net *net = dev_net(skb->dev);
361         int reg_vif_num = net->ipv6.mroute_reg_vif_num;
362
363         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
364                 goto drop;
365
366         pim = (struct pimreghdr *)skb_transport_header(skb);
367         if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
368             (pim->flags & PIM_NULL_REGISTER) ||
369             (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
370                              sizeof(*pim), IPPROTO_PIM,
371                              csum_partial((void *)pim, sizeof(*pim), 0)) &&
372              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
373                 goto drop;
374
375         /* check if the inner packet is destined to mcast group */
376         encap = (struct ipv6hdr *)(skb_transport_header(skb) +
377                                    sizeof(*pim));
378
379         if (!ipv6_addr_is_multicast(&encap->daddr) ||
380             encap->payload_len == 0 ||
381             ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
382                 goto drop;
383
384         read_lock(&mrt_lock);
385         if (reg_vif_num >= 0)
386                 reg_dev = net->ipv6.vif6_table[reg_vif_num].dev;
387         if (reg_dev)
388                 dev_hold(reg_dev);
389         read_unlock(&mrt_lock);
390
391         if (reg_dev == NULL)
392                 goto drop;
393
394         skb->mac_header = skb->network_header;
395         skb_pull(skb, (u8 *)encap - skb->data);
396         skb_reset_network_header(skb);
397         skb->dev = reg_dev;
398         skb->protocol = htons(ETH_P_IPV6);
399         skb->ip_summed = 0;
400         skb->pkt_type = PACKET_HOST;
401         skb_dst_drop(skb);
402         reg_dev->stats.rx_bytes += skb->len;
403         reg_dev->stats.rx_packets++;
404         nf_reset(skb);
405         netif_rx(skb);
406         dev_put(reg_dev);
407         return 0;
408  drop:
409         kfree_skb(skb);
410         return 0;
411 }
412
413 static struct inet6_protocol pim6_protocol = {
414         .handler        =       pim6_rcv,
415 };
416
417 /* Service routines creating virtual interfaces: PIMREG */
418
419 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
420                                       struct net_device *dev)
421 {
422         struct net *net = dev_net(dev);
423
424         read_lock(&mrt_lock);
425         dev->stats.tx_bytes += skb->len;
426         dev->stats.tx_packets++;
427         ip6mr_cache_report(net, skb, net->ipv6.mroute_reg_vif_num,
428                            MRT6MSG_WHOLEPKT);
429         read_unlock(&mrt_lock);
430         kfree_skb(skb);
431         return NETDEV_TX_OK;
432 }
433
434 static const struct net_device_ops reg_vif_netdev_ops = {
435         .ndo_start_xmit = reg_vif_xmit,
436 };
437
438 static void reg_vif_setup(struct net_device *dev)
439 {
440         dev->type               = ARPHRD_PIMREG;
441         dev->mtu                = 1500 - sizeof(struct ipv6hdr) - 8;
442         dev->flags              = IFF_NOARP;
443         dev->netdev_ops         = &reg_vif_netdev_ops;
444         dev->destructor         = free_netdev;
445         dev->features           |= NETIF_F_NETNS_LOCAL;
446 }
447
448 static struct net_device *ip6mr_reg_vif(struct net *net)
449 {
450         struct net_device *dev;
451
452         dev = alloc_netdev(0, "pim6reg", reg_vif_setup);
453         if (dev == NULL)
454                 return NULL;
455
456         dev_net_set(dev, net);
457
458         if (register_netdevice(dev)) {
459                 free_netdev(dev);
460                 return NULL;
461         }
462         dev->iflink = 0;
463
464         if (dev_open(dev))
465                 goto failure;
466
467         dev_hold(dev);
468         return dev;
469
470 failure:
471         /* allow the register to be completed before unregistering. */
472         rtnl_unlock();
473         rtnl_lock();
474
475         unregister_netdevice(dev);
476         return NULL;
477 }
478 #endif
479
480 /*
481  *      Delete a VIF entry
482  */
483
484 static int mif6_delete(struct net *net, int vifi)
485 {
486         struct mif_device *v;
487         struct net_device *dev;
488         struct inet6_dev *in6_dev;
489         if (vifi < 0 || vifi >= net->ipv6.maxvif)
490                 return -EADDRNOTAVAIL;
491
492         v = &net->ipv6.vif6_table[vifi];
493
494         write_lock_bh(&mrt_lock);
495         dev = v->dev;
496         v->dev = NULL;
497
498         if (!dev) {
499                 write_unlock_bh(&mrt_lock);
500                 return -EADDRNOTAVAIL;
501         }
502
503 #ifdef CONFIG_IPV6_PIMSM_V2
504         if (vifi == net->ipv6.mroute_reg_vif_num)
505                 net->ipv6.mroute_reg_vif_num = -1;
506 #endif
507
508         if (vifi + 1 == net->ipv6.maxvif) {
509                 int tmp;
510                 for (tmp = vifi - 1; tmp >= 0; tmp--) {
511                         if (MIF_EXISTS(net, tmp))
512                                 break;
513                 }
514                 net->ipv6.maxvif = tmp + 1;
515         }
516
517         write_unlock_bh(&mrt_lock);
518
519         dev_set_allmulti(dev, -1);
520
521         in6_dev = __in6_dev_get(dev);
522         if (in6_dev)
523                 in6_dev->cnf.mc_forwarding--;
524
525         if (v->flags & MIFF_REGISTER)
526                 unregister_netdevice(dev);
527
528         dev_put(dev);
529         return 0;
530 }
531
532 static inline void ip6mr_cache_free(struct mfc6_cache *c)
533 {
534         release_net(mfc6_net(c));
535         kmem_cache_free(mrt_cachep, c);
536 }
537
538 /* Destroy an unresolved cache entry, killing queued skbs
539    and reporting error to netlink readers.
540  */
541
542 static void ip6mr_destroy_unres(struct mfc6_cache *c)
543 {
544         struct sk_buff *skb;
545         struct net *net = mfc6_net(c);
546
547         atomic_dec(&net->ipv6.cache_resolve_queue_len);
548
549         while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
550                 if (ipv6_hdr(skb)->version == 0) {
551                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
552                         nlh->nlmsg_type = NLMSG_ERROR;
553                         nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
554                         skb_trim(skb, nlh->nlmsg_len);
555                         ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
556                         rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
557                 } else
558                         kfree_skb(skb);
559         }
560
561         ip6mr_cache_free(c);
562 }
563
564
565 /* Single timer process for all the unresolved queue. */
566
567 static void ipmr_do_expire_process(unsigned long dummy)
568 {
569         unsigned long now = jiffies;
570         unsigned long expires = 10 * HZ;
571         struct mfc6_cache *c, **cp;
572
573         cp = &mfc_unres_queue;
574
575         while ((c = *cp) != NULL) {
576                 if (time_after(c->mfc_un.unres.expires, now)) {
577                         /* not yet... */
578                         unsigned long interval = c->mfc_un.unres.expires - now;
579                         if (interval < expires)
580                                 expires = interval;
581                         cp = &c->next;
582                         continue;
583                 }
584
585                 *cp = c->next;
586                 ip6mr_destroy_unres(c);
587         }
588
589         if (mfc_unres_queue != NULL)
590                 mod_timer(&ipmr_expire_timer, jiffies + expires);
591 }
592
593 static void ipmr_expire_process(unsigned long dummy)
594 {
595         if (!spin_trylock(&mfc_unres_lock)) {
596                 mod_timer(&ipmr_expire_timer, jiffies + 1);
597                 return;
598         }
599
600         if (mfc_unres_queue != NULL)
601                 ipmr_do_expire_process(dummy);
602
603         spin_unlock(&mfc_unres_lock);
604 }
605
606 /* Fill oifs list. It is called under write locked mrt_lock. */
607
608 static void ip6mr_update_thresholds(struct mfc6_cache *cache, unsigned char *ttls)
609 {
610         int vifi;
611         struct net *net = mfc6_net(cache);
612
613         cache->mfc_un.res.minvif = MAXMIFS;
614         cache->mfc_un.res.maxvif = 0;
615         memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
616
617         for (vifi = 0; vifi < net->ipv6.maxvif; vifi++) {
618                 if (MIF_EXISTS(net, vifi) &&
619                     ttls[vifi] && ttls[vifi] < 255) {
620                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
621                         if (cache->mfc_un.res.minvif > vifi)
622                                 cache->mfc_un.res.minvif = vifi;
623                         if (cache->mfc_un.res.maxvif <= vifi)
624                                 cache->mfc_un.res.maxvif = vifi + 1;
625                 }
626         }
627 }
628
629 static int mif6_add(struct net *net, struct mif6ctl *vifc, int mrtsock)
630 {
631         int vifi = vifc->mif6c_mifi;
632         struct mif_device *v = &net->ipv6.vif6_table[vifi];
633         struct net_device *dev;
634         struct inet6_dev *in6_dev;
635         int err;
636
637         /* Is vif busy ? */
638         if (MIF_EXISTS(net, vifi))
639                 return -EADDRINUSE;
640
641         switch (vifc->mif6c_flags) {
642 #ifdef CONFIG_IPV6_PIMSM_V2
643         case MIFF_REGISTER:
644                 /*
645                  * Special Purpose VIF in PIM
646                  * All the packets will be sent to the daemon
647                  */
648                 if (net->ipv6.mroute_reg_vif_num >= 0)
649                         return -EADDRINUSE;
650                 dev = ip6mr_reg_vif(net);
651                 if (!dev)
652                         return -ENOBUFS;
653                 err = dev_set_allmulti(dev, 1);
654                 if (err) {
655                         unregister_netdevice(dev);
656                         dev_put(dev);
657                         return err;
658                 }
659                 break;
660 #endif
661         case 0:
662                 dev = dev_get_by_index(net, vifc->mif6c_pifi);
663                 if (!dev)
664                         return -EADDRNOTAVAIL;
665                 err = dev_set_allmulti(dev, 1);
666                 if (err) {
667                         dev_put(dev);
668                         return err;
669                 }
670                 break;
671         default:
672                 return -EINVAL;
673         }
674
675         in6_dev = __in6_dev_get(dev);
676         if (in6_dev)
677                 in6_dev->cnf.mc_forwarding++;
678
679         /*
680          *      Fill in the VIF structures
681          */
682         v->rate_limit = vifc->vifc_rate_limit;
683         v->flags = vifc->mif6c_flags;
684         if (!mrtsock)
685                 v->flags |= VIFF_STATIC;
686         v->threshold = vifc->vifc_threshold;
687         v->bytes_in = 0;
688         v->bytes_out = 0;
689         v->pkt_in = 0;
690         v->pkt_out = 0;
691         v->link = dev->ifindex;
692         if (v->flags & MIFF_REGISTER)
693                 v->link = dev->iflink;
694
695         /* And finish update writing critical data */
696         write_lock_bh(&mrt_lock);
697         v->dev = dev;
698 #ifdef CONFIG_IPV6_PIMSM_V2
699         if (v->flags & MIFF_REGISTER)
700                 net->ipv6.mroute_reg_vif_num = vifi;
701 #endif
702         if (vifi + 1 > net->ipv6.maxvif)
703                 net->ipv6.maxvif = vifi + 1;
704         write_unlock_bh(&mrt_lock);
705         return 0;
706 }
707
708 static struct mfc6_cache *ip6mr_cache_find(struct net *net,
709                                            struct in6_addr *origin,
710                                            struct in6_addr *mcastgrp)
711 {
712         int line = MFC6_HASH(mcastgrp, origin);
713         struct mfc6_cache *c;
714
715         for (c = net->ipv6.mfc6_cache_array[line]; c; c = c->next) {
716                 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
717                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
718                         break;
719         }
720         return c;
721 }
722
723 /*
724  *      Allocate a multicast cache entry
725  */
726 static struct mfc6_cache *ip6mr_cache_alloc(struct net *net)
727 {
728         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
729         if (c == NULL)
730                 return NULL;
731         c->mfc_un.res.minvif = MAXMIFS;
732         mfc6_net_set(c, net);
733         return c;
734 }
735
736 static struct mfc6_cache *ip6mr_cache_alloc_unres(struct net *net)
737 {
738         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
739         if (c == NULL)
740                 return NULL;
741         skb_queue_head_init(&c->mfc_un.unres.unresolved);
742         c->mfc_un.unres.expires = jiffies + 10 * HZ;
743         mfc6_net_set(c, net);
744         return c;
745 }
746
747 /*
748  *      A cache entry has gone into a resolved state from queued
749  */
750
751 static void ip6mr_cache_resolve(struct mfc6_cache *uc, struct mfc6_cache *c)
752 {
753         struct sk_buff *skb;
754
755         /*
756          *      Play the pending entries through our router
757          */
758
759         while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
760                 if (ipv6_hdr(skb)->version == 0) {
761                         int err;
762                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
763
764                         if (ip6mr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
765                                 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
766                         } else {
767                                 nlh->nlmsg_type = NLMSG_ERROR;
768                                 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
769                                 skb_trim(skb, nlh->nlmsg_len);
770                                 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
771                         }
772                         err = rtnl_unicast(skb, mfc6_net(uc), NETLINK_CB(skb).pid);
773                 } else
774                         ip6_mr_forward(skb, c);
775         }
776 }
777
778 /*
779  *      Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
780  *      expects the following bizarre scheme.
781  *
782  *      Called under mrt_lock.
783  */
784
785 static int ip6mr_cache_report(struct net *net, struct sk_buff *pkt, mifi_t mifi,
786                               int assert)
787 {
788         struct sk_buff *skb;
789         struct mrt6msg *msg;
790         int ret;
791
792 #ifdef CONFIG_IPV6_PIMSM_V2
793         if (assert == MRT6MSG_WHOLEPKT)
794                 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
795                                                 +sizeof(*msg));
796         else
797 #endif
798                 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
799
800         if (!skb)
801                 return -ENOBUFS;
802
803         /* I suppose that internal messages
804          * do not require checksums */
805
806         skb->ip_summed = CHECKSUM_UNNECESSARY;
807
808 #ifdef CONFIG_IPV6_PIMSM_V2
809         if (assert == MRT6MSG_WHOLEPKT) {
810                 /* Ugly, but we have no choice with this interface.
811                    Duplicate old header, fix length etc.
812                    And all this only to mangle msg->im6_msgtype and
813                    to set msg->im6_mbz to "mbz" :-)
814                  */
815                 skb_push(skb, -skb_network_offset(pkt));
816
817                 skb_push(skb, sizeof(*msg));
818                 skb_reset_transport_header(skb);
819                 msg = (struct mrt6msg *)skb_transport_header(skb);
820                 msg->im6_mbz = 0;
821                 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
822                 msg->im6_mif = net->ipv6.mroute_reg_vif_num;
823                 msg->im6_pad = 0;
824                 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
825                 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
826
827                 skb->ip_summed = CHECKSUM_UNNECESSARY;
828         } else
829 #endif
830         {
831         /*
832          *      Copy the IP header
833          */
834
835         skb_put(skb, sizeof(struct ipv6hdr));
836         skb_reset_network_header(skb);
837         skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
838
839         /*
840          *      Add our header
841          */
842         skb_put(skb, sizeof(*msg));
843         skb_reset_transport_header(skb);
844         msg = (struct mrt6msg *)skb_transport_header(skb);
845
846         msg->im6_mbz = 0;
847         msg->im6_msgtype = assert;
848         msg->im6_mif = mifi;
849         msg->im6_pad = 0;
850         ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
851         ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
852
853         skb_dst_set(skb, dst_clone(skb_dst(pkt)));
854         skb->ip_summed = CHECKSUM_UNNECESSARY;
855         }
856
857         if (net->ipv6.mroute6_sk == NULL) {
858                 kfree_skb(skb);
859                 return -EINVAL;
860         }
861
862         /*
863          *      Deliver to user space multicast routing algorithms
864          */
865         ret = sock_queue_rcv_skb(net->ipv6.mroute6_sk, skb);
866         if (ret < 0) {
867                 if (net_ratelimit())
868                         printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
869                 kfree_skb(skb);
870         }
871
872         return ret;
873 }
874
875 /*
876  *      Queue a packet for resolution. It gets locked cache entry!
877  */
878
879 static int
880 ip6mr_cache_unresolved(struct net *net, mifi_t mifi, struct sk_buff *skb)
881 {
882         int err;
883         struct mfc6_cache *c;
884
885         spin_lock_bh(&mfc_unres_lock);
886         for (c = mfc_unres_queue; c; c = c->next) {
887                 if (net_eq(mfc6_net(c), net) &&
888                     ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
889                     ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr))
890                         break;
891         }
892
893         if (c == NULL) {
894                 /*
895                  *      Create a new entry if allowable
896                  */
897
898                 if (atomic_read(&net->ipv6.cache_resolve_queue_len) >= 10 ||
899                     (c = ip6mr_cache_alloc_unres(net)) == NULL) {
900                         spin_unlock_bh(&mfc_unres_lock);
901
902                         kfree_skb(skb);
903                         return -ENOBUFS;
904                 }
905
906                 /*
907                  *      Fill in the new cache entry
908                  */
909                 c->mf6c_parent = -1;
910                 c->mf6c_origin = ipv6_hdr(skb)->saddr;
911                 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
912
913                 /*
914                  *      Reflect first query at pim6sd
915                  */
916                 err = ip6mr_cache_report(net, skb, mifi, MRT6MSG_NOCACHE);
917                 if (err < 0) {
918                         /* If the report failed throw the cache entry
919                            out - Brad Parker
920                          */
921                         spin_unlock_bh(&mfc_unres_lock);
922
923                         ip6mr_cache_free(c);
924                         kfree_skb(skb);
925                         return err;
926                 }
927
928                 atomic_inc(&net->ipv6.cache_resolve_queue_len);
929                 c->next = mfc_unres_queue;
930                 mfc_unres_queue = c;
931
932                 ipmr_do_expire_process(1);
933         }
934
935         /*
936          *      See if we can append the packet
937          */
938         if (c->mfc_un.unres.unresolved.qlen > 3) {
939                 kfree_skb(skb);
940                 err = -ENOBUFS;
941         } else {
942                 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
943                 err = 0;
944         }
945
946         spin_unlock_bh(&mfc_unres_lock);
947         return err;
948 }
949
950 /*
951  *      MFC6 cache manipulation by user space
952  */
953
954 static int ip6mr_mfc_delete(struct net *net, struct mf6cctl *mfc)
955 {
956         int line;
957         struct mfc6_cache *c, **cp;
958
959         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
960
961         for (cp = &net->ipv6.mfc6_cache_array[line];
962              (c = *cp) != NULL; cp = &c->next) {
963                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
964                     ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
965                         write_lock_bh(&mrt_lock);
966                         *cp = c->next;
967                         write_unlock_bh(&mrt_lock);
968
969                         ip6mr_cache_free(c);
970                         return 0;
971                 }
972         }
973         return -ENOENT;
974 }
975
976 static int ip6mr_device_event(struct notifier_block *this,
977                               unsigned long event, void *ptr)
978 {
979         struct net_device *dev = ptr;
980         struct net *net = dev_net(dev);
981         struct mif_device *v;
982         int ct;
983
984         if (event != NETDEV_UNREGISTER)
985                 return NOTIFY_DONE;
986
987         v = &net->ipv6.vif6_table[0];
988         for (ct = 0; ct < net->ipv6.maxvif; ct++, v++) {
989                 if (v->dev == dev)
990                         mif6_delete(net, ct);
991         }
992         return NOTIFY_DONE;
993 }
994
995 static struct notifier_block ip6_mr_notifier = {
996         .notifier_call = ip6mr_device_event
997 };
998
999 /*
1000  *      Setup for IP multicast routing
1001  */
1002
1003 static int __net_init ip6mr_net_init(struct net *net)
1004 {
1005         int err = 0;
1006         net->ipv6.vif6_table = kcalloc(MAXMIFS, sizeof(struct mif_device),
1007                                        GFP_KERNEL);
1008         if (!net->ipv6.vif6_table) {
1009                 err = -ENOMEM;
1010                 goto fail;
1011         }
1012
1013         /* Forwarding cache */
1014         net->ipv6.mfc6_cache_array = kcalloc(MFC6_LINES,
1015                                              sizeof(struct mfc6_cache *),
1016                                              GFP_KERNEL);
1017         if (!net->ipv6.mfc6_cache_array) {
1018                 err = -ENOMEM;
1019                 goto fail_mfc6_cache;
1020         }
1021
1022 #ifdef CONFIG_IPV6_PIMSM_V2
1023         net->ipv6.mroute_reg_vif_num = -1;
1024 #endif
1025
1026 #ifdef CONFIG_PROC_FS
1027         err = -ENOMEM;
1028         if (!proc_net_fops_create(net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
1029                 goto proc_vif_fail;
1030         if (!proc_net_fops_create(net, "ip6_mr_cache", 0, &ip6mr_mfc_fops))
1031                 goto proc_cache_fail;
1032 #endif
1033         return 0;
1034
1035 #ifdef CONFIG_PROC_FS
1036 proc_cache_fail:
1037         proc_net_remove(net, "ip6_mr_vif");
1038 proc_vif_fail:
1039         kfree(net->ipv6.mfc6_cache_array);
1040 #endif
1041 fail_mfc6_cache:
1042         kfree(net->ipv6.vif6_table);
1043 fail:
1044         return err;
1045 }
1046
1047 static void __net_exit ip6mr_net_exit(struct net *net)
1048 {
1049 #ifdef CONFIG_PROC_FS
1050         proc_net_remove(net, "ip6_mr_cache");
1051         proc_net_remove(net, "ip6_mr_vif");
1052 #endif
1053         mroute_clean_tables(net);
1054         kfree(net->ipv6.mfc6_cache_array);
1055         kfree(net->ipv6.vif6_table);
1056 }
1057
1058 static struct pernet_operations ip6mr_net_ops = {
1059         .init = ip6mr_net_init,
1060         .exit = ip6mr_net_exit,
1061 };
1062
1063 int __init ip6_mr_init(void)
1064 {
1065         int err;
1066
1067         mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1068                                        sizeof(struct mfc6_cache),
1069                                        0, SLAB_HWCACHE_ALIGN,
1070                                        NULL);
1071         if (!mrt_cachep)
1072                 return -ENOMEM;
1073
1074         err = register_pernet_subsys(&ip6mr_net_ops);
1075         if (err)
1076                 goto reg_pernet_fail;
1077
1078         setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
1079         err = register_netdevice_notifier(&ip6_mr_notifier);
1080         if (err)
1081                 goto reg_notif_fail;
1082 #ifdef CONFIG_IPV6_PIMSM_V2
1083         if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1084                 printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n");
1085                 err = -EAGAIN;
1086                 goto add_proto_fail;
1087         }
1088 #endif
1089         return 0;
1090 #ifdef CONFIG_IPV6_PIMSM_V2
1091 add_proto_fail:
1092         unregister_netdevice_notifier(&ip6_mr_notifier);
1093 #endif
1094 reg_notif_fail:
1095         del_timer(&ipmr_expire_timer);
1096         unregister_pernet_subsys(&ip6mr_net_ops);
1097 reg_pernet_fail:
1098         kmem_cache_destroy(mrt_cachep);
1099         return err;
1100 }
1101
1102 void ip6_mr_cleanup(void)
1103 {
1104         unregister_netdevice_notifier(&ip6_mr_notifier);
1105         del_timer(&ipmr_expire_timer);
1106         unregister_pernet_subsys(&ip6mr_net_ops);
1107         kmem_cache_destroy(mrt_cachep);
1108 }
1109
1110 static int ip6mr_mfc_add(struct net *net, struct mf6cctl *mfc, int mrtsock)
1111 {
1112         int line;
1113         struct mfc6_cache *uc, *c, **cp;
1114         unsigned char ttls[MAXMIFS];
1115         int i;
1116
1117         memset(ttls, 255, MAXMIFS);
1118         for (i = 0; i < MAXMIFS; i++) {
1119                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1120                         ttls[i] = 1;
1121
1122         }
1123
1124         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1125
1126         for (cp = &net->ipv6.mfc6_cache_array[line];
1127              (c = *cp) != NULL; cp = &c->next) {
1128                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1129                     ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr))
1130                         break;
1131         }
1132
1133         if (c != NULL) {
1134                 write_lock_bh(&mrt_lock);
1135                 c->mf6c_parent = mfc->mf6cc_parent;
1136                 ip6mr_update_thresholds(c, ttls);
1137                 if (!mrtsock)
1138                         c->mfc_flags |= MFC_STATIC;
1139                 write_unlock_bh(&mrt_lock);
1140                 return 0;
1141         }
1142
1143         if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1144                 return -EINVAL;
1145
1146         c = ip6mr_cache_alloc(net);
1147         if (c == NULL)
1148                 return -ENOMEM;
1149
1150         c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1151         c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1152         c->mf6c_parent = mfc->mf6cc_parent;
1153         ip6mr_update_thresholds(c, ttls);
1154         if (!mrtsock)
1155                 c->mfc_flags |= MFC_STATIC;
1156
1157         write_lock_bh(&mrt_lock);
1158         c->next = net->ipv6.mfc6_cache_array[line];
1159         net->ipv6.mfc6_cache_array[line] = c;
1160         write_unlock_bh(&mrt_lock);
1161
1162         /*
1163          *      Check to see if we resolved a queued list. If so we
1164          *      need to send on the frames and tidy up.
1165          */
1166         spin_lock_bh(&mfc_unres_lock);
1167         for (cp = &mfc_unres_queue; (uc = *cp) != NULL;
1168              cp = &uc->next) {
1169                 if (net_eq(mfc6_net(uc), net) &&
1170                     ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1171                     ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1172                         *cp = uc->next;
1173                         atomic_dec(&net->ipv6.cache_resolve_queue_len);
1174                         break;
1175                 }
1176         }
1177         if (mfc_unres_queue == NULL)
1178                 del_timer(&ipmr_expire_timer);
1179         spin_unlock_bh(&mfc_unres_lock);
1180
1181         if (uc) {
1182                 ip6mr_cache_resolve(uc, c);
1183                 ip6mr_cache_free(uc);
1184         }
1185         return 0;
1186 }
1187
1188 /*
1189  *      Close the multicast socket, and clear the vif tables etc
1190  */
1191
1192 static void mroute_clean_tables(struct net *net)
1193 {
1194         int i;
1195
1196         /*
1197          *      Shut down all active vif entries
1198          */
1199         for (i = 0; i < net->ipv6.maxvif; i++) {
1200                 if (!(net->ipv6.vif6_table[i].flags & VIFF_STATIC))
1201                         mif6_delete(net, i);
1202         }
1203
1204         /*
1205          *      Wipe the cache
1206          */
1207         for (i = 0; i < MFC6_LINES; i++) {
1208                 struct mfc6_cache *c, **cp;
1209
1210                 cp = &net->ipv6.mfc6_cache_array[i];
1211                 while ((c = *cp) != NULL) {
1212                         if (c->mfc_flags & MFC_STATIC) {
1213                                 cp = &c->next;
1214                                 continue;
1215                         }
1216                         write_lock_bh(&mrt_lock);
1217                         *cp = c->next;
1218                         write_unlock_bh(&mrt_lock);
1219
1220                         ip6mr_cache_free(c);
1221                 }
1222         }
1223
1224         if (atomic_read(&net->ipv6.cache_resolve_queue_len) != 0) {
1225                 struct mfc6_cache *c, **cp;
1226
1227                 spin_lock_bh(&mfc_unres_lock);
1228                 cp = &mfc_unres_queue;
1229                 while ((c = *cp) != NULL) {
1230                         if (!net_eq(mfc6_net(c), net)) {
1231                                 cp = &c->next;
1232                                 continue;
1233                         }
1234                         *cp = c->next;
1235                         ip6mr_destroy_unres(c);
1236                 }
1237                 spin_unlock_bh(&mfc_unres_lock);
1238         }
1239 }
1240
1241 static int ip6mr_sk_init(struct sock *sk)
1242 {
1243         int err = 0;
1244         struct net *net = sock_net(sk);
1245
1246         rtnl_lock();
1247         write_lock_bh(&mrt_lock);
1248         if (likely(net->ipv6.mroute6_sk == NULL)) {
1249                 net->ipv6.mroute6_sk = sk;
1250                 net->ipv6.devconf_all->mc_forwarding++;
1251         }
1252         else
1253                 err = -EADDRINUSE;
1254         write_unlock_bh(&mrt_lock);
1255
1256         rtnl_unlock();
1257
1258         return err;
1259 }
1260
1261 int ip6mr_sk_done(struct sock *sk)
1262 {
1263         int err = 0;
1264         struct net *net = sock_net(sk);
1265
1266         rtnl_lock();
1267         if (sk == net->ipv6.mroute6_sk) {
1268                 write_lock_bh(&mrt_lock);
1269                 net->ipv6.mroute6_sk = NULL;
1270                 net->ipv6.devconf_all->mc_forwarding--;
1271                 write_unlock_bh(&mrt_lock);
1272
1273                 mroute_clean_tables(net);
1274         } else
1275                 err = -EACCES;
1276         rtnl_unlock();
1277
1278         return err;
1279 }
1280
1281 /*
1282  *      Socket options and virtual interface manipulation. The whole
1283  *      virtual interface system is a complete heap, but unfortunately
1284  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1285  *      MOSPF/PIM router set up we can clean this up.
1286  */
1287
1288 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
1289 {
1290         int ret;
1291         struct mif6ctl vif;
1292         struct mf6cctl mfc;
1293         mifi_t mifi;
1294         struct net *net = sock_net(sk);
1295
1296         if (optname != MRT6_INIT) {
1297                 if (sk != net->ipv6.mroute6_sk && !capable(CAP_NET_ADMIN))
1298                         return -EACCES;
1299         }
1300
1301         switch (optname) {
1302         case MRT6_INIT:
1303                 if (sk->sk_type != SOCK_RAW ||
1304                     inet_sk(sk)->num != IPPROTO_ICMPV6)
1305                         return -EOPNOTSUPP;
1306                 if (optlen < sizeof(int))
1307                         return -EINVAL;
1308
1309                 return ip6mr_sk_init(sk);
1310
1311         case MRT6_DONE:
1312                 return ip6mr_sk_done(sk);
1313
1314         case MRT6_ADD_MIF:
1315                 if (optlen < sizeof(vif))
1316                         return -EINVAL;
1317                 if (copy_from_user(&vif, optval, sizeof(vif)))
1318                         return -EFAULT;
1319                 if (vif.mif6c_mifi >= MAXMIFS)
1320                         return -ENFILE;
1321                 rtnl_lock();
1322                 ret = mif6_add(net, &vif, sk == net->ipv6.mroute6_sk);
1323                 rtnl_unlock();
1324                 return ret;
1325
1326         case MRT6_DEL_MIF:
1327                 if (optlen < sizeof(mifi_t))
1328                         return -EINVAL;
1329                 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1330                         return -EFAULT;
1331                 rtnl_lock();
1332                 ret = mif6_delete(net, mifi);
1333                 rtnl_unlock();
1334                 return ret;
1335
1336         /*
1337          *      Manipulate the forwarding caches. These live
1338          *      in a sort of kernel/user symbiosis.
1339          */
1340         case MRT6_ADD_MFC:
1341         case MRT6_DEL_MFC:
1342                 if (optlen < sizeof(mfc))
1343                         return -EINVAL;
1344                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1345                         return -EFAULT;
1346                 rtnl_lock();
1347                 if (optname == MRT6_DEL_MFC)
1348                         ret = ip6mr_mfc_delete(net, &mfc);
1349                 else
1350                         ret = ip6mr_mfc_add(net, &mfc,
1351                                             sk == net->ipv6.mroute6_sk);
1352                 rtnl_unlock();
1353                 return ret;
1354
1355         /*
1356          *      Control PIM assert (to activate pim will activate assert)
1357          */
1358         case MRT6_ASSERT:
1359         {
1360                 int v;
1361                 if (get_user(v, (int __user *)optval))
1362                         return -EFAULT;
1363                 net->ipv6.mroute_do_assert = !!v;
1364                 return 0;
1365         }
1366
1367 #ifdef CONFIG_IPV6_PIMSM_V2
1368         case MRT6_PIM:
1369         {
1370                 int v;
1371                 if (get_user(v, (int __user *)optval))
1372                         return -EFAULT;
1373                 v = !!v;
1374                 rtnl_lock();
1375                 ret = 0;
1376                 if (v != net->ipv6.mroute_do_pim) {
1377                         net->ipv6.mroute_do_pim = v;
1378                         net->ipv6.mroute_do_assert = v;
1379                 }
1380                 rtnl_unlock();
1381                 return ret;
1382         }
1383
1384 #endif
1385         /*
1386          *      Spurious command, or MRT6_VERSION which you cannot
1387          *      set.
1388          */
1389         default:
1390                 return -ENOPROTOOPT;
1391         }
1392 }
1393
1394 /*
1395  *      Getsock opt support for the multicast routing system.
1396  */
1397
1398 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1399                           int __user *optlen)
1400 {
1401         int olr;
1402         int val;
1403         struct net *net = sock_net(sk);
1404
1405         switch (optname) {
1406         case MRT6_VERSION:
1407                 val = 0x0305;
1408                 break;
1409 #ifdef CONFIG_IPV6_PIMSM_V2
1410         case MRT6_PIM:
1411                 val = net->ipv6.mroute_do_pim;
1412                 break;
1413 #endif
1414         case MRT6_ASSERT:
1415                 val = net->ipv6.mroute_do_assert;
1416                 break;
1417         default:
1418                 return -ENOPROTOOPT;
1419         }
1420
1421         if (get_user(olr, optlen))
1422                 return -EFAULT;
1423
1424         olr = min_t(int, olr, sizeof(int));
1425         if (olr < 0)
1426                 return -EINVAL;
1427
1428         if (put_user(olr, optlen))
1429                 return -EFAULT;
1430         if (copy_to_user(optval, &val, olr))
1431                 return -EFAULT;
1432         return 0;
1433 }
1434
1435 /*
1436  *      The IP multicast ioctl support routines.
1437  */
1438
1439 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1440 {
1441         struct sioc_sg_req6 sr;
1442         struct sioc_mif_req6 vr;
1443         struct mif_device *vif;
1444         struct mfc6_cache *c;
1445         struct net *net = sock_net(sk);
1446
1447         switch (cmd) {
1448         case SIOCGETMIFCNT_IN6:
1449                 if (copy_from_user(&vr, arg, sizeof(vr)))
1450                         return -EFAULT;
1451                 if (vr.mifi >= net->ipv6.maxvif)
1452                         return -EINVAL;
1453                 read_lock(&mrt_lock);
1454                 vif = &net->ipv6.vif6_table[vr.mifi];
1455                 if (MIF_EXISTS(net, vr.mifi)) {
1456                         vr.icount = vif->pkt_in;
1457                         vr.ocount = vif->pkt_out;
1458                         vr.ibytes = vif->bytes_in;
1459                         vr.obytes = vif->bytes_out;
1460                         read_unlock(&mrt_lock);
1461
1462                         if (copy_to_user(arg, &vr, sizeof(vr)))
1463                                 return -EFAULT;
1464                         return 0;
1465                 }
1466                 read_unlock(&mrt_lock);
1467                 return -EADDRNOTAVAIL;
1468         case SIOCGETSGCNT_IN6:
1469                 if (copy_from_user(&sr, arg, sizeof(sr)))
1470                         return -EFAULT;
1471
1472                 read_lock(&mrt_lock);
1473                 c = ip6mr_cache_find(net, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1474                 if (c) {
1475                         sr.pktcnt = c->mfc_un.res.pkt;
1476                         sr.bytecnt = c->mfc_un.res.bytes;
1477                         sr.wrong_if = c->mfc_un.res.wrong_if;
1478                         read_unlock(&mrt_lock);
1479
1480                         if (copy_to_user(arg, &sr, sizeof(sr)))
1481                                 return -EFAULT;
1482                         return 0;
1483                 }
1484                 read_unlock(&mrt_lock);
1485                 return -EADDRNOTAVAIL;
1486         default:
1487                 return -ENOIOCTLCMD;
1488         }
1489 }
1490
1491
1492 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1493 {
1494         IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1495                          IPSTATS_MIB_OUTFORWDATAGRAMS);
1496         return dst_output(skb);
1497 }
1498
1499 /*
1500  *      Processing handlers for ip6mr_forward
1501  */
1502
1503 static int ip6mr_forward2(struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1504 {
1505         struct ipv6hdr *ipv6h;
1506         struct net *net = mfc6_net(c);
1507         struct mif_device *vif = &net->ipv6.vif6_table[vifi];
1508         struct net_device *dev;
1509         struct dst_entry *dst;
1510         struct flowi fl;
1511
1512         if (vif->dev == NULL)
1513                 goto out_free;
1514
1515 #ifdef CONFIG_IPV6_PIMSM_V2
1516         if (vif->flags & MIFF_REGISTER) {
1517                 vif->pkt_out++;
1518                 vif->bytes_out += skb->len;
1519                 vif->dev->stats.tx_bytes += skb->len;
1520                 vif->dev->stats.tx_packets++;
1521                 ip6mr_cache_report(net, skb, vifi, MRT6MSG_WHOLEPKT);
1522                 goto out_free;
1523         }
1524 #endif
1525
1526         ipv6h = ipv6_hdr(skb);
1527
1528         fl = (struct flowi) {
1529                 .oif = vif->link,
1530                 .nl_u = { .ip6_u =
1531                                 { .daddr = ipv6h->daddr, }
1532                 }
1533         };
1534
1535         dst = ip6_route_output(net, NULL, &fl);
1536         if (!dst)
1537                 goto out_free;
1538
1539         skb_dst_drop(skb);
1540         skb_dst_set(skb, dst);
1541
1542         /*
1543          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1544          * not only before forwarding, but after forwarding on all output
1545          * interfaces. It is clear, if mrouter runs a multicasting
1546          * program, it should receive packets not depending to what interface
1547          * program is joined.
1548          * If we will not make it, the program will have to join on all
1549          * interfaces. On the other hand, multihoming host (or router, but
1550          * not mrouter) cannot join to more than one interface - it will
1551          * result in receiving multiple packets.
1552          */
1553         dev = vif->dev;
1554         skb->dev = dev;
1555         vif->pkt_out++;
1556         vif->bytes_out += skb->len;
1557
1558         /* We are about to write */
1559         /* XXX: extension headers? */
1560         if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1561                 goto out_free;
1562
1563         ipv6h = ipv6_hdr(skb);
1564         ipv6h->hop_limit--;
1565
1566         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1567
1568         return NF_HOOK(PF_INET6, NF_INET_FORWARD, skb, skb->dev, dev,
1569                        ip6mr_forward2_finish);
1570
1571 out_free:
1572         kfree_skb(skb);
1573         return 0;
1574 }
1575
1576 static int ip6mr_find_vif(struct net_device *dev)
1577 {
1578         struct net *net = dev_net(dev);
1579         int ct;
1580         for (ct = net->ipv6.maxvif - 1; ct >= 0; ct--) {
1581                 if (net->ipv6.vif6_table[ct].dev == dev)
1582                         break;
1583         }
1584         return ct;
1585 }
1586
1587 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache)
1588 {
1589         int psend = -1;
1590         int vif, ct;
1591         struct net *net = mfc6_net(cache);
1592
1593         vif = cache->mf6c_parent;
1594         cache->mfc_un.res.pkt++;
1595         cache->mfc_un.res.bytes += skb->len;
1596
1597         /*
1598          * Wrong interface: drop packet and (maybe) send PIM assert.
1599          */
1600         if (net->ipv6.vif6_table[vif].dev != skb->dev) {
1601                 int true_vifi;
1602
1603                 cache->mfc_un.res.wrong_if++;
1604                 true_vifi = ip6mr_find_vif(skb->dev);
1605
1606                 if (true_vifi >= 0 && net->ipv6.mroute_do_assert &&
1607                     /* pimsm uses asserts, when switching from RPT to SPT,
1608                        so that we cannot check that packet arrived on an oif.
1609                        It is bad, but otherwise we would need to move pretty
1610                        large chunk of pimd to kernel. Ough... --ANK
1611                      */
1612                     (net->ipv6.mroute_do_pim ||
1613                      cache->mfc_un.res.ttls[true_vifi] < 255) &&
1614                     time_after(jiffies,
1615                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1616                         cache->mfc_un.res.last_assert = jiffies;
1617                         ip6mr_cache_report(net, skb, true_vifi, MRT6MSG_WRONGMIF);
1618                 }
1619                 goto dont_forward;
1620         }
1621
1622         net->ipv6.vif6_table[vif].pkt_in++;
1623         net->ipv6.vif6_table[vif].bytes_in += skb->len;
1624
1625         /*
1626          *      Forward the frame
1627          */
1628         for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
1629                 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
1630                         if (psend != -1) {
1631                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1632                                 if (skb2)
1633                                         ip6mr_forward2(skb2, cache, psend);
1634                         }
1635                         psend = ct;
1636                 }
1637         }
1638         if (psend != -1) {
1639                 ip6mr_forward2(skb, cache, psend);
1640                 return 0;
1641         }
1642
1643 dont_forward:
1644         kfree_skb(skb);
1645         return 0;
1646 }
1647
1648
1649 /*
1650  *      Multicast packets for forwarding arrive here
1651  */
1652
1653 int ip6_mr_input(struct sk_buff *skb)
1654 {
1655         struct mfc6_cache *cache;
1656         struct net *net = dev_net(skb->dev);
1657
1658         read_lock(&mrt_lock);
1659         cache = ip6mr_cache_find(net,
1660                                  &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
1661
1662         /*
1663          *      No usable cache entry
1664          */
1665         if (cache == NULL) {
1666                 int vif;
1667
1668                 vif = ip6mr_find_vif(skb->dev);
1669                 if (vif >= 0) {
1670                         int err = ip6mr_cache_unresolved(net, vif, skb);
1671                         read_unlock(&mrt_lock);
1672
1673                         return err;
1674                 }
1675                 read_unlock(&mrt_lock);
1676                 kfree_skb(skb);
1677                 return -ENODEV;
1678         }
1679
1680         ip6_mr_forward(skb, cache);
1681
1682         read_unlock(&mrt_lock);
1683
1684         return 0;
1685 }
1686
1687
1688 static int
1689 ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm)
1690 {
1691         int ct;
1692         struct rtnexthop *nhp;
1693         struct net *net = mfc6_net(c);
1694         struct net_device *dev = net->ipv6.vif6_table[c->mf6c_parent].dev;
1695         u8 *b = skb_tail_pointer(skb);
1696         struct rtattr *mp_head;
1697
1698         if (dev)
1699                 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1700
1701         mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1702
1703         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1704                 if (c->mfc_un.res.ttls[ct] < 255) {
1705                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1706                                 goto rtattr_failure;
1707                         nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1708                         nhp->rtnh_flags = 0;
1709                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1710                         nhp->rtnh_ifindex = net->ipv6.vif6_table[ct].dev->ifindex;
1711                         nhp->rtnh_len = sizeof(*nhp);
1712                 }
1713         }
1714         mp_head->rta_type = RTA_MULTIPATH;
1715         mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1716         rtm->rtm_type = RTN_MULTICAST;
1717         return 1;
1718
1719 rtattr_failure:
1720         nlmsg_trim(skb, b);
1721         return -EMSGSIZE;
1722 }
1723
1724 int ip6mr_get_route(struct net *net,
1725                     struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1726 {
1727         int err;
1728         struct mfc6_cache *cache;
1729         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
1730
1731         read_lock(&mrt_lock);
1732         cache = ip6mr_cache_find(net, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
1733
1734         if (!cache) {
1735                 struct sk_buff *skb2;
1736                 struct ipv6hdr *iph;
1737                 struct net_device *dev;
1738                 int vif;
1739
1740                 if (nowait) {
1741                         read_unlock(&mrt_lock);
1742                         return -EAGAIN;
1743                 }
1744
1745                 dev = skb->dev;
1746                 if (dev == NULL || (vif = ip6mr_find_vif(dev)) < 0) {
1747                         read_unlock(&mrt_lock);
1748                         return -ENODEV;
1749                 }
1750
1751                 /* really correct? */
1752                 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
1753                 if (!skb2) {
1754                         read_unlock(&mrt_lock);
1755                         return -ENOMEM;
1756                 }
1757
1758                 skb_reset_transport_header(skb2);
1759
1760                 skb_put(skb2, sizeof(struct ipv6hdr));
1761                 skb_reset_network_header(skb2);
1762
1763                 iph = ipv6_hdr(skb2);
1764                 iph->version = 0;
1765                 iph->priority = 0;
1766                 iph->flow_lbl[0] = 0;
1767                 iph->flow_lbl[1] = 0;
1768                 iph->flow_lbl[2] = 0;
1769                 iph->payload_len = 0;
1770                 iph->nexthdr = IPPROTO_NONE;
1771                 iph->hop_limit = 0;
1772                 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
1773                 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
1774
1775                 err = ip6mr_cache_unresolved(net, vif, skb2);
1776                 read_unlock(&mrt_lock);
1777
1778                 return err;
1779         }
1780
1781         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1782                 cache->mfc_flags |= MFC_NOTIFY;
1783
1784         err = ip6mr_fill_mroute(skb, cache, rtm);
1785         read_unlock(&mrt_lock);
1786         return err;
1787 }
1788