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