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