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