1 /* 2 * IP multicast routing support for mrouted 3.6/3.8 3 * 4 * (c) 1995 Alan Cox, <alan@redhat.com> 5 * Linux Consultancy and Custom Driver Development 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 * 12 * Version: $Id: ipmr.c,v 1.65 2001/10/31 21:55:54 davem Exp $ 13 * 14 * Fixes: 15 * Michael Chastain : Incorrect size of copying. 16 * Alan Cox : Added the cache manager code 17 * Alan Cox : Fixed the clone/copy bug and device race. 18 * Mike McLagan : Routing by source 19 * Malcolm Beattie : Buffer handling fixes. 20 * Alexey Kuznetsov : Double buffer free and other fixes. 21 * SVR Anand : Fixed several multicast bugs and problems. 22 * Alexey Kuznetsov : Status, optimisations and more. 23 * Brad Parker : Better behaviour on mrouted upcall 24 * overflow. 25 * Carlos Picoto : PIMv1 Support 26 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header 27 * Relax this requrement to work with older peers. 28 * 29 */ 30 31 #include <asm/system.h> 32 #include <asm/uaccess.h> 33 #include <linux/types.h> 34 #include <linux/capability.h> 35 #include <linux/errno.h> 36 #include <linux/timer.h> 37 #include <linux/mm.h> 38 #include <linux/kernel.h> 39 #include <linux/fcntl.h> 40 #include <linux/stat.h> 41 #include <linux/socket.h> 42 #include <linux/in.h> 43 #include <linux/inet.h> 44 #include <linux/netdevice.h> 45 #include <linux/inetdevice.h> 46 #include <linux/igmp.h> 47 #include <linux/proc_fs.h> 48 #include <linux/seq_file.h> 49 #include <linux/mroute.h> 50 #include <linux/init.h> 51 #include <linux/if_ether.h> 52 #include <net/ip.h> 53 #include <net/protocol.h> 54 #include <linux/skbuff.h> 55 #include <net/route.h> 56 #include <net/sock.h> 57 #include <net/icmp.h> 58 #include <net/udp.h> 59 #include <net/raw.h> 60 #include <linux/notifier.h> 61 #include <linux/if_arp.h> 62 #include <linux/netfilter_ipv4.h> 63 #include <net/ipip.h> 64 #include <net/checksum.h> 65 #include <net/netlink.h> 66 67 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2) 68 #define CONFIG_IP_PIMSM 1 69 #endif 70 71 static struct sock *mroute_socket; 72 73 74 /* Big lock, protecting vif table, mrt cache and mroute socket state. 75 Note that the changes are semaphored via rtnl_lock. 76 */ 77 78 static DEFINE_RWLOCK(mrt_lock); 79 80 /* 81 * Multicast router control variables 82 */ 83 84 static struct vif_device vif_table[MAXVIFS]; /* Devices */ 85 static int maxvif; 86 87 #define VIF_EXISTS(idx) (vif_table[idx].dev != NULL) 88 89 static int mroute_do_assert; /* Set in PIM assert */ 90 static int mroute_do_pim; 91 92 static struct mfc_cache *mfc_cache_array[MFC_LINES]; /* Forwarding cache */ 93 94 static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */ 95 static atomic_t cache_resolve_queue_len; /* Size of unresolved */ 96 97 /* Special spinlock for queue of unresolved entries */ 98 static DEFINE_SPINLOCK(mfc_unres_lock); 99 100 /* We return to original Alan's scheme. Hash table of resolved 101 entries is changed only in process context and protected 102 with weak lock mrt_lock. Queue of unresolved entries is protected 103 with strong spinlock mfc_unres_lock. 104 105 In this case data path is free of exclusive locks at all. 106 */ 107 108 static struct kmem_cache *mrt_cachep __read_mostly; 109 110 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local); 111 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert); 112 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm); 113 114 #ifdef CONFIG_IP_PIMSM_V2 115 static struct net_protocol pim_protocol; 116 #endif 117 118 static struct timer_list ipmr_expire_timer; 119 120 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */ 121 122 static 123 struct net_device *ipmr_new_tunnel(struct vifctl *v) 124 { 125 struct net_device *dev; 126 127 dev = __dev_get_by_name("tunl0"); 128 129 if (dev) { 130 int err; 131 struct ifreq ifr; 132 mm_segment_t oldfs; 133 struct ip_tunnel_parm p; 134 struct in_device *in_dev; 135 136 memset(&p, 0, sizeof(p)); 137 p.iph.daddr = v->vifc_rmt_addr.s_addr; 138 p.iph.saddr = v->vifc_lcl_addr.s_addr; 139 p.iph.version = 4; 140 p.iph.ihl = 5; 141 p.iph.protocol = IPPROTO_IPIP; 142 sprintf(p.name, "dvmrp%d", v->vifc_vifi); 143 ifr.ifr_ifru.ifru_data = (void*)&p; 144 145 oldfs = get_fs(); set_fs(KERNEL_DS); 146 err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL); 147 set_fs(oldfs); 148 149 dev = NULL; 150 151 if (err == 0 && (dev = __dev_get_by_name(p.name)) != NULL) { 152 dev->flags |= IFF_MULTICAST; 153 154 in_dev = __in_dev_get_rtnl(dev); 155 if (in_dev == NULL) 156 goto failure; 157 158 ipv4_devconf_setall(in_dev); 159 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 160 161 if (dev_open(dev)) 162 goto failure; 163 } 164 } 165 return dev; 166 167 failure: 168 /* allow the register to be completed before unregistering. */ 169 rtnl_unlock(); 170 rtnl_lock(); 171 172 unregister_netdevice(dev); 173 return NULL; 174 } 175 176 #ifdef CONFIG_IP_PIMSM 177 178 static int reg_vif_num = -1; 179 180 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev) 181 { 182 read_lock(&mrt_lock); 183 ((struct net_device_stats*)netdev_priv(dev))->tx_bytes += skb->len; 184 ((struct net_device_stats*)netdev_priv(dev))->tx_packets++; 185 ipmr_cache_report(skb, reg_vif_num, IGMPMSG_WHOLEPKT); 186 read_unlock(&mrt_lock); 187 kfree_skb(skb); 188 return 0; 189 } 190 191 static struct net_device_stats *reg_vif_get_stats(struct net_device *dev) 192 { 193 return (struct net_device_stats*)netdev_priv(dev); 194 } 195 196 static void reg_vif_setup(struct net_device *dev) 197 { 198 dev->type = ARPHRD_PIMREG; 199 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8; 200 dev->flags = IFF_NOARP; 201 dev->hard_start_xmit = reg_vif_xmit; 202 dev->get_stats = reg_vif_get_stats; 203 dev->destructor = free_netdev; 204 } 205 206 static struct net_device *ipmr_reg_vif(void) 207 { 208 struct net_device *dev; 209 struct in_device *in_dev; 210 211 dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg", 212 reg_vif_setup); 213 214 if (dev == NULL) 215 return NULL; 216 217 if (register_netdevice(dev)) { 218 free_netdev(dev); 219 return NULL; 220 } 221 dev->iflink = 0; 222 223 rcu_read_lock(); 224 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) { 225 rcu_read_unlock(); 226 goto failure; 227 } 228 229 ipv4_devconf_setall(in_dev); 230 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 231 rcu_read_unlock(); 232 233 if (dev_open(dev)) 234 goto failure; 235 236 return dev; 237 238 failure: 239 /* allow the register to be completed before unregistering. */ 240 rtnl_unlock(); 241 rtnl_lock(); 242 243 unregister_netdevice(dev); 244 return NULL; 245 } 246 #endif 247 248 /* 249 * Delete a VIF entry 250 */ 251 252 static int vif_delete(int vifi) 253 { 254 struct vif_device *v; 255 struct net_device *dev; 256 struct in_device *in_dev; 257 258 if (vifi < 0 || vifi >= maxvif) 259 return -EADDRNOTAVAIL; 260 261 v = &vif_table[vifi]; 262 263 write_lock_bh(&mrt_lock); 264 dev = v->dev; 265 v->dev = NULL; 266 267 if (!dev) { 268 write_unlock_bh(&mrt_lock); 269 return -EADDRNOTAVAIL; 270 } 271 272 #ifdef CONFIG_IP_PIMSM 273 if (vifi == reg_vif_num) 274 reg_vif_num = -1; 275 #endif 276 277 if (vifi+1 == maxvif) { 278 int tmp; 279 for (tmp=vifi-1; tmp>=0; tmp--) { 280 if (VIF_EXISTS(tmp)) 281 break; 282 } 283 maxvif = tmp+1; 284 } 285 286 write_unlock_bh(&mrt_lock); 287 288 dev_set_allmulti(dev, -1); 289 290 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 291 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--; 292 ip_rt_multicast_event(in_dev); 293 } 294 295 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER)) 296 unregister_netdevice(dev); 297 298 dev_put(dev); 299 return 0; 300 } 301 302 /* Destroy an unresolved cache entry, killing queued skbs 303 and reporting error to netlink readers. 304 */ 305 306 static void ipmr_destroy_unres(struct mfc_cache *c) 307 { 308 struct sk_buff *skb; 309 struct nlmsgerr *e; 310 311 atomic_dec(&cache_resolve_queue_len); 312 313 while ((skb=skb_dequeue(&c->mfc_un.unres.unresolved))) { 314 if (ip_hdr(skb)->version == 0) { 315 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 316 nlh->nlmsg_type = NLMSG_ERROR; 317 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 318 skb_trim(skb, nlh->nlmsg_len); 319 e = NLMSG_DATA(nlh); 320 e->error = -ETIMEDOUT; 321 memset(&e->msg, 0, sizeof(e->msg)); 322 323 rtnl_unicast(skb, NETLINK_CB(skb).pid); 324 } else 325 kfree_skb(skb); 326 } 327 328 kmem_cache_free(mrt_cachep, c); 329 } 330 331 332 /* Single timer process for all the unresolved queue. */ 333 334 static void ipmr_expire_process(unsigned long dummy) 335 { 336 unsigned long now; 337 unsigned long expires; 338 struct mfc_cache *c, **cp; 339 340 if (!spin_trylock(&mfc_unres_lock)) { 341 mod_timer(&ipmr_expire_timer, jiffies+HZ/10); 342 return; 343 } 344 345 if (atomic_read(&cache_resolve_queue_len) == 0) 346 goto out; 347 348 now = jiffies; 349 expires = 10*HZ; 350 cp = &mfc_unres_queue; 351 352 while ((c=*cp) != NULL) { 353 if (time_after(c->mfc_un.unres.expires, now)) { 354 unsigned long interval = c->mfc_un.unres.expires - now; 355 if (interval < expires) 356 expires = interval; 357 cp = &c->next; 358 continue; 359 } 360 361 *cp = c->next; 362 363 ipmr_destroy_unres(c); 364 } 365 366 if (atomic_read(&cache_resolve_queue_len)) 367 mod_timer(&ipmr_expire_timer, jiffies + expires); 368 369 out: 370 spin_unlock(&mfc_unres_lock); 371 } 372 373 /* Fill oifs list. It is called under write locked mrt_lock. */ 374 375 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls) 376 { 377 int vifi; 378 379 cache->mfc_un.res.minvif = MAXVIFS; 380 cache->mfc_un.res.maxvif = 0; 381 memset(cache->mfc_un.res.ttls, 255, MAXVIFS); 382 383 for (vifi=0; vifi<maxvif; vifi++) { 384 if (VIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) { 385 cache->mfc_un.res.ttls[vifi] = ttls[vifi]; 386 if (cache->mfc_un.res.minvif > vifi) 387 cache->mfc_un.res.minvif = vifi; 388 if (cache->mfc_un.res.maxvif <= vifi) 389 cache->mfc_un.res.maxvif = vifi + 1; 390 } 391 } 392 } 393 394 static int vif_add(struct vifctl *vifc, int mrtsock) 395 { 396 int vifi = vifc->vifc_vifi; 397 struct vif_device *v = &vif_table[vifi]; 398 struct net_device *dev; 399 struct in_device *in_dev; 400 401 /* Is vif busy ? */ 402 if (VIF_EXISTS(vifi)) 403 return -EADDRINUSE; 404 405 switch (vifc->vifc_flags) { 406 #ifdef CONFIG_IP_PIMSM 407 case VIFF_REGISTER: 408 /* 409 * Special Purpose VIF in PIM 410 * All the packets will be sent to the daemon 411 */ 412 if (reg_vif_num >= 0) 413 return -EADDRINUSE; 414 dev = ipmr_reg_vif(); 415 if (!dev) 416 return -ENOBUFS; 417 break; 418 #endif 419 case VIFF_TUNNEL: 420 dev = ipmr_new_tunnel(vifc); 421 if (!dev) 422 return -ENOBUFS; 423 break; 424 case 0: 425 dev = ip_dev_find(vifc->vifc_lcl_addr.s_addr); 426 if (!dev) 427 return -EADDRNOTAVAIL; 428 dev_put(dev); 429 break; 430 default: 431 return -EINVAL; 432 } 433 434 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) 435 return -EADDRNOTAVAIL; 436 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++; 437 dev_set_allmulti(dev, +1); 438 ip_rt_multicast_event(in_dev); 439 440 /* 441 * Fill in the VIF structures 442 */ 443 v->rate_limit=vifc->vifc_rate_limit; 444 v->local=vifc->vifc_lcl_addr.s_addr; 445 v->remote=vifc->vifc_rmt_addr.s_addr; 446 v->flags=vifc->vifc_flags; 447 if (!mrtsock) 448 v->flags |= VIFF_STATIC; 449 v->threshold=vifc->vifc_threshold; 450 v->bytes_in = 0; 451 v->bytes_out = 0; 452 v->pkt_in = 0; 453 v->pkt_out = 0; 454 v->link = dev->ifindex; 455 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER)) 456 v->link = dev->iflink; 457 458 /* And finish update writing critical data */ 459 write_lock_bh(&mrt_lock); 460 dev_hold(dev); 461 v->dev=dev; 462 #ifdef CONFIG_IP_PIMSM 463 if (v->flags&VIFF_REGISTER) 464 reg_vif_num = vifi; 465 #endif 466 if (vifi+1 > maxvif) 467 maxvif = vifi+1; 468 write_unlock_bh(&mrt_lock); 469 return 0; 470 } 471 472 static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp) 473 { 474 int line=MFC_HASH(mcastgrp,origin); 475 struct mfc_cache *c; 476 477 for (c=mfc_cache_array[line]; c; c = c->next) { 478 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp) 479 break; 480 } 481 return c; 482 } 483 484 /* 485 * Allocate a multicast cache entry 486 */ 487 static struct mfc_cache *ipmr_cache_alloc(void) 488 { 489 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_KERNEL); 490 if (c==NULL) 491 return NULL; 492 c->mfc_un.res.minvif = MAXVIFS; 493 return c; 494 } 495 496 static struct mfc_cache *ipmr_cache_alloc_unres(void) 497 { 498 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC); 499 if (c==NULL) 500 return NULL; 501 skb_queue_head_init(&c->mfc_un.unres.unresolved); 502 c->mfc_un.unres.expires = jiffies + 10*HZ; 503 return c; 504 } 505 506 /* 507 * A cache entry has gone into a resolved state from queued 508 */ 509 510 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c) 511 { 512 struct sk_buff *skb; 513 struct nlmsgerr *e; 514 515 /* 516 * Play the pending entries through our router 517 */ 518 519 while ((skb=__skb_dequeue(&uc->mfc_un.unres.unresolved))) { 520 if (ip_hdr(skb)->version == 0) { 521 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 522 523 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) { 524 nlh->nlmsg_len = (skb_tail_pointer(skb) - 525 (u8 *)nlh); 526 } else { 527 nlh->nlmsg_type = NLMSG_ERROR; 528 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 529 skb_trim(skb, nlh->nlmsg_len); 530 e = NLMSG_DATA(nlh); 531 e->error = -EMSGSIZE; 532 memset(&e->msg, 0, sizeof(e->msg)); 533 } 534 535 rtnl_unicast(skb, NETLINK_CB(skb).pid); 536 } else 537 ip_mr_forward(skb, c, 0); 538 } 539 } 540 541 /* 542 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted 543 * expects the following bizarre scheme. 544 * 545 * Called under mrt_lock. 546 */ 547 548 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert) 549 { 550 struct sk_buff *skb; 551 const int ihl = ip_hdrlen(pkt); 552 struct igmphdr *igmp; 553 struct igmpmsg *msg; 554 int ret; 555 556 #ifdef CONFIG_IP_PIMSM 557 if (assert == IGMPMSG_WHOLEPKT) 558 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr)); 559 else 560 #endif 561 skb = alloc_skb(128, GFP_ATOMIC); 562 563 if (!skb) 564 return -ENOBUFS; 565 566 #ifdef CONFIG_IP_PIMSM 567 if (assert == IGMPMSG_WHOLEPKT) { 568 /* Ugly, but we have no choice with this interface. 569 Duplicate old header, fix ihl, length etc. 570 And all this only to mangle msg->im_msgtype and 571 to set msg->im_mbz to "mbz" :-) 572 */ 573 skb_push(skb, sizeof(struct iphdr)); 574 skb_reset_network_header(skb); 575 skb_reset_transport_header(skb); 576 msg = (struct igmpmsg *)skb_network_header(skb); 577 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr)); 578 msg->im_msgtype = IGMPMSG_WHOLEPKT; 579 msg->im_mbz = 0; 580 msg->im_vif = reg_vif_num; 581 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2; 582 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) + 583 sizeof(struct iphdr)); 584 } else 585 #endif 586 { 587 588 /* 589 * Copy the IP header 590 */ 591 592 skb->network_header = skb->tail; 593 skb_put(skb, ihl); 594 skb_copy_to_linear_data(skb, pkt->data, ihl); 595 ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */ 596 msg = (struct igmpmsg *)skb_network_header(skb); 597 msg->im_vif = vifi; 598 skb->dst = dst_clone(pkt->dst); 599 600 /* 601 * Add our header 602 */ 603 604 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr)); 605 igmp->type = 606 msg->im_msgtype = assert; 607 igmp->code = 0; 608 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */ 609 skb->transport_header = skb->network_header; 610 } 611 612 if (mroute_socket == NULL) { 613 kfree_skb(skb); 614 return -EINVAL; 615 } 616 617 /* 618 * Deliver to mrouted 619 */ 620 if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) { 621 if (net_ratelimit()) 622 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n"); 623 kfree_skb(skb); 624 } 625 626 return ret; 627 } 628 629 /* 630 * Queue a packet for resolution. It gets locked cache entry! 631 */ 632 633 static int 634 ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb) 635 { 636 int err; 637 struct mfc_cache *c; 638 const struct iphdr *iph = ip_hdr(skb); 639 640 spin_lock_bh(&mfc_unres_lock); 641 for (c=mfc_unres_queue; c; c=c->next) { 642 if (c->mfc_mcastgrp == iph->daddr && 643 c->mfc_origin == iph->saddr) 644 break; 645 } 646 647 if (c == NULL) { 648 /* 649 * Create a new entry if allowable 650 */ 651 652 if (atomic_read(&cache_resolve_queue_len)>=10 || 653 (c=ipmr_cache_alloc_unres())==NULL) { 654 spin_unlock_bh(&mfc_unres_lock); 655 656 kfree_skb(skb); 657 return -ENOBUFS; 658 } 659 660 /* 661 * Fill in the new cache entry 662 */ 663 c->mfc_parent = -1; 664 c->mfc_origin = iph->saddr; 665 c->mfc_mcastgrp = iph->daddr; 666 667 /* 668 * Reflect first query at mrouted. 669 */ 670 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) { 671 /* If the report failed throw the cache entry 672 out - Brad Parker 673 */ 674 spin_unlock_bh(&mfc_unres_lock); 675 676 kmem_cache_free(mrt_cachep, c); 677 kfree_skb(skb); 678 return err; 679 } 680 681 atomic_inc(&cache_resolve_queue_len); 682 c->next = mfc_unres_queue; 683 mfc_unres_queue = c; 684 685 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires); 686 } 687 688 /* 689 * See if we can append the packet 690 */ 691 if (c->mfc_un.unres.unresolved.qlen>3) { 692 kfree_skb(skb); 693 err = -ENOBUFS; 694 } else { 695 skb_queue_tail(&c->mfc_un.unres.unresolved,skb); 696 err = 0; 697 } 698 699 spin_unlock_bh(&mfc_unres_lock); 700 return err; 701 } 702 703 /* 704 * MFC cache manipulation by user space mroute daemon 705 */ 706 707 static int ipmr_mfc_delete(struct mfcctl *mfc) 708 { 709 int line; 710 struct mfc_cache *c, **cp; 711 712 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 713 714 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) { 715 if (c->mfc_origin == mfc->mfcc_origin.s_addr && 716 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) { 717 write_lock_bh(&mrt_lock); 718 *cp = c->next; 719 write_unlock_bh(&mrt_lock); 720 721 kmem_cache_free(mrt_cachep, c); 722 return 0; 723 } 724 } 725 return -ENOENT; 726 } 727 728 static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock) 729 { 730 int line; 731 struct mfc_cache *uc, *c, **cp; 732 733 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 734 735 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) { 736 if (c->mfc_origin == mfc->mfcc_origin.s_addr && 737 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) 738 break; 739 } 740 741 if (c != NULL) { 742 write_lock_bh(&mrt_lock); 743 c->mfc_parent = mfc->mfcc_parent; 744 ipmr_update_thresholds(c, mfc->mfcc_ttls); 745 if (!mrtsock) 746 c->mfc_flags |= MFC_STATIC; 747 write_unlock_bh(&mrt_lock); 748 return 0; 749 } 750 751 if (!MULTICAST(mfc->mfcc_mcastgrp.s_addr)) 752 return -EINVAL; 753 754 c=ipmr_cache_alloc(); 755 if (c==NULL) 756 return -ENOMEM; 757 758 c->mfc_origin=mfc->mfcc_origin.s_addr; 759 c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr; 760 c->mfc_parent=mfc->mfcc_parent; 761 ipmr_update_thresholds(c, mfc->mfcc_ttls); 762 if (!mrtsock) 763 c->mfc_flags |= MFC_STATIC; 764 765 write_lock_bh(&mrt_lock); 766 c->next = mfc_cache_array[line]; 767 mfc_cache_array[line] = c; 768 write_unlock_bh(&mrt_lock); 769 770 /* 771 * Check to see if we resolved a queued list. If so we 772 * need to send on the frames and tidy up. 773 */ 774 spin_lock_bh(&mfc_unres_lock); 775 for (cp = &mfc_unres_queue; (uc=*cp) != NULL; 776 cp = &uc->next) { 777 if (uc->mfc_origin == c->mfc_origin && 778 uc->mfc_mcastgrp == c->mfc_mcastgrp) { 779 *cp = uc->next; 780 if (atomic_dec_and_test(&cache_resolve_queue_len)) 781 del_timer(&ipmr_expire_timer); 782 break; 783 } 784 } 785 spin_unlock_bh(&mfc_unres_lock); 786 787 if (uc) { 788 ipmr_cache_resolve(uc, c); 789 kmem_cache_free(mrt_cachep, uc); 790 } 791 return 0; 792 } 793 794 /* 795 * Close the multicast socket, and clear the vif tables etc 796 */ 797 798 static void mroute_clean_tables(struct sock *sk) 799 { 800 int i; 801 802 /* 803 * Shut down all active vif entries 804 */ 805 for (i=0; i<maxvif; i++) { 806 if (!(vif_table[i].flags&VIFF_STATIC)) 807 vif_delete(i); 808 } 809 810 /* 811 * Wipe the cache 812 */ 813 for (i=0;i<MFC_LINES;i++) { 814 struct mfc_cache *c, **cp; 815 816 cp = &mfc_cache_array[i]; 817 while ((c = *cp) != NULL) { 818 if (c->mfc_flags&MFC_STATIC) { 819 cp = &c->next; 820 continue; 821 } 822 write_lock_bh(&mrt_lock); 823 *cp = c->next; 824 write_unlock_bh(&mrt_lock); 825 826 kmem_cache_free(mrt_cachep, c); 827 } 828 } 829 830 if (atomic_read(&cache_resolve_queue_len) != 0) { 831 struct mfc_cache *c; 832 833 spin_lock_bh(&mfc_unres_lock); 834 while (mfc_unres_queue != NULL) { 835 c = mfc_unres_queue; 836 mfc_unres_queue = c->next; 837 spin_unlock_bh(&mfc_unres_lock); 838 839 ipmr_destroy_unres(c); 840 841 spin_lock_bh(&mfc_unres_lock); 842 } 843 spin_unlock_bh(&mfc_unres_lock); 844 } 845 } 846 847 static void mrtsock_destruct(struct sock *sk) 848 { 849 rtnl_lock(); 850 if (sk == mroute_socket) { 851 IPV4_DEVCONF_ALL(MC_FORWARDING)--; 852 853 write_lock_bh(&mrt_lock); 854 mroute_socket=NULL; 855 write_unlock_bh(&mrt_lock); 856 857 mroute_clean_tables(sk); 858 } 859 rtnl_unlock(); 860 } 861 862 /* 863 * Socket options and virtual interface manipulation. The whole 864 * virtual interface system is a complete heap, but unfortunately 865 * that's how BSD mrouted happens to think. Maybe one day with a proper 866 * MOSPF/PIM router set up we can clean this up. 867 */ 868 869 int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen) 870 { 871 int ret; 872 struct vifctl vif; 873 struct mfcctl mfc; 874 875 if (optname != MRT_INIT) { 876 if (sk != mroute_socket && !capable(CAP_NET_ADMIN)) 877 return -EACCES; 878 } 879 880 switch (optname) { 881 case MRT_INIT: 882 if (sk->sk_type != SOCK_RAW || 883 inet_sk(sk)->num != IPPROTO_IGMP) 884 return -EOPNOTSUPP; 885 if (optlen!=sizeof(int)) 886 return -ENOPROTOOPT; 887 888 rtnl_lock(); 889 if (mroute_socket) { 890 rtnl_unlock(); 891 return -EADDRINUSE; 892 } 893 894 ret = ip_ra_control(sk, 1, mrtsock_destruct); 895 if (ret == 0) { 896 write_lock_bh(&mrt_lock); 897 mroute_socket=sk; 898 write_unlock_bh(&mrt_lock); 899 900 IPV4_DEVCONF_ALL(MC_FORWARDING)++; 901 } 902 rtnl_unlock(); 903 return ret; 904 case MRT_DONE: 905 if (sk!=mroute_socket) 906 return -EACCES; 907 return ip_ra_control(sk, 0, NULL); 908 case MRT_ADD_VIF: 909 case MRT_DEL_VIF: 910 if (optlen!=sizeof(vif)) 911 return -EINVAL; 912 if (copy_from_user(&vif,optval,sizeof(vif))) 913 return -EFAULT; 914 if (vif.vifc_vifi >= MAXVIFS) 915 return -ENFILE; 916 rtnl_lock(); 917 if (optname==MRT_ADD_VIF) { 918 ret = vif_add(&vif, sk==mroute_socket); 919 } else { 920 ret = vif_delete(vif.vifc_vifi); 921 } 922 rtnl_unlock(); 923 return ret; 924 925 /* 926 * Manipulate the forwarding caches. These live 927 * in a sort of kernel/user symbiosis. 928 */ 929 case MRT_ADD_MFC: 930 case MRT_DEL_MFC: 931 if (optlen!=sizeof(mfc)) 932 return -EINVAL; 933 if (copy_from_user(&mfc,optval, sizeof(mfc))) 934 return -EFAULT; 935 rtnl_lock(); 936 if (optname==MRT_DEL_MFC) 937 ret = ipmr_mfc_delete(&mfc); 938 else 939 ret = ipmr_mfc_add(&mfc, sk==mroute_socket); 940 rtnl_unlock(); 941 return ret; 942 /* 943 * Control PIM assert. 944 */ 945 case MRT_ASSERT: 946 { 947 int v; 948 if (get_user(v,(int __user *)optval)) 949 return -EFAULT; 950 mroute_do_assert=(v)?1:0; 951 return 0; 952 } 953 #ifdef CONFIG_IP_PIMSM 954 case MRT_PIM: 955 { 956 int v, ret; 957 if (get_user(v,(int __user *)optval)) 958 return -EFAULT; 959 v = (v)?1:0; 960 rtnl_lock(); 961 ret = 0; 962 if (v != mroute_do_pim) { 963 mroute_do_pim = v; 964 mroute_do_assert = v; 965 #ifdef CONFIG_IP_PIMSM_V2 966 if (mroute_do_pim) 967 ret = inet_add_protocol(&pim_protocol, 968 IPPROTO_PIM); 969 else 970 ret = inet_del_protocol(&pim_protocol, 971 IPPROTO_PIM); 972 if (ret < 0) 973 ret = -EAGAIN; 974 #endif 975 } 976 rtnl_unlock(); 977 return ret; 978 } 979 #endif 980 /* 981 * Spurious command, or MRT_VERSION which you cannot 982 * set. 983 */ 984 default: 985 return -ENOPROTOOPT; 986 } 987 } 988 989 /* 990 * Getsock opt support for the multicast routing system. 991 */ 992 993 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen) 994 { 995 int olr; 996 int val; 997 998 if (optname!=MRT_VERSION && 999 #ifdef CONFIG_IP_PIMSM 1000 optname!=MRT_PIM && 1001 #endif 1002 optname!=MRT_ASSERT) 1003 return -ENOPROTOOPT; 1004 1005 if (get_user(olr, optlen)) 1006 return -EFAULT; 1007 1008 olr = min_t(unsigned int, olr, sizeof(int)); 1009 if (olr < 0) 1010 return -EINVAL; 1011 1012 if (put_user(olr,optlen)) 1013 return -EFAULT; 1014 if (optname==MRT_VERSION) 1015 val=0x0305; 1016 #ifdef CONFIG_IP_PIMSM 1017 else if (optname==MRT_PIM) 1018 val=mroute_do_pim; 1019 #endif 1020 else 1021 val=mroute_do_assert; 1022 if (copy_to_user(optval,&val,olr)) 1023 return -EFAULT; 1024 return 0; 1025 } 1026 1027 /* 1028 * The IP multicast ioctl support routines. 1029 */ 1030 1031 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg) 1032 { 1033 struct sioc_sg_req sr; 1034 struct sioc_vif_req vr; 1035 struct vif_device *vif; 1036 struct mfc_cache *c; 1037 1038 switch (cmd) { 1039 case SIOCGETVIFCNT: 1040 if (copy_from_user(&vr,arg,sizeof(vr))) 1041 return -EFAULT; 1042 if (vr.vifi>=maxvif) 1043 return -EINVAL; 1044 read_lock(&mrt_lock); 1045 vif=&vif_table[vr.vifi]; 1046 if (VIF_EXISTS(vr.vifi)) { 1047 vr.icount=vif->pkt_in; 1048 vr.ocount=vif->pkt_out; 1049 vr.ibytes=vif->bytes_in; 1050 vr.obytes=vif->bytes_out; 1051 read_unlock(&mrt_lock); 1052 1053 if (copy_to_user(arg,&vr,sizeof(vr))) 1054 return -EFAULT; 1055 return 0; 1056 } 1057 read_unlock(&mrt_lock); 1058 return -EADDRNOTAVAIL; 1059 case SIOCGETSGCNT: 1060 if (copy_from_user(&sr,arg,sizeof(sr))) 1061 return -EFAULT; 1062 1063 read_lock(&mrt_lock); 1064 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr); 1065 if (c) { 1066 sr.pktcnt = c->mfc_un.res.pkt; 1067 sr.bytecnt = c->mfc_un.res.bytes; 1068 sr.wrong_if = c->mfc_un.res.wrong_if; 1069 read_unlock(&mrt_lock); 1070 1071 if (copy_to_user(arg,&sr,sizeof(sr))) 1072 return -EFAULT; 1073 return 0; 1074 } 1075 read_unlock(&mrt_lock); 1076 return -EADDRNOTAVAIL; 1077 default: 1078 return -ENOIOCTLCMD; 1079 } 1080 } 1081 1082 1083 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr) 1084 { 1085 struct vif_device *v; 1086 int ct; 1087 if (event != NETDEV_UNREGISTER) 1088 return NOTIFY_DONE; 1089 v=&vif_table[0]; 1090 for (ct=0;ct<maxvif;ct++,v++) { 1091 if (v->dev==ptr) 1092 vif_delete(ct); 1093 } 1094 return NOTIFY_DONE; 1095 } 1096 1097 1098 static struct notifier_block ip_mr_notifier={ 1099 .notifier_call = ipmr_device_event, 1100 }; 1101 1102 /* 1103 * Encapsulate a packet by attaching a valid IPIP header to it. 1104 * This avoids tunnel drivers and other mess and gives us the speed so 1105 * important for multicast video. 1106 */ 1107 1108 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr) 1109 { 1110 struct iphdr *iph; 1111 struct iphdr *old_iph = ip_hdr(skb); 1112 1113 skb_push(skb, sizeof(struct iphdr)); 1114 skb->transport_header = skb->network_header; 1115 skb_reset_network_header(skb); 1116 iph = ip_hdr(skb); 1117 1118 iph->version = 4; 1119 iph->tos = old_iph->tos; 1120 iph->ttl = old_iph->ttl; 1121 iph->frag_off = 0; 1122 iph->daddr = daddr; 1123 iph->saddr = saddr; 1124 iph->protocol = IPPROTO_IPIP; 1125 iph->ihl = 5; 1126 iph->tot_len = htons(skb->len); 1127 ip_select_ident(iph, skb->dst, NULL); 1128 ip_send_check(iph); 1129 1130 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 1131 nf_reset(skb); 1132 } 1133 1134 static inline int ipmr_forward_finish(struct sk_buff *skb) 1135 { 1136 struct ip_options * opt = &(IPCB(skb)->opt); 1137 1138 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS); 1139 1140 if (unlikely(opt->optlen)) 1141 ip_forward_options(skb); 1142 1143 return dst_output(skb); 1144 } 1145 1146 /* 1147 * Processing handlers for ipmr_forward 1148 */ 1149 1150 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi) 1151 { 1152 const struct iphdr *iph = ip_hdr(skb); 1153 struct vif_device *vif = &vif_table[vifi]; 1154 struct net_device *dev; 1155 struct rtable *rt; 1156 int encap = 0; 1157 1158 if (vif->dev == NULL) 1159 goto out_free; 1160 1161 #ifdef CONFIG_IP_PIMSM 1162 if (vif->flags & VIFF_REGISTER) { 1163 vif->pkt_out++; 1164 vif->bytes_out+=skb->len; 1165 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len; 1166 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++; 1167 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT); 1168 kfree_skb(skb); 1169 return; 1170 } 1171 #endif 1172 1173 if (vif->flags&VIFF_TUNNEL) { 1174 struct flowi fl = { .oif = vif->link, 1175 .nl_u = { .ip4_u = 1176 { .daddr = vif->remote, 1177 .saddr = vif->local, 1178 .tos = RT_TOS(iph->tos) } }, 1179 .proto = IPPROTO_IPIP }; 1180 if (ip_route_output_key(&rt, &fl)) 1181 goto out_free; 1182 encap = sizeof(struct iphdr); 1183 } else { 1184 struct flowi fl = { .oif = vif->link, 1185 .nl_u = { .ip4_u = 1186 { .daddr = iph->daddr, 1187 .tos = RT_TOS(iph->tos) } }, 1188 .proto = IPPROTO_IPIP }; 1189 if (ip_route_output_key(&rt, &fl)) 1190 goto out_free; 1191 } 1192 1193 dev = rt->u.dst.dev; 1194 1195 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) { 1196 /* Do not fragment multicasts. Alas, IPv4 does not 1197 allow to send ICMP, so that packets will disappear 1198 to blackhole. 1199 */ 1200 1201 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS); 1202 ip_rt_put(rt); 1203 goto out_free; 1204 } 1205 1206 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len; 1207 1208 if (skb_cow(skb, encap)) { 1209 ip_rt_put(rt); 1210 goto out_free; 1211 } 1212 1213 vif->pkt_out++; 1214 vif->bytes_out+=skb->len; 1215 1216 dst_release(skb->dst); 1217 skb->dst = &rt->u.dst; 1218 ip_decrease_ttl(ip_hdr(skb)); 1219 1220 /* FIXME: forward and output firewalls used to be called here. 1221 * What do we do with netfilter? -- RR */ 1222 if (vif->flags & VIFF_TUNNEL) { 1223 ip_encap(skb, vif->local, vif->remote); 1224 /* FIXME: extra output firewall step used to be here. --RR */ 1225 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++; 1226 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len; 1227 } 1228 1229 IPCB(skb)->flags |= IPSKB_FORWARDED; 1230 1231 /* 1232 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally 1233 * not only before forwarding, but after forwarding on all output 1234 * interfaces. It is clear, if mrouter runs a multicasting 1235 * program, it should receive packets not depending to what interface 1236 * program is joined. 1237 * If we will not make it, the program will have to join on all 1238 * interfaces. On the other hand, multihoming host (or router, but 1239 * not mrouter) cannot join to more than one interface - it will 1240 * result in receiving multiple packets. 1241 */ 1242 NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev, 1243 ipmr_forward_finish); 1244 return; 1245 1246 out_free: 1247 kfree_skb(skb); 1248 return; 1249 } 1250 1251 static int ipmr_find_vif(struct net_device *dev) 1252 { 1253 int ct; 1254 for (ct=maxvif-1; ct>=0; ct--) { 1255 if (vif_table[ct].dev == dev) 1256 break; 1257 } 1258 return ct; 1259 } 1260 1261 /* "local" means that we should preserve one skb (for local delivery) */ 1262 1263 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local) 1264 { 1265 int psend = -1; 1266 int vif, ct; 1267 1268 vif = cache->mfc_parent; 1269 cache->mfc_un.res.pkt++; 1270 cache->mfc_un.res.bytes += skb->len; 1271 1272 /* 1273 * Wrong interface: drop packet and (maybe) send PIM assert. 1274 */ 1275 if (vif_table[vif].dev != skb->dev) { 1276 int true_vifi; 1277 1278 if (((struct rtable*)skb->dst)->fl.iif == 0) { 1279 /* It is our own packet, looped back. 1280 Very complicated situation... 1281 1282 The best workaround until routing daemons will be 1283 fixed is not to redistribute packet, if it was 1284 send through wrong interface. It means, that 1285 multicast applications WILL NOT work for 1286 (S,G), which have default multicast route pointing 1287 to wrong oif. In any case, it is not a good 1288 idea to use multicasting applications on router. 1289 */ 1290 goto dont_forward; 1291 } 1292 1293 cache->mfc_un.res.wrong_if++; 1294 true_vifi = ipmr_find_vif(skb->dev); 1295 1296 if (true_vifi >= 0 && mroute_do_assert && 1297 /* pimsm uses asserts, when switching from RPT to SPT, 1298 so that we cannot check that packet arrived on an oif. 1299 It is bad, but otherwise we would need to move pretty 1300 large chunk of pimd to kernel. Ough... --ANK 1301 */ 1302 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) && 1303 time_after(jiffies, 1304 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) { 1305 cache->mfc_un.res.last_assert = jiffies; 1306 ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF); 1307 } 1308 goto dont_forward; 1309 } 1310 1311 vif_table[vif].pkt_in++; 1312 vif_table[vif].bytes_in+=skb->len; 1313 1314 /* 1315 * Forward the frame 1316 */ 1317 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) { 1318 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) { 1319 if (psend != -1) { 1320 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 1321 if (skb2) 1322 ipmr_queue_xmit(skb2, cache, psend); 1323 } 1324 psend=ct; 1325 } 1326 } 1327 if (psend != -1) { 1328 if (local) { 1329 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 1330 if (skb2) 1331 ipmr_queue_xmit(skb2, cache, psend); 1332 } else { 1333 ipmr_queue_xmit(skb, cache, psend); 1334 return 0; 1335 } 1336 } 1337 1338 dont_forward: 1339 if (!local) 1340 kfree_skb(skb); 1341 return 0; 1342 } 1343 1344 1345 /* 1346 * Multicast packets for forwarding arrive here 1347 */ 1348 1349 int ip_mr_input(struct sk_buff *skb) 1350 { 1351 struct mfc_cache *cache; 1352 int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL; 1353 1354 /* Packet is looped back after forward, it should not be 1355 forwarded second time, but still can be delivered locally. 1356 */ 1357 if (IPCB(skb)->flags&IPSKB_FORWARDED) 1358 goto dont_forward; 1359 1360 if (!local) { 1361 if (IPCB(skb)->opt.router_alert) { 1362 if (ip_call_ra_chain(skb)) 1363 return 0; 1364 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){ 1365 /* IGMPv1 (and broken IGMPv2 implementations sort of 1366 Cisco IOS <= 11.2(8)) do not put router alert 1367 option to IGMP packets destined to routable 1368 groups. It is very bad, because it means 1369 that we can forward NO IGMP messages. 1370 */ 1371 read_lock(&mrt_lock); 1372 if (mroute_socket) { 1373 nf_reset(skb); 1374 raw_rcv(mroute_socket, skb); 1375 read_unlock(&mrt_lock); 1376 return 0; 1377 } 1378 read_unlock(&mrt_lock); 1379 } 1380 } 1381 1382 read_lock(&mrt_lock); 1383 cache = ipmr_cache_find(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 1384 1385 /* 1386 * No usable cache entry 1387 */ 1388 if (cache==NULL) { 1389 int vif; 1390 1391 if (local) { 1392 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 1393 ip_local_deliver(skb); 1394 if (skb2 == NULL) { 1395 read_unlock(&mrt_lock); 1396 return -ENOBUFS; 1397 } 1398 skb = skb2; 1399 } 1400 1401 vif = ipmr_find_vif(skb->dev); 1402 if (vif >= 0) { 1403 int err = ipmr_cache_unresolved(vif, skb); 1404 read_unlock(&mrt_lock); 1405 1406 return err; 1407 } 1408 read_unlock(&mrt_lock); 1409 kfree_skb(skb); 1410 return -ENODEV; 1411 } 1412 1413 ip_mr_forward(skb, cache, local); 1414 1415 read_unlock(&mrt_lock); 1416 1417 if (local) 1418 return ip_local_deliver(skb); 1419 1420 return 0; 1421 1422 dont_forward: 1423 if (local) 1424 return ip_local_deliver(skb); 1425 kfree_skb(skb); 1426 return 0; 1427 } 1428 1429 #ifdef CONFIG_IP_PIMSM_V1 1430 /* 1431 * Handle IGMP messages of PIMv1 1432 */ 1433 1434 int pim_rcv_v1(struct sk_buff * skb) 1435 { 1436 struct igmphdr *pim; 1437 struct iphdr *encap; 1438 struct net_device *reg_dev = NULL; 1439 1440 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap))) 1441 goto drop; 1442 1443 pim = igmp_hdr(skb); 1444 1445 if (!mroute_do_pim || 1446 skb->len < sizeof(*pim) + sizeof(*encap) || 1447 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER) 1448 goto drop; 1449 1450 encap = (struct iphdr *)(skb_transport_header(skb) + 1451 sizeof(struct igmphdr)); 1452 /* 1453 Check that: 1454 a. packet is really destinted to a multicast group 1455 b. packet is not a NULL-REGISTER 1456 c. packet is not truncated 1457 */ 1458 if (!MULTICAST(encap->daddr) || 1459 encap->tot_len == 0 || 1460 ntohs(encap->tot_len) + sizeof(*pim) > skb->len) 1461 goto drop; 1462 1463 read_lock(&mrt_lock); 1464 if (reg_vif_num >= 0) 1465 reg_dev = vif_table[reg_vif_num].dev; 1466 if (reg_dev) 1467 dev_hold(reg_dev); 1468 read_unlock(&mrt_lock); 1469 1470 if (reg_dev == NULL) 1471 goto drop; 1472 1473 skb->mac_header = skb->network_header; 1474 skb_pull(skb, (u8*)encap - skb->data); 1475 skb_reset_network_header(skb); 1476 skb->dev = reg_dev; 1477 skb->protocol = htons(ETH_P_IP); 1478 skb->ip_summed = 0; 1479 skb->pkt_type = PACKET_HOST; 1480 dst_release(skb->dst); 1481 skb->dst = NULL; 1482 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len; 1483 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++; 1484 nf_reset(skb); 1485 netif_rx(skb); 1486 dev_put(reg_dev); 1487 return 0; 1488 drop: 1489 kfree_skb(skb); 1490 return 0; 1491 } 1492 #endif 1493 1494 #ifdef CONFIG_IP_PIMSM_V2 1495 static int pim_rcv(struct sk_buff * skb) 1496 { 1497 struct pimreghdr *pim; 1498 struct iphdr *encap; 1499 struct net_device *reg_dev = NULL; 1500 1501 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap))) 1502 goto drop; 1503 1504 pim = (struct pimreghdr *)skb_transport_header(skb); 1505 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) || 1506 (pim->flags&PIM_NULL_REGISTER) || 1507 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 && 1508 csum_fold(skb_checksum(skb, 0, skb->len, 0)))) 1509 goto drop; 1510 1511 /* check if the inner packet is destined to mcast group */ 1512 encap = (struct iphdr *)(skb_transport_header(skb) + 1513 sizeof(struct pimreghdr)); 1514 if (!MULTICAST(encap->daddr) || 1515 encap->tot_len == 0 || 1516 ntohs(encap->tot_len) + sizeof(*pim) > skb->len) 1517 goto drop; 1518 1519 read_lock(&mrt_lock); 1520 if (reg_vif_num >= 0) 1521 reg_dev = vif_table[reg_vif_num].dev; 1522 if (reg_dev) 1523 dev_hold(reg_dev); 1524 read_unlock(&mrt_lock); 1525 1526 if (reg_dev == NULL) 1527 goto drop; 1528 1529 skb->mac_header = skb->network_header; 1530 skb_pull(skb, (u8*)encap - skb->data); 1531 skb_reset_network_header(skb); 1532 skb->dev = reg_dev; 1533 skb->protocol = htons(ETH_P_IP); 1534 skb->ip_summed = 0; 1535 skb->pkt_type = PACKET_HOST; 1536 dst_release(skb->dst); 1537 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len; 1538 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++; 1539 skb->dst = NULL; 1540 nf_reset(skb); 1541 netif_rx(skb); 1542 dev_put(reg_dev); 1543 return 0; 1544 drop: 1545 kfree_skb(skb); 1546 return 0; 1547 } 1548 #endif 1549 1550 static int 1551 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm) 1552 { 1553 int ct; 1554 struct rtnexthop *nhp; 1555 struct net_device *dev = vif_table[c->mfc_parent].dev; 1556 u8 *b = skb_tail_pointer(skb); 1557 struct rtattr *mp_head; 1558 1559 if (dev) 1560 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex); 1561 1562 mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0)); 1563 1564 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 1565 if (c->mfc_un.res.ttls[ct] < 255) { 1566 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4)) 1567 goto rtattr_failure; 1568 nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp))); 1569 nhp->rtnh_flags = 0; 1570 nhp->rtnh_hops = c->mfc_un.res.ttls[ct]; 1571 nhp->rtnh_ifindex = vif_table[ct].dev->ifindex; 1572 nhp->rtnh_len = sizeof(*nhp); 1573 } 1574 } 1575 mp_head->rta_type = RTA_MULTIPATH; 1576 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head; 1577 rtm->rtm_type = RTN_MULTICAST; 1578 return 1; 1579 1580 rtattr_failure: 1581 nlmsg_trim(skb, b); 1582 return -EMSGSIZE; 1583 } 1584 1585 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait) 1586 { 1587 int err; 1588 struct mfc_cache *cache; 1589 struct rtable *rt = (struct rtable*)skb->dst; 1590 1591 read_lock(&mrt_lock); 1592 cache = ipmr_cache_find(rt->rt_src, rt->rt_dst); 1593 1594 if (cache==NULL) { 1595 struct sk_buff *skb2; 1596 struct iphdr *iph; 1597 struct net_device *dev; 1598 int vif; 1599 1600 if (nowait) { 1601 read_unlock(&mrt_lock); 1602 return -EAGAIN; 1603 } 1604 1605 dev = skb->dev; 1606 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) { 1607 read_unlock(&mrt_lock); 1608 return -ENODEV; 1609 } 1610 skb2 = skb_clone(skb, GFP_ATOMIC); 1611 if (!skb2) { 1612 read_unlock(&mrt_lock); 1613 return -ENOMEM; 1614 } 1615 1616 skb_push(skb2, sizeof(struct iphdr)); 1617 skb_reset_network_header(skb2); 1618 iph = ip_hdr(skb2); 1619 iph->ihl = sizeof(struct iphdr) >> 2; 1620 iph->saddr = rt->rt_src; 1621 iph->daddr = rt->rt_dst; 1622 iph->version = 0; 1623 err = ipmr_cache_unresolved(vif, skb2); 1624 read_unlock(&mrt_lock); 1625 return err; 1626 } 1627 1628 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY)) 1629 cache->mfc_flags |= MFC_NOTIFY; 1630 err = ipmr_fill_mroute(skb, cache, rtm); 1631 read_unlock(&mrt_lock); 1632 return err; 1633 } 1634 1635 #ifdef CONFIG_PROC_FS 1636 /* 1637 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif 1638 */ 1639 struct ipmr_vif_iter { 1640 int ct; 1641 }; 1642 1643 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter, 1644 loff_t pos) 1645 { 1646 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) { 1647 if (!VIF_EXISTS(iter->ct)) 1648 continue; 1649 if (pos-- == 0) 1650 return &vif_table[iter->ct]; 1651 } 1652 return NULL; 1653 } 1654 1655 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos) 1656 { 1657 read_lock(&mrt_lock); 1658 return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1) 1659 : SEQ_START_TOKEN; 1660 } 1661 1662 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1663 { 1664 struct ipmr_vif_iter *iter = seq->private; 1665 1666 ++*pos; 1667 if (v == SEQ_START_TOKEN) 1668 return ipmr_vif_seq_idx(iter, 0); 1669 1670 while (++iter->ct < maxvif) { 1671 if (!VIF_EXISTS(iter->ct)) 1672 continue; 1673 return &vif_table[iter->ct]; 1674 } 1675 return NULL; 1676 } 1677 1678 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v) 1679 { 1680 read_unlock(&mrt_lock); 1681 } 1682 1683 static int ipmr_vif_seq_show(struct seq_file *seq, void *v) 1684 { 1685 if (v == SEQ_START_TOKEN) { 1686 seq_puts(seq, 1687 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n"); 1688 } else { 1689 const struct vif_device *vif = v; 1690 const char *name = vif->dev ? vif->dev->name : "none"; 1691 1692 seq_printf(seq, 1693 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 1694 vif - vif_table, 1695 name, vif->bytes_in, vif->pkt_in, 1696 vif->bytes_out, vif->pkt_out, 1697 vif->flags, vif->local, vif->remote); 1698 } 1699 return 0; 1700 } 1701 1702 static const struct seq_operations ipmr_vif_seq_ops = { 1703 .start = ipmr_vif_seq_start, 1704 .next = ipmr_vif_seq_next, 1705 .stop = ipmr_vif_seq_stop, 1706 .show = ipmr_vif_seq_show, 1707 }; 1708 1709 static int ipmr_vif_open(struct inode *inode, struct file *file) 1710 { 1711 struct seq_file *seq; 1712 int rc = -ENOMEM; 1713 struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL); 1714 1715 if (!s) 1716 goto out; 1717 1718 rc = seq_open(file, &ipmr_vif_seq_ops); 1719 if (rc) 1720 goto out_kfree; 1721 1722 s->ct = 0; 1723 seq = file->private_data; 1724 seq->private = s; 1725 out: 1726 return rc; 1727 out_kfree: 1728 kfree(s); 1729 goto out; 1730 1731 } 1732 1733 static const struct file_operations ipmr_vif_fops = { 1734 .owner = THIS_MODULE, 1735 .open = ipmr_vif_open, 1736 .read = seq_read, 1737 .llseek = seq_lseek, 1738 .release = seq_release_private, 1739 }; 1740 1741 struct ipmr_mfc_iter { 1742 struct mfc_cache **cache; 1743 int ct; 1744 }; 1745 1746 1747 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos) 1748 { 1749 struct mfc_cache *mfc; 1750 1751 it->cache = mfc_cache_array; 1752 read_lock(&mrt_lock); 1753 for (it->ct = 0; it->ct < MFC_LINES; it->ct++) 1754 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next) 1755 if (pos-- == 0) 1756 return mfc; 1757 read_unlock(&mrt_lock); 1758 1759 it->cache = &mfc_unres_queue; 1760 spin_lock_bh(&mfc_unres_lock); 1761 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next) 1762 if (pos-- == 0) 1763 return mfc; 1764 spin_unlock_bh(&mfc_unres_lock); 1765 1766 it->cache = NULL; 1767 return NULL; 1768 } 1769 1770 1771 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 1772 { 1773 struct ipmr_mfc_iter *it = seq->private; 1774 it->cache = NULL; 1775 it->ct = 0; 1776 return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1) 1777 : SEQ_START_TOKEN; 1778 } 1779 1780 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1781 { 1782 struct mfc_cache *mfc = v; 1783 struct ipmr_mfc_iter *it = seq->private; 1784 1785 ++*pos; 1786 1787 if (v == SEQ_START_TOKEN) 1788 return ipmr_mfc_seq_idx(seq->private, 0); 1789 1790 if (mfc->next) 1791 return mfc->next; 1792 1793 if (it->cache == &mfc_unres_queue) 1794 goto end_of_list; 1795 1796 BUG_ON(it->cache != mfc_cache_array); 1797 1798 while (++it->ct < MFC_LINES) { 1799 mfc = mfc_cache_array[it->ct]; 1800 if (mfc) 1801 return mfc; 1802 } 1803 1804 /* exhausted cache_array, show unresolved */ 1805 read_unlock(&mrt_lock); 1806 it->cache = &mfc_unres_queue; 1807 it->ct = 0; 1808 1809 spin_lock_bh(&mfc_unres_lock); 1810 mfc = mfc_unres_queue; 1811 if (mfc) 1812 return mfc; 1813 1814 end_of_list: 1815 spin_unlock_bh(&mfc_unres_lock); 1816 it->cache = NULL; 1817 1818 return NULL; 1819 } 1820 1821 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v) 1822 { 1823 struct ipmr_mfc_iter *it = seq->private; 1824 1825 if (it->cache == &mfc_unres_queue) 1826 spin_unlock_bh(&mfc_unres_lock); 1827 else if (it->cache == mfc_cache_array) 1828 read_unlock(&mrt_lock); 1829 } 1830 1831 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v) 1832 { 1833 int n; 1834 1835 if (v == SEQ_START_TOKEN) { 1836 seq_puts(seq, 1837 "Group Origin Iif Pkts Bytes Wrong Oifs\n"); 1838 } else { 1839 const struct mfc_cache *mfc = v; 1840 const struct ipmr_mfc_iter *it = seq->private; 1841 1842 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld", 1843 (unsigned long) mfc->mfc_mcastgrp, 1844 (unsigned long) mfc->mfc_origin, 1845 mfc->mfc_parent, 1846 mfc->mfc_un.res.pkt, 1847 mfc->mfc_un.res.bytes, 1848 mfc->mfc_un.res.wrong_if); 1849 1850 if (it->cache != &mfc_unres_queue) { 1851 for (n = mfc->mfc_un.res.minvif; 1852 n < mfc->mfc_un.res.maxvif; n++ ) { 1853 if (VIF_EXISTS(n) 1854 && mfc->mfc_un.res.ttls[n] < 255) 1855 seq_printf(seq, 1856 " %2d:%-3d", 1857 n, mfc->mfc_un.res.ttls[n]); 1858 } 1859 } 1860 seq_putc(seq, '\n'); 1861 } 1862 return 0; 1863 } 1864 1865 static const struct seq_operations ipmr_mfc_seq_ops = { 1866 .start = ipmr_mfc_seq_start, 1867 .next = ipmr_mfc_seq_next, 1868 .stop = ipmr_mfc_seq_stop, 1869 .show = ipmr_mfc_seq_show, 1870 }; 1871 1872 static int ipmr_mfc_open(struct inode *inode, struct file *file) 1873 { 1874 struct seq_file *seq; 1875 int rc = -ENOMEM; 1876 struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL); 1877 1878 if (!s) 1879 goto out; 1880 1881 rc = seq_open(file, &ipmr_mfc_seq_ops); 1882 if (rc) 1883 goto out_kfree; 1884 1885 seq = file->private_data; 1886 seq->private = s; 1887 out: 1888 return rc; 1889 out_kfree: 1890 kfree(s); 1891 goto out; 1892 1893 } 1894 1895 static const struct file_operations ipmr_mfc_fops = { 1896 .owner = THIS_MODULE, 1897 .open = ipmr_mfc_open, 1898 .read = seq_read, 1899 .llseek = seq_lseek, 1900 .release = seq_release_private, 1901 }; 1902 #endif 1903 1904 #ifdef CONFIG_IP_PIMSM_V2 1905 static struct net_protocol pim_protocol = { 1906 .handler = pim_rcv, 1907 }; 1908 #endif 1909 1910 1911 /* 1912 * Setup for IP multicast routing 1913 */ 1914 1915 void __init ip_mr_init(void) 1916 { 1917 mrt_cachep = kmem_cache_create("ip_mrt_cache", 1918 sizeof(struct mfc_cache), 1919 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, 1920 NULL); 1921 init_timer(&ipmr_expire_timer); 1922 ipmr_expire_timer.function=ipmr_expire_process; 1923 register_netdevice_notifier(&ip_mr_notifier); 1924 #ifdef CONFIG_PROC_FS 1925 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops); 1926 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops); 1927 #endif 1928 } 1929