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