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