?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
warning removal
[cor_2_6_31.git] / net / ipv6 / ip6mr.c
blobc769f155c6987ba0fd39339e6a2ec929fde62372
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 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 int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
420 {
421 struct net *net = dev_net(dev);
422
423 read_lock(&mrt_lock);
424 dev->stats.tx_bytes += skb->len;
425 dev->stats.tx_packets++;
426 ip6mr_cache_report(net, skb, net->ipv6.mroute_reg_vif_num,
427 MRT6MSG_WHOLEPKT);
428 read_unlock(&mrt_lock);
429 kfree_skb(skb);
430 return 0;
431 }
432
433 static const struct net_device_ops reg_vif_netdev_ops = {
434 .ndo_start_xmit = reg_vif_xmit,
435 };
436
437 static void reg_vif_setup(struct net_device *dev)
438 {
439 dev->type = ARPHRD_PIMREG;
440 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
441 dev->flags = IFF_NOARP;
442 dev->netdev_ops = &reg_vif_netdev_ops;
443 dev->destructor = free_netdev;
444 dev->features |= NETIF_F_NETNS_LOCAL;
445 }
446
447 static struct net_device *ip6mr_reg_vif(struct net *net)
448 {
449 struct net_device *dev;
450
451 dev = alloc_netdev(0, "pim6reg", reg_vif_setup);
452 if (dev == NULL)
453 return NULL;
454
455 dev_net_set(dev, net);
456
457 if (register_netdevice(dev)) {
458 free_netdev(dev);
459 return NULL;
460 }
461 dev->iflink = 0;
462
463 if (dev_open(dev))
464 goto failure;
465
466 dev_hold(dev);
467 return dev;
468
469 failure:
470 /* allow the register to be completed before unregistering. */
471 rtnl_unlock();
472 rtnl_lock();
473
474 unregister_netdevice(dev);
475 return NULL;
476 }
477 #endif
478
479 /*
480 * Delete a VIF entry
481 */
482
483 static int mif6_delete(struct net *net, int vifi)
484 {
485 struct mif_device *v;
486 struct net_device *dev;
487 struct inet6_dev *in6_dev;
488 if (vifi < 0 || vifi >= net->ipv6.maxvif)
489 return -EADDRNOTAVAIL;
490
491 v = &net->ipv6.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 == net->ipv6.mroute_reg_vif_num)
504 net->ipv6.mroute_reg_vif_num = -1;
505 #endif
506
507 if (vifi + 1 == net->ipv6.maxvif) {
508 int tmp;
509 for (tmp = vifi - 1; tmp >= 0; tmp--) {
510 if (MIF_EXISTS(net, tmp))
511 break;
512 }
513 net->ipv6.maxvif = tmp + 1;
514 }
515
516 write_unlock_bh(&mrt_lock);
517
518 dev_set_allmulti(dev, -1);
519
520 in6_dev = __in6_dev_get(dev);
521 if (in6_dev)
522 in6_dev->cnf.mc_forwarding--;
523
524 if (v->flags & MIFF_REGISTER)
525 unregister_netdevice(dev);
526
527 dev_put(dev);
528 return 0;
529 }
530
531 static inline void ip6mr_cache_free(struct mfc6_cache *c)
532 {
533 release_net(mfc6_net(c));
534 kmem_cache_free(mrt_cachep, c);
535 }
536
537 /* Destroy an unresolved cache entry, killing queued skbs
538 and reporting error to netlink readers.
539 */
540
541 static void ip6mr_destroy_unres(struct mfc6_cache *c)
542 {
543 struct sk_buff *skb;
544 struct net *net = mfc6_net(c);
545
546 atomic_dec(&net->ipv6.cache_resolve_queue_len);
547
548 while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
549 if (ipv6_hdr(skb)->version == 0) {
550 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
551 nlh->nlmsg_type = NLMSG_ERROR;
552 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
553 skb_trim(skb, nlh->nlmsg_len);
554 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
555 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
556 } else
557 kfree_skb(skb);
558 }
559
560 ip6mr_cache_free(c);
561 }
562
563
564 /* Single timer process for all the unresolved queue. */
565
566 static void ipmr_do_expire_process(unsigned long dummy)
567 {
568 unsigned long now = jiffies;
569 unsigned long expires = 10 * HZ;
570 struct mfc6_cache *c, **cp;
571
572 cp = &mfc_unres_queue;
573
574 while ((c = *cp) != NULL) {
575 if (time_after(c->mfc_un.unres.expires, now)) {
576 /* not yet... */
577 unsigned long interval = c->mfc_un.unres.expires - now;
578 if (interval < expires)
579 expires = interval;
580 cp = &c->next;
581 continue;
582 }
583
584 *cp = c->next;
585 ip6mr_destroy_unres(c);
586 }
587
588 if (mfc_unres_queue != NULL)
589 mod_timer(&ipmr_expire_timer, jiffies + expires);
590 }
591
592 static void ipmr_expire_process(unsigned long dummy)
593 {
594 if (!spin_trylock(&mfc_unres_lock)) {
595 mod_timer(&ipmr_expire_timer, jiffies + 1);
596 return;
597 }
598
599 if (mfc_unres_queue != NULL)
600 ipmr_do_expire_process(dummy);
601
602 spin_unlock(&mfc_unres_lock);
603 }
604
605 /* Fill oifs list. It is called under write locked mrt_lock. */
606
607 static void ip6mr_update_thresholds(struct mfc6_cache *cache, unsigned char *ttls)
608 {
609 int vifi;
610 struct net *net = mfc6_net(cache);
611
612 cache->mfc_un.res.minvif = MAXMIFS;
613 cache->mfc_un.res.maxvif = 0;
614 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
615
616 for (vifi = 0; vifi < net->ipv6.maxvif; vifi++) {
617 if (MIF_EXISTS(net, vifi) &&
618 ttls[vifi] && ttls[vifi] < 255) {
619 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
620 if (cache->mfc_un.res.minvif > vifi)
621 cache->mfc_un.res.minvif = vifi;
622 if (cache->mfc_un.res.maxvif <= vifi)
623 cache->mfc_un.res.maxvif = vifi + 1;
624 }
625 }
626 }
627
628 static int mif6_add(struct net *net, struct mif6ctl *vifc, int mrtsock)
629 {
630 int vifi = vifc->mif6c_mifi;
631 struct mif_device *v = &net->ipv6.vif6_table[vifi];
632 struct net_device *dev;
633 struct inet6_dev *in6_dev;
634 int err;
635
636 /* Is vif busy ? */
637 if (MIF_EXISTS(net, vifi))
638 return -EADDRINUSE;
639
640 switch (vifc->mif6c_flags) {
641 #ifdef CONFIG_IPV6_PIMSM_V2
642 case MIFF_REGISTER:
643 /*
644 * Special Purpose VIF in PIM
645 * All the packets will be sent to the daemon
646 */
647 if (net->ipv6.mroute_reg_vif_num >= 0)
648 return -EADDRINUSE;
649 dev = ip6mr_reg_vif(net);
650 if (!dev)
651 return -ENOBUFS;
652 err = dev_set_allmulti(dev, 1);
653 if (err) {
654 unregister_netdevice(dev);
655 dev_put(dev);
656 return err;
657 }
658 break;
659 #endif
660 case 0:
661 dev = dev_get_by_index(net, vifc->mif6c_pifi);
662 if (!dev)
663 return -EADDRNOTAVAIL;
664 err = dev_set_allmulti(dev, 1);
665 if (err) {
666 dev_put(dev);
667 return err;
668 }
669 break;
670 default:
671 return -EINVAL;
672 }
673
674 in6_dev = __in6_dev_get(dev);
675 if (in6_dev)
676 in6_dev->cnf.mc_forwarding++;
677
678 /*
679 * Fill in the VIF structures
680 */
681 v->rate_limit = vifc->vifc_rate_limit;
682 v->flags = vifc->mif6c_flags;
683 if (!mrtsock)
684 v->flags |= VIFF_STATIC;
685 v->threshold = vifc->vifc_threshold;
686 v->bytes_in = 0;
687 v->bytes_out = 0;
688 v->pkt_in = 0;
689 v->pkt_out = 0;
690 v->link = dev->ifindex;
691 if (v->flags & MIFF_REGISTER)
692 v->link = dev->iflink;
693
694 /* And finish update writing critical data */
695 write_lock_bh(&mrt_lock);
696 v->dev = dev;
697 #ifdef CONFIG_IPV6_PIMSM_V2
698 if (v->flags & MIFF_REGISTER)
699 net->ipv6.mroute_reg_vif_num = vifi;
700 #endif
701 if (vifi + 1 > net->ipv6.maxvif)
702 net->ipv6.maxvif = vifi + 1;
703 write_unlock_bh(&mrt_lock);
704 return 0;
705 }
706
707 static struct mfc6_cache *ip6mr_cache_find(struct net *net,
708 struct in6_addr *origin,
709 struct in6_addr *mcastgrp)
710 {
711 int line = MFC6_HASH(mcastgrp, origin);
712 struct mfc6_cache *c;
713
714 for (c = net->ipv6.mfc6_cache_array[line]; c; c = c->next) {
715 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
716 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
717 break;
718 }
719 return c;
720 }
721
722 /*
723 * Allocate a multicast cache entry
724 */
725 static struct mfc6_cache *ip6mr_cache_alloc(struct net *net)
726 {
727 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
728 if (c == NULL)
729 return NULL;
730 c->mfc_un.res.minvif = MAXMIFS;
731 mfc6_net_set(c, net);
732 return c;
733 }
734
735 static struct mfc6_cache *ip6mr_cache_alloc_unres(struct net *net)
736 {
737 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
738 if (c == NULL)
739 return NULL;
740 skb_queue_head_init(&c->mfc_un.unres.unresolved);
741 c->mfc_un.unres.expires = jiffies + 10 * HZ;
742 mfc6_net_set(c, net);
743 return c;
744 }
745
746 /*
747 * A cache entry has gone into a resolved state from queued
748 */
749
750 static void ip6mr_cache_resolve(struct mfc6_cache *uc, struct mfc6_cache *c)
751 {
752 struct sk_buff *skb;
753
754 /*
755 * Play the pending entries through our router
756 */
757
758 while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
759 if (ipv6_hdr(skb)->version == 0) {
760 int err;
761 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
762
763 if (ip6mr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
764 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
765 } else {
766 nlh->nlmsg_type = NLMSG_ERROR;
767 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
768 skb_trim(skb, nlh->nlmsg_len);
769 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
770 }
771 err = rtnl_unicast(skb, mfc6_net(uc), NETLINK_CB(skb).pid);
772 } else
773 ip6_mr_forward(skb, c);
774 }
775 }
776
777 /*
778 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
779 * expects the following bizarre scheme.
780 *
781 * Called under mrt_lock.
782 */
783
784 static int ip6mr_cache_report(struct net *net, struct sk_buff *pkt, mifi_t mifi,
785 int assert)
786 {
787 struct sk_buff *skb;
788 struct mrt6msg *msg;
789 int ret;
790
791 #ifdef CONFIG_IPV6_PIMSM_V2
792 if (assert == MRT6MSG_WHOLEPKT)
793 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
794 +sizeof(*msg));
795 else
796 #endif
797 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
798
799 if (!skb)
800 return -ENOBUFS;
801
802 /* I suppose that internal messages
803 * do not require checksums */
804
805 skb->ip_summed = CHECKSUM_UNNECESSARY;
806
807 #ifdef CONFIG_IPV6_PIMSM_V2
808 if (assert == MRT6MSG_WHOLEPKT) {
809 /* Ugly, but we have no choice with this interface.
810 Duplicate old header, fix length etc.
811 And all this only to mangle msg->im6_msgtype and
812 to set msg->im6_mbz to "mbz" :-)
813 */
814 skb_push(skb, -skb_network_offset(pkt));
815
816 skb_push(skb, sizeof(*msg));
817 skb_reset_transport_header(skb);
818 msg = (struct mrt6msg *)skb_transport_header(skb);
819 msg->im6_mbz = 0;
820 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
821 msg->im6_mif = net->ipv6.mroute_reg_vif_num;
822 msg->im6_pad = 0;
823 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
824 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
825
826 skb->ip_summed = CHECKSUM_UNNECESSARY;
827 } else
828 #endif
829 {
830 /*
831 * Copy the IP header
832 */
833
834 skb_put(skb, sizeof(struct ipv6hdr));
835 skb_reset_network_header(skb);
836 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
837
838 /*
839 * Add our header
840 */
841 skb_put(skb, sizeof(*msg));
842 skb_reset_transport_header(skb);
843 msg = (struct mrt6msg *)skb_transport_header(skb);
844
845 msg->im6_mbz = 0;
846 msg->im6_msgtype = assert;
847 msg->im6_mif = mifi;
848 msg->im6_pad = 0;
849 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
850 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
851
852 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
853 skb->ip_summed = CHECKSUM_UNNECESSARY;
854 }
855
856 if (net->ipv6.mroute6_sk == NULL) {
857 kfree_skb(skb);
858 return -EINVAL;
859 }
860
861 /*
862 * Deliver to user space multicast routing algorithms
863 */
864 ret = sock_queue_rcv_skb(net->ipv6.mroute6_sk, skb);
865 if (ret < 0) {
866 if (net_ratelimit())
867 printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
868 kfree_skb(skb);
869 }
870
871 return ret;
872 }
873
874 /*
875 * Queue a packet for resolution. It gets locked cache entry!
876 */
877
878 static int
879 ip6mr_cache_unresolved(struct net *net, mifi_t mifi, struct sk_buff *skb)
880 {
881 int err;
882 struct mfc6_cache *c;
883
884 spin_lock_bh(&mfc_unres_lock);
885 for (c = mfc_unres_queue; c; c = c->next) {
886 if (net_eq(mfc6_net(c), net) &&
887 ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
888 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr))
889 break;
890 }
891
892 if (c == NULL) {
893 /*
894 * Create a new entry if allowable
895 */
896
897 if (atomic_read(&net->ipv6.cache_resolve_queue_len) >= 10 ||
898 (c = ip6mr_cache_alloc_unres(net)) == NULL) {
899 spin_unlock_bh(&mfc_unres_lock);
900
901 kfree_skb(skb);
902 return -ENOBUFS;
903 }
904
905 /*
906 * Fill in the new cache entry
907 */
908 c->mf6c_parent = -1;
909 c->mf6c_origin = ipv6_hdr(skb)->saddr;
910 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
911
912 /*
913 * Reflect first query at pim6sd
914 */
915 err = ip6mr_cache_report(net, skb, mifi, MRT6MSG_NOCACHE);
916 if (err < 0) {
917 /* If the report failed throw the cache entry
918 out - Brad Parker
919 */
920 spin_unlock_bh(&mfc_unres_lock);
921
922 ip6mr_cache_free(c);
923 kfree_skb(skb);
924 return err;
925 }
926
927 atomic_inc(&net->ipv6.cache_resolve_queue_len);
928 c->next = mfc_unres_queue;
929 mfc_unres_queue = c;
930
931 ipmr_do_expire_process(1);
932 }
933
934 /*
935 * See if we can append the packet
936 */
937 if (c->mfc_un.unres.unresolved.qlen > 3) {
938 kfree_skb(skb);
939 err = -ENOBUFS;
940 } else {
941 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
942 err = 0;
943 }
944
945 spin_unlock_bh(&mfc_unres_lock);
946 return err;
947 }
948
949 /*
950 * MFC6 cache manipulation by user space
951 */
952
953 static int ip6mr_mfc_delete(struct net *net, struct mf6cctl *mfc)
954 {
955 int line;
956 struct mfc6_cache *c, **cp;
957
958 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
959
960 for (cp = &net->ipv6.mfc6_cache_array[line];
961 (c = *cp) != NULL; cp = &c->next) {
962 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
963 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
964 write_lock_bh(&mrt_lock);
965 *cp = c->next;
966 write_unlock_bh(&mrt_lock);
967
968 ip6mr_cache_free(c);
969 return 0;
970 }
971 }
972 return -ENOENT;
973 }
974
975 static int ip6mr_device_event(struct notifier_block *this,
976 unsigned long event, void *ptr)
977 {
978 struct net_device *dev = ptr;
979 struct net *net = dev_net(dev);
980 struct mif_device *v;
981 int ct;
982
983 if (event != NETDEV_UNREGISTER)
984 return NOTIFY_DONE;
985
986 v = &net->ipv6.vif6_table[0];
987 for (ct = 0; ct < net->ipv6.maxvif; ct++, v++) {
988 if (v->dev == dev)
989 mif6_delete(net, ct);
990 }
991 return NOTIFY_DONE;
992 }
993
994 static struct notifier_block ip6_mr_notifier = {
995 .notifier_call = ip6mr_device_event
996 };
997
998 /*
999 * Setup for IP multicast routing
1000 */
1001
1002 static int __net_init ip6mr_net_init(struct net *net)
1003 {
1004 int err = 0;
1005 net->ipv6.vif6_table = kcalloc(MAXMIFS, sizeof(struct mif_device),
1006 GFP_KERNEL);
1007 if (!net->ipv6.vif6_table) {
1008 err = -ENOMEM;
1009 goto fail;
1010 }
1011
1012 /* Forwarding cache */
1013 net->ipv6.mfc6_cache_array = kcalloc(MFC6_LINES,
1014 sizeof(struct mfc6_cache *),
1015 GFP_KERNEL);
1016 if (!net->ipv6.mfc6_cache_array) {
1017 err = -ENOMEM;
1018 goto fail_mfc6_cache;
1019 }
1020
1021 #ifdef CONFIG_IPV6_PIMSM_V2
1022 net->ipv6.mroute_reg_vif_num = -1;
1023 #endif
1024
1025 #ifdef CONFIG_PROC_FS
1026 err = -ENOMEM;
1027 if (!proc_net_fops_create(net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
1028 goto proc_vif_fail;
1029 if (!proc_net_fops_create(net, "ip6_mr_cache", 0, &ip6mr_mfc_fops))
1030 goto proc_cache_fail;
1031 #endif
1032 return 0;
1033
1034 #ifdef CONFIG_PROC_FS
1035 proc_cache_fail:
1036 proc_net_remove(net, "ip6_mr_vif");
1037 proc_vif_fail:
1038 kfree(net->ipv6.mfc6_cache_array);
1039 #endif
1040 fail_mfc6_cache:
1041 kfree(net->ipv6.vif6_table);
1042 fail:
1043 return err;
1044 }
1045
1046 static void __net_exit ip6mr_net_exit(struct net *net)
1047 {
1048 #ifdef CONFIG_PROC_FS
1049 proc_net_remove(net, "ip6_mr_cache");
1050 proc_net_remove(net, "ip6_mr_vif");
1051 #endif
1052 mroute_clean_tables(net);
1053 kfree(net->ipv6.mfc6_cache_array);
1054 kfree(net->ipv6.vif6_table);
1055 }
1056
1057 static struct pernet_operations ip6mr_net_ops = {
1058 .init = ip6mr_net_init,
1059 .exit = ip6mr_net_exit,
1060 };
1061
1062 int __init ip6_mr_init(void)
1063 {
1064 int err;
1065
1066 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1067 sizeof(struct mfc6_cache),
1068 0, SLAB_HWCACHE_ALIGN,
1069 NULL);
1070 if (!mrt_cachep)
1071 return -ENOMEM;
1072
1073 err = register_pernet_subsys(&ip6mr_net_ops);
1074 if (err)
1075 goto reg_pernet_fail;
1076
1077 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
1078 err = register_netdevice_notifier(&ip6_mr_notifier);
1079 if (err)
1080 goto reg_notif_fail;
1081 #ifdef CONFIG_IPV6_PIMSM_V2
1082 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1083 printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n");
1084 err = -EAGAIN;
1085 goto add_proto_fail;
1086 }
1087 #endif
1088 return 0;
1089 #ifdef CONFIG_IPV6_PIMSM_V2
1090 add_proto_fail:
1091 unregister_netdevice_notifier(&ip6_mr_notifier);
1092 #endif
1093 reg_notif_fail:
1094 del_timer(&ipmr_expire_timer);
1095 unregister_pernet_subsys(&ip6mr_net_ops);
1096 reg_pernet_fail:
1097 kmem_cache_destroy(mrt_cachep);
1098 return err;
1099 }
1100
1101 void ip6_mr_cleanup(void)
1102 {
1103 unregister_netdevice_notifier(&ip6_mr_notifier);
1104 del_timer(&ipmr_expire_timer);
1105 unregister_pernet_subsys(&ip6mr_net_ops);
1106 kmem_cache_destroy(mrt_cachep);
1107 }
1108
1109 static int ip6mr_mfc_add(struct net *net, struct mf6cctl *mfc, int mrtsock)
1110 {
1111 int line;
1112 struct mfc6_cache *uc, *c, **cp;
1113 unsigned char ttls[MAXMIFS];
1114 int i;
1115
1116 memset(ttls, 255, MAXMIFS);
1117 for (i = 0; i < MAXMIFS; i++) {
1118 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1119 ttls[i] = 1;
1120
1121 }
1122
1123 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1124
1125 for (cp = &net->ipv6.mfc6_cache_array[line];
1126 (c = *cp) != NULL; cp = &c->next) {
1127 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1128 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr))
1129 break;
1130 }
1131
1132 if (c != NULL) {
1133 write_lock_bh(&mrt_lock);
1134 c->mf6c_parent = mfc->mf6cc_parent;
1135 ip6mr_update_thresholds(c, ttls);
1136 if (!mrtsock)
1137 c->mfc_flags |= MFC_STATIC;
1138 write_unlock_bh(&mrt_lock);
1139 return 0;
1140 }
1141
1142 if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1143 return -EINVAL;
1144
1145 c = ip6mr_cache_alloc(net);
1146 if (c == NULL)
1147 return -ENOMEM;
1148
1149 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1150 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1151 c->mf6c_parent = mfc->mf6cc_parent;
1152 ip6mr_update_thresholds(c, ttls);
1153 if (!mrtsock)
1154 c->mfc_flags |= MFC_STATIC;
1155
1156 write_lock_bh(&mrt_lock);
1157 c->next = net->ipv6.mfc6_cache_array[line];
1158 net->ipv6.mfc6_cache_array[line] = c;
1159 write_unlock_bh(&mrt_lock);
1160
1161 /*
1162 * Check to see if we resolved a queued list. If so we
1163 * need to send on the frames and tidy up.
1164 */
1165 spin_lock_bh(&mfc_unres_lock);
1166 for (cp = &mfc_unres_queue; (uc = *cp) != NULL;
1167 cp = &uc->next) {
1168 if (net_eq(mfc6_net(uc), net) &&
1169 ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1170 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1171 *cp = uc->next;
1172 atomic_dec(&net->ipv6.cache_resolve_queue_len);
1173 break;
1174 }
1175 }
1176 if (mfc_unres_queue == NULL)
1177 del_timer(&ipmr_expire_timer);
1178 spin_unlock_bh(&mfc_unres_lock);
1179
1180 if (uc) {
1181 ip6mr_cache_resolve(uc, c);
1182 ip6mr_cache_free(uc);
1183 }
1184 return 0;
1185 }
1186
1187 /*
1188 * Close the multicast socket, and clear the vif tables etc
1189 */
1190
1191 static void mroute_clean_tables(struct net *net)
1192 {
1193 int i;
1194
1195 /*
1196 * Shut down all active vif entries
1197 */
1198 for (i = 0; i < net->ipv6.maxvif; i++) {
1199 if (!(net->ipv6.vif6_table[i].flags & VIFF_STATIC))
1200 mif6_delete(net, i);
1201 }
1202
1203 /*
1204 * Wipe the cache
1205 */
1206 for (i = 0; i < MFC6_LINES; i++) {
1207 struct mfc6_cache *c, **cp;
1208
1209 cp = &net->ipv6.mfc6_cache_array[i];
1210 while ((c = *cp) != NULL) {
1211 if (c->mfc_flags & MFC_STATIC) {
1212 cp = &c->next;
1213 continue;
1214 }
1215 write_lock_bh(&mrt_lock);
1216 *cp = c->next;
1217 write_unlock_bh(&mrt_lock);
1218
1219 ip6mr_cache_free(c);
1220 }
1221 }
1222
1223 if (atomic_read(&net->ipv6.cache_resolve_queue_len) != 0) {
1224 struct mfc6_cache *c, **cp;
1225
1226 spin_lock_bh(&mfc_unres_lock);
1227 cp = &mfc_unres_queue;
1228 while ((c = *cp) != NULL) {
1229 if (!net_eq(mfc6_net(c), net)) {
1230 cp = &c->next;
1231 continue;
1232 }
1233 *cp = c->next;
1234 ip6mr_destroy_unres(c);
1235 }
1236 spin_unlock_bh(&mfc_unres_lock);
1237 }
1238 }
1239
1240 static int ip6mr_sk_init(struct sock *sk)
1241 {
1242 int err = 0;
1243 struct net *net = sock_net(sk);
1244
1245 rtnl_lock();
1246 write_lock_bh(&mrt_lock);
1247 if (likely(net->ipv6.mroute6_sk == NULL)) {
1248 net->ipv6.mroute6_sk = sk;
1249 net->ipv6.devconf_all->mc_forwarding++;
1250 }
1251 else
1252 err = -EADDRINUSE;
1253 write_unlock_bh(&mrt_lock);
1254
1255 rtnl_unlock();
1256
1257 return err;
1258 }
1259
1260 int ip6mr_sk_done(struct sock *sk)
1261 {
1262 int err = 0;
1263 struct net *net = sock_net(sk);
1264
1265 rtnl_lock();
1266 if (sk == net->ipv6.mroute6_sk) {
1267 write_lock_bh(&mrt_lock);
1268 net->ipv6.mroute6_sk = NULL;
1269 net->ipv6.devconf_all->mc_forwarding--;
1270 write_unlock_bh(&mrt_lock);
1271
1272 mroute_clean_tables(net);
1273 } else
1274 err = -EACCES;
1275 rtnl_unlock();
1276
1277 return err;
1278 }
1279
1280 /*
1281 * Socket options and virtual interface manipulation. The whole
1282 * virtual interface system is a complete heap, but unfortunately
1283 * that's how BSD mrouted happens to think. Maybe one day with a proper
1284 * MOSPF/PIM router set up we can clean this up.
1285 */
1286
1287 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
1288 {
1289 int ret;
1290 struct mif6ctl vif;
1291 struct mf6cctl mfc;
1292 mifi_t mifi;
1293 struct net *net = sock_net(sk);
1294
1295 if (optname != MRT6_INIT) {
1296 if (sk != net->ipv6.mroute6_sk && !capable(CAP_NET_ADMIN))
1297 return -EACCES;
1298 }
1299
1300 switch (optname) {
1301 case MRT6_INIT:
1302 if (sk->sk_type != SOCK_RAW ||
1303 inet_sk(sk)->num != IPPROTO_ICMPV6)
1304 return -EOPNOTSUPP;
1305 if (optlen < sizeof(int))
1306 return -EINVAL;
1307
1308 return ip6mr_sk_init(sk);
1309
1310 case MRT6_DONE:
1311 return ip6mr_sk_done(sk);
1312
1313 case MRT6_ADD_MIF:
1314 if (optlen < sizeof(vif))
1315 return -EINVAL;
1316 if (copy_from_user(&vif, optval, sizeof(vif)))
1317 return -EFAULT;
1318 if (vif.mif6c_mifi >= MAXMIFS)
1319 return -ENFILE;
1320 rtnl_lock();
1321 ret = mif6_add(net, &vif, sk == net->ipv6.mroute6_sk);
1322 rtnl_unlock();
1323 return ret;
1324
1325 case MRT6_DEL_MIF:
1326 if (optlen < sizeof(mifi_t))
1327 return -EINVAL;
1328 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1329 return -EFAULT;
1330 rtnl_lock();
1331 ret = mif6_delete(net, mifi);
1332 rtnl_unlock();
1333 return ret;
1334
1335 /*
1336 * Manipulate the forwarding caches. These live
1337 * in a sort of kernel/user symbiosis.
1338 */
1339 case MRT6_ADD_MFC:
1340 case MRT6_DEL_MFC:
1341 if (optlen < sizeof(mfc))
1342 return -EINVAL;
1343 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1344 return -EFAULT;
1345 rtnl_lock();
1346 if (optname == MRT6_DEL_MFC)
1347 ret = ip6mr_mfc_delete(net, &mfc);
1348 else
1349 ret = ip6mr_mfc_add(net, &mfc,
1350 sk == net->ipv6.mroute6_sk);
1351 rtnl_unlock();
1352 return ret;
1353
1354 /*
1355 * Control PIM assert (to activate pim will activate assert)
1356 */
1357 case MRT6_ASSERT:
1358 {
1359 int v;
1360 if (get_user(v, (int __user *)optval))
1361 return -EFAULT;
1362 net->ipv6.mroute_do_assert = !!v;
1363 return 0;
1364 }
1365
1366 #ifdef CONFIG_IPV6_PIMSM_V2
1367 case MRT6_PIM:
1368 {
1369 int v;
1370 if (get_user(v, (int __user *)optval))
1371 return -EFAULT;
1372 v = !!v;
1373 rtnl_lock();
1374 ret = 0;
1375 if (v != net->ipv6.mroute_do_pim) {
1376 net->ipv6.mroute_do_pim = v;
1377 net->ipv6.mroute_do_assert = v;
1378 }
1379 rtnl_unlock();
1380 return ret;
1381 }
1382
1383 #endif
1384 /*
1385 * Spurious command, or MRT6_VERSION which you cannot
1386 * set.
1387 */
1388 default:
1389 return -ENOPROTOOPT;
1390 }
1391 }
1392
1393 /*
1394 * Getsock opt support for the multicast routing system.
1395 */
1396
1397 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1398 int __user *optlen)
1399 {
1400 int olr;
1401 int val;
1402 struct net *net = sock_net(sk);
1403
1404 switch (optname) {
1405 case MRT6_VERSION:
1406 val = 0x0305;
1407 break;
1408 #ifdef CONFIG_IPV6_PIMSM_V2
1409 case MRT6_PIM:
1410 val = net->ipv6.mroute_do_pim;
1411 break;
1412 #endif
1413 case MRT6_ASSERT:
1414 val = net->ipv6.mroute_do_assert;
1415 break;
1416 default:
1417 return -ENOPROTOOPT;
1418 }
1419
1420 if (get_user(olr, optlen))
1421 return -EFAULT;
1422
1423 olr = min_t(int, olr, sizeof(int));
1424 if (olr < 0)
1425 return -EINVAL;
1426
1427 if (put_user(olr, optlen))
1428 return -EFAULT;
1429 if (copy_to_user(optval, &val, olr))
1430 return -EFAULT;
1431 return 0;
1432 }
1433
1434 /*
1435 * The IP multicast ioctl support routines.
1436 */
1437
1438 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1439 {
1440 struct sioc_sg_req6 sr;
1441 struct sioc_mif_req6 vr;
1442 struct mif_device *vif;
1443 struct mfc6_cache *c;
1444 struct net *net = sock_net(sk);
1445
1446 switch (cmd) {
1447 case SIOCGETMIFCNT_IN6:
1448 if (copy_from_user(&vr, arg, sizeof(vr)))
1449 return -EFAULT;
1450 if (vr.mifi >= net->ipv6.maxvif)
1451 return -EINVAL;
1452 read_lock(&mrt_lock);
1453 vif = &net->ipv6.vif6_table[vr.mifi];
1454 if (MIF_EXISTS(net, vr.mifi)) {
1455 vr.icount = vif->pkt_in;
1456 vr.ocount = vif->pkt_out;
1457 vr.ibytes = vif->bytes_in;
1458 vr.obytes = vif->bytes_out;
1459 read_unlock(&mrt_lock);
1460
1461 if (copy_to_user(arg, &vr, sizeof(vr)))
1462 return -EFAULT;
1463 return 0;
1464 }
1465 read_unlock(&mrt_lock);
1466 return -EADDRNOTAVAIL;
1467 case SIOCGETSGCNT_IN6:
1468 if (copy_from_user(&sr, arg, sizeof(sr)))
1469 return -EFAULT;
1470
1471 read_lock(&mrt_lock);
1472 c = ip6mr_cache_find(net, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1473 if (c) {
1474 sr.pktcnt = c->mfc_un.res.pkt;
1475 sr.bytecnt = c->mfc_un.res.bytes;
1476 sr.wrong_if = c->mfc_un.res.wrong_if;
1477 read_unlock(&mrt_lock);
1478
1479 if (copy_to_user(arg, &sr, sizeof(sr)))
1480 return -EFAULT;
1481 return 0;
1482 }
1483 read_unlock(&mrt_lock);
1484 return -EADDRNOTAVAIL;
1485 default:
1486 return -ENOIOCTLCMD;
1487 }
1488 }
1489
1490
1491 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1492 {
1493 IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1494 IPSTATS_MIB_OUTFORWDATAGRAMS);
1495 return dst_output(skb);
1496 }
1497
1498 /*
1499 * Processing handlers for ip6mr_forward
1500 */
1501
1502 static int ip6mr_forward2(struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1503 {
1504 struct ipv6hdr *ipv6h;
1505 struct net *net = mfc6_net(c);
1506 struct mif_device *vif = &net->ipv6.vif6_table[vifi];
1507 struct net_device *dev;
1508 struct dst_entry *dst;
1509 struct flowi fl;
1510
1511 if (vif->dev == NULL)
1512 goto out_free;
1513
1514 #ifdef CONFIG_IPV6_PIMSM_V2
1515 if (vif->flags & MIFF_REGISTER) {
1516 vif->pkt_out++;
1517 vif->bytes_out += skb->len;
1518 vif->dev->stats.tx_bytes += skb->len;
1519 vif->dev->stats.tx_packets++;
1520 ip6mr_cache_report(net, skb, vifi, MRT6MSG_WHOLEPKT);
1521 goto out_free;
1522 }
1523 #endif
1524
1525 ipv6h = ipv6_hdr(skb);
1526
1527 fl = (struct flowi) {
1528 .oif = vif->link,
1529 .nl_u = { .ip6_u =
1530 { .daddr = ipv6h->daddr, }
1531 }
1532 };
1533
1534 dst = ip6_route_output(net, NULL, &fl);
1535 if (!dst)
1536 goto out_free;
1537
1538 skb_dst_drop(skb);
1539 skb_dst_set(skb, dst);
1540
1541 /*
1542 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1543 * not only before forwarding, but after forwarding on all output
1544 * interfaces. It is clear, if mrouter runs a multicasting
1545 * program, it should receive packets not depending to what interface
1546 * program is joined.
1547 * If we will not make it, the program will have to join on all
1548 * interfaces. On the other hand, multihoming host (or router, but
1549 * not mrouter) cannot join to more than one interface - it will
1550 * result in receiving multiple packets.
1551 */
1552 dev = vif->dev;
1553 skb->dev = dev;
1554 vif->pkt_out++;
1555 vif->bytes_out += skb->len;
1556
1557 /* We are about to write */
1558 /* XXX: extension headers? */
1559 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1560 goto out_free;
1561
1562 ipv6h = ipv6_hdr(skb);
1563 ipv6h->hop_limit--;
1564
1565 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1566
1567 return NF_HOOK(PF_INET6, NF_INET_FORWARD, skb, skb->dev, dev,
1568 ip6mr_forward2_finish);
1569
1570 out_free:
1571 kfree_skb(skb);
1572 return 0;
1573 }
1574
1575 static int ip6mr_find_vif(struct net_device *dev)
1576 {
1577 struct net *net = dev_net(dev);
1578 int ct;
1579 for (ct = net->ipv6.maxvif - 1; ct >= 0; ct--) {
1580 if (net->ipv6.vif6_table[ct].dev == dev)
1581 break;
1582 }
1583 return ct;
1584 }
1585
1586 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache)
1587 {
1588 int psend = -1;
1589 int vif, ct;
1590 struct net *net = mfc6_net(cache);
1591
1592 vif = cache->mf6c_parent;
1593 cache->mfc_un.res.pkt++;
1594 cache->mfc_un.res.bytes += skb->len;
1595
1596 /*
1597 * Wrong interface: drop packet and (maybe) send PIM assert.
1598 */
1599 if (net->ipv6.vif6_table[vif].dev != skb->dev) {
1600 int true_vifi;
1601
1602 cache->mfc_un.res.wrong_if++;
1603 true_vifi = ip6mr_find_vif(skb->dev);
1604
1605 if (true_vifi >= 0 && net->ipv6.mroute_do_assert &&
1606 /* pimsm uses asserts, when switching from RPT to SPT,
1607 so that we cannot check that packet arrived on an oif.
1608 It is bad, but otherwise we would need to move pretty
1609 large chunk of pimd to kernel. Ough... --ANK
1610 */
1611 (net->ipv6.mroute_do_pim ||
1612 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1613 time_after(jiffies,
1614 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1615 cache->mfc_un.res.last_assert = jiffies;
1616 ip6mr_cache_report(net, skb, true_vifi, MRT6MSG_WRONGMIF);
1617 }
1618 goto dont_forward;
1619 }
1620
1621 net->ipv6.vif6_table[vif].pkt_in++;
1622 net->ipv6.vif6_table[vif].bytes_in += skb->len;
1623
1624 /*
1625 * Forward the frame
1626 */
1627 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
1628 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
1629 if (psend != -1) {
1630 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1631 if (skb2)
1632 ip6mr_forward2(skb2, cache, psend);
1633 }
1634 psend = ct;
1635 }
1636 }
1637 if (psend != -1) {
1638 ip6mr_forward2(skb, cache, psend);
1639 return 0;
1640 }
1641
1642 dont_forward:
1643 kfree_skb(skb);
1644 return 0;
1645 }
1646
1647
1648 /*
1649 * Multicast packets for forwarding arrive here
1650 */
1651
1652 int ip6_mr_input(struct sk_buff *skb)
1653 {
1654 struct mfc6_cache *cache;
1655 struct net *net = dev_net(skb->dev);
1656
1657 read_lock(&mrt_lock);
1658 cache = ip6mr_cache_find(net,
1659 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
1660
1661 /*
1662 * No usable cache entry
1663 */
1664 if (cache == NULL) {
1665 int vif;
1666
1667 vif = ip6mr_find_vif(skb->dev);
1668 if (vif >= 0) {
1669 int err = ip6mr_cache_unresolved(net, vif, skb);
1670 read_unlock(&mrt_lock);
1671
1672 return err;
1673 }
1674 read_unlock(&mrt_lock);
1675 kfree_skb(skb);
1676 return -ENODEV;
1677 }
1678
1679 ip6_mr_forward(skb, cache);
1680
1681 read_unlock(&mrt_lock);
1682
1683 return 0;
1684 }
1685
1686
1687 static int
1688 ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm)
1689 {
1690 int ct;
1691 struct rtnexthop *nhp;
1692 struct net *net = mfc6_net(c);
1693 struct net_device *dev = net->ipv6.vif6_table[c->mf6c_parent].dev;
1694 u8 *b = skb_tail_pointer(skb);
1695 struct rtattr *mp_head;
1696
1697 if (dev)
1698 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1699
1700 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1701
1702 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1703 if (c->mfc_un.res.ttls[ct] < 255) {
1704 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1705 goto rtattr_failure;
1706 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1707 nhp->rtnh_flags = 0;
1708 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1709 nhp->rtnh_ifindex = net->ipv6.vif6_table[ct].dev->ifindex;
1710 nhp->rtnh_len = sizeof(*nhp);
1711 }
1712 }
1713 mp_head->rta_type = RTA_MULTIPATH;
1714 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1715 rtm->rtm_type = RTN_MULTICAST;
1716 return 1;
1717
1718 rtattr_failure:
1719 nlmsg_trim(skb, b);
1720 return -EMSGSIZE;
1721 }
1722
1723 int ip6mr_get_route(struct net *net,
1724 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1725 {
1726 int err;
1727 struct mfc6_cache *cache;
1728 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
1729
1730 read_lock(&mrt_lock);
1731 cache = ip6mr_cache_find(net, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
1732
1733 if (!cache) {
1734 struct sk_buff *skb2;
1735 struct ipv6hdr *iph;
1736 struct net_device *dev;
1737 int vif;
1738
1739 if (nowait) {
1740 read_unlock(&mrt_lock);
1741 return -EAGAIN;
1742 }
1743
1744 dev = skb->dev;
1745 if (dev == NULL || (vif = ip6mr_find_vif(dev)) < 0) {
1746 read_unlock(&mrt_lock);
1747 return -ENODEV;
1748 }
1749
1750 /* really correct? */
1751 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
1752 if (!skb2) {
1753 read_unlock(&mrt_lock);
1754 return -ENOMEM;
1755 }
1756
1757 skb_reset_transport_header(skb2);
1758
1759 skb_put(skb2, sizeof(struct ipv6hdr));
1760 skb_reset_network_header(skb2);
1761
1762 iph = ipv6_hdr(skb2);
1763 iph->version = 0;
1764 iph->priority = 0;
1765 iph->flow_lbl[0] = 0;
1766 iph->flow_lbl[1] = 0;
1767 iph->flow_lbl[2] = 0;
1768 iph->payload_len = 0;
1769 iph->nexthdr = IPPROTO_NONE;
1770 iph->hop_limit = 0;
1771 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
1772 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
1773
1774 err = ip6mr_cache_unresolved(net, vif, skb2);
1775 read_unlock(&mrt_lock);
1776
1777 return err;
1778 }
1779
1780 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1781 cache->mfc_flags |= MFC_NOTIFY;
1782
1783 err = ip6mr_fill_mroute(skb, cache, rtm);
1784 read_unlock(&mrt_lock);
1785 return err;
1786 }
1787
connection oriented routing - ARCHIVE NO UPDATES HERE