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#include <net/fib_rules.h> 46 47#include <net/ipv6.h> 48#include <net/ip6_route.h> 49#include <linux/mroute6.h> 50#include <linux/pim.h> 51#include <net/addrconf.h> 52#include <linux/netfilter_ipv6.h> 53#include <net/ip6_checksum.h> 54 55struct mr6_table { 56 struct list_head list; 57#ifdef CONFIG_NET_NS 58 struct net *net; 59#endif 60 u32 id; 61 struct sock *mroute6_sk; 62 struct timer_list ipmr_expire_timer; 63 struct list_head mfc6_unres_queue; 64 struct list_head mfc6_cache_array[MFC6_LINES]; 65 struct mif_device vif6_table[MAXMIFS]; 66 int maxvif; 67 atomic_t cache_resolve_queue_len; 68 int mroute_do_assert; 69 int mroute_do_pim; 70#ifdef CONFIG_IPV6_PIMSM_V2 71 int mroute_reg_vif_num; 72#endif 73}; 74 75struct ip6mr_rule { 76 struct fib_rule common; 77}; 78 79struct ip6mr_result { 80 struct mr6_table *mrt; 81}; 82 83/* Big lock, protecting vif table, mrt cache and mroute socket state. 84 Note that the changes are semaphored via rtnl_lock. 85 */ 86 87static DEFINE_RWLOCK(mrt_lock); 88 89/* 90 * Multicast router control variables 91 */ 92 93#define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL) 94 95/* Special spinlock for queue of unresolved entries */ 96static DEFINE_SPINLOCK(mfc_unres_lock); 97 98/* We return to original Alan's scheme. Hash table of resolved 99 entries is changed only in process context and protected 100 with weak lock mrt_lock. Queue of unresolved entries is protected 101 with strong spinlock mfc_unres_lock. 102 103 In this case data path is free of exclusive locks at all. 104 */ 105 106static struct kmem_cache *mrt_cachep __read_mostly; 107 108static struct mr6_table *ip6mr_new_table(struct net *net, u32 id); 109static void ip6mr_free_table(struct mr6_table *mrt); 110 111static int ip6_mr_forward(struct net *net, struct mr6_table *mrt, 112 struct sk_buff *skb, struct mfc6_cache *cache); 113static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt, 114 mifi_t mifi, int assert); 115static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb, 116 struct mfc6_cache *c, struct rtmsg *rtm); 117static int ip6mr_rtm_dumproute(struct sk_buff *skb, 118 struct netlink_callback *cb); 119static void mroute_clean_tables(struct mr6_table *mrt); 120static void ipmr_expire_process(unsigned long arg); 121 122#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES 123#define ip6mr_for_each_table(mrt, net) \ 124 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list) 125 126static struct mr6_table *ip6mr_get_table(struct net *net, u32 id) 127{ 128 struct mr6_table *mrt; 129 130 ip6mr_for_each_table(mrt, net) { 131 if (mrt->id == id) 132 return mrt; 133 } 134 return NULL; 135} 136 137static int ip6mr_fib_lookup(struct net *net, struct flowi *flp, 138 struct mr6_table **mrt) 139{ 140 struct ip6mr_result res; 141 struct fib_lookup_arg arg = { .result = &res, }; 142 int err; 143 144 err = fib_rules_lookup(net->ipv6.mr6_rules_ops, flp, 0, &arg); 145 if (err < 0) 146 return err; 147 *mrt = res.mrt; 148 return 0; 149} 150 151static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp, 152 int flags, struct fib_lookup_arg *arg) 153{ 154 struct ip6mr_result *res = arg->result; 155 struct mr6_table *mrt; 156 157 switch (rule->action) { 158 case FR_ACT_TO_TBL: 159 break; 160 case FR_ACT_UNREACHABLE: 161 return -ENETUNREACH; 162 case FR_ACT_PROHIBIT: 163 return -EACCES; 164 case FR_ACT_BLACKHOLE: 165 default: 166 return -EINVAL; 167 } 168 169 mrt = ip6mr_get_table(rule->fr_net, rule->table); 170 if (mrt == NULL) 171 return -EAGAIN; 172 res->mrt = mrt; 173 return 0; 174} 175 176static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags) 177{ 178 return 1; 179} 180 181static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = { 182 FRA_GENERIC_POLICY, 183}; 184 185static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb, 186 struct fib_rule_hdr *frh, struct nlattr **tb) 187{ 188 return 0; 189} 190 191static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh, 192 struct nlattr **tb) 193{ 194 return 1; 195} 196 197static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb, 198 struct fib_rule_hdr *frh) 199{ 200 frh->dst_len = 0; 201 frh->src_len = 0; 202 frh->tos = 0; 203 return 0; 204} 205 206static const struct fib_rules_ops __net_initdata ip6mr_rules_ops_template = { 207 .family = RTNL_FAMILY_IP6MR, 208 .rule_size = sizeof(struct ip6mr_rule), 209 .addr_size = sizeof(struct in6_addr), 210 .action = ip6mr_rule_action, 211 .match = ip6mr_rule_match, 212 .configure = ip6mr_rule_configure, 213 .compare = ip6mr_rule_compare, 214 .default_pref = fib_default_rule_pref, 215 .fill = ip6mr_rule_fill, 216 .nlgroup = RTNLGRP_IPV6_RULE, 217 .policy = ip6mr_rule_policy, 218 .owner = THIS_MODULE, 219}; 220 221static int __net_init ip6mr_rules_init(struct net *net) 222{ 223 struct fib_rules_ops *ops; 224 struct mr6_table *mrt; 225 int err; 226 227 ops = fib_rules_register(&ip6mr_rules_ops_template, net); 228 if (IS_ERR(ops)) 229 return PTR_ERR(ops); 230 231 INIT_LIST_HEAD(&net->ipv6.mr6_tables); 232 233 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT); 234 if (mrt == NULL) { 235 err = -ENOMEM; 236 goto err1; 237 } 238 239 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0); 240 if (err < 0) 241 goto err2; 242 243 net->ipv6.mr6_rules_ops = ops; 244 return 0; 245 246err2: 247 kfree(mrt); 248err1: 249 fib_rules_unregister(ops); 250 return err; 251} 252 253static void __net_exit ip6mr_rules_exit(struct net *net) 254{ 255 struct mr6_table *mrt, *next; 256 257 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) { 258 list_del(&mrt->list); 259 ip6mr_free_table(mrt); 260 } 261 fib_rules_unregister(net->ipv6.mr6_rules_ops); 262} 263#else 264#define ip6mr_for_each_table(mrt, net) \ 265 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL) 266 267static struct mr6_table *ip6mr_get_table(struct net *net, u32 id) 268{ 269 return net->ipv6.mrt6; 270} 271 272static int ip6mr_fib_lookup(struct net *net, struct flowi *flp, 273 struct mr6_table **mrt) 274{ 275 *mrt = net->ipv6.mrt6; 276 return 0; 277} 278 279static int __net_init ip6mr_rules_init(struct net *net) 280{ 281 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT); 282 return net->ipv6.mrt6 ? 0 : -ENOMEM; 283} 284 285static void __net_exit ip6mr_rules_exit(struct net *net) 286{ 287 ip6mr_free_table(net->ipv6.mrt6); 288} 289#endif 290 291static struct mr6_table *ip6mr_new_table(struct net *net, u32 id) 292{ 293 struct mr6_table *mrt; 294 unsigned int i; 295 296 mrt = ip6mr_get_table(net, id); 297 if (mrt != NULL) 298 return mrt; 299 300 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL); 301 if (mrt == NULL) 302 return NULL; 303 mrt->id = id; 304 write_pnet(&mrt->net, net); 305 306 /* Forwarding cache */ 307 for (i = 0; i < MFC6_LINES; i++) 308 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]); 309 310 INIT_LIST_HEAD(&mrt->mfc6_unres_queue); 311 312 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process, 313 (unsigned long)mrt); 314 315#ifdef CONFIG_IPV6_PIMSM_V2 316 mrt->mroute_reg_vif_num = -1; 317#endif 318#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES 319 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables); 320#endif 321 return mrt; 322} 323 324static void ip6mr_free_table(struct mr6_table *mrt) 325{ 326 del_timer(&mrt->ipmr_expire_timer); 327 mroute_clean_tables(mrt); 328 kfree(mrt); 329} 330 331#ifdef CONFIG_PROC_FS 332 333struct ipmr_mfc_iter { 334 struct seq_net_private p; 335 struct mr6_table *mrt; 336 struct list_head *cache; 337 int ct; 338}; 339 340 341static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net, 342 struct ipmr_mfc_iter *it, loff_t pos) 343{ 344 struct mr6_table *mrt = it->mrt; 345 struct mfc6_cache *mfc; 346 347 read_lock(&mrt_lock); 348 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) { 349 it->cache = &mrt->mfc6_cache_array[it->ct]; 350 list_for_each_entry(mfc, it->cache, list) 351 if (pos-- == 0) 352 return mfc; 353 } 354 read_unlock(&mrt_lock); 355 356 spin_lock_bh(&mfc_unres_lock); 357 it->cache = &mrt->mfc6_unres_queue; 358 list_for_each_entry(mfc, it->cache, list) 359 if (pos-- == 0) 360 return mfc; 361 spin_unlock_bh(&mfc_unres_lock); 362 363 it->cache = NULL; 364 return NULL; 365} 366 367/* 368 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif 369 */ 370 371struct ipmr_vif_iter { 372 struct seq_net_private p; 373 struct mr6_table *mrt; 374 int ct; 375}; 376 377static struct mif_device *ip6mr_vif_seq_idx(struct net *net, 378 struct ipmr_vif_iter *iter, 379 loff_t pos) 380{ 381 struct mr6_table *mrt = iter->mrt; 382 383 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) { 384 if (!MIF_EXISTS(mrt, iter->ct)) 385 continue; 386 if (pos-- == 0) 387 return &mrt->vif6_table[iter->ct]; 388 } 389 return NULL; 390} 391 392static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos) 393 __acquires(mrt_lock) 394{ 395 struct ipmr_vif_iter *iter = seq->private; 396 struct net *net = seq_file_net(seq); 397 struct mr6_table *mrt; 398 399 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT); 400 if (mrt == NULL) 401 return ERR_PTR(-ENOENT); 402 403 iter->mrt = mrt; 404 405 read_lock(&mrt_lock); 406 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1) 407 : SEQ_START_TOKEN; 408} 409 410static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos) 411{ 412 struct ipmr_vif_iter *iter = seq->private; 413 struct net *net = seq_file_net(seq); 414 struct mr6_table *mrt = iter->mrt; 415 416 ++*pos; 417 if (v == SEQ_START_TOKEN) 418 return ip6mr_vif_seq_idx(net, iter, 0); 419 420 while (++iter->ct < mrt->maxvif) { 421 if (!MIF_EXISTS(mrt, iter->ct)) 422 continue; 423 return &mrt->vif6_table[iter->ct]; 424 } 425 return NULL; 426} 427 428static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v) 429 __releases(mrt_lock) 430{ 431 read_unlock(&mrt_lock); 432} 433 434static int ip6mr_vif_seq_show(struct seq_file *seq, void *v) 435{ 436 struct ipmr_vif_iter *iter = seq->private; 437 struct mr6_table *mrt = iter->mrt; 438 439 if (v == SEQ_START_TOKEN) { 440 seq_puts(seq, 441 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n"); 442 } else { 443 const struct mif_device *vif = v; 444 const char *name = vif->dev ? vif->dev->name : "none"; 445 446 seq_printf(seq, 447 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n", 448 vif - mrt->vif6_table, 449 name, vif->bytes_in, vif->pkt_in, 450 vif->bytes_out, vif->pkt_out, 451 vif->flags); 452 } 453 return 0; 454} 455 456static const struct seq_operations ip6mr_vif_seq_ops = { 457 .start = ip6mr_vif_seq_start, 458 .next = ip6mr_vif_seq_next, 459 .stop = ip6mr_vif_seq_stop, 460 .show = ip6mr_vif_seq_show, 461}; 462 463static int ip6mr_vif_open(struct inode *inode, struct file *file) 464{ 465 return seq_open_net(inode, file, &ip6mr_vif_seq_ops, 466 sizeof(struct ipmr_vif_iter)); 467} 468 469static const struct file_operations ip6mr_vif_fops = { 470 .owner = THIS_MODULE, 471 .open = ip6mr_vif_open, 472 .read = seq_read, 473 .llseek = seq_lseek, 474 .release = seq_release_net, 475}; 476 477static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 478{ 479 struct ipmr_mfc_iter *it = seq->private; 480 struct net *net = seq_file_net(seq); 481 struct mr6_table *mrt; 482 483 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT); 484 if (mrt == NULL) 485 return ERR_PTR(-ENOENT); 486 487 it->mrt = mrt; 488 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1) 489 : SEQ_START_TOKEN; 490} 491 492static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 493{ 494 struct mfc6_cache *mfc = v; 495 struct ipmr_mfc_iter *it = seq->private; 496 struct net *net = seq_file_net(seq); 497 struct mr6_table *mrt = it->mrt; 498 499 ++*pos; 500 501 if (v == SEQ_START_TOKEN) 502 return ipmr_mfc_seq_idx(net, seq->private, 0); 503 504 if (mfc->list.next != it->cache) 505 return list_entry(mfc->list.next, struct mfc6_cache, list); 506 507 if (it->cache == &mrt->mfc6_unres_queue) 508 goto end_of_list; 509 510 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]); 511 512 while (++it->ct < MFC6_LINES) { 513 it->cache = &mrt->mfc6_cache_array[it->ct]; 514 if (list_empty(it->cache)) 515 continue; 516 return list_first_entry(it->cache, struct mfc6_cache, list); 517 } 518 519 /* exhausted cache_array, show unresolved */ 520 read_unlock(&mrt_lock); 521 it->cache = &mrt->mfc6_unres_queue; 522 it->ct = 0; 523 524 spin_lock_bh(&mfc_unres_lock); 525 if (!list_empty(it->cache)) 526 return list_first_entry(it->cache, struct mfc6_cache, list); 527 528 end_of_list: 529 spin_unlock_bh(&mfc_unres_lock); 530 it->cache = NULL; 531 532 return NULL; 533} 534 535static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v) 536{ 537 struct ipmr_mfc_iter *it = seq->private; 538 struct mr6_table *mrt = it->mrt; 539 540 if (it->cache == &mrt->mfc6_unres_queue) 541 spin_unlock_bh(&mfc_unres_lock); 542 else if (it->cache == mrt->mfc6_cache_array) 543 read_unlock(&mrt_lock); 544} 545 546static int ipmr_mfc_seq_show(struct seq_file *seq, void *v) 547{ 548 int n; 549 550 if (v == SEQ_START_TOKEN) { 551 seq_puts(seq, 552 "Group " 553 "Origin " 554 "Iif Pkts Bytes Wrong Oifs\n"); 555 } else { 556 const struct mfc6_cache *mfc = v; 557 const struct ipmr_mfc_iter *it = seq->private; 558 struct mr6_table *mrt = it->mrt; 559 560 seq_printf(seq, "%pI6 %pI6 %-3hd", 561 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin, 562 mfc->mf6c_parent); 563 564 if (it->cache != &mrt->mfc6_unres_queue) { 565 seq_printf(seq, " %8lu %8lu %8lu", 566 mfc->mfc_un.res.pkt, 567 mfc->mfc_un.res.bytes, 568 mfc->mfc_un.res.wrong_if); 569 for (n = mfc->mfc_un.res.minvif; 570 n < mfc->mfc_un.res.maxvif; n++) { 571 if (MIF_EXISTS(mrt, n) && 572 mfc->mfc_un.res.ttls[n] < 255) 573 seq_printf(seq, 574 " %2d:%-3d", 575 n, mfc->mfc_un.res.ttls[n]); 576 } 577 } else { 578 /* unresolved mfc_caches don't contain 579 * pkt, bytes and wrong_if values 580 */ 581 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul); 582 } 583 seq_putc(seq, '\n'); 584 } 585 return 0; 586} 587 588static const struct seq_operations ipmr_mfc_seq_ops = { 589 .start = ipmr_mfc_seq_start, 590 .next = ipmr_mfc_seq_next, 591 .stop = ipmr_mfc_seq_stop, 592 .show = ipmr_mfc_seq_show, 593}; 594 595static int ipmr_mfc_open(struct inode *inode, struct file *file) 596{ 597 return seq_open_net(inode, file, &ipmr_mfc_seq_ops, 598 sizeof(struct ipmr_mfc_iter)); 599} 600 601static const struct file_operations ip6mr_mfc_fops = { 602 .owner = THIS_MODULE, 603 .open = ipmr_mfc_open, 604 .read = seq_read, 605 .llseek = seq_lseek, 606 .release = seq_release_net, 607}; 608#endif 609 610#ifdef CONFIG_IPV6_PIMSM_V2 611 612static int pim6_rcv(struct sk_buff *skb) 613{ 614 struct pimreghdr *pim; 615 struct ipv6hdr *encap; 616 struct net_device *reg_dev = NULL; 617 struct net *net = dev_net(skb->dev); 618 struct mr6_table *mrt; 619 struct flowi fl = { 620 .iif = skb->dev->ifindex, 621 .mark = skb->mark, 622 }; 623 int reg_vif_num; 624 625 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap))) 626 goto drop; 627 628 pim = (struct pimreghdr *)skb_transport_header(skb); 629 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) || 630 (pim->flags & PIM_NULL_REGISTER) || 631 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr, 632 sizeof(*pim), IPPROTO_PIM, 633 csum_partial((void *)pim, sizeof(*pim), 0)) && 634 csum_fold(skb_checksum(skb, 0, skb->len, 0)))) 635 goto drop; 636 637 /* check if the inner packet is destined to mcast group */ 638 encap = (struct ipv6hdr *)(skb_transport_header(skb) + 639 sizeof(*pim)); 640 641 if (!ipv6_addr_is_multicast(&encap->daddr) || 642 encap->payload_len == 0 || 643 ntohs(encap->payload_len) + sizeof(*pim) > skb->len) 644 goto drop; 645 646 if (ip6mr_fib_lookup(net, &fl, &mrt) < 0) 647 goto drop; 648 reg_vif_num = mrt->mroute_reg_vif_num; 649 650 read_lock(&mrt_lock); 651 if (reg_vif_num >= 0) 652 reg_dev = mrt->vif6_table[reg_vif_num].dev; 653 if (reg_dev) 654 dev_hold(reg_dev); 655 read_unlock(&mrt_lock); 656 657 if (reg_dev == NULL) 658 goto drop; 659 660 skb->mac_header = skb->network_header; 661 skb_pull(skb, (u8 *)encap - skb->data); 662 skb_reset_network_header(skb); 663 skb->protocol = htons(ETH_P_IPV6); 664 skb->ip_summed = 0; 665 skb->pkt_type = PACKET_HOST; 666 667 skb_tunnel_rx(skb, reg_dev); 668 669 netif_rx(skb); 670 dev_put(reg_dev); 671 return 0; 672 drop: 673 kfree_skb(skb); 674 return 0; 675} 676 677static const struct inet6_protocol pim6_protocol = { 678 .handler = pim6_rcv, 679}; 680 681/* Service routines creating virtual interfaces: PIMREG */ 682 683static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, 684 struct net_device *dev) 685{ 686 struct net *net = dev_net(dev); 687 struct mr6_table *mrt; 688 struct flowi fl = { 689 .oif = dev->ifindex, 690 .iif = skb->skb_iif, 691 .mark = skb->mark, 692 }; 693 int err; 694 695 err = ip6mr_fib_lookup(net, &fl, &mrt); 696 if (err < 0) 697 return err; 698 699 read_lock(&mrt_lock); 700 dev->stats.tx_bytes += skb->len; 701 dev->stats.tx_packets++; 702 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT); 703 read_unlock(&mrt_lock); 704 kfree_skb(skb); 705 return NETDEV_TX_OK; 706} 707 708static const struct net_device_ops reg_vif_netdev_ops = { 709 .ndo_start_xmit = reg_vif_xmit, 710}; 711 712static void reg_vif_setup(struct net_device *dev) 713{ 714 dev->type = ARPHRD_PIMREG; 715 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8; 716 dev->flags = IFF_NOARP; 717 dev->netdev_ops = ®_vif_netdev_ops; 718 dev->destructor = free_netdev; 719 dev->features |= NETIF_F_NETNS_LOCAL; 720} 721 722static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt) 723{ 724 struct net_device *dev; 725 char name[IFNAMSIZ]; 726 727 if (mrt->id == RT6_TABLE_DFLT) 728 sprintf(name, "pim6reg"); 729 else 730 sprintf(name, "pim6reg%u", mrt->id); 731 732 dev = alloc_netdev(0, name, reg_vif_setup); 733 if (dev == NULL) 734 return NULL; 735 736 dev_net_set(dev, net); 737 738 if (register_netdevice(dev)) { 739 free_netdev(dev); 740 return NULL; 741 } 742 dev->iflink = 0; 743 744 if (dev_open(dev)) 745 goto failure; 746 747 dev_hold(dev); 748 return dev; 749 750failure: 751 /* allow the register to be completed before unregistering. */ 752 rtnl_unlock(); 753 rtnl_lock(); 754 755 unregister_netdevice(dev); 756 return NULL; 757} 758#endif 759 760/* 761 * Delete a VIF entry 762 */ 763 764static int mif6_delete(struct mr6_table *mrt, int vifi, struct list_head *head) 765{ 766 struct mif_device *v; 767 struct net_device *dev; 768 struct inet6_dev *in6_dev; 769 770 if (vifi < 0 || vifi >= mrt->maxvif) 771 return -EADDRNOTAVAIL; 772 773 v = &mrt->vif6_table[vifi]; 774 775 write_lock_bh(&mrt_lock); 776 dev = v->dev; 777 v->dev = NULL; 778 779 if (!dev) { 780 write_unlock_bh(&mrt_lock); 781 return -EADDRNOTAVAIL; 782 } 783 784#ifdef CONFIG_IPV6_PIMSM_V2 785 if (vifi == mrt->mroute_reg_vif_num) 786 mrt->mroute_reg_vif_num = -1; 787#endif 788 789 if (vifi + 1 == mrt->maxvif) { 790 int tmp; 791 for (tmp = vifi - 1; tmp >= 0; tmp--) { 792 if (MIF_EXISTS(mrt, tmp)) 793 break; 794 } 795 mrt->maxvif = tmp + 1; 796 } 797 798 write_unlock_bh(&mrt_lock); 799 800 dev_set_allmulti(dev, -1); 801 802 in6_dev = __in6_dev_get(dev); 803 if (in6_dev) 804 in6_dev->cnf.mc_forwarding--; 805 806 if (v->flags & MIFF_REGISTER) 807 unregister_netdevice_queue(dev, head); 808 809 dev_put(dev); 810 return 0; 811} 812 813static inline void ip6mr_cache_free(struct mfc6_cache *c) 814{ 815 kmem_cache_free(mrt_cachep, c); 816} 817 818/* Destroy an unresolved cache entry, killing queued skbs 819 and reporting error to netlink readers. 820 */ 821 822static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c) 823{ 824 struct net *net = read_pnet(&mrt->net); 825 struct sk_buff *skb; 826 827 atomic_dec(&mrt->cache_resolve_queue_len); 828 829 while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) { 830 if (ipv6_hdr(skb)->version == 0) { 831 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr)); 832 nlh->nlmsg_type = NLMSG_ERROR; 833 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 834 skb_trim(skb, nlh->nlmsg_len); 835 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT; 836 rtnl_unicast(skb, net, NETLINK_CB(skb).pid); 837 } else 838 kfree_skb(skb); 839 } 840 841 ip6mr_cache_free(c); 842} 843 844 845/* Timer process for all the unresolved queue. */ 846 847static void ipmr_do_expire_process(struct mr6_table *mrt) 848{ 849 unsigned long now = jiffies; 850 unsigned long expires = 10 * HZ; 851 struct mfc6_cache *c, *next; 852 853 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) { 854 if (time_after(c->mfc_un.unres.expires, now)) { 855 /* not yet... */ 856 unsigned long interval = c->mfc_un.unres.expires - now; 857 if (interval < expires) 858 expires = interval; 859 continue; 860 } 861 862 list_del(&c->list); 863 ip6mr_destroy_unres(mrt, c); 864 } 865 866 if (!list_empty(&mrt->mfc6_unres_queue)) 867 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires); 868} 869 870static void ipmr_expire_process(unsigned long arg) 871{ 872 struct mr6_table *mrt = (struct mr6_table *)arg; 873 874 if (!spin_trylock(&mfc_unres_lock)) { 875 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1); 876 return; 877 } 878 879 if (!list_empty(&mrt->mfc6_unres_queue)) 880 ipmr_do_expire_process(mrt); 881 882 spin_unlock(&mfc_unres_lock); 883} 884 885/* Fill oifs list. It is called under write locked mrt_lock. */ 886 887static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache, 888 unsigned char *ttls) 889{ 890 int vifi; 891 892 cache->mfc_un.res.minvif = MAXMIFS; 893 cache->mfc_un.res.maxvif = 0; 894 memset(cache->mfc_un.res.ttls, 255, MAXMIFS); 895 896 for (vifi = 0; vifi < mrt->maxvif; vifi++) { 897 if (MIF_EXISTS(mrt, vifi) && 898 ttls[vifi] && ttls[vifi] < 255) { 899 cache->mfc_un.res.ttls[vifi] = ttls[vifi]; 900 if (cache->mfc_un.res.minvif > vifi) 901 cache->mfc_un.res.minvif = vifi; 902 if (cache->mfc_un.res.maxvif <= vifi) 903 cache->mfc_un.res.maxvif = vifi + 1; 904 } 905 } 906} 907 908static int mif6_add(struct net *net, struct mr6_table *mrt, 909 struct mif6ctl *vifc, int mrtsock) 910{ 911 int vifi = vifc->mif6c_mifi; 912 struct mif_device *v = &mrt->vif6_table[vifi]; 913 struct net_device *dev; 914 struct inet6_dev *in6_dev; 915 int err; 916 917 /* Is vif busy ? */ 918 if (MIF_EXISTS(mrt, vifi)) 919 return -EADDRINUSE; 920 921 switch (vifc->mif6c_flags) { 922#ifdef CONFIG_IPV6_PIMSM_V2 923 case MIFF_REGISTER: 924 /* 925 * Special Purpose VIF in PIM 926 * All the packets will be sent to the daemon 927 */ 928 if (mrt->mroute_reg_vif_num >= 0) 929 return -EADDRINUSE; 930 dev = ip6mr_reg_vif(net, mrt); 931 if (!dev) 932 return -ENOBUFS; 933 err = dev_set_allmulti(dev, 1); 934 if (err) { 935 unregister_netdevice(dev); 936 dev_put(dev); 937 return err; 938 } 939 break; 940#endif 941 case 0: 942 dev = dev_get_by_index(net, vifc->mif6c_pifi); 943 if (!dev) 944 return -EADDRNOTAVAIL; 945 err = dev_set_allmulti(dev, 1); 946 if (err) { 947 dev_put(dev); 948 return err; 949 } 950 break; 951 default: 952 return -EINVAL; 953 } 954 955 in6_dev = __in6_dev_get(dev); 956 if (in6_dev) 957 in6_dev->cnf.mc_forwarding++; 958 959 /* 960 * Fill in the VIF structures 961 */ 962 v->rate_limit = vifc->vifc_rate_limit; 963 v->flags = vifc->mif6c_flags; 964 if (!mrtsock) 965 v->flags |= VIFF_STATIC; 966 v->threshold = vifc->vifc_threshold; 967 v->bytes_in = 0; 968 v->bytes_out = 0; 969 v->pkt_in = 0; 970 v->pkt_out = 0; 971 v->link = dev->ifindex; 972 if (v->flags & MIFF_REGISTER) 973 v->link = dev->iflink; 974 975 /* And finish update writing critical data */ 976 write_lock_bh(&mrt_lock); 977 v->dev = dev; 978#ifdef CONFIG_IPV6_PIMSM_V2 979 if (v->flags & MIFF_REGISTER) 980 mrt->mroute_reg_vif_num = vifi; 981#endif 982 if (vifi + 1 > mrt->maxvif) 983 mrt->maxvif = vifi + 1; 984 write_unlock_bh(&mrt_lock); 985 return 0; 986} 987 988static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt, 989 struct in6_addr *origin, 990 struct in6_addr *mcastgrp) 991{ 992 /* Bob modified start, 04/01/2013, ipv6ready logo */ 993 994 int line; 995 struct mfc6_cache *c=NULL; 996 997#if 0 //debug purpose 998 struct in6_addr *mc_addr; 999 char pkt_buff[1024]; 1000 1001 mc_addr = origin; 1002 sprintf(pkt_buff, "origin: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n", 1003 mc_addr->s6_addr[0], mc_addr->s6_addr[1], mc_addr->s6_addr[2], mc_addr->s6_addr[3], mc_addr->s6_addr[4], mc_addr->s6_addr[5], mc_addr->s6_addr[6], mc_addr->s6_addr[7], mc_addr->s6_addr[8], mc_addr->s6_addr[9], mc_addr->s6_addr[10], mc_addr->s6_addr[11], mc_addr->s6_addr[12], mc_addr->s6_addr[13], mc_addr->s6_addr[14], mc_addr->s6_addr[15]); 1004 printk(KERN_EMERG"%s\n", pkt_buff); 1005 1006 mc_addr = mcastgrp; 1007 sprintf(pkt_buff, "mcastgrp: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n", 1008 mc_addr->s6_addr[0], mc_addr->s6_addr[1], mc_addr->s6_addr[2], mc_addr->s6_addr[3], mc_addr->s6_addr[4], mc_addr->s6_addr[5], mc_addr->s6_addr[6], mc_addr->s6_addr[7], mc_addr->s6_addr[8], mc_addr->s6_addr[9], mc_addr->s6_addr[10], mc_addr->s6_addr[11], mc_addr->s6_addr[12], mc_addr->s6_addr[13], mc_addr->s6_addr[14], mc_addr->s6_addr[15]); 1009 printk(KERN_EMERG"%s\n", pkt_buff); 1010#endif 1011 1012 line = MFC6_HASH(mcastgrp, origin); 1013 1014 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) 1015 1016 { 1017 1018 1019#if 0 //debug purpose 1020 mc_addr = &c->mf6c_mcastgrp; 1021 sprintf(pkt_buff, "mcastgrp: %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x", 1022 mc_addr->s6_addr[0], mc_addr->s6_addr[1], mc_addr->s6_addr[2], mc_addr->s6_addr[3], 1023 mc_addr->s6_addr[4], mc_addr->s6_addr[5], mc_addr->s6_addr[6], mc_addr->s6_addr[7], 1024 mc_addr->s6_addr[8], mc_addr->s6_addr[9], mc_addr->s6_addr[10], mc_addr->s6_addr[11], 1025 mc_addr->s6_addr[12], mc_addr->s6_addr[13], mc_addr->s6_addr[14], mc_addr->s6_addr[15] ); 1026 printk(KERN_EMERG"%s\n", pkt_buff); 1027#endif 1028 1029 /* if (ipv6_addr_equal(&c->mf6c_origin, origin) && 1030 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) */ 1031 1032 if ( ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) 1033 return c; 1034 } 1035 1036 1037 return NULL; 1038 /* Bob modified end, 04/01/2013, ipv6ready logo */ 1039} 1040 1041/* 1042 * Allocate a multicast cache entry 1043 */ 1044static struct mfc6_cache *ip6mr_cache_alloc(void) 1045{ 1046 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL); 1047 if (c == NULL) 1048 return NULL; 1049 c->mfc_un.res.minvif = MAXMIFS; 1050 return c; 1051} 1052 1053static struct mfc6_cache *ip6mr_cache_alloc_unres(void) 1054{ 1055 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC); 1056 if (c == NULL) 1057 return NULL; 1058 skb_queue_head_init(&c->mfc_un.unres.unresolved); 1059 c->mfc_un.unres.expires = jiffies + 10 * HZ; 1060 return c; 1061} 1062 1063/* 1064 * A cache entry has gone into a resolved state from queued 1065 */ 1066 1067static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt, 1068 struct mfc6_cache *uc, struct mfc6_cache *c) 1069{ 1070 struct sk_buff *skb; 1071 1072 /* 1073 * Play the pending entries through our router 1074 */ 1075 1076 while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) { 1077 if (ipv6_hdr(skb)->version == 0) { 1078 int err; 1079 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr)); 1080 1081 if (__ip6mr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) { 1082 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh; 1083 } else { 1084 nlh->nlmsg_type = NLMSG_ERROR; 1085 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 1086 skb_trim(skb, nlh->nlmsg_len); 1087 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE; 1088 } 1089 err = rtnl_unicast(skb, net, NETLINK_CB(skb).pid); 1090 } else 1091 ip6_mr_forward(net, mrt, skb, c); 1092 } 1093} 1094 1095/* 1096 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd 1097 * expects the following bizarre scheme. 1098 * 1099 * Called under mrt_lock. 1100 */ 1101 1102static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt, 1103 mifi_t mifi, int assert) 1104{ 1105 struct sk_buff *skb; 1106 struct mrt6msg *msg; 1107 int ret; 1108 1109#ifdef CONFIG_IPV6_PIMSM_V2 1110 if (assert == MRT6MSG_WHOLEPKT) 1111 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt) 1112 +sizeof(*msg)); 1113 else 1114#endif 1115 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC); 1116 1117 if (!skb) 1118 return -ENOBUFS; 1119 1120 /* I suppose that internal messages 1121 * do not require checksums */ 1122 1123 skb->ip_summed = CHECKSUM_UNNECESSARY; 1124 1125#ifdef CONFIG_IPV6_PIMSM_V2 1126 if (assert == MRT6MSG_WHOLEPKT) { 1127 /* Ugly, but we have no choice with this interface. 1128 Duplicate old header, fix length etc. 1129 And all this only to mangle msg->im6_msgtype and 1130 to set msg->im6_mbz to "mbz" :-) 1131 */ 1132 skb_push(skb, -skb_network_offset(pkt)); 1133 1134 skb_push(skb, sizeof(*msg)); 1135 skb_reset_transport_header(skb); 1136 msg = (struct mrt6msg *)skb_transport_header(skb); 1137 msg->im6_mbz = 0; 1138 msg->im6_msgtype = MRT6MSG_WHOLEPKT; 1139 msg->im6_mif = mrt->mroute_reg_vif_num; 1140 msg->im6_pad = 0; 1141 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr); 1142 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr); 1143 1144 skb->ip_summed = CHECKSUM_UNNECESSARY; 1145 } else 1146#endif 1147 { 1148 /* 1149 * Copy the IP header 1150 */ 1151 1152 skb_put(skb, sizeof(struct ipv6hdr)); 1153 skb_reset_network_header(skb); 1154 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr)); 1155 1156 /* 1157 * Add our header 1158 */ 1159 skb_put(skb, sizeof(*msg)); 1160 skb_reset_transport_header(skb); 1161 msg = (struct mrt6msg *)skb_transport_header(skb); 1162 1163 msg->im6_mbz = 0; 1164 msg->im6_msgtype = assert; 1165 msg->im6_mif = mifi; 1166 msg->im6_pad = 0; 1167 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr); 1168 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr); 1169 1170 skb_dst_set(skb, dst_clone(skb_dst(pkt))); 1171 skb->ip_summed = CHECKSUM_UNNECESSARY; 1172 } 1173 1174 if (mrt->mroute6_sk == NULL) { 1175 kfree_skb(skb); 1176 return -EINVAL; 1177 } 1178 1179 /* 1180 * Deliver to user space multicast routing algorithms 1181 */ 1182 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb); 1183 if (ret < 0) { 1184 if (net_ratelimit()) 1185 printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n"); 1186 kfree_skb(skb); 1187 } 1188 1189 return ret; 1190} 1191 1192/* 1193 * Queue a packet for resolution. It gets locked cache entry! 1194 */ 1195 1196static int 1197ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb) 1198{ 1199 bool found = false; 1200 int err; 1201 struct mfc6_cache *c; 1202 1203 spin_lock_bh(&mfc_unres_lock); 1204 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) { 1205 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) && 1206 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) { 1207 found = true; 1208 break; 1209 } 1210 } 1211 1212 if (!found) { 1213 /* 1214 * Create a new entry if allowable 1215 */ 1216 1217 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 || 1218 (c = ip6mr_cache_alloc_unres()) == NULL) { 1219 spin_unlock_bh(&mfc_unres_lock); 1220 1221 kfree_skb(skb); 1222 return -ENOBUFS; 1223 } 1224 1225 /* 1226 * Fill in the new cache entry 1227 */ 1228 c->mf6c_parent = -1; 1229 c->mf6c_origin = ipv6_hdr(skb)->saddr; 1230 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr; 1231 1232 /* 1233 * Reflect first query at pim6sd 1234 */ 1235 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE); 1236 if (err < 0) { 1237 /* If the report failed throw the cache entry 1238 out - Brad Parker 1239 */ 1240 spin_unlock_bh(&mfc_unres_lock); 1241 1242 ip6mr_cache_free(c); 1243 kfree_skb(skb); 1244 return err; 1245 } 1246 1247 atomic_inc(&mrt->cache_resolve_queue_len); 1248 list_add(&c->list, &mrt->mfc6_unres_queue); 1249 1250 ipmr_do_expire_process(mrt); 1251 } 1252 1253 /* 1254 * See if we can append the packet 1255 */ 1256 if (c->mfc_un.unres.unresolved.qlen > 3) { 1257 kfree_skb(skb); 1258 err = -ENOBUFS; 1259 } else { 1260 skb_queue_tail(&c->mfc_un.unres.unresolved, skb); 1261 err = 0; 1262 } 1263 1264 spin_unlock_bh(&mfc_unres_lock); 1265 return err; 1266} 1267 1268/* 1269 * MFC6 cache manipulation by user space 1270 */ 1271 1272static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc) 1273{ 1274 int line; 1275 struct mfc6_cache *c, *next; 1276 1277 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr); 1278 1279 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) { 1280 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) && 1281 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) { 1282 write_lock_bh(&mrt_lock); 1283 list_del(&c->list); 1284 write_unlock_bh(&mrt_lock); 1285 1286 ip6mr_cache_free(c); 1287 return 0; 1288 } 1289 } 1290 return -ENOENT; 1291} 1292 1293static int ip6mr_device_event(struct notifier_block *this, 1294 unsigned long event, void *ptr) 1295{ 1296 struct net_device *dev = ptr; 1297 struct net *net = dev_net(dev); 1298 struct mr6_table *mrt; 1299 struct mif_device *v; 1300 int ct; 1301 LIST_HEAD(list); 1302 1303 if (event != NETDEV_UNREGISTER) 1304 return NOTIFY_DONE; 1305 1306 ip6mr_for_each_table(mrt, net) { 1307 v = &mrt->vif6_table[0]; 1308 for (ct = 0; ct < mrt->maxvif; ct++, v++) { 1309 if (v->dev == dev) 1310 mif6_delete(mrt, ct, &list); 1311 } 1312 } 1313 unregister_netdevice_many(&list); 1314 1315 return NOTIFY_DONE; 1316} 1317 1318static struct notifier_block ip6_mr_notifier = { 1319 .notifier_call = ip6mr_device_event 1320}; 1321 1322/* 1323 * Setup for IP multicast routing 1324 */ 1325 1326static int __net_init ip6mr_net_init(struct net *net) 1327{ 1328 int err; 1329 1330 err = ip6mr_rules_init(net); 1331 if (err < 0) 1332 goto fail; 1333 1334#ifdef CONFIG_PROC_FS 1335 err = -ENOMEM; 1336 if (!proc_net_fops_create(net, "ip6_mr_vif", 0, &ip6mr_vif_fops)) 1337 goto proc_vif_fail; 1338 if (!proc_net_fops_create(net, "ip6_mr_cache", 0, &ip6mr_mfc_fops)) 1339 goto proc_cache_fail; 1340#endif 1341 1342 return 0; 1343 1344#ifdef CONFIG_PROC_FS 1345proc_cache_fail: 1346 proc_net_remove(net, "ip6_mr_vif"); 1347proc_vif_fail: 1348 ip6mr_rules_exit(net); 1349#endif 1350fail: 1351 return err; 1352} 1353 1354static void __net_exit ip6mr_net_exit(struct net *net) 1355{ 1356#ifdef CONFIG_PROC_FS 1357 proc_net_remove(net, "ip6_mr_cache"); 1358 proc_net_remove(net, "ip6_mr_vif"); 1359#endif 1360 ip6mr_rules_exit(net); 1361} 1362 1363static struct pernet_operations ip6mr_net_ops = { 1364 .init = ip6mr_net_init, 1365 .exit = ip6mr_net_exit, 1366}; 1367 1368int __init ip6_mr_init(void) 1369{ 1370 int err; 1371 1372 mrt_cachep = kmem_cache_create("ip6_mrt_cache", 1373 sizeof(struct mfc6_cache), 1374 0, SLAB_HWCACHE_ALIGN, 1375 NULL); 1376 if (!mrt_cachep) 1377 return -ENOMEM; 1378 1379 err = register_pernet_subsys(&ip6mr_net_ops); 1380 if (err) 1381 goto reg_pernet_fail; 1382 1383 err = register_netdevice_notifier(&ip6_mr_notifier); 1384 if (err) 1385 goto reg_notif_fail; 1386#ifdef CONFIG_IPV6_PIMSM_V2 1387 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) { 1388 printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n"); 1389 err = -EAGAIN; 1390 goto add_proto_fail; 1391 } 1392#endif 1393 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL, ip6mr_rtm_dumproute); 1394 return 0; 1395#ifdef CONFIG_IPV6_PIMSM_V2 1396add_proto_fail: 1397 unregister_netdevice_notifier(&ip6_mr_notifier); 1398#endif 1399reg_notif_fail: 1400 unregister_pernet_subsys(&ip6mr_net_ops); 1401reg_pernet_fail: 1402 kmem_cache_destroy(mrt_cachep); 1403 return err; 1404} 1405 1406void ip6_mr_cleanup(void) 1407{ 1408 unregister_netdevice_notifier(&ip6_mr_notifier); 1409 unregister_pernet_subsys(&ip6mr_net_ops); 1410 kmem_cache_destroy(mrt_cachep); 1411} 1412 1413static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt, 1414 struct mf6cctl *mfc, int mrtsock) 1415{ 1416 bool found = false; 1417 int line; 1418 struct mfc6_cache *uc, *c; 1419 unsigned char ttls[MAXMIFS]; 1420 int i; 1421 1422 if (mfc->mf6cc_parent >= MAXMIFS) 1423 return -ENFILE; 1424 1425 memset(ttls, 255, MAXMIFS); 1426 for (i = 0; i < MAXMIFS; i++) { 1427 if (IF_ISSET(i, &mfc->mf6cc_ifset)) 1428 ttls[i] = 1; 1429 1430 } 1431 1432 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr); 1433 1434 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) { 1435 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) && 1436 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) { 1437 found = true; 1438 break; 1439 } 1440 } 1441 1442 if (found) { 1443 write_lock_bh(&mrt_lock); 1444 c->mf6c_parent = mfc->mf6cc_parent; 1445 ip6mr_update_thresholds(mrt, c, ttls); 1446 if (!mrtsock) 1447 c->mfc_flags |= MFC_STATIC; 1448 write_unlock_bh(&mrt_lock); 1449 return 0; 1450 } 1451 1452 if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr)) 1453 return -EINVAL; 1454 1455 c = ip6mr_cache_alloc(); 1456 if (c == NULL) 1457 return -ENOMEM; 1458 1459 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr; 1460 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr; 1461 c->mf6c_parent = mfc->mf6cc_parent; 1462 ip6mr_update_thresholds(mrt, c, ttls); 1463 if (!mrtsock) 1464 c->mfc_flags |= MFC_STATIC; 1465 1466 write_lock_bh(&mrt_lock); 1467 list_add(&c->list, &mrt->mfc6_cache_array[line]); 1468 write_unlock_bh(&mrt_lock); 1469 1470 /* 1471 * Check to see if we resolved a queued list. If so we 1472 * need to send on the frames and tidy up. 1473 */ 1474 found = false; 1475 spin_lock_bh(&mfc_unres_lock); 1476 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) { 1477 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) && 1478 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) { 1479 list_del(&uc->list); 1480 atomic_dec(&mrt->cache_resolve_queue_len); 1481 found = true; 1482 break; 1483 } 1484 } 1485 if (list_empty(&mrt->mfc6_unres_queue)) 1486 del_timer(&mrt->ipmr_expire_timer); 1487 spin_unlock_bh(&mfc_unres_lock); 1488 1489 if (found) { 1490 ip6mr_cache_resolve(net, mrt, uc, c); 1491 ip6mr_cache_free(uc); 1492 } 1493 return 0; 1494} 1495 1496/* 1497 * Close the multicast socket, and clear the vif tables etc 1498 */ 1499 1500static void mroute_clean_tables(struct mr6_table *mrt) 1501{ 1502 int i; 1503 LIST_HEAD(list); 1504 struct mfc6_cache *c, *next; 1505 1506 /* 1507 * Shut down all active vif entries 1508 */ 1509 for (i = 0; i < mrt->maxvif; i++) { 1510 if (!(mrt->vif6_table[i].flags & VIFF_STATIC)) 1511 mif6_delete(mrt, i, &list); 1512 } 1513 unregister_netdevice_many(&list); 1514 1515 /* 1516 * Wipe the cache 1517 */ 1518 for (i = 0; i < MFC6_LINES; i++) { 1519 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) { 1520 if (c->mfc_flags & MFC_STATIC) 1521 continue; 1522 write_lock_bh(&mrt_lock); 1523 list_del(&c->list); 1524 write_unlock_bh(&mrt_lock); 1525 1526 ip6mr_cache_free(c); 1527 } 1528 } 1529 1530 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) { 1531 spin_lock_bh(&mfc_unres_lock); 1532 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) { 1533 list_del(&c->list); 1534 ip6mr_destroy_unres(mrt, c); 1535 } 1536 spin_unlock_bh(&mfc_unres_lock); 1537 } 1538} 1539 1540static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk) 1541{ 1542 int err = 0; 1543 struct net *net = sock_net(sk); 1544 1545 rtnl_lock(); 1546 write_lock_bh(&mrt_lock); 1547 if (likely(mrt->mroute6_sk == NULL)) { 1548 mrt->mroute6_sk = sk; 1549 net->ipv6.devconf_all->mc_forwarding++; 1550 } 1551 else 1552 err = -EADDRINUSE; 1553 write_unlock_bh(&mrt_lock); 1554 1555 rtnl_unlock(); 1556 1557 return err; 1558} 1559 1560int ip6mr_sk_done(struct sock *sk) 1561{ 1562 int err = -EACCES; 1563 struct net *net = sock_net(sk); 1564 struct mr6_table *mrt; 1565 1566 rtnl_lock(); 1567 ip6mr_for_each_table(mrt, net) { 1568 if (sk == mrt->mroute6_sk) { 1569 write_lock_bh(&mrt_lock); 1570 mrt->mroute6_sk = NULL; 1571 net->ipv6.devconf_all->mc_forwarding--; 1572 write_unlock_bh(&mrt_lock); 1573 1574 mroute_clean_tables(mrt); 1575 err = 0; 1576 break; 1577 } 1578 } 1579 rtnl_unlock(); 1580 1581 return err; 1582} 1583 1584struct sock *mroute6_socket(struct net *net, struct sk_buff *skb) 1585{ 1586 struct mr6_table *mrt; 1587 struct flowi fl = { 1588 .iif = skb->skb_iif, 1589 .oif = skb->dev->ifindex, 1590 .mark = skb->mark, 1591 }; 1592 1593 if (ip6mr_fib_lookup(net, &fl, &mrt) < 0) 1594 return NULL; 1595 1596 return mrt->mroute6_sk; 1597} 1598 1599/* 1600 * Socket options and virtual interface manipulation. The whole 1601 * virtual interface system is a complete heap, but unfortunately 1602 * that's how BSD mrouted happens to think. Maybe one day with a proper 1603 * MOSPF/PIM router set up we can clean this up. 1604 */ 1605 1606int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen) 1607{ 1608 int ret; 1609 struct mif6ctl vif; 1610 struct mf6cctl mfc; 1611 mifi_t mifi; 1612 struct net *net = sock_net(sk); 1613 struct mr6_table *mrt; 1614 1615 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT); 1616 if (mrt == NULL) 1617 return -ENOENT; 1618 1619 if (optname != MRT6_INIT) { 1620 if (sk != mrt->mroute6_sk && !capable(CAP_NET_ADMIN)) 1621 return -EACCES; 1622 } 1623 1624 switch (optname) { 1625 case MRT6_INIT: 1626 if (sk->sk_type != SOCK_RAW || 1627 inet_sk(sk)->inet_num != IPPROTO_ICMPV6) 1628 return -EOPNOTSUPP; 1629 if (optlen < sizeof(int)) 1630 return -EINVAL; 1631 1632 return ip6mr_sk_init(mrt, sk); 1633 1634 case MRT6_DONE: 1635 return ip6mr_sk_done(sk); 1636 1637 case MRT6_ADD_MIF: 1638 if (optlen < sizeof(vif)) 1639 return -EINVAL; 1640 if (copy_from_user(&vif, optval, sizeof(vif))) 1641 return -EFAULT; 1642 if (vif.mif6c_mifi >= MAXMIFS) 1643 return -ENFILE; 1644 rtnl_lock(); 1645 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk); 1646 rtnl_unlock(); 1647 return ret; 1648 1649 case MRT6_DEL_MIF: 1650 if (optlen < sizeof(mifi_t)) 1651 return -EINVAL; 1652 if (copy_from_user(&mifi, optval, sizeof(mifi_t))) 1653 return -EFAULT; 1654 rtnl_lock(); 1655 ret = mif6_delete(mrt, mifi, NULL); 1656 rtnl_unlock(); 1657 return ret; 1658 1659 /* 1660 * Manipulate the forwarding caches. These live 1661 * in a sort of kernel/user symbiosis. 1662 */ 1663 case MRT6_ADD_MFC: 1664 case MRT6_DEL_MFC: 1665 if (optlen < sizeof(mfc)) 1666 return -EINVAL; 1667 if (copy_from_user(&mfc, optval, sizeof(mfc))) 1668 return -EFAULT; 1669 rtnl_lock(); 1670 if (optname == MRT6_DEL_MFC) 1671 ret = ip6mr_mfc_delete(mrt, &mfc); 1672 else 1673 ret = ip6mr_mfc_add(net, mrt, &mfc, sk == mrt->mroute6_sk); 1674 rtnl_unlock(); 1675 return ret; 1676 1677 /* 1678 * Control PIM assert (to activate pim will activate assert) 1679 */ 1680 case MRT6_ASSERT: 1681 { 1682 int v; 1683 if (get_user(v, (int __user *)optval)) 1684 return -EFAULT; 1685 mrt->mroute_do_assert = !!v; 1686 return 0; 1687 } 1688 1689#ifdef CONFIG_IPV6_PIMSM_V2 1690 case MRT6_PIM: 1691 { 1692 int v; 1693 if (get_user(v, (int __user *)optval)) 1694 return -EFAULT; 1695 v = !!v; 1696 rtnl_lock(); 1697 ret = 0; 1698 if (v != mrt->mroute_do_pim) { 1699 mrt->mroute_do_pim = v; 1700 mrt->mroute_do_assert = v; 1701 } 1702 rtnl_unlock(); 1703 return ret; 1704 } 1705 1706#endif 1707#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES 1708 case MRT6_TABLE: 1709 { 1710 u32 v; 1711 1712 if (optlen != sizeof(u32)) 1713 return -EINVAL; 1714 if (get_user(v, (u32 __user *)optval)) 1715 return -EFAULT; 1716 if (sk == mrt->mroute6_sk) 1717 return -EBUSY; 1718 1719 rtnl_lock(); 1720 ret = 0; 1721 if (!ip6mr_new_table(net, v)) 1722 ret = -ENOMEM; 1723 raw6_sk(sk)->ip6mr_table = v; 1724 rtnl_unlock(); 1725 return ret; 1726 } 1727#endif 1728 /* 1729 * Spurious command, or MRT6_VERSION which you cannot 1730 * set. 1731 */ 1732 default: 1733 return -ENOPROTOOPT; 1734 } 1735} 1736 1737/* 1738 * Getsock opt support for the multicast routing system. 1739 */ 1740 1741int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, 1742 int __user *optlen) 1743{ 1744 int olr; 1745 int val; 1746 struct net *net = sock_net(sk); 1747 struct mr6_table *mrt; 1748 1749 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT); 1750 if (mrt == NULL) 1751 return -ENOENT; 1752 1753 switch (optname) { 1754 case MRT6_VERSION: 1755 val = 0x0305; 1756 break; 1757#ifdef CONFIG_IPV6_PIMSM_V2 1758 case MRT6_PIM: 1759 val = mrt->mroute_do_pim; 1760 break; 1761#endif 1762 case MRT6_ASSERT: 1763 val = mrt->mroute_do_assert; 1764 break; 1765 default: 1766 return -ENOPROTOOPT; 1767 } 1768 1769 if (get_user(olr, optlen)) 1770 return -EFAULT; 1771 1772 olr = min_t(int, olr, sizeof(int)); 1773 if (olr < 0) 1774 return -EINVAL; 1775 1776 if (put_user(olr, optlen)) 1777 return -EFAULT; 1778 if (copy_to_user(optval, &val, olr)) 1779 return -EFAULT; 1780 return 0; 1781} 1782 1783/* 1784 * The IP multicast ioctl support routines. 1785 */ 1786 1787int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg) 1788{ 1789 struct sioc_sg_req6 sr; 1790 struct sioc_mif_req6 vr; 1791 struct mif_device *vif; 1792 struct mfc6_cache *c; 1793 struct net *net = sock_net(sk); 1794 struct mr6_table *mrt; 1795 1796 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT); 1797 if (mrt == NULL) 1798 return -ENOENT; 1799 1800 switch (cmd) { 1801 case SIOCGETMIFCNT_IN6: 1802 if (copy_from_user(&vr, arg, sizeof(vr))) 1803 return -EFAULT; 1804 if (vr.mifi >= mrt->maxvif) 1805 return -EINVAL; 1806 read_lock(&mrt_lock); 1807 vif = &mrt->vif6_table[vr.mifi]; 1808 if (MIF_EXISTS(mrt, vr.mifi)) { 1809 vr.icount = vif->pkt_in; 1810 vr.ocount = vif->pkt_out; 1811 vr.ibytes = vif->bytes_in; 1812 vr.obytes = vif->bytes_out; 1813 read_unlock(&mrt_lock); 1814 1815 if (copy_to_user(arg, &vr, sizeof(vr))) 1816 return -EFAULT; 1817 return 0; 1818 } 1819 read_unlock(&mrt_lock); 1820 return -EADDRNOTAVAIL; 1821 case SIOCGETSGCNT_IN6: 1822 if (copy_from_user(&sr, arg, sizeof(sr))) 1823 return -EFAULT; 1824 1825 read_lock(&mrt_lock); 1826 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr); 1827 if (c) { 1828 sr.pktcnt = c->mfc_un.res.pkt; 1829 sr.bytecnt = c->mfc_un.res.bytes; 1830 sr.wrong_if = c->mfc_un.res.wrong_if; 1831 read_unlock(&mrt_lock); 1832 1833 if (copy_to_user(arg, &sr, sizeof(sr))) 1834 return -EFAULT; 1835 return 0; 1836 } 1837 read_unlock(&mrt_lock); 1838 return -EADDRNOTAVAIL; 1839 default: 1840 return -ENOIOCTLCMD; 1841 } 1842} 1843 1844 1845static inline int ip6mr_forward2_finish(struct sk_buff *skb) 1846{ 1847 IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)), 1848 IPSTATS_MIB_OUTFORWDATAGRAMS); 1849 return dst_output(skb); 1850} 1851 1852/* 1853 * Processing handlers for ip6mr_forward 1854 */ 1855 1856static int ip6mr_forward2(struct net *net, struct mr6_table *mrt, 1857 struct sk_buff *skb, struct mfc6_cache *c, int vifi) 1858{ 1859 struct ipv6hdr *ipv6h; 1860 struct mif_device *vif = &mrt->vif6_table[vifi]; 1861 struct net_device *dev; 1862 struct dst_entry *dst; 1863 struct flowi fl; 1864 1865 if (vif->dev == NULL) 1866 goto out_free; 1867 1868#ifdef CONFIG_IPV6_PIMSM_V2 1869 if (vif->flags & MIFF_REGISTER) { 1870 vif->pkt_out++; 1871 vif->bytes_out += skb->len; 1872 vif->dev->stats.tx_bytes += skb->len; 1873 vif->dev->stats.tx_packets++; 1874 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT); 1875 goto out_free; 1876 } 1877#endif 1878 1879 ipv6h = ipv6_hdr(skb); 1880 1881 fl = (struct flowi) { 1882 .oif = vif->link, 1883 .nl_u = { .ip6_u = 1884 { .daddr = ipv6h->daddr, } 1885 } 1886 }; 1887 1888 dst = ip6_route_output(net, NULL, &fl); 1889 if (!dst) 1890 goto out_free; 1891 1892 skb_dst_drop(skb); 1893 skb_dst_set(skb, dst); 1894 1895 /* 1896 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally 1897 * not only before forwarding, but after forwarding on all output 1898 * interfaces. It is clear, if mrouter runs a multicasting 1899 * program, it should receive packets not depending to what interface 1900 * program is joined. 1901 * If we will not make it, the program will have to join on all 1902 * interfaces. On the other hand, multihoming host (or router, but 1903 * not mrouter) cannot join to more than one interface - it will 1904 * result in receiving multiple packets. 1905 */ 1906 dev = vif->dev; 1907 skb->dev = dev; 1908 vif->pkt_out++; 1909 vif->bytes_out += skb->len; 1910 1911 /* We are about to write */ 1912 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev))) 1913 goto out_free; 1914 1915 ipv6h = ipv6_hdr(skb); 1916 ipv6h->hop_limit--; 1917 1918 IP6CB(skb)->flags |= IP6SKB_FORWARDED; 1919 1920 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dev, 1921 ip6mr_forward2_finish); 1922 1923out_free: 1924 kfree_skb(skb); 1925 return 0; 1926} 1927 1928static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev) 1929{ 1930 int ct; 1931 1932 for (ct = mrt->maxvif - 1; ct >= 0; ct--) { 1933 if (mrt->vif6_table[ct].dev == dev) 1934 break; 1935 } 1936 return ct; 1937} 1938 1939static int ip6_mr_forward(struct net *net, struct mr6_table *mrt, 1940 struct sk_buff *skb, struct mfc6_cache *cache) 1941{ 1942 int psend = -1; 1943 int vif, ct; 1944 struct dst_entry *dst = skb_dst(skb); 1945 static struct net_device *lan_device = NULL; 1946 1947 vif = cache->mf6c_parent; 1948 cache->mfc_un.res.pkt++; 1949 cache->mfc_un.res.bytes += skb->len; 1950 1951 1952 /* Bob added start, 08/19/2009, ipv6ready v6LC.1.1.10 part J */ 1953 if(! (ipv6_hdr(skb)->daddr.s6_addr[1] & 0x0f)) 1954 { 1955 goto dont_forward; 1956 } 1957 /* Bob added end, 08/19/2009, ipv6ready v6LC.1.1.10 part J */ 1958 /* Bob added start, 08/19/2009, ipv6ready v6LC.5.1.4 part B */ 1959 if(!lan_device) 1960 lan_device = dev_get_by_name(&init_net, "eth0"); //todo: not to hardcode br0 1961 //lan_device = dev_get_by_name("br0"); //todo: not to hardcode br0 1962 if (skb->len > lan_device->mtu) 1963 { 1964 skb->dev = lan_device; 1965 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, lan_device->mtu); 1966 //IP6_INC_STATS_BH((skb_dst(skb)->dev), ip6_dst_idev(dst), IPSTATS_MIB_INTOOBIGERRORS); 1967 //IP6_INC_STATS_BH((skb_dst(skb)->dev), ip6_dst_idev(dst), IPSTATS_MIB_FRAGFAILS); 1968 1969 kfree_skb(skb); 1970 return -EMSGSIZE; 1971 } 1972 /* Bob added end, 08/19/2009, ipv6ready v6LC.5.1.4 part B */ 1973 1974 /* 1975 * Wrong interface: drop packet and (maybe) send PIM assert. 1976 */ 1977 if (mrt->vif6_table[vif].dev != skb->dev) { 1978 int true_vifi; 1979 1980 cache->mfc_un.res.wrong_if++; 1981 true_vifi = ip6mr_find_vif(mrt, skb->dev); 1982 1983 if (true_vifi >= 0 && mrt->mroute_do_assert && 1984 /* pimsm uses asserts, when switching from RPT to SPT, 1985 so that we cannot check that packet arrived on an oif. 1986 It is bad, but otherwise we would need to move pretty 1987 large chunk of pimd to kernel. Ough... --ANK 1988 */ 1989 (mrt->mroute_do_pim || 1990 cache->mfc_un.res.ttls[true_vifi] < 255) && 1991 time_after(jiffies, 1992 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) { 1993 cache->mfc_un.res.last_assert = jiffies; 1994 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF); 1995 } 1996 goto dont_forward; 1997 } 1998 1999 mrt->vif6_table[vif].pkt_in++; 2000 mrt->vif6_table[vif].bytes_in += skb->len; 2001 2002 /* 2003 * Forward the frame 2004 */ 2005 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) { 2006 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) { 2007 if (psend != -1) { 2008 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 2009 if (skb2) 2010 ip6mr_forward2(net, mrt, skb2, cache, psend); 2011 } 2012 psend = ct; 2013 } 2014 } 2015 if (psend != -1) { 2016 ip6mr_forward2(net, mrt, skb, cache, psend); 2017 return 0; 2018 } 2019 2020dont_forward: 2021 kfree_skb(skb); 2022 return 0; 2023} 2024 2025 2026/* 2027 * Multicast packets for forwarding arrive here 2028 */ 2029 2030int ip6_mr_input(struct sk_buff *skb) 2031{ 2032 struct mfc6_cache *cache; 2033 struct net *net = dev_net(skb->dev); 2034 struct mr6_table *mrt; 2035 struct flowi fl = { 2036 .iif = skb->dev->ifindex, 2037 .mark = skb->mark, 2038 }; 2039 int err; 2040 2041 err = ip6mr_fib_lookup(net, &fl, &mrt); 2042 if (err < 0) 2043 return err; 2044 2045 read_lock(&mrt_lock); 2046 cache = ip6mr_cache_find(mrt, 2047 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr); 2048 2049 /* 2050 * No usable cache entry 2051 */ 2052 if (cache == NULL) { 2053 int vif; 2054 2055 vif = ip6mr_find_vif(mrt, skb->dev); 2056 if (vif >= 0) { 2057 int err = ip6mr_cache_unresolved(mrt, vif, skb); 2058 read_unlock(&mrt_lock); 2059 2060 return err; 2061 } 2062 read_unlock(&mrt_lock); 2063 kfree_skb(skb); 2064 return -ENODEV; 2065 } 2066 2067 ip6_mr_forward(net, mrt, skb, cache); 2068 2069 read_unlock(&mrt_lock); 2070 2071 return 0; 2072} 2073 2074 2075static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb, 2076 struct mfc6_cache *c, struct rtmsg *rtm) 2077{ 2078 int ct; 2079 struct rtnexthop *nhp; 2080 u8 *b = skb_tail_pointer(skb); 2081 struct rtattr *mp_head; 2082 2083 /* If cache is unresolved, don't try to parse IIF and OIF */ 2084 if (c->mf6c_parent >= MAXMIFS) 2085 return -ENOENT; 2086 2087 if (MIF_EXISTS(mrt, c->mf6c_parent)) 2088 RTA_PUT(skb, RTA_IIF, 4, &mrt->vif6_table[c->mf6c_parent].dev->ifindex); 2089 2090 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0)); 2091 2092 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 2093 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) { 2094 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4)) 2095 goto rtattr_failure; 2096 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp))); 2097 nhp->rtnh_flags = 0; 2098 nhp->rtnh_hops = c->mfc_un.res.ttls[ct]; 2099 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex; 2100 nhp->rtnh_len = sizeof(*nhp); 2101 } 2102 } 2103 mp_head->rta_type = RTA_MULTIPATH; 2104 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head; 2105 rtm->rtm_type = RTN_MULTICAST; 2106 return 1; 2107 2108rtattr_failure: 2109 nlmsg_trim(skb, b); 2110 return -EMSGSIZE; 2111} 2112 2113int ip6mr_get_route(struct net *net, 2114 struct sk_buff *skb, struct rtmsg *rtm, int nowait) 2115{ 2116 int err; 2117 struct mr6_table *mrt; 2118 struct mfc6_cache *cache; 2119 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb); 2120 2121 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT); 2122 if (mrt == NULL) 2123 return -ENOENT; 2124 2125 read_lock(&mrt_lock); 2126 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr); 2127 2128 if (!cache) { 2129 struct sk_buff *skb2; 2130 struct ipv6hdr *iph; 2131 struct net_device *dev; 2132 int vif; 2133 2134 if (nowait) { 2135 read_unlock(&mrt_lock); 2136 return -EAGAIN; 2137 } 2138 2139 dev = skb->dev; 2140 if (dev == NULL || (vif = ip6mr_find_vif(mrt, dev)) < 0) { 2141 read_unlock(&mrt_lock); 2142 return -ENODEV; 2143 } 2144 2145 /* really correct? */ 2146 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC); 2147 if (!skb2) { 2148 read_unlock(&mrt_lock); 2149 return -ENOMEM; 2150 } 2151 2152 skb_reset_transport_header(skb2); 2153 2154 skb_put(skb2, sizeof(struct ipv6hdr)); 2155 skb_reset_network_header(skb2); 2156 2157 iph = ipv6_hdr(skb2); 2158 iph->version = 0; 2159 iph->priority = 0; 2160 iph->flow_lbl[0] = 0; 2161 iph->flow_lbl[1] = 0; 2162 iph->flow_lbl[2] = 0; 2163 iph->payload_len = 0; 2164 iph->nexthdr = IPPROTO_NONE; 2165 iph->hop_limit = 0; 2166 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr); 2167 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr); 2168 2169 err = ip6mr_cache_unresolved(mrt, vif, skb2); 2170 read_unlock(&mrt_lock); 2171 2172 return err; 2173 } 2174 2175 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY)) 2176 cache->mfc_flags |= MFC_NOTIFY; 2177 2178 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm); 2179 read_unlock(&mrt_lock); 2180 return err; 2181} 2182 2183static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb, 2184 u32 pid, u32 seq, struct mfc6_cache *c) 2185{ 2186 struct nlmsghdr *nlh; 2187 struct rtmsg *rtm; 2188 2189 nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI); 2190 if (nlh == NULL) 2191 return -EMSGSIZE; 2192 2193 rtm = nlmsg_data(nlh); 2194 rtm->rtm_family = RTNL_FAMILY_IPMR; 2195 rtm->rtm_dst_len = 128; 2196 rtm->rtm_src_len = 128; 2197 rtm->rtm_tos = 0; 2198 rtm->rtm_table = mrt->id; 2199 NLA_PUT_U32(skb, RTA_TABLE, mrt->id); 2200 rtm->rtm_scope = RT_SCOPE_UNIVERSE; 2201 rtm->rtm_protocol = RTPROT_UNSPEC; 2202 rtm->rtm_flags = 0; 2203 2204 NLA_PUT(skb, RTA_SRC, 16, &c->mf6c_origin); 2205 NLA_PUT(skb, RTA_DST, 16, &c->mf6c_mcastgrp); 2206 2207 if (__ip6mr_fill_mroute(mrt, skb, c, rtm) < 0) 2208 goto nla_put_failure; 2209 2210 return nlmsg_end(skb, nlh); 2211 2212nla_put_failure: 2213 nlmsg_cancel(skb, nlh); 2214 return -EMSGSIZE; 2215} 2216 2217static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb) 2218{ 2219 struct net *net = sock_net(skb->sk); 2220 struct mr6_table *mrt; 2221 struct mfc6_cache *mfc; 2222 unsigned int t = 0, s_t; 2223 unsigned int h = 0, s_h; 2224 unsigned int e = 0, s_e; 2225 2226 s_t = cb->args[0]; 2227 s_h = cb->args[1]; 2228 s_e = cb->args[2]; 2229 2230 read_lock(&mrt_lock); 2231 ip6mr_for_each_table(mrt, net) { 2232 if (t < s_t) 2233 goto next_table; 2234 if (t > s_t) 2235 s_h = 0; 2236 for (h = s_h; h < MFC6_LINES; h++) { 2237 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) { 2238 if (e < s_e) 2239 goto next_entry; 2240 if (ip6mr_fill_mroute(mrt, skb, 2241 NETLINK_CB(cb->skb).pid, 2242 cb->nlh->nlmsg_seq, 2243 mfc) < 0) 2244 goto done; 2245next_entry: 2246 e++; 2247 } 2248 e = s_e = 0; 2249 } 2250 s_h = 0; 2251next_table: 2252 t++; 2253 } 2254done: 2255 read_unlock(&mrt_lock); 2256 2257 cb->args[2] = e; 2258 cb->args[1] = h; 2259 cb->args[0] = t; 2260 2261 return skb->len; 2262} 2263