projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
hwmon: (max6650) Add support for alarms
[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 <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 dst_release(skb->dst);
402 reg_dev->stats.rx_bytes += skb->len;
403 reg_dev->stats.rx_packets++;
404 skb->dst = NULL;
405 nf_reset(skb);
406 netif_rx(skb);
407 dev_put(reg_dev);
408 return 0;
409 drop:
410 kfree_skb(skb);
411 return 0;
412 }
413
414 static struct inet6_protocol pim6_protocol = {
415 .handler = pim6_rcv,
416 };
417
418 /* Service routines creating virtual interfaces: PIMREG */
419
420 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
421 {
422 struct net *net = dev_net(dev);
423
424 read_lock(&mrt_lock);
425 dev->stats.tx_bytes += skb->len;
426 dev->stats.tx_packets++;
427 ip6mr_cache_report(net, skb, net->ipv6.mroute_reg_vif_num,
428 MRT6MSG_WHOLEPKT);
429 read_unlock(&mrt_lock);
430 kfree_skb(skb);
431 return 0;
432 }
433
434 static const struct net_device_ops reg_vif_netdev_ops = {
435 .ndo_start_xmit = reg_vif_xmit,
436 };
437
438 static void reg_vif_setup(struct net_device *dev)
439 {
440 dev->type = ARPHRD_PIMREG;
441 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
442 dev->flags = IFF_NOARP;
443 dev->netdev_ops = &reg_vif_netdev_ops;
444 dev->destructor = free_netdev;
445 }
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 = dst_clone(pkt->dst);
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 return 0;
1082 reg_notif_fail:
1083 del_timer(&ipmr_expire_timer);
1084 unregister_pernet_subsys(&ip6mr_net_ops);
1085 reg_pernet_fail:
1086 kmem_cache_destroy(mrt_cachep);
1087 return err;
1088 }
1089
1090 void ip6_mr_cleanup(void)
1091 {
1092 unregister_netdevice_notifier(&ip6_mr_notifier);
1093 del_timer(&ipmr_expire_timer);
1094 unregister_pernet_subsys(&ip6mr_net_ops);
1095 kmem_cache_destroy(mrt_cachep);
1096 }
1097
1098 static int ip6mr_mfc_add(struct net *net, struct mf6cctl *mfc, int mrtsock)
1099 {
1100 int line;
1101 struct mfc6_cache *uc, *c, **cp;
1102 unsigned char ttls[MAXMIFS];
1103 int i;
1104
1105 memset(ttls, 255, MAXMIFS);
1106 for (i = 0; i < MAXMIFS; i++) {
1107 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1108 ttls[i] = 1;
1109
1110 }
1111
1112 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1113
1114 for (cp = &net->ipv6.mfc6_cache_array[line];
1115 (c = *cp) != NULL; cp = &c->next) {
1116 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1117 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr))
1118 break;
1119 }
1120
1121 if (c != NULL) {
1122 write_lock_bh(&mrt_lock);
1123 c->mf6c_parent = mfc->mf6cc_parent;
1124 ip6mr_update_thresholds(c, ttls);
1125 if (!mrtsock)
1126 c->mfc_flags |= MFC_STATIC;
1127 write_unlock_bh(&mrt_lock);
1128 return 0;
1129 }
1130
1131 if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1132 return -EINVAL;
1133
1134 c = ip6mr_cache_alloc(net);
1135 if (c == NULL)
1136 return -ENOMEM;
1137
1138 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1139 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1140 c->mf6c_parent = mfc->mf6cc_parent;
1141 ip6mr_update_thresholds(c, ttls);
1142 if (!mrtsock)
1143 c->mfc_flags |= MFC_STATIC;
1144
1145 write_lock_bh(&mrt_lock);
1146 c->next = net->ipv6.mfc6_cache_array[line];
1147 net->ipv6.mfc6_cache_array[line] = c;
1148 write_unlock_bh(&mrt_lock);
1149
1150 /*
1151 * Check to see if we resolved a queued list. If so we
1152 * need to send on the frames and tidy up.
1153 */
1154 spin_lock_bh(&mfc_unres_lock);
1155 for (cp = &mfc_unres_queue; (uc = *cp) != NULL;
1156 cp = &uc->next) {
1157 if (net_eq(mfc6_net(uc), net) &&
1158 ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1159 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1160 *cp = uc->next;
1161 atomic_dec(&net->ipv6.cache_resolve_queue_len);
1162 break;
1163 }
1164 }
1165 if (mfc_unres_queue == NULL)
1166 del_timer(&ipmr_expire_timer);
1167 spin_unlock_bh(&mfc_unres_lock);
1168
1169 if (uc) {
1170 ip6mr_cache_resolve(uc, c);
1171 ip6mr_cache_free(uc);
1172 }
1173 return 0;
1174 }
1175
1176 /*
1177 * Close the multicast socket, and clear the vif tables etc
1178 */
1179
1180 static void mroute_clean_tables(struct net *net)
1181 {
1182 int i;
1183
1184 /*
1185 * Shut down all active vif entries
1186 */
1187 for (i = 0; i < net->ipv6.maxvif; i++) {
1188 if (!(net->ipv6.vif6_table[i].flags & VIFF_STATIC))
1189 mif6_delete(net, i);
1190 }
1191
1192 /*
1193 * Wipe the cache
1194 */
1195 for (i = 0; i < MFC6_LINES; i++) {
1196 struct mfc6_cache *c, **cp;
1197
1198 cp = &net->ipv6.mfc6_cache_array[i];
1199 while ((c = *cp) != NULL) {
1200 if (c->mfc_flags & MFC_STATIC) {
1201 cp = &c->next;
1202 continue;
1203 }
1204 write_lock_bh(&mrt_lock);
1205 *cp = c->next;
1206 write_unlock_bh(&mrt_lock);
1207
1208 ip6mr_cache_free(c);
1209 }
1210 }
1211
1212 if (atomic_read(&net->ipv6.cache_resolve_queue_len) != 0) {
1213 struct mfc6_cache *c, **cp;
1214
1215 spin_lock_bh(&mfc_unres_lock);
1216 cp = &mfc_unres_queue;
1217 while ((c = *cp) != NULL) {
1218 if (!net_eq(mfc6_net(c), net)) {
1219 cp = &c->next;
1220 continue;
1221 }
1222 *cp = c->next;
1223 ip6mr_destroy_unres(c);
1224 }
1225 spin_unlock_bh(&mfc_unres_lock);
1226 }
1227 }
1228
1229 static int ip6mr_sk_init(struct sock *sk)
1230 {
1231 int err = 0;
1232 struct net *net = sock_net(sk);
1233
1234 rtnl_lock();
1235 write_lock_bh(&mrt_lock);
1236 if (likely(net->ipv6.mroute6_sk == NULL)) {
1237 net->ipv6.mroute6_sk = sk;
1238 net->ipv6.devconf_all->mc_forwarding++;
1239 }
1240 else
1241 err = -EADDRINUSE;
1242 write_unlock_bh(&mrt_lock);
1243
1244 rtnl_unlock();
1245
1246 return err;
1247 }
1248
1249 int ip6mr_sk_done(struct sock *sk)
1250 {
1251 int err = 0;
1252 struct net *net = sock_net(sk);
1253
1254 rtnl_lock();
1255 if (sk == net->ipv6.mroute6_sk) {
1256 write_lock_bh(&mrt_lock);
1257 net->ipv6.mroute6_sk = NULL;
1258 net->ipv6.devconf_all->mc_forwarding--;
1259 write_unlock_bh(&mrt_lock);
1260
1261 mroute_clean_tables(net);
1262 } else
1263 err = -EACCES;
1264 rtnl_unlock();
1265
1266 return err;
1267 }
1268
1269 /*
1270 * Socket options and virtual interface manipulation. The whole
1271 * virtual interface system is a complete heap, but unfortunately
1272 * that's how BSD mrouted happens to think. Maybe one day with a proper
1273 * MOSPF/PIM router set up we can clean this up.
1274 */
1275
1276 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
1277 {
1278 int ret;
1279 struct mif6ctl vif;
1280 struct mf6cctl mfc;
1281 mifi_t mifi;
1282 struct net *net = sock_net(sk);
1283
1284 if (optname != MRT6_INIT) {
1285 if (sk != net->ipv6.mroute6_sk && !capable(CAP_NET_ADMIN))
1286 return -EACCES;
1287 }
1288
1289 switch (optname) {
1290 case MRT6_INIT:
1291 if (sk->sk_type != SOCK_RAW ||
1292 inet_sk(sk)->num != IPPROTO_ICMPV6)
1293 return -EOPNOTSUPP;
1294 if (optlen < sizeof(int))
1295 return -EINVAL;
1296
1297 return ip6mr_sk_init(sk);
1298
1299 case MRT6_DONE:
1300 return ip6mr_sk_done(sk);
1301
1302 case MRT6_ADD_MIF:
1303 if (optlen < sizeof(vif))
1304 return -EINVAL;
1305 if (copy_from_user(&vif, optval, sizeof(vif)))
1306 return -EFAULT;
1307 if (vif.mif6c_mifi >= MAXMIFS)
1308 return -ENFILE;
1309 rtnl_lock();
1310 ret = mif6_add(net, &vif, sk == net->ipv6.mroute6_sk);
1311 rtnl_unlock();
1312 return ret;
1313
1314 case MRT6_DEL_MIF:
1315 if (optlen < sizeof(mifi_t))
1316 return -EINVAL;
1317 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1318 return -EFAULT;
1319 rtnl_lock();
1320 ret = mif6_delete(net, mifi);
1321 rtnl_unlock();
1322 return ret;
1323
1324 /*
1325 * Manipulate the forwarding caches. These live
1326 * in a sort of kernel/user symbiosis.
1327 */
1328 case MRT6_ADD_MFC:
1329 case MRT6_DEL_MFC:
1330 if (optlen < sizeof(mfc))
1331 return -EINVAL;
1332 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1333 return -EFAULT;
1334 rtnl_lock();
1335 if (optname == MRT6_DEL_MFC)
1336 ret = ip6mr_mfc_delete(net, &mfc);
1337 else
1338 ret = ip6mr_mfc_add(net, &mfc,
1339 sk == net->ipv6.mroute6_sk);
1340 rtnl_unlock();
1341 return ret;
1342
1343 /*
1344 * Control PIM assert (to activate pim will activate assert)
1345 */
1346 case MRT6_ASSERT:
1347 {
1348 int v;
1349 if (get_user(v, (int __user *)optval))
1350 return -EFAULT;
1351 net->ipv6.mroute_do_assert = !!v;
1352 return 0;
1353 }
1354
1355 #ifdef CONFIG_IPV6_PIMSM_V2
1356 case MRT6_PIM:
1357 {
1358 int v;
1359 if (get_user(v, (int __user *)optval))
1360 return -EFAULT;
1361 v = !!v;
1362 rtnl_lock();
1363 ret = 0;
1364 if (v != net->ipv6.mroute_do_pim) {
1365 net->ipv6.mroute_do_pim = v;
1366 net->ipv6.mroute_do_assert = v;
1367 if (net->ipv6.mroute_do_pim)
1368 ret = inet6_add_protocol(&pim6_protocol,
1369 IPPROTO_PIM);
1370 else
1371 ret = inet6_del_protocol(&pim6_protocol,
1372 IPPROTO_PIM);
1373 if (ret < 0)
1374 ret = -EAGAIN;
1375 }
1376 rtnl_unlock();
1377 return ret;
1378 }
1379
1380 #endif
1381 /*
1382 * Spurious command, or MRT6_VERSION which you cannot
1383 * set.
1384 */
1385 default:
1386 return -ENOPROTOOPT;
1387 }
1388 }
1389
1390 /*
1391 * Getsock opt support for the multicast routing system.
1392 */
1393
1394 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1395 int __user *optlen)
1396 {
1397 int olr;
1398 int val;
1399 struct net *net = sock_net(sk);
1400
1401 switch (optname) {
1402 case MRT6_VERSION:
1403 val = 0x0305;
1404 break;
1405 #ifdef CONFIG_IPV6_PIMSM_V2
1406 case MRT6_PIM:
1407 val = net->ipv6.mroute_do_pim;
1408 break;
1409 #endif
1410 case MRT6_ASSERT:
1411 val = net->ipv6.mroute_do_assert;
1412 break;
1413 default:
1414 return -ENOPROTOOPT;
1415 }
1416
1417 if (get_user(olr, optlen))
1418 return -EFAULT;
1419
1420 olr = min_t(int, olr, sizeof(int));
1421 if (olr < 0)
1422 return -EINVAL;
1423
1424 if (put_user(olr, optlen))
1425 return -EFAULT;
1426 if (copy_to_user(optval, &val, olr))
1427 return -EFAULT;
1428 return 0;
1429 }
1430
1431 /*
1432 * The IP multicast ioctl support routines.
1433 */
1434
1435 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1436 {
1437 struct sioc_sg_req6 sr;
1438 struct sioc_mif_req6 vr;
1439 struct mif_device *vif;
1440 struct mfc6_cache *c;
1441 struct net *net = sock_net(sk);
1442
1443 switch (cmd) {
1444 case SIOCGETMIFCNT_IN6:
1445 if (copy_from_user(&vr, arg, sizeof(vr)))
1446 return -EFAULT;
1447 if (vr.mifi >= net->ipv6.maxvif)
1448 return -EINVAL;
1449 read_lock(&mrt_lock);
1450 vif = &net->ipv6.vif6_table[vr.mifi];
1451 if (MIF_EXISTS(net, vr.mifi)) {
1452 vr.icount = vif->pkt_in;
1453 vr.ocount = vif->pkt_out;
1454 vr.ibytes = vif->bytes_in;
1455 vr.obytes = vif->bytes_out;
1456 read_unlock(&mrt_lock);
1457
1458 if (copy_to_user(arg, &vr, sizeof(vr)))
1459 return -EFAULT;
1460 return 0;
1461 }
1462 read_unlock(&mrt_lock);
1463 return -EADDRNOTAVAIL;
1464 case SIOCGETSGCNT_IN6:
1465 if (copy_from_user(&sr, arg, sizeof(sr)))
1466 return -EFAULT;
1467
1468 read_lock(&mrt_lock);
1469 c = ip6mr_cache_find(net, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1470 if (c) {
1471 sr.pktcnt = c->mfc_un.res.pkt;
1472 sr.bytecnt = c->mfc_un.res.bytes;
1473 sr.wrong_if = c->mfc_un.res.wrong_if;
1474 read_unlock(&mrt_lock);
1475
1476 if (copy_to_user(arg, &sr, sizeof(sr)))
1477 return -EFAULT;
1478 return 0;
1479 }
1480 read_unlock(&mrt_lock);
1481 return -EADDRNOTAVAIL;
1482 default:
1483 return -ENOIOCTLCMD;
1484 }
1485 }
1486
1487
1488 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1489 {
1490 IP6_INC_STATS_BH(dev_net(skb->dst->dev), ip6_dst_idev(skb->dst),
1491 IPSTATS_MIB_OUTFORWDATAGRAMS);
1492 return dst_output(skb);
1493 }
1494
1495 /*
1496 * Processing handlers for ip6mr_forward
1497 */
1498
1499 static int ip6mr_forward2(struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1500 {
1501 struct ipv6hdr *ipv6h;
1502 struct net *net = mfc6_net(c);
1503 struct mif_device *vif = &net->ipv6.vif6_table[vifi];
1504 struct net_device *dev;
1505 struct dst_entry *dst;
1506 struct flowi fl;
1507
1508 if (vif->dev == NULL)
1509 goto out_free;
1510
1511 #ifdef CONFIG_IPV6_PIMSM_V2
1512 if (vif->flags & MIFF_REGISTER) {
1513 vif->pkt_out++;
1514 vif->bytes_out += skb->len;
1515 vif->dev->stats.tx_bytes += skb->len;
1516 vif->dev->stats.tx_packets++;
1517 ip6mr_cache_report(net, skb, vifi, MRT6MSG_WHOLEPKT);
1518 goto out_free;
1519 }
1520 #endif
1521
1522 ipv6h = ipv6_hdr(skb);
1523
1524 fl = (struct flowi) {
1525 .oif = vif->link,
1526 .nl_u = { .ip6_u =
1527 { .daddr = ipv6h->daddr, }
1528 }
1529 };
1530
1531 dst = ip6_route_output(net, NULL, &fl);
1532 if (!dst)
1533 goto out_free;
1534
1535 dst_release(skb->dst);
1536 skb->dst = dst;
1537
1538 /*
1539 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1540 * not only before forwarding, but after forwarding on all output
1541 * interfaces. It is clear, if mrouter runs a multicasting
1542 * program, it should receive packets not depending to what interface
1543 * program is joined.
1544 * If we will not make it, the program will have to join on all
1545 * interfaces. On the other hand, multihoming host (or router, but
1546 * not mrouter) cannot join to more than one interface - it will
1547 * result in receiving multiple packets.
1548 */
1549 dev = vif->dev;
1550 skb->dev = dev;
1551 vif->pkt_out++;
1552 vif->bytes_out += skb->len;
1553
1554 /* We are about to write */
1555 /* XXX: extension headers? */
1556 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1557 goto out_free;
1558
1559 ipv6h = ipv6_hdr(skb);
1560 ipv6h->hop_limit--;
1561
1562 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1563
1564 return NF_HOOK(PF_INET6, NF_INET_FORWARD, skb, skb->dev, dev,
1565 ip6mr_forward2_finish);
1566
1567 out_free:
1568 kfree_skb(skb);
1569 return 0;
1570 }
1571
1572 static int ip6mr_find_vif(struct net_device *dev)
1573 {
1574 struct net *net = dev_net(dev);
1575 int ct;
1576 for (ct = net->ipv6.maxvif - 1; ct >= 0; ct--) {
1577 if (net->ipv6.vif6_table[ct].dev == dev)
1578 break;
1579 }
1580 return ct;
1581 }
1582
1583 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache)
1584 {
1585 int psend = -1;
1586 int vif, ct;
1587 struct net *net = mfc6_net(cache);
1588
1589 vif = cache->mf6c_parent;
1590 cache->mfc_un.res.pkt++;
1591 cache->mfc_un.res.bytes += skb->len;
1592
1593 /*
1594 * Wrong interface: drop packet and (maybe) send PIM assert.
1595 */
1596 if (net->ipv6.vif6_table[vif].dev != skb->dev) {
1597 int true_vifi;
1598
1599 cache->mfc_un.res.wrong_if++;
1600 true_vifi = ip6mr_find_vif(skb->dev);
1601
1602 if (true_vifi >= 0 && net->ipv6.mroute_do_assert &&
1603 /* pimsm uses asserts, when switching from RPT to SPT,
1604 so that we cannot check that packet arrived on an oif.
1605 It is bad, but otherwise we would need to move pretty
1606 large chunk of pimd to kernel. Ough... --ANK
1607 */
1608 (net->ipv6.mroute_do_pim ||
1609 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1610 time_after(jiffies,
1611 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1612 cache->mfc_un.res.last_assert = jiffies;
1613 ip6mr_cache_report(net, skb, true_vifi, MRT6MSG_WRONGMIF);
1614 }
1615 goto dont_forward;
1616 }
1617
1618 net->ipv6.vif6_table[vif].pkt_in++;
1619 net->ipv6.vif6_table[vif].bytes_in += skb->len;
1620
1621 /*
1622 * Forward the frame
1623 */
1624 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
1625 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
1626 if (psend != -1) {
1627 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1628 if (skb2)
1629 ip6mr_forward2(skb2, cache, psend);
1630 }
1631 psend = ct;
1632 }
1633 }
1634 if (psend != -1) {
1635 ip6mr_forward2(skb, cache, psend);
1636 return 0;
1637 }
1638
1639 dont_forward:
1640 kfree_skb(skb);
1641 return 0;
1642 }
1643
1644
1645 /*
1646 * Multicast packets for forwarding arrive here
1647 */
1648
1649 int ip6_mr_input(struct sk_buff *skb)
1650 {
1651 struct mfc6_cache *cache;
1652 struct net *net = dev_net(skb->dev);
1653
1654 read_lock(&mrt_lock);
1655 cache = ip6mr_cache_find(net,
1656 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
1657
1658 /*
1659 * No usable cache entry
1660 */
1661 if (cache == NULL) {
1662 int vif;
1663
1664 vif = ip6mr_find_vif(skb->dev);
1665 if (vif >= 0) {
1666 int err = ip6mr_cache_unresolved(net, vif, skb);
1667 read_unlock(&mrt_lock);
1668
1669 return err;
1670 }
1671 read_unlock(&mrt_lock);
1672 kfree_skb(skb);
1673 return -ENODEV;
1674 }
1675
1676 ip6_mr_forward(skb, cache);
1677
1678 read_unlock(&mrt_lock);
1679
1680 return 0;
1681 }
1682
1683
1684 static int
1685 ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm)
1686 {
1687 int ct;
1688 struct rtnexthop *nhp;
1689 struct net *net = mfc6_net(c);
1690 struct net_device *dev = net->ipv6.vif6_table[c->mf6c_parent].dev;
1691 u8 *b = skb_tail_pointer(skb);
1692 struct rtattr *mp_head;
1693
1694 if (dev)
1695 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1696
1697 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1698
1699 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1700 if (c->mfc_un.res.ttls[ct] < 255) {
1701 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1702 goto rtattr_failure;
1703 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1704 nhp->rtnh_flags = 0;
1705 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1706 nhp->rtnh_ifindex = net->ipv6.vif6_table[ct].dev->ifindex;
1707 nhp->rtnh_len = sizeof(*nhp);
1708 }
1709 }
1710 mp_head->rta_type = RTA_MULTIPATH;
1711 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1712 rtm->rtm_type = RTN_MULTICAST;
1713 return 1;
1714
1715 rtattr_failure:
1716 nlmsg_trim(skb, b);
1717 return -EMSGSIZE;
1718 }
1719
1720 int ip6mr_get_route(struct net *net,
1721 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1722 {
1723 int err;
1724 struct mfc6_cache *cache;
1725 struct rt6_info *rt = (struct rt6_info *)skb->dst;
1726
1727 read_lock(&mrt_lock);
1728 cache = ip6mr_cache_find(net, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
1729
1730 if (!cache) {
1731 struct sk_buff *skb2;
1732 struct ipv6hdr *iph;
1733 struct net_device *dev;
1734 int vif;
1735
1736 if (nowait) {
1737 read_unlock(&mrt_lock);
1738 return -EAGAIN;
1739 }
1740
1741 dev = skb->dev;
1742 if (dev == NULL || (vif = ip6mr_find_vif(dev)) < 0) {
1743 read_unlock(&mrt_lock);
1744 return -ENODEV;
1745 }
1746
1747 /* really correct? */
1748 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
1749 if (!skb2) {
1750 read_unlock(&mrt_lock);
1751 return -ENOMEM;
1752 }
1753
1754 skb_reset_transport_header(skb2);
1755
1756 skb_put(skb2, sizeof(struct ipv6hdr));
1757 skb_reset_network_header(skb2);
1758
1759 iph = ipv6_hdr(skb2);
1760 iph->version = 0;
1761 iph->priority = 0;
1762 iph->flow_lbl[0] = 0;
1763 iph->flow_lbl[1] = 0;
1764 iph->flow_lbl[2] = 0;
1765 iph->payload_len = 0;
1766 iph->nexthdr = IPPROTO_NONE;
1767 iph->hop_limit = 0;
1768 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
1769 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
1770
1771 err = ip6mr_cache_unresolved(net, vif, skb2);
1772 read_unlock(&mrt_lock);
1773
1774 return err;
1775 }
1776
1777 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1778 cache->mfc_flags |= MFC_NOTIFY;
1779
1780 err = ip6mr_fill_mroute(skb, cache, rtm);
1781 read_unlock(&mrt_lock);
1782 return err;
1783 }
1784
Linux kernel - Deliverables
This page took 0.07292 seconds and 5 git commands to generate.