1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * IP multicast routing support for mrouted 3.6/3.8 4 * 5 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk> 6 * Linux Consultancy and Custom Driver Development 7 * 8 * Fixes: 9 * Michael Chastain : Incorrect size of copying. 10 * Alan Cox : Added the cache manager code 11 * Alan Cox : Fixed the clone/copy bug and device race. 12 * Mike McLagan : Routing by source 13 * Malcolm Beattie : Buffer handling fixes. 14 * Alexey Kuznetsov : Double buffer free and other fixes. 15 * SVR Anand : Fixed several multicast bugs and problems. 16 * Alexey Kuznetsov : Status, optimisations and more. 17 * Brad Parker : Better behaviour on mrouted upcall 18 * overflow. 19 * Carlos Picoto : PIMv1 Support 20 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header 21 * Relax this requirement to work with older peers. 22 */ 23 24 #include <linux/uaccess.h> 25 #include <linux/types.h> 26 #include <linux/cache.h> 27 #include <linux/capability.h> 28 #include <linux/errno.h> 29 #include <linux/mm.h> 30 #include <linux/kernel.h> 31 #include <linux/fcntl.h> 32 #include <linux/stat.h> 33 #include <linux/socket.h> 34 #include <linux/in.h> 35 #include <linux/inet.h> 36 #include <linux/netdevice.h> 37 #include <linux/inetdevice.h> 38 #include <linux/igmp.h> 39 #include <linux/proc_fs.h> 40 #include <linux/seq_file.h> 41 #include <linux/mroute.h> 42 #include <linux/init.h> 43 #include <linux/if_ether.h> 44 #include <linux/slab.h> 45 #include <net/flow.h> 46 #include <net/net_namespace.h> 47 #include <net/ip.h> 48 #include <net/protocol.h> 49 #include <linux/skbuff.h> 50 #include <net/route.h> 51 #include <net/icmp.h> 52 #include <net/udp.h> 53 #include <net/raw.h> 54 #include <linux/notifier.h> 55 #include <linux/if_arp.h> 56 #include <linux/netfilter_ipv4.h> 57 #include <linux/compat.h> 58 #include <linux/export.h> 59 #include <linux/rhashtable.h> 60 #include <net/ip_tunnels.h> 61 #include <net/checksum.h> 62 #include <net/netlink.h> 63 #include <net/fib_rules.h> 64 #include <linux/netconf.h> 65 #include <net/rtnh.h> 66 #include <net/inet_dscp.h> 67 68 #include <linux/nospec.h> 69 70 struct ipmr_rule { 71 struct fib_rule common; 72 }; 73 74 struct ipmr_result { 75 struct mr_table *mrt; 76 }; 77 78 /* Big lock, protecting vif table, mrt cache and mroute socket state. 79 * Note that the changes are semaphored via rtnl_lock. 80 */ 81 82 static DEFINE_SPINLOCK(mrt_lock); 83 84 static struct net_device *vif_dev_read(const struct vif_device *vif) 85 { 86 return rcu_dereference(vif->dev); 87 } 88 89 /* Multicast router control variables */ 90 91 /* Special spinlock for queue of unresolved entries */ 92 static DEFINE_SPINLOCK(mfc_unres_lock); 93 94 /* We return to original Alan's scheme. Hash table of resolved 95 * entries is changed only in process context and protected 96 * with weak lock mrt_lock. Queue of unresolved entries is protected 97 * with strong spinlock mfc_unres_lock. 98 * 99 * In this case data path is free of exclusive locks at all. 100 */ 101 102 static struct kmem_cache *mrt_cachep __ro_after_init; 103 104 static struct mr_table *ipmr_new_table(struct net *net, u32 id); 105 static void ipmr_free_table(struct mr_table *mrt, 106 struct list_head *dev_kill_list); 107 108 static void ip_mr_forward(struct net *net, struct mr_table *mrt, 109 struct net_device *dev, struct sk_buff *skb, 110 struct mfc_cache *cache, int local); 111 static int ipmr_cache_report(const struct mr_table *mrt, 112 struct sk_buff *pkt, vifi_t vifi, int assert, 113 bool nl_query); 114 static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc, 115 int cmd); 116 static void igmpmsg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt); 117 static void mroute_clean_tables(struct mr_table *mrt, int flags, 118 struct list_head *dev_kill_list); 119 static void ipmr_expire_process(struct timer_list *t); 120 121 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES 122 #define ipmr_for_each_table(mrt, net) \ 123 list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list, \ 124 lockdep_rtnl_is_held() || \ 125 list_empty(&net->ipv4.mr_tables)) 126 127 static struct mr_table *ipmr_mr_table_iter(struct net *net, 128 struct mr_table *mrt) 129 { 130 struct mr_table *ret; 131 132 if (!mrt) 133 ret = list_entry_rcu(net->ipv4.mr_tables.next, 134 struct mr_table, list); 135 else 136 ret = list_entry_rcu(mrt->list.next, 137 struct mr_table, list); 138 139 if (&ret->list == &net->ipv4.mr_tables) 140 return NULL; 141 return ret; 142 } 143 144 static struct mr_table *__ipmr_get_table(struct net *net, u32 id) 145 { 146 struct mr_table *mrt; 147 148 ipmr_for_each_table(mrt, net) { 149 if (mrt->id == id) 150 return mrt; 151 } 152 return NULL; 153 } 154 155 static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4, 156 struct mr_table **mrt) 157 { 158 int err; 159 struct ipmr_result res; 160 struct fib_lookup_arg arg = { 161 .result = &res, 162 .flags = FIB_LOOKUP_NOREF, 163 }; 164 165 /* update flow if oif or iif point to device enslaved to l3mdev */ 166 l3mdev_update_flow(net, flowi4_to_flowi(flp4)); 167 168 err = fib_rules_lookup(net->ipv4.mr_rules_ops, 169 flowi4_to_flowi(flp4), 0, &arg); 170 if (err < 0) 171 return err; 172 *mrt = res.mrt; 173 return 0; 174 } 175 176 static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp, 177 int flags, struct fib_lookup_arg *arg) 178 { 179 struct ipmr_result *res = arg->result; 180 struct mr_table *mrt; 181 182 switch (rule->action) { 183 case FR_ACT_TO_TBL: 184 break; 185 case FR_ACT_UNREACHABLE: 186 return -ENETUNREACH; 187 case FR_ACT_PROHIBIT: 188 return -EACCES; 189 case FR_ACT_BLACKHOLE: 190 default: 191 return -EINVAL; 192 } 193 194 arg->table = fib_rule_get_table(rule, arg); 195 196 mrt = __ipmr_get_table(rule->fr_net, arg->table); 197 if (!mrt) 198 return -EAGAIN; 199 res->mrt = mrt; 200 return 0; 201 } 202 203 static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags) 204 { 205 return 1; 206 } 207 208 static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb, 209 struct fib_rule_hdr *frh, struct nlattr **tb, 210 struct netlink_ext_ack *extack) 211 { 212 return 0; 213 } 214 215 static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh, 216 struct nlattr **tb) 217 { 218 return 1; 219 } 220 221 static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb, 222 struct fib_rule_hdr *frh) 223 { 224 frh->dst_len = 0; 225 frh->src_len = 0; 226 frh->tos = 0; 227 return 0; 228 } 229 230 static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = { 231 .family = RTNL_FAMILY_IPMR, 232 .rule_size = sizeof(struct ipmr_rule), 233 .addr_size = sizeof(u32), 234 .action = ipmr_rule_action, 235 .match = ipmr_rule_match, 236 .configure = ipmr_rule_configure, 237 .compare = ipmr_rule_compare, 238 .fill = ipmr_rule_fill, 239 .nlgroup = RTNLGRP_IPV4_RULE, 240 .owner = THIS_MODULE, 241 }; 242 243 static int __net_init ipmr_rules_init(struct net *net) 244 { 245 struct fib_rules_ops *ops; 246 LIST_HEAD(dev_kill_list); 247 struct mr_table *mrt; 248 int err; 249 250 ops = fib_rules_register(&ipmr_rules_ops_template, net); 251 if (IS_ERR(ops)) 252 return PTR_ERR(ops); 253 254 INIT_LIST_HEAD(&net->ipv4.mr_tables); 255 256 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT); 257 if (IS_ERR(mrt)) { 258 err = PTR_ERR(mrt); 259 goto err1; 260 } 261 262 err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT); 263 if (err < 0) 264 goto err2; 265 266 net->ipv4.mr_rules_ops = ops; 267 return 0; 268 269 err2: 270 ipmr_free_table(mrt, &dev_kill_list); 271 err1: 272 fib_rules_unregister(ops); 273 return err; 274 } 275 276 static void __net_exit ipmr_rules_exit(struct net *net) 277 { 278 fib_rules_unregister(net->ipv4.mr_rules_ops); 279 } 280 281 static void __net_exit ipmr_rules_exit_rtnl(struct net *net, 282 struct list_head *dev_kill_list) 283 { 284 struct mr_table *mrt, *next; 285 286 list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) { 287 list_del_rcu(&mrt->list); 288 ipmr_free_table(mrt, dev_kill_list); 289 } 290 } 291 292 static int ipmr_rules_dump(struct net *net, struct notifier_block *nb, 293 struct netlink_ext_ack *extack) 294 { 295 return fib_rules_dump(net, nb, RTNL_FAMILY_IPMR, extack); 296 } 297 298 static unsigned int ipmr_rules_seq_read(const struct net *net) 299 { 300 return fib_rules_seq_read(net, RTNL_FAMILY_IPMR); 301 } 302 303 bool ipmr_rule_default(const struct fib_rule *rule) 304 { 305 return fib_rule_matchall(rule) && rule->table == RT_TABLE_DEFAULT; 306 } 307 EXPORT_SYMBOL(ipmr_rule_default); 308 #else 309 static struct mr_table *ipmr_mr_table_iter(struct net *net, 310 struct mr_table *mrt) 311 { 312 if (!mrt) 313 return rcu_dereference(net->ipv4.mrt); 314 return NULL; 315 } 316 317 static struct mr_table *__ipmr_get_table(struct net *net, u32 id) 318 { 319 return rcu_dereference_check(net->ipv4.mrt, 320 lockdep_rtnl_is_held() || 321 !rcu_access_pointer(net->ipv4.mrt)); 322 } 323 324 #define ipmr_for_each_table(mrt, net) \ 325 for (mrt = __ipmr_get_table(net, 0); mrt; mrt = NULL) 326 327 static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4, 328 struct mr_table **mrt) 329 { 330 *mrt = rcu_dereference(net->ipv4.mrt); 331 if (!*mrt) 332 return -EAGAIN; 333 return 0; 334 } 335 336 static int __net_init ipmr_rules_init(struct net *net) 337 { 338 struct mr_table *mrt; 339 340 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT); 341 if (IS_ERR(mrt)) 342 return PTR_ERR(mrt); 343 344 rcu_assign_pointer(net->ipv4.mrt, mrt); 345 return 0; 346 } 347 348 static void __net_exit ipmr_rules_exit(struct net *net) 349 { 350 } 351 352 static void __net_exit ipmr_rules_exit_rtnl(struct net *net, 353 struct list_head *dev_kill_list) 354 { 355 struct mr_table *mrt = rcu_dereference_protected(net->ipv4.mrt, 1); 356 357 RCU_INIT_POINTER(net->ipv4.mrt, NULL); 358 ipmr_free_table(mrt, dev_kill_list); 359 } 360 361 static int ipmr_rules_dump(struct net *net, struct notifier_block *nb, 362 struct netlink_ext_ack *extack) 363 { 364 return 0; 365 } 366 367 static unsigned int ipmr_rules_seq_read(const struct net *net) 368 { 369 return 0; 370 } 371 372 bool ipmr_rule_default(const struct fib_rule *rule) 373 { 374 return true; 375 } 376 EXPORT_SYMBOL(ipmr_rule_default); 377 #endif 378 379 static struct mr_table *ipmr_get_table(struct net *net, u32 id) 380 { 381 struct mr_table *mrt; 382 383 rcu_read_lock(); 384 mrt = __ipmr_get_table(net, id); 385 rcu_read_unlock(); 386 387 return mrt; 388 } 389 390 static inline int ipmr_hash_cmp(struct rhashtable_compare_arg *arg, 391 const void *ptr) 392 { 393 const struct mfc_cache_cmp_arg *cmparg = arg->key; 394 const struct mfc_cache *c = ptr; 395 396 return cmparg->mfc_mcastgrp != c->mfc_mcastgrp || 397 cmparg->mfc_origin != c->mfc_origin; 398 } 399 400 static const struct rhashtable_params ipmr_rht_params = { 401 .head_offset = offsetof(struct mr_mfc, mnode), 402 .key_offset = offsetof(struct mfc_cache, cmparg), 403 .key_len = sizeof(struct mfc_cache_cmp_arg), 404 .nelem_hint = 3, 405 .obj_cmpfn = ipmr_hash_cmp, 406 .automatic_shrinking = true, 407 }; 408 409 static void ipmr_new_table_set(struct mr_table *mrt, 410 struct net *net) 411 { 412 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES 413 list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables); 414 #endif 415 } 416 417 static struct mfc_cache_cmp_arg ipmr_mr_table_ops_cmparg_any = { 418 .mfc_mcastgrp = htonl(INADDR_ANY), 419 .mfc_origin = htonl(INADDR_ANY), 420 }; 421 422 static struct mr_table_ops ipmr_mr_table_ops = { 423 .rht_params = &ipmr_rht_params, 424 .cmparg_any = &ipmr_mr_table_ops_cmparg_any, 425 }; 426 427 static struct mr_table *ipmr_new_table(struct net *net, u32 id) 428 { 429 struct mr_table *mrt; 430 431 /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */ 432 if (id != RT_TABLE_DEFAULT && id >= 1000000000) 433 return ERR_PTR(-EINVAL); 434 435 mrt = __ipmr_get_table(net, id); 436 if (mrt) 437 return mrt; 438 439 return mr_table_alloc(net, id, &ipmr_mr_table_ops, 440 ipmr_expire_process, ipmr_new_table_set); 441 } 442 443 static void ipmr_free_table(struct mr_table *mrt, struct list_head *dev_kill_list) 444 { 445 struct net *net = read_pnet(&mrt->net); 446 LIST_HEAD(ipmr_dev_kill_list); 447 448 WARN_ON_ONCE(!mr_can_free_table(net)); 449 450 mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC | 451 MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC, 452 &ipmr_dev_kill_list); 453 timer_shutdown_sync(&mrt->ipmr_expire_timer); 454 mr_table_free(mrt); 455 456 WARN_ON_ONCE(!net_initialized(net) && !list_empty(&ipmr_dev_kill_list)); 457 list_splice(&ipmr_dev_kill_list, dev_kill_list); 458 } 459 460 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */ 461 462 /* Initialize ipmr pimreg/tunnel in_device */ 463 static bool ipmr_init_vif_indev(const struct net_device *dev) 464 { 465 struct in_device *in_dev; 466 467 ASSERT_RTNL(); 468 469 in_dev = __in_dev_get_rtnl(dev); 470 if (!in_dev) 471 return false; 472 ipv4_devconf_setall(in_dev); 473 neigh_parms_data_state_setall(in_dev->arp_parms); 474 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 475 476 return true; 477 } 478 479 static struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v) 480 { 481 struct net_device *tunnel_dev, *new_dev; 482 struct ip_tunnel_parm_kern p = { }; 483 LIST_HEAD(dev_kill_list); 484 int err; 485 486 tunnel_dev = __dev_get_by_name(net, "tunl0"); 487 if (!tunnel_dev) 488 goto out; 489 490 p.iph.daddr = v->vifc_rmt_addr.s_addr; 491 p.iph.saddr = v->vifc_lcl_addr.s_addr; 492 p.iph.version = 4; 493 p.iph.ihl = 5; 494 p.iph.protocol = IPPROTO_IPIP; 495 sprintf(p.name, "dvmrp%d", v->vifc_vifi); 496 497 if (!tunnel_dev->netdev_ops->ndo_tunnel_ctl) 498 goto out; 499 err = tunnel_dev->netdev_ops->ndo_tunnel_ctl(tunnel_dev, &p, 500 SIOCADDTUNNEL); 501 if (err) 502 goto out; 503 504 new_dev = __dev_get_by_name(net, p.name); 505 if (!new_dev) 506 goto out; 507 508 new_dev->flags |= IFF_MULTICAST; 509 if (!ipmr_init_vif_indev(new_dev)) 510 goto out_unregister; 511 if (dev_open(new_dev, NULL)) 512 goto out_unregister; 513 dev_hold(new_dev); 514 err = dev_set_allmulti(new_dev, 1); 515 if (err) { 516 dev_close(new_dev); 517 tunnel_dev->netdev_ops->ndo_tunnel_ctl(tunnel_dev, &p, 518 SIOCDELTUNNEL); 519 dev_put(new_dev); 520 new_dev = ERR_PTR(err); 521 } 522 return new_dev; 523 524 out_unregister: 525 new_dev->rtnl_link_ops->dellink(new_dev, &dev_kill_list); 526 unregister_netdevice_many(&dev_kill_list); 527 out: 528 return ERR_PTR(-ENOBUFS); 529 } 530 531 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2) 532 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev) 533 { 534 struct net *net = dev_net(dev); 535 struct mr_table *mrt; 536 struct flowi4 fl4 = { 537 .flowi4_oif = dev->ifindex, 538 .flowi4_iif = skb->skb_iif ? : LOOPBACK_IFINDEX, 539 .flowi4_mark = skb->mark, 540 }; 541 int err; 542 543 if (skb->protocol != htons(ETH_P_IP) || !pskb_inet_may_pull(skb)) { 544 DEV_STATS_INC(dev, tx_errors); 545 kfree_skb(skb); 546 return NETDEV_TX_OK; 547 } 548 549 rcu_read_lock(); 550 err = ipmr_fib_lookup(net, &fl4, &mrt); 551 if (err < 0) { 552 rcu_read_unlock(); 553 kfree_skb(skb); 554 return err; 555 } 556 557 DEV_STATS_ADD(dev, tx_bytes, skb->len); 558 DEV_STATS_INC(dev, tx_packets); 559 560 /* skb->cb[] holds qdisc/tc state at this point, not IPCB. 561 * ipmr_cache_report() reads it as IPCB to build IP_PKTINFO. 562 */ 563 memset(IPCB(skb), 0, sizeof(*IPCB(skb))); 564 565 /* Pairs with WRITE_ONCE() in vif_add() and vif_delete() */ 566 ipmr_cache_report(mrt, skb, READ_ONCE(mrt->mroute_reg_vif_num), 567 IGMPMSG_WHOLEPKT, false); 568 569 rcu_read_unlock(); 570 kfree_skb(skb); 571 return NETDEV_TX_OK; 572 } 573 574 static int reg_vif_get_iflink(const struct net_device *dev) 575 { 576 return 0; 577 } 578 579 static const struct net_device_ops reg_vif_netdev_ops = { 580 .ndo_start_xmit = reg_vif_xmit, 581 .ndo_get_iflink = reg_vif_get_iflink, 582 }; 583 584 static void reg_vif_setup(struct net_device *dev) 585 { 586 dev->type = ARPHRD_PIMREG; 587 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8; 588 dev->flags = IFF_NOARP; 589 dev->netdev_ops = ®_vif_netdev_ops; 590 dev->needs_free_netdev = true; 591 dev->netns_immutable = true; 592 } 593 594 static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt) 595 { 596 struct net_device *dev; 597 char name[IFNAMSIZ]; 598 599 if (mrt->id == RT_TABLE_DEFAULT) 600 sprintf(name, "pimreg"); 601 else 602 sprintf(name, "pimreg%u", mrt->id); 603 604 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup); 605 606 if (!dev) 607 return NULL; 608 609 dev_net_set(dev, net); 610 611 if (register_netdevice(dev)) { 612 free_netdev(dev); 613 return NULL; 614 } 615 616 if (!ipmr_init_vif_indev(dev)) 617 goto failure; 618 if (dev_open(dev, NULL)) 619 goto failure; 620 621 dev_hold(dev); 622 623 return dev; 624 625 failure: 626 unregister_netdevice(dev); 627 return NULL; 628 } 629 630 /* called with rcu_read_lock() */ 631 static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb, 632 unsigned int pimlen) 633 { 634 struct net_device *reg_dev = NULL; 635 struct iphdr *encap; 636 int vif_num; 637 638 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen); 639 /* Check that: 640 * a. packet is really sent to a multicast group 641 * b. packet is not a NULL-REGISTER 642 * c. packet is not truncated 643 */ 644 if (!ipv4_is_multicast(encap->daddr) || 645 encap->tot_len == 0 || 646 ntohs(encap->tot_len) + pimlen > skb->len) 647 return 1; 648 649 /* Pairs with WRITE_ONCE() in vif_add()/vid_delete() */ 650 vif_num = READ_ONCE(mrt->mroute_reg_vif_num); 651 if (vif_num >= 0) 652 reg_dev = vif_dev_read(&mrt->vif_table[vif_num]); 653 if (!reg_dev) 654 return 1; 655 656 skb->mac_header = skb->network_header; 657 skb_pull(skb, (u8 *)encap - skb->data); 658 skb_reset_network_header(skb); 659 skb->protocol = htons(ETH_P_IP); 660 skb->ip_summed = CHECKSUM_NONE; 661 662 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev)); 663 664 netif_rx(skb); 665 666 return NET_RX_SUCCESS; 667 } 668 #else 669 static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt) 670 { 671 return NULL; 672 } 673 #endif 674 675 static int call_ipmr_vif_entry_notifiers(struct net *net, 676 enum fib_event_type event_type, 677 struct vif_device *vif, 678 struct net_device *vif_dev, 679 vifi_t vif_index, u32 tb_id) 680 { 681 return mr_call_vif_notifiers(net, RTNL_FAMILY_IPMR, event_type, 682 vif, vif_dev, vif_index, tb_id, 683 &net->ipv4.ipmr_seq); 684 } 685 686 static int call_ipmr_mfc_entry_notifiers(struct net *net, 687 enum fib_event_type event_type, 688 struct mfc_cache *mfc, u32 tb_id) 689 { 690 return mr_call_mfc_notifiers(net, RTNL_FAMILY_IPMR, event_type, 691 &mfc->_c, tb_id, &net->ipv4.ipmr_seq); 692 } 693 694 /** 695 * vif_delete - Delete a VIF entry 696 * @mrt: Table to delete from 697 * @vifi: VIF identifier to delete 698 * @notify: Set to 1, if the caller is a notifier_call 699 * @head: if unregistering the VIF, place it on this queue 700 */ 701 static int vif_delete(struct mr_table *mrt, int vifi, int notify, 702 struct list_head *head) 703 { 704 struct net *net = read_pnet(&mrt->net); 705 struct vif_device *v; 706 struct net_device *dev; 707 struct in_device *in_dev; 708 709 if (vifi < 0 || vifi >= mrt->maxvif) 710 return -EADDRNOTAVAIL; 711 712 v = &mrt->vif_table[vifi]; 713 714 dev = rtnl_dereference(v->dev); 715 if (!dev) 716 return -EADDRNOTAVAIL; 717 718 spin_lock(&mrt_lock); 719 call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_DEL, v, dev, 720 vifi, mrt->id); 721 RCU_INIT_POINTER(v->dev, NULL); 722 723 if (vifi == mrt->mroute_reg_vif_num) { 724 /* Pairs with READ_ONCE() in ipmr_cache_report() and reg_vif_xmit() */ 725 WRITE_ONCE(mrt->mroute_reg_vif_num, -1); 726 } 727 if (vifi + 1 == mrt->maxvif) { 728 int tmp; 729 730 for (tmp = vifi - 1; tmp >= 0; tmp--) { 731 if (VIF_EXISTS(mrt, tmp)) 732 break; 733 } 734 WRITE_ONCE(mrt->maxvif, tmp + 1); 735 } 736 737 spin_unlock(&mrt_lock); 738 739 dev_set_allmulti(dev, -1); 740 741 in_dev = __in_dev_get_rtnl(dev); 742 if (in_dev) { 743 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--; 744 inet_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF, 745 NETCONFA_MC_FORWARDING, 746 dev->ifindex, &in_dev->cnf); 747 ip_rt_multicast_event(in_dev); 748 } 749 750 if (!notify) { 751 if (v->flags & VIFF_TUNNEL) 752 dev->rtnl_link_ops->dellink(dev, head); 753 else if (v->flags & VIFF_REGISTER) 754 unregister_netdevice_queue(dev, head); 755 } 756 757 netdev_put(dev, &v->dev_tracker); 758 return 0; 759 } 760 761 static void ipmr_cache_free_rcu(struct rcu_head *head) 762 { 763 struct mr_mfc *c = container_of(head, struct mr_mfc, rcu); 764 765 kmem_cache_free(mrt_cachep, (struct mfc_cache *)c); 766 } 767 768 static void ipmr_cache_free(struct mfc_cache *c) 769 { 770 call_rcu(&c->_c.rcu, ipmr_cache_free_rcu); 771 } 772 773 /* Destroy an unresolved cache entry, killing queued skbs 774 * and reporting error to netlink readers. 775 */ 776 static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c) 777 { 778 struct net *net = read_pnet(&mrt->net); 779 struct sk_buff *skb; 780 struct nlmsgerr *e; 781 782 WRITE_ONCE(mrt->cache_resolve_queue_len, 783 mrt->cache_resolve_queue_len - 1); 784 785 while ((skb = skb_dequeue(&c->_c.mfc_un.unres.nl_queries))) { 786 struct nlmsghdr *nlh = skb_pull(skb, sizeof(struct iphdr)); 787 788 nlh->nlmsg_type = NLMSG_ERROR; 789 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr)); 790 skb_trim(skb, nlh->nlmsg_len); 791 e = nlmsg_data(nlh); 792 e->error = -ETIMEDOUT; 793 memset(&e->msg, 0, sizeof(e->msg)); 794 795 rtnl_unicast(skb, net, NETLINK_CB(skb).portid); 796 } 797 798 skb_queue_purge(&c->_c.mfc_un.unres.unresolved); 799 800 ipmr_cache_free(c); 801 } 802 803 /* Timer process for the unresolved queue. */ 804 static void ipmr_expire_process(struct timer_list *t) 805 { 806 struct mr_table *mrt = timer_container_of(mrt, t, ipmr_expire_timer); 807 struct mr_mfc *c, *next; 808 unsigned long expires; 809 unsigned long now; 810 811 if (!spin_trylock(&mfc_unres_lock)) { 812 mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10); 813 return; 814 } 815 816 if (list_empty(&mrt->mfc_unres_queue)) 817 goto out; 818 819 now = jiffies; 820 expires = 10*HZ; 821 822 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) { 823 if (time_after(c->mfc_un.unres.expires, now)) { 824 unsigned long interval = c->mfc_un.unres.expires - now; 825 if (interval < expires) 826 expires = interval; 827 continue; 828 } 829 830 list_del(&c->list); 831 mroute_netlink_event(mrt, (struct mfc_cache *)c, RTM_DELROUTE); 832 ipmr_destroy_unres(mrt, (struct mfc_cache *)c); 833 } 834 835 if (!list_empty(&mrt->mfc_unres_queue)) 836 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires); 837 838 out: 839 spin_unlock(&mfc_unres_lock); 840 } 841 842 /* Fill oifs list. It is called under locked mrt_lock. */ 843 static void ipmr_update_thresholds(struct mr_table *mrt, struct mr_mfc *cache, 844 unsigned char *ttls) 845 { 846 int vifi; 847 848 cache->mfc_un.res.minvif = MAXVIFS; 849 cache->mfc_un.res.maxvif = 0; 850 memset(cache->mfc_un.res.ttls, 255, MAXVIFS); 851 852 for (vifi = 0; vifi < mrt->maxvif; vifi++) { 853 if (VIF_EXISTS(mrt, vifi) && 854 ttls[vifi] && ttls[vifi] < 255) { 855 cache->mfc_un.res.ttls[vifi] = ttls[vifi]; 856 if (cache->mfc_un.res.minvif > vifi) 857 cache->mfc_un.res.minvif = vifi; 858 if (cache->mfc_un.res.maxvif <= vifi) 859 cache->mfc_un.res.maxvif = vifi + 1; 860 } 861 } 862 WRITE_ONCE(cache->mfc_un.res.lastuse, jiffies); 863 } 864 865 static int vif_add(struct net *net, struct mr_table *mrt, 866 struct vifctl *vifc, int mrtsock) 867 { 868 struct netdev_phys_item_id ppid = { }; 869 int vifi = vifc->vifc_vifi; 870 struct vif_device *v = &mrt->vif_table[vifi]; 871 struct net_device *dev; 872 struct in_device *in_dev; 873 int err; 874 875 /* Is vif busy ? */ 876 if (VIF_EXISTS(mrt, vifi)) 877 return -EADDRINUSE; 878 879 switch (vifc->vifc_flags) { 880 case VIFF_REGISTER: 881 if (!ipmr_pimsm_enabled()) 882 return -EINVAL; 883 /* Special Purpose VIF in PIM 884 * All the packets will be sent to the daemon 885 */ 886 if (mrt->mroute_reg_vif_num >= 0) 887 return -EADDRINUSE; 888 dev = ipmr_reg_vif(net, mrt); 889 if (!dev) 890 return -ENOBUFS; 891 err = dev_set_allmulti(dev, 1); 892 if (err) { 893 unregister_netdevice(dev); 894 dev_put(dev); 895 return err; 896 } 897 break; 898 case VIFF_TUNNEL: 899 dev = ipmr_new_tunnel(net, vifc); 900 if (IS_ERR(dev)) 901 return PTR_ERR(dev); 902 break; 903 case VIFF_USE_IFINDEX: 904 case 0: 905 if (vifc->vifc_flags == VIFF_USE_IFINDEX) { 906 dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex); 907 if (dev && !__in_dev_get_rtnl(dev)) { 908 dev_put(dev); 909 return -EADDRNOTAVAIL; 910 } 911 } else { 912 dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr); 913 } 914 if (!dev) 915 return -EADDRNOTAVAIL; 916 err = dev_set_allmulti(dev, 1); 917 if (err) { 918 dev_put(dev); 919 return err; 920 } 921 break; 922 default: 923 return -EINVAL; 924 } 925 926 in_dev = __in_dev_get_rtnl(dev); 927 if (!in_dev) { 928 dev_put(dev); 929 return -EADDRNOTAVAIL; 930 } 931 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++; 932 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_MC_FORWARDING, 933 dev->ifindex, &in_dev->cnf); 934 ip_rt_multicast_event(in_dev); 935 936 /* Fill in the VIF structures */ 937 vif_device_init(v, dev, vifc->vifc_rate_limit, 938 vifc->vifc_threshold, 939 vifc->vifc_flags | (!mrtsock ? VIFF_STATIC : 0), 940 (VIFF_TUNNEL | VIFF_REGISTER)); 941 942 err = netif_get_port_parent_id(dev, &ppid, true); 943 if (err == 0) { 944 memcpy(v->dev_parent_id.id, ppid.id, ppid.id_len); 945 v->dev_parent_id.id_len = ppid.id_len; 946 } else { 947 v->dev_parent_id.id_len = 0; 948 } 949 950 v->local = vifc->vifc_lcl_addr.s_addr; 951 v->remote = vifc->vifc_rmt_addr.s_addr; 952 953 /* And finish update writing critical data */ 954 spin_lock(&mrt_lock); 955 rcu_assign_pointer(v->dev, dev); 956 netdev_tracker_alloc(dev, &v->dev_tracker, GFP_ATOMIC); 957 if (v->flags & VIFF_REGISTER) { 958 /* Pairs with READ_ONCE() in ipmr_cache_report() and reg_vif_xmit() */ 959 WRITE_ONCE(mrt->mroute_reg_vif_num, vifi); 960 } 961 if (vifi+1 > mrt->maxvif) 962 WRITE_ONCE(mrt->maxvif, vifi + 1); 963 spin_unlock(&mrt_lock); 964 call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD, v, dev, 965 vifi, mrt->id); 966 return 0; 967 } 968 969 /* called with rcu_read_lock() */ 970 static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt, 971 __be32 origin, 972 __be32 mcastgrp) 973 { 974 struct mfc_cache_cmp_arg arg = { 975 .mfc_mcastgrp = mcastgrp, 976 .mfc_origin = origin 977 }; 978 979 return mr_mfc_find(mrt, &arg); 980 } 981 982 /* Look for a (*,G) entry */ 983 static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt, 984 __be32 mcastgrp, int vifi) 985 { 986 struct mfc_cache_cmp_arg arg = { 987 .mfc_mcastgrp = mcastgrp, 988 .mfc_origin = htonl(INADDR_ANY) 989 }; 990 991 if (mcastgrp == htonl(INADDR_ANY)) 992 return mr_mfc_find_any_parent(mrt, vifi); 993 return mr_mfc_find_any(mrt, vifi, &arg); 994 } 995 996 /* Look for a (S,G,iif) entry if parent != -1 */ 997 static struct mfc_cache *ipmr_cache_find_parent(struct mr_table *mrt, 998 __be32 origin, __be32 mcastgrp, 999 int parent) 1000 { 1001 struct mfc_cache_cmp_arg arg = { 1002 .mfc_mcastgrp = mcastgrp, 1003 .mfc_origin = origin, 1004 }; 1005 1006 return mr_mfc_find_parent(mrt, &arg, parent); 1007 } 1008 1009 /* Allocate a multicast cache entry */ 1010 static struct mfc_cache *ipmr_cache_alloc(void) 1011 { 1012 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL); 1013 1014 if (c) { 1015 c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1; 1016 c->_c.mfc_un.res.minvif = MAXVIFS; 1017 c->_c.free = ipmr_cache_free_rcu; 1018 refcount_set(&c->_c.mfc_un.res.refcount, 1); 1019 } 1020 return c; 1021 } 1022 1023 static struct mfc_cache *ipmr_cache_alloc_unres(void) 1024 { 1025 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC); 1026 1027 if (c) { 1028 skb_queue_head_init(&c->_c.mfc_un.unres.unresolved); 1029 skb_queue_head_init(&c->_c.mfc_un.unres.nl_queries); 1030 c->_c.mfc_un.unres.expires = jiffies + 10 * HZ; 1031 } 1032 return c; 1033 } 1034 1035 /* A cache entry has gone into a resolved state from queued */ 1036 static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt, 1037 struct mfc_cache *uc, struct mfc_cache *c) 1038 { 1039 struct sk_buff *skb; 1040 struct nlmsgerr *e; 1041 1042 /* Answer the pending netlink route queries */ 1043 while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.nl_queries))) { 1044 struct nlmsghdr *nlh = skb_pull(skb, sizeof(struct iphdr)); 1045 1046 if (mr_fill_mroute(mrt, skb, &c->_c, nlmsg_data(nlh)) > 0) { 1047 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh; 1048 } else { 1049 nlh->nlmsg_type = NLMSG_ERROR; 1050 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr)); 1051 skb_trim(skb, nlh->nlmsg_len); 1052 e = nlmsg_data(nlh); 1053 e->error = -EMSGSIZE; 1054 memset(&e->msg, 0, sizeof(e->msg)); 1055 } 1056 1057 rtnl_unicast(skb, net, NETLINK_CB(skb).portid); 1058 } 1059 1060 /* Play the pending packets through our router */ 1061 while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) { 1062 rcu_read_lock(); 1063 ip_mr_forward(net, mrt, skb->dev, skb, c, 0); 1064 rcu_read_unlock(); 1065 } 1066 } 1067 1068 /* Bounce a cache query up to mrouted and netlink. 1069 * 1070 * Called under rcu_read_lock(). 1071 */ 1072 static int ipmr_cache_report(const struct mr_table *mrt, 1073 struct sk_buff *pkt, vifi_t vifi, int assert, 1074 bool nl_query) 1075 { 1076 unsigned char pkt_cb[sizeof(pkt->cb)]; 1077 const int ihl = ip_hdrlen(pkt); 1078 struct sock *mroute_sk; 1079 struct igmphdr *igmp; 1080 struct igmpmsg *msg; 1081 struct sk_buff *skb; 1082 int ret; 1083 1084 mroute_sk = rcu_dereference(mrt->mroute_sk); 1085 if (!mroute_sk) 1086 return -EINVAL; 1087 1088 if (assert == IGMPMSG_WHOLEPKT || assert == IGMPMSG_WRVIFWHOLE) 1089 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr)); 1090 else 1091 skb = alloc_skb(128, GFP_ATOMIC); 1092 1093 if (!skb) 1094 return -ENOBUFS; 1095 1096 if (assert == IGMPMSG_WHOLEPKT || assert == IGMPMSG_WRVIFWHOLE) { 1097 /* Ugly, but we have no choice with this interface. 1098 * Duplicate old header, fix ihl, length etc. 1099 * And all this only to mangle msg->im_msgtype and 1100 * to set msg->im_mbz to "mbz" :-) 1101 */ 1102 skb_push(skb, sizeof(struct iphdr)); 1103 skb_reset_network_header(skb); 1104 skb_reset_transport_header(skb); 1105 msg = (struct igmpmsg *)skb_network_header(skb); 1106 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr)); 1107 msg->im_msgtype = assert; 1108 msg->im_mbz = 0; 1109 if (assert == IGMPMSG_WRVIFWHOLE) { 1110 msg->im_vif = vifi; 1111 msg->im_vif_hi = vifi >> 8; 1112 } else { 1113 /* Pairs with WRITE_ONCE() in vif_add() and vif_delete() */ 1114 int vif_num = READ_ONCE(mrt->mroute_reg_vif_num); 1115 1116 msg->im_vif = vif_num; 1117 msg->im_vif_hi = vif_num >> 8; 1118 } 1119 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2; 1120 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) + 1121 sizeof(struct iphdr)); 1122 } else { 1123 /* Copy the IP header */ 1124 skb_set_network_header(skb, skb->len); 1125 skb_put(skb, ihl); 1126 skb_copy_to_linear_data(skb, pkt->data, ihl); 1127 /* Flag to the kernel this is a route add */ 1128 ip_hdr(skb)->protocol = 0; 1129 msg = (struct igmpmsg *)skb_network_header(skb); 1130 msg->im_vif = vifi; 1131 msg->im_vif_hi = vifi >> 8; 1132 /* Add our header. 1133 * Note that code, csum and group fields are cleared. 1134 */ 1135 igmp = skb_put_zero(skb, sizeof(struct igmphdr)); 1136 igmp->type = assert; 1137 msg->im_msgtype = assert; 1138 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */ 1139 skb->transport_header = skb->network_header; 1140 } 1141 1142 memset(skb->cb, 0, sizeof(skb->cb)); 1143 /* Route queries from ipmr_get_route() carry NETLINK_CB, not IPCB. */ 1144 if (!nl_query) { 1145 memcpy(pkt_cb, pkt->cb, sizeof(pkt_cb)); 1146 ipv4_pktinfo_prepare(mroute_sk, pkt, false); 1147 *PKTINFO_SKB_CB(skb) = *PKTINFO_SKB_CB(pkt); 1148 memcpy(pkt->cb, pkt_cb, sizeof(pkt_cb)); 1149 } 1150 1151 igmpmsg_netlink_event(mrt, skb); 1152 1153 /* Deliver to mrouted */ 1154 ret = sock_queue_rcv_skb(mroute_sk, skb); 1155 1156 if (ret < 0) { 1157 net_warn_ratelimited("mroute: pending queue full, dropping entries\n"); 1158 kfree_skb(skb); 1159 } 1160 1161 return ret; 1162 } 1163 1164 /* Queue a packet for resolution. It gets locked cache entry! */ 1165 /* Called under rcu_read_lock() */ 1166 static int ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, 1167 struct sk_buff *skb, struct net_device *dev, 1168 bool nl_query) 1169 { 1170 struct net *net = read_pnet(&mrt->net); 1171 const struct iphdr *iph = ip_hdr(skb); 1172 struct mfc_cache *c = NULL; 1173 bool found = false; 1174 int err; 1175 1176 spin_lock_bh(&mfc_unres_lock); 1177 1178 if (!check_net(net)) { 1179 err = -EINVAL; 1180 goto err; 1181 } 1182 1183 list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) { 1184 if (c->mfc_mcastgrp == iph->daddr && 1185 c->mfc_origin == iph->saddr) { 1186 found = true; 1187 break; 1188 } 1189 } 1190 1191 if (!found) { 1192 /* Create a new entry if allowable */ 1193 c = ipmr_cache_alloc_unres(); 1194 if (!c) { 1195 err = -ENOBUFS; 1196 goto err; 1197 } 1198 1199 /* Fill in the new cache entry */ 1200 c->_c.mfc_parent = -1; 1201 c->mfc_origin = iph->saddr; 1202 c->mfc_mcastgrp = iph->daddr; 1203 1204 /* Reflect first query at mrouted. */ 1205 err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE, 1206 nl_query); 1207 if (err < 0) 1208 goto err; 1209 1210 WRITE_ONCE(mrt->cache_resolve_queue_len, 1211 mrt->cache_resolve_queue_len + 1); 1212 list_add(&c->_c.list, &mrt->mfc_unres_queue); 1213 mroute_netlink_event(mrt, c, RTM_NEWROUTE); 1214 1215 if (mrt->cache_resolve_queue_len == 1) 1216 mod_timer(&mrt->ipmr_expire_timer, 1217 c->_c.mfc_un.unres.expires); 1218 } 1219 1220 /* See if we can append the packet */ 1221 if (skb_queue_len(&c->_c.mfc_un.unres.unresolved) + 1222 skb_queue_len(&c->_c.mfc_un.unres.nl_queries) > 3) { 1223 c = NULL; 1224 err = -ENOBUFS; 1225 goto err; 1226 } 1227 1228 if (dev) { 1229 skb->dev = dev; 1230 skb->skb_iif = dev->ifindex; 1231 } 1232 1233 skb_queue_tail(nl_query ? &c->_c.mfc_un.unres.nl_queries : 1234 &c->_c.mfc_un.unres.unresolved, skb); 1235 1236 spin_unlock_bh(&mfc_unres_lock); 1237 return 0; 1238 1239 err: 1240 spin_unlock_bh(&mfc_unres_lock); 1241 if (c) 1242 ipmr_cache_free(c); 1243 kfree_skb(skb); 1244 return err; 1245 } 1246 1247 /* MFC cache manipulation by user space mroute daemon */ 1248 1249 static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent) 1250 { 1251 struct net *net = read_pnet(&mrt->net); 1252 struct mfc_cache *c; 1253 1254 rcu_read_lock(); 1255 c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr, 1256 mfc->mfcc_mcastgrp.s_addr, parent); 1257 rcu_read_unlock(); 1258 if (!c) 1259 return -ENOENT; 1260 rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ipmr_rht_params); 1261 list_del_rcu(&c->_c.list); 1262 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, c, mrt->id); 1263 mroute_netlink_event(mrt, c, RTM_DELROUTE); 1264 mr_cache_put(&c->_c); 1265 1266 return 0; 1267 } 1268 1269 static int ipmr_mfc_add(struct net *net, struct mr_table *mrt, 1270 struct mfcctl *mfc, int mrtsock, int parent) 1271 { 1272 struct mfc_cache *uc, *c; 1273 struct mr_mfc *_uc; 1274 bool found; 1275 int ret; 1276 1277 if (mfc->mfcc_parent >= MAXVIFS) 1278 return -ENFILE; 1279 1280 rcu_read_lock(); 1281 c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr, 1282 mfc->mfcc_mcastgrp.s_addr, parent); 1283 rcu_read_unlock(); 1284 if (c) { 1285 spin_lock(&mrt_lock); 1286 c->_c.mfc_parent = mfc->mfcc_parent; 1287 ipmr_update_thresholds(mrt, &c->_c, mfc->mfcc_ttls); 1288 if (!mrtsock) 1289 c->_c.mfc_flags |= MFC_STATIC; 1290 spin_unlock(&mrt_lock); 1291 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE, c, 1292 mrt->id); 1293 mroute_netlink_event(mrt, c, RTM_NEWROUTE); 1294 return 0; 1295 } 1296 1297 if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) && 1298 !ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr)) 1299 return -EINVAL; 1300 1301 c = ipmr_cache_alloc(); 1302 if (!c) 1303 return -ENOMEM; 1304 1305 c->mfc_origin = mfc->mfcc_origin.s_addr; 1306 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr; 1307 c->_c.mfc_parent = mfc->mfcc_parent; 1308 ipmr_update_thresholds(mrt, &c->_c, mfc->mfcc_ttls); 1309 if (!mrtsock) 1310 c->_c.mfc_flags |= MFC_STATIC; 1311 1312 ret = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode, 1313 ipmr_rht_params); 1314 if (ret) { 1315 pr_err("ipmr: rhtable insert error %d\n", ret); 1316 ipmr_cache_free(c); 1317 return ret; 1318 } 1319 list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list); 1320 /* Check to see if we resolved a queued list. If so we 1321 * need to send on the frames and tidy up. 1322 */ 1323 found = false; 1324 spin_lock_bh(&mfc_unres_lock); 1325 list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) { 1326 uc = (struct mfc_cache *)_uc; 1327 if (uc->mfc_origin == c->mfc_origin && 1328 uc->mfc_mcastgrp == c->mfc_mcastgrp) { 1329 list_del(&_uc->list); 1330 WRITE_ONCE(mrt->cache_resolve_queue_len, 1331 mrt->cache_resolve_queue_len - 1); 1332 found = true; 1333 break; 1334 } 1335 } 1336 if (list_empty(&mrt->mfc_unres_queue)) 1337 timer_delete(&mrt->ipmr_expire_timer); 1338 spin_unlock_bh(&mfc_unres_lock); 1339 1340 if (found) { 1341 ipmr_cache_resolve(net, mrt, uc, c); 1342 ipmr_cache_free(uc); 1343 } 1344 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD, c, mrt->id); 1345 mroute_netlink_event(mrt, c, RTM_NEWROUTE); 1346 return 0; 1347 } 1348 1349 /* Close the multicast socket, and clear the vif tables etc */ 1350 static void mroute_clean_tables(struct mr_table *mrt, int flags, 1351 struct list_head *dev_kill_list) 1352 { 1353 struct net *net = read_pnet(&mrt->net); 1354 struct mfc_cache *cache; 1355 struct mr_mfc *c, *tmp; 1356 int i; 1357 1358 /* Shut down all active vif entries */ 1359 if (flags & (MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC)) { 1360 for (i = 0; i < mrt->maxvif; i++) { 1361 if (((mrt->vif_table[i].flags & VIFF_STATIC) && 1362 !(flags & MRT_FLUSH_VIFS_STATIC)) || 1363 (!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT_FLUSH_VIFS))) 1364 continue; 1365 vif_delete(mrt, i, 0, dev_kill_list); 1366 } 1367 } 1368 1369 /* Wipe the cache */ 1370 if (flags & (MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC)) { 1371 mutex_lock(&net->ipv4.mfc_mutex); 1372 1373 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) { 1374 if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT_FLUSH_MFC_STATIC)) || 1375 (!(c->mfc_flags & MFC_STATIC) && !(flags & MRT_FLUSH_MFC))) 1376 continue; 1377 rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params); 1378 list_del_rcu(&c->list); 1379 cache = (struct mfc_cache *)c; 1380 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, cache, 1381 mrt->id); 1382 mroute_netlink_event(mrt, cache, RTM_DELROUTE); 1383 mr_cache_put(c); 1384 } 1385 1386 mutex_unlock(&net->ipv4.mfc_mutex); 1387 } 1388 1389 if (flags & MRT_FLUSH_MFC) { 1390 if (READ_ONCE(mrt->cache_resolve_queue_len) || !check_net(net)) { 1391 spin_lock_bh(&mfc_unres_lock); 1392 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) { 1393 list_del(&c->list); 1394 cache = (struct mfc_cache *)c; 1395 mroute_netlink_event(mrt, cache, RTM_DELROUTE); 1396 ipmr_destroy_unres(mrt, cache); 1397 } 1398 spin_unlock_bh(&mfc_unres_lock); 1399 } 1400 } 1401 } 1402 1403 /* called from ip_ra_control(), before an RCU grace period, 1404 * we don't need to call synchronize_rcu() here 1405 */ 1406 static void mrtsock_destruct(struct sock *sk) 1407 { 1408 struct net *net = sock_net(sk); 1409 LIST_HEAD(dev_kill_list); 1410 struct mr_table *mrt; 1411 1412 rtnl_lock(); 1413 1414 ipmr_for_each_table(mrt, net) { 1415 if (sk == rtnl_dereference(mrt->mroute_sk)) { 1416 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--; 1417 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 1418 NETCONFA_MC_FORWARDING, 1419 NETCONFA_IFINDEX_ALL, 1420 net->ipv4.devconf_all); 1421 RCU_INIT_POINTER(mrt->mroute_sk, NULL); 1422 mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_MFC, 1423 &dev_kill_list); 1424 } 1425 } 1426 1427 unregister_netdevice_many(&dev_kill_list); 1428 1429 rtnl_unlock(); 1430 } 1431 1432 /* Socket options and virtual interface manipulation. The whole 1433 * virtual interface system is a complete heap, but unfortunately 1434 * that's how BSD mrouted happens to think. Maybe one day with a proper 1435 * MOSPF/PIM router set up we can clean this up. 1436 */ 1437 1438 int ip_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval, 1439 unsigned int optlen) 1440 { 1441 struct net *net = sock_net(sk); 1442 int val, ret = 0, parent = 0; 1443 struct mr_table *mrt; 1444 struct vifctl vif; 1445 struct mfcctl mfc; 1446 bool do_wrvifwhole; 1447 u32 uval; 1448 1449 /* There's one exception to the lock - MRT_DONE which needs to unlock */ 1450 rtnl_lock(); 1451 if (sk->sk_type != SOCK_RAW || 1452 inet_sk(sk)->inet_num != IPPROTO_IGMP) { 1453 ret = -EOPNOTSUPP; 1454 goto out_unlock; 1455 } 1456 1457 mrt = __ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT); 1458 if (!mrt) { 1459 ret = -ENOENT; 1460 goto out_unlock; 1461 } 1462 if (optname != MRT_INIT) { 1463 if (sk != rcu_access_pointer(mrt->mroute_sk) && 1464 !ns_capable(net->user_ns, CAP_NET_ADMIN)) { 1465 ret = -EACCES; 1466 goto out_unlock; 1467 } 1468 } 1469 1470 switch (optname) { 1471 case MRT_INIT: 1472 if (optlen != sizeof(int)) { 1473 ret = -EINVAL; 1474 break; 1475 } 1476 if (rtnl_dereference(mrt->mroute_sk)) { 1477 ret = -EADDRINUSE; 1478 break; 1479 } 1480 1481 ret = ip_ra_control(sk, 1, mrtsock_destruct); 1482 if (ret == 0) { 1483 rcu_assign_pointer(mrt->mroute_sk, sk); 1484 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++; 1485 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, 1486 NETCONFA_MC_FORWARDING, 1487 NETCONFA_IFINDEX_ALL, 1488 net->ipv4.devconf_all); 1489 } 1490 break; 1491 case MRT_DONE: 1492 if (sk != rcu_access_pointer(mrt->mroute_sk)) { 1493 ret = -EACCES; 1494 } else { 1495 /* We need to unlock here because mrtsock_destruct takes 1496 * care of rtnl itself and we can't change that due to 1497 * the IP_ROUTER_ALERT setsockopt which runs without it. 1498 */ 1499 rtnl_unlock(); 1500 ret = ip_ra_control(sk, 0, NULL); 1501 goto out; 1502 } 1503 break; 1504 case MRT_ADD_VIF: 1505 case MRT_DEL_VIF: 1506 if (optlen != sizeof(vif)) { 1507 ret = -EINVAL; 1508 break; 1509 } 1510 if (copy_from_sockptr(&vif, optval, sizeof(vif))) { 1511 ret = -EFAULT; 1512 break; 1513 } 1514 if (vif.vifc_vifi >= MAXVIFS) { 1515 ret = -ENFILE; 1516 break; 1517 } 1518 if (optname == MRT_ADD_VIF) { 1519 ret = vif_add(net, mrt, &vif, 1520 sk == rtnl_dereference(mrt->mroute_sk)); 1521 } else { 1522 ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL); 1523 } 1524 break; 1525 /* Manipulate the forwarding caches. These live 1526 * in a sort of kernel/user symbiosis. 1527 */ 1528 case MRT_ADD_MFC: 1529 case MRT_DEL_MFC: 1530 parent = -1; 1531 fallthrough; 1532 case MRT_ADD_MFC_PROXY: 1533 case MRT_DEL_MFC_PROXY: 1534 if (optlen != sizeof(mfc)) { 1535 ret = -EINVAL; 1536 break; 1537 } 1538 if (copy_from_sockptr(&mfc, optval, sizeof(mfc))) { 1539 ret = -EFAULT; 1540 break; 1541 } 1542 if (parent == 0) 1543 parent = mfc.mfcc_parent; 1544 1545 mutex_lock(&net->ipv4.mfc_mutex); 1546 1547 if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY) 1548 ret = ipmr_mfc_delete(mrt, &mfc, parent); 1549 else 1550 ret = ipmr_mfc_add(net, mrt, &mfc, 1551 sk == rtnl_dereference(mrt->mroute_sk), 1552 parent); 1553 1554 mutex_unlock(&net->ipv4.mfc_mutex); 1555 break; 1556 case MRT_FLUSH: { 1557 LIST_HEAD(dev_kill_list); 1558 1559 if (optlen != sizeof(val)) { 1560 ret = -EINVAL; 1561 break; 1562 } 1563 if (copy_from_sockptr(&val, optval, sizeof(val))) { 1564 ret = -EFAULT; 1565 break; 1566 } 1567 1568 mroute_clean_tables(mrt, val, &dev_kill_list); 1569 unregister_netdevice_many(&dev_kill_list); 1570 break; 1571 } 1572 /* Control PIM assert. */ 1573 case MRT_ASSERT: 1574 if (optlen != sizeof(val)) { 1575 ret = -EINVAL; 1576 break; 1577 } 1578 if (copy_from_sockptr(&val, optval, sizeof(val))) { 1579 ret = -EFAULT; 1580 break; 1581 } 1582 WRITE_ONCE(mrt->mroute_do_assert, val); 1583 break; 1584 case MRT_PIM: 1585 if (!ipmr_pimsm_enabled()) { 1586 ret = -ENOPROTOOPT; 1587 break; 1588 } 1589 if (optlen != sizeof(val)) { 1590 ret = -EINVAL; 1591 break; 1592 } 1593 if (copy_from_sockptr(&val, optval, sizeof(val))) { 1594 ret = -EFAULT; 1595 break; 1596 } 1597 1598 do_wrvifwhole = (val == IGMPMSG_WRVIFWHOLE); 1599 val = !!val; 1600 if (val != mrt->mroute_do_pim) { 1601 WRITE_ONCE(mrt->mroute_do_pim, val); 1602 WRITE_ONCE(mrt->mroute_do_assert, val); 1603 WRITE_ONCE(mrt->mroute_do_wrvifwhole, do_wrvifwhole); 1604 } 1605 break; 1606 case MRT_TABLE: 1607 if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES)) { 1608 ret = -ENOPROTOOPT; 1609 break; 1610 } 1611 if (optlen != sizeof(uval)) { 1612 ret = -EINVAL; 1613 break; 1614 } 1615 if (copy_from_sockptr(&uval, optval, sizeof(uval))) { 1616 ret = -EFAULT; 1617 break; 1618 } 1619 1620 if (sk == rtnl_dereference(mrt->mroute_sk)) { 1621 ret = -EBUSY; 1622 } else { 1623 mrt = ipmr_new_table(net, uval); 1624 if (IS_ERR(mrt)) 1625 ret = PTR_ERR(mrt); 1626 else 1627 raw_sk(sk)->ipmr_table = uval; 1628 } 1629 break; 1630 /* Spurious command, or MRT_VERSION which you cannot set. */ 1631 default: 1632 ret = -ENOPROTOOPT; 1633 } 1634 out_unlock: 1635 rtnl_unlock(); 1636 out: 1637 return ret; 1638 } 1639 1640 /* Execute if this ioctl is a special mroute ioctl */ 1641 int ipmr_sk_ioctl(struct sock *sk, unsigned int cmd, void __user *arg) 1642 { 1643 switch (cmd) { 1644 /* These userspace buffers will be consumed by ipmr_ioctl() */ 1645 case SIOCGETVIFCNT: { 1646 struct sioc_vif_req buffer; 1647 1648 return sock_ioctl_inout(sk, cmd, arg, &buffer, 1649 sizeof(buffer)); 1650 } 1651 case SIOCGETSGCNT: { 1652 struct sioc_sg_req buffer; 1653 1654 return sock_ioctl_inout(sk, cmd, arg, &buffer, 1655 sizeof(buffer)); 1656 } 1657 } 1658 /* return code > 0 means that the ioctl was not executed */ 1659 return 1; 1660 } 1661 1662 /* Getsock opt support for the multicast routing system. */ 1663 int ip_mroute_getsockopt(struct sock *sk, int optname, sockptr_t optval, 1664 sockptr_t optlen) 1665 { 1666 int olr; 1667 int val; 1668 struct net *net = sock_net(sk); 1669 struct mr_table *mrt; 1670 1671 if (sk->sk_type != SOCK_RAW || 1672 inet_sk(sk)->inet_num != IPPROTO_IGMP) 1673 return -EOPNOTSUPP; 1674 1675 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT); 1676 if (!mrt) 1677 return -ENOENT; 1678 1679 switch (optname) { 1680 case MRT_VERSION: 1681 val = 0x0305; 1682 break; 1683 case MRT_PIM: 1684 if (!ipmr_pimsm_enabled()) 1685 return -ENOPROTOOPT; 1686 val = READ_ONCE(mrt->mroute_do_pim); 1687 break; 1688 case MRT_ASSERT: 1689 val = READ_ONCE(mrt->mroute_do_assert); 1690 break; 1691 default: 1692 return -ENOPROTOOPT; 1693 } 1694 1695 if (copy_from_sockptr(&olr, optlen, sizeof(int))) 1696 return -EFAULT; 1697 if (olr < 0) 1698 return -EINVAL; 1699 1700 olr = min_t(unsigned int, olr, sizeof(int)); 1701 1702 if (copy_to_sockptr(optlen, &olr, sizeof(int))) 1703 return -EFAULT; 1704 if (copy_to_sockptr(optval, &val, olr)) 1705 return -EFAULT; 1706 return 0; 1707 } 1708 1709 /* The IP multicast ioctl support routines. */ 1710 int ipmr_ioctl(struct sock *sk, int cmd, void *arg) 1711 { 1712 struct vif_device *vif; 1713 struct mfc_cache *c; 1714 struct net *net = sock_net(sk); 1715 struct sioc_vif_req *vr; 1716 struct sioc_sg_req *sr; 1717 struct mr_table *mrt; 1718 1719 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT); 1720 if (!mrt) 1721 return -ENOENT; 1722 1723 switch (cmd) { 1724 case SIOCGETVIFCNT: 1725 vr = (struct sioc_vif_req *)arg; 1726 if (vr->vifi >= mrt->maxvif) 1727 return -EINVAL; 1728 vr->vifi = array_index_nospec(vr->vifi, mrt->maxvif); 1729 rcu_read_lock(); 1730 vif = &mrt->vif_table[vr->vifi]; 1731 if (VIF_EXISTS(mrt, vr->vifi)) { 1732 vr->icount = READ_ONCE(vif->pkt_in); 1733 vr->ocount = READ_ONCE(vif->pkt_out); 1734 vr->ibytes = READ_ONCE(vif->bytes_in); 1735 vr->obytes = READ_ONCE(vif->bytes_out); 1736 rcu_read_unlock(); 1737 1738 return 0; 1739 } 1740 rcu_read_unlock(); 1741 return -EADDRNOTAVAIL; 1742 case SIOCGETSGCNT: 1743 sr = (struct sioc_sg_req *)arg; 1744 1745 rcu_read_lock(); 1746 c = ipmr_cache_find(mrt, sr->src.s_addr, sr->grp.s_addr); 1747 if (c) { 1748 sr->pktcnt = atomic_long_read(&c->_c.mfc_un.res.pkt); 1749 sr->bytecnt = atomic_long_read(&c->_c.mfc_un.res.bytes); 1750 sr->wrong_if = atomic_long_read(&c->_c.mfc_un.res.wrong_if); 1751 rcu_read_unlock(); 1752 return 0; 1753 } 1754 rcu_read_unlock(); 1755 return -EADDRNOTAVAIL; 1756 default: 1757 return -ENOIOCTLCMD; 1758 } 1759 } 1760 1761 #ifdef CONFIG_COMPAT 1762 struct compat_sioc_sg_req { 1763 struct in_addr src; 1764 struct in_addr grp; 1765 compat_ulong_t pktcnt; 1766 compat_ulong_t bytecnt; 1767 compat_ulong_t wrong_if; 1768 }; 1769 1770 struct compat_sioc_vif_req { 1771 vifi_t vifi; /* Which iface */ 1772 compat_ulong_t icount; 1773 compat_ulong_t ocount; 1774 compat_ulong_t ibytes; 1775 compat_ulong_t obytes; 1776 }; 1777 1778 int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg) 1779 { 1780 struct compat_sioc_sg_req sr; 1781 struct compat_sioc_vif_req vr; 1782 struct vif_device *vif; 1783 struct mfc_cache *c; 1784 struct net *net = sock_net(sk); 1785 struct mr_table *mrt; 1786 1787 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT); 1788 if (!mrt) 1789 return -ENOENT; 1790 1791 switch (cmd) { 1792 case SIOCGETVIFCNT: 1793 if (copy_from_user(&vr, arg, sizeof(vr))) 1794 return -EFAULT; 1795 if (vr.vifi >= mrt->maxvif) 1796 return -EINVAL; 1797 vr.vifi = array_index_nospec(vr.vifi, mrt->maxvif); 1798 rcu_read_lock(); 1799 vif = &mrt->vif_table[vr.vifi]; 1800 if (VIF_EXISTS(mrt, vr.vifi)) { 1801 vr.icount = READ_ONCE(vif->pkt_in); 1802 vr.ocount = READ_ONCE(vif->pkt_out); 1803 vr.ibytes = READ_ONCE(vif->bytes_in); 1804 vr.obytes = READ_ONCE(vif->bytes_out); 1805 rcu_read_unlock(); 1806 1807 if (copy_to_user(arg, &vr, sizeof(vr))) 1808 return -EFAULT; 1809 return 0; 1810 } 1811 rcu_read_unlock(); 1812 return -EADDRNOTAVAIL; 1813 case SIOCGETSGCNT: 1814 if (copy_from_user(&sr, arg, sizeof(sr))) 1815 return -EFAULT; 1816 1817 rcu_read_lock(); 1818 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr); 1819 if (c) { 1820 sr.pktcnt = atomic_long_read(&c->_c.mfc_un.res.pkt); 1821 sr.bytecnt = atomic_long_read(&c->_c.mfc_un.res.bytes); 1822 sr.wrong_if = atomic_long_read(&c->_c.mfc_un.res.wrong_if); 1823 rcu_read_unlock(); 1824 1825 if (copy_to_user(arg, &sr, sizeof(sr))) 1826 return -EFAULT; 1827 return 0; 1828 } 1829 rcu_read_unlock(); 1830 return -EADDRNOTAVAIL; 1831 default: 1832 return -ENOIOCTLCMD; 1833 } 1834 } 1835 #endif 1836 1837 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr) 1838 { 1839 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1840 struct net *net = dev_net(dev); 1841 struct mr_table *mrt; 1842 struct vif_device *v; 1843 int ct; 1844 1845 if (event != NETDEV_UNREGISTER) 1846 return NOTIFY_DONE; 1847 1848 ipmr_for_each_table(mrt, net) { 1849 v = &mrt->vif_table[0]; 1850 for (ct = 0; ct < mrt->maxvif; ct++, v++) { 1851 if (rcu_access_pointer(v->dev) == dev) 1852 vif_delete(mrt, ct, 1, NULL); 1853 } 1854 } 1855 return NOTIFY_DONE; 1856 } 1857 1858 static struct notifier_block ip_mr_notifier = { 1859 .notifier_call = ipmr_device_event, 1860 }; 1861 1862 /* Encapsulate a packet by attaching a valid IPIP header to it. 1863 * This avoids tunnel drivers and other mess and gives us the speed so 1864 * important for multicast video. 1865 */ 1866 static void ip_encap(struct net *net, struct sk_buff *skb, 1867 __be32 saddr, __be32 daddr) 1868 { 1869 struct iphdr *iph; 1870 const struct iphdr *old_iph = ip_hdr(skb); 1871 1872 skb_push(skb, sizeof(struct iphdr)); 1873 skb->transport_header = skb->network_header; 1874 skb_reset_network_header(skb); 1875 iph = ip_hdr(skb); 1876 1877 iph->version = 4; 1878 iph->tos = old_iph->tos; 1879 iph->ttl = old_iph->ttl; 1880 iph->frag_off = 0; 1881 iph->daddr = daddr; 1882 iph->saddr = saddr; 1883 iph->protocol = IPPROTO_IPIP; 1884 iph->ihl = 5; 1885 iph->tot_len = htons(skb->len); 1886 ip_select_ident(net, skb, NULL); 1887 ip_send_check(iph); 1888 1889 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 1890 nf_reset_ct(skb); 1891 } 1892 1893 static inline int ipmr_forward_finish(struct net *net, struct sock *sk, 1894 struct sk_buff *skb) 1895 { 1896 struct ip_options *opt = &(IPCB(skb)->opt); 1897 1898 IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS); 1899 1900 if (unlikely(opt->optlen)) 1901 ip_forward_options(skb); 1902 1903 return dst_output(net, sk, skb); 1904 } 1905 1906 #ifdef CONFIG_NET_SWITCHDEV 1907 static bool ipmr_forward_offloaded(struct sk_buff *skb, struct mr_table *mrt, 1908 int in_vifi, int out_vifi) 1909 { 1910 struct vif_device *out_vif = &mrt->vif_table[out_vifi]; 1911 struct vif_device *in_vif = &mrt->vif_table[in_vifi]; 1912 1913 if (!skb->offload_l3_fwd_mark) 1914 return false; 1915 if (!out_vif->dev_parent_id.id_len || !in_vif->dev_parent_id.id_len) 1916 return false; 1917 return netdev_phys_item_id_same(&out_vif->dev_parent_id, 1918 &in_vif->dev_parent_id); 1919 } 1920 #else 1921 static bool ipmr_forward_offloaded(struct sk_buff *skb, struct mr_table *mrt, 1922 int in_vifi, int out_vifi) 1923 { 1924 return false; 1925 } 1926 #endif 1927 1928 /* Processing handlers for ipmr_forward, under rcu_read_lock() */ 1929 1930 static int ipmr_prepare_xmit(struct net *net, struct mr_table *mrt, 1931 struct sk_buff *skb, int vifi) 1932 { 1933 const struct iphdr *iph = ip_hdr(skb); 1934 struct vif_device *vif = &mrt->vif_table[vifi]; 1935 struct net_device *vif_dev; 1936 struct rtable *rt; 1937 struct flowi4 fl4; 1938 int encap = 0; 1939 1940 vif_dev = vif_dev_read(vif); 1941 if (!vif_dev) 1942 return -1; 1943 1944 if (vif->flags & VIFF_REGISTER) { 1945 WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1); 1946 WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len); 1947 DEV_STATS_ADD(vif_dev, tx_bytes, skb->len); 1948 DEV_STATS_INC(vif_dev, tx_packets); 1949 ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT, false); 1950 return -1; 1951 } 1952 1953 if (vif->flags & VIFF_TUNNEL) { 1954 rt = ip_route_output_ports(net, &fl4, NULL, 1955 vif->remote, vif->local, 1956 0, 0, 1957 IPPROTO_IPIP, 1958 iph->tos & INET_DSCP_MASK, vif->link); 1959 if (IS_ERR(rt)) 1960 return -1; 1961 encap = sizeof(struct iphdr); 1962 } else { 1963 rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0, 1964 0, 0, 1965 IPPROTO_IPIP, 1966 iph->tos & INET_DSCP_MASK, vif->link); 1967 if (IS_ERR(rt)) 1968 return -1; 1969 } 1970 1971 if (skb->len+encap > dst4_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) { 1972 /* Do not fragment multicasts. Alas, IPv4 does not 1973 * allow to send ICMP, so that packets will disappear 1974 * to blackhole. 1975 */ 1976 IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS); 1977 ip_rt_put(rt); 1978 return -1; 1979 } 1980 1981 encap += LL_RESERVED_SPACE(dst_dev_rcu(&rt->dst)) + rt->dst.header_len; 1982 1983 if (skb_cow(skb, encap)) { 1984 ip_rt_put(rt); 1985 return -1; 1986 } 1987 1988 WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1); 1989 WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len); 1990 1991 skb_dst_drop(skb); 1992 skb_dst_set(skb, &rt->dst); 1993 ip_decrease_ttl(ip_hdr(skb)); 1994 1995 /* FIXME: forward and output firewalls used to be called here. 1996 * What do we do with netfilter? -- RR 1997 */ 1998 if (vif->flags & VIFF_TUNNEL) { 1999 ip_encap(net, skb, vif->local, vif->remote); 2000 /* FIXME: extra output firewall step used to be here. --RR */ 2001 DEV_STATS_INC(vif_dev, tx_packets); 2002 DEV_STATS_ADD(vif_dev, tx_bytes, skb->len); 2003 } 2004 2005 return 0; 2006 } 2007 2008 static void ipmr_queue_fwd_xmit(struct net *net, struct mr_table *mrt, 2009 int in_vifi, struct sk_buff *skb, int vifi) 2010 { 2011 struct rtable *rt; 2012 2013 if (ipmr_forward_offloaded(skb, mrt, in_vifi, vifi)) 2014 goto out_free; 2015 2016 if (ipmr_prepare_xmit(net, mrt, skb, vifi)) 2017 goto out_free; 2018 2019 rt = skb_rtable(skb); 2020 2021 IPCB(skb)->flags |= IPSKB_FORWARDED; 2022 2023 /* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally 2024 * not only before forwarding, but after forwarding on all output 2025 * interfaces. It is clear, if mrouter runs a multicasting 2026 * program, it should receive packets not depending to what interface 2027 * program is joined. 2028 * If we will not make it, the program will have to join on all 2029 * interfaces. On the other hand, multihoming host (or router, but 2030 * not mrouter) cannot join to more than one interface - it will 2031 * result in receiving multiple packets. 2032 */ 2033 NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, 2034 net, NULL, skb, skb->dev, dst_dev_rcu(&rt->dst), 2035 ipmr_forward_finish); 2036 return; 2037 2038 out_free: 2039 kfree_skb(skb); 2040 } 2041 2042 static void ipmr_queue_output_xmit(struct net *net, struct mr_table *mrt, 2043 struct sk_buff *skb, int vifi) 2044 { 2045 if (ipmr_prepare_xmit(net, mrt, skb, vifi)) 2046 goto out_free; 2047 2048 ip_mc_output(net, NULL, skb); 2049 return; 2050 2051 out_free: 2052 kfree_skb(skb); 2053 } 2054 2055 /* Called with mrt_lock or rcu_read_lock() */ 2056 static int ipmr_find_vif(const struct mr_table *mrt, struct net_device *dev) 2057 { 2058 int ct; 2059 /* Pairs with WRITE_ONCE() in vif_delete()/vif_add() */ 2060 for (ct = READ_ONCE(mrt->maxvif) - 1; ct >= 0; ct--) { 2061 if (rcu_access_pointer(mrt->vif_table[ct].dev) == dev) 2062 break; 2063 } 2064 return ct; 2065 } 2066 2067 /* "local" means that we should preserve one skb (for local delivery) */ 2068 /* Called uner rcu_read_lock() */ 2069 static void ip_mr_forward(struct net *net, struct mr_table *mrt, 2070 struct net_device *dev, struct sk_buff *skb, 2071 struct mfc_cache *c, int local) 2072 { 2073 int true_vifi = ipmr_find_vif(mrt, dev); 2074 int psend = -1; 2075 int vif, ct; 2076 2077 vif = c->_c.mfc_parent; 2078 atomic_long_inc(&c->_c.mfc_un.res.pkt); 2079 atomic_long_add(skb->len, &c->_c.mfc_un.res.bytes); 2080 WRITE_ONCE(c->_c.mfc_un.res.lastuse, jiffies); 2081 2082 if (c->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) { 2083 struct mfc_cache *cache_proxy; 2084 2085 /* For an (*,G) entry, we only check that the incoming 2086 * interface is part of the static tree. 2087 */ 2088 cache_proxy = mr_mfc_find_any_parent(mrt, vif); 2089 if (cache_proxy && 2090 cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255) 2091 goto forward; 2092 } 2093 2094 /* Wrong interface: drop packet and (maybe) send PIM assert. */ 2095 if (true_vifi < 0 || 2096 rcu_access_pointer(mrt->vif_table[vif].dev) != dev) { 2097 if (rt_is_output_route(skb_rtable(skb))) { 2098 /* It is our own packet, looped back. 2099 * Very complicated situation... 2100 * 2101 * The best workaround until routing daemons will be 2102 * fixed is not to redistribute packet, if it was 2103 * send through wrong interface. It means, that 2104 * multicast applications WILL NOT work for 2105 * (S,G), which have default multicast route pointing 2106 * to wrong oif. In any case, it is not a good 2107 * idea to use multicasting applications on router. 2108 */ 2109 goto dont_forward; 2110 } 2111 2112 atomic_long_inc(&c->_c.mfc_un.res.wrong_if); 2113 2114 if (true_vifi >= 0 && READ_ONCE(mrt->mroute_do_assert) && 2115 /* pimsm uses asserts, when switching from RPT to SPT, 2116 * so that we cannot check that packet arrived on an oif. 2117 * It is bad, but otherwise we would need to move pretty 2118 * large chunk of pimd to kernel. Ough... --ANK 2119 */ 2120 (READ_ONCE(mrt->mroute_do_pim) || 2121 c->_c.mfc_un.res.ttls[true_vifi] < 255) && 2122 time_after(jiffies, 2123 c->_c.mfc_un.res.last_assert + 2124 MFC_ASSERT_THRESH)) { 2125 c->_c.mfc_un.res.last_assert = jiffies; 2126 ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF, 2127 false); 2128 if (READ_ONCE(mrt->mroute_do_wrvifwhole)) 2129 ipmr_cache_report(mrt, skb, true_vifi, 2130 IGMPMSG_WRVIFWHOLE, false); 2131 } 2132 goto dont_forward; 2133 } 2134 2135 forward: 2136 WRITE_ONCE(mrt->vif_table[vif].pkt_in, 2137 mrt->vif_table[vif].pkt_in + 1); 2138 WRITE_ONCE(mrt->vif_table[vif].bytes_in, 2139 mrt->vif_table[vif].bytes_in + skb->len); 2140 2141 /* Forward the frame */ 2142 if (c->mfc_origin == htonl(INADDR_ANY) && 2143 c->mfc_mcastgrp == htonl(INADDR_ANY)) { 2144 if (true_vifi >= 0 && 2145 true_vifi != c->_c.mfc_parent && 2146 ip_hdr(skb)->ttl > 2147 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) { 2148 /* It's an (*,*) entry and the packet is not coming from 2149 * the upstream: forward the packet to the upstream 2150 * only. 2151 */ 2152 psend = c->_c.mfc_parent; 2153 goto last_forward; 2154 } 2155 goto dont_forward; 2156 } 2157 for (ct = c->_c.mfc_un.res.maxvif - 1; 2158 ct >= c->_c.mfc_un.res.minvif; ct--) { 2159 /* For (*,G) entry, don't forward to the incoming interface */ 2160 if ((c->mfc_origin != htonl(INADDR_ANY) || 2161 ct != true_vifi) && 2162 ip_hdr(skb)->ttl > c->_c.mfc_un.res.ttls[ct]) { 2163 if (psend != -1) { 2164 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 2165 2166 if (skb2) 2167 ipmr_queue_fwd_xmit(net, mrt, true_vifi, 2168 skb2, psend); 2169 } 2170 psend = ct; 2171 } 2172 } 2173 last_forward: 2174 if (psend != -1) { 2175 if (local) { 2176 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 2177 2178 if (skb2) 2179 ipmr_queue_fwd_xmit(net, mrt, true_vifi, skb2, 2180 psend); 2181 } else { 2182 ipmr_queue_fwd_xmit(net, mrt, true_vifi, skb, psend); 2183 return; 2184 } 2185 } 2186 2187 dont_forward: 2188 if (!local) 2189 kfree_skb(skb); 2190 } 2191 2192 static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb) 2193 { 2194 struct rtable *rt = skb_rtable(skb); 2195 struct iphdr *iph = ip_hdr(skb); 2196 struct flowi4 fl4 = { 2197 .daddr = iph->daddr, 2198 .saddr = iph->saddr, 2199 .flowi4_dscp = ip4h_dscp(iph), 2200 .flowi4_oif = (rt_is_output_route(rt) ? 2201 skb->dev->ifindex : 0), 2202 .flowi4_iif = (rt_is_output_route(rt) ? 2203 LOOPBACK_IFINDEX : 2204 skb->dev->ifindex), 2205 .flowi4_mark = skb->mark, 2206 }; 2207 struct mr_table *mrt; 2208 int err; 2209 2210 err = ipmr_fib_lookup(net, &fl4, &mrt); 2211 if (err) 2212 return ERR_PTR(err); 2213 return mrt; 2214 } 2215 2216 /* Multicast packets for forwarding arrive here 2217 * Called with rcu_read_lock(); 2218 */ 2219 int ip_mr_input(struct sk_buff *skb) 2220 { 2221 struct mfc_cache *cache; 2222 struct net *net = dev_net(skb->dev); 2223 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL; 2224 struct mr_table *mrt; 2225 struct net_device *dev; 2226 2227 /* skb->dev passed in is the loX master dev for vrfs. 2228 * As there are no vifs associated with loopback devices, 2229 * get the proper interface that does have a vif associated with it. 2230 */ 2231 dev = skb->dev; 2232 if (netif_is_l3_master(skb->dev)) { 2233 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif); 2234 if (!dev) { 2235 kfree_skb(skb); 2236 return -ENODEV; 2237 } 2238 } 2239 2240 /* Packet is looped back after forward, it should not be 2241 * forwarded second time, but still can be delivered locally. 2242 */ 2243 if (IPCB(skb)->flags & IPSKB_FORWARDED) 2244 goto dont_forward; 2245 2246 if (!local) 2247 skb_orphan(skb); 2248 2249 mrt = ipmr_rt_fib_lookup(net, skb); 2250 if (IS_ERR(mrt)) { 2251 kfree_skb(skb); 2252 return PTR_ERR(mrt); 2253 } 2254 if (!local) { 2255 if (IPCB(skb)->opt.router_alert) { 2256 if (ip_call_ra_chain(skb)) 2257 return 0; 2258 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) { 2259 /* IGMPv1 (and broken IGMPv2 implementations sort of 2260 * Cisco IOS <= 11.2(8)) do not put router alert 2261 * option to IGMP packets destined to routable 2262 * groups. It is very bad, because it means 2263 * that we can forward NO IGMP messages. 2264 */ 2265 struct sock *mroute_sk; 2266 2267 mroute_sk = rcu_dereference(mrt->mroute_sk); 2268 if (mroute_sk) { 2269 nf_reset_ct(skb); 2270 raw_rcv(mroute_sk, skb); 2271 return 0; 2272 } 2273 } 2274 } 2275 2276 /* already under rcu_read_lock() */ 2277 cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 2278 if (!cache) { 2279 int vif = ipmr_find_vif(mrt, dev); 2280 2281 if (vif >= 0) 2282 cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr, 2283 vif); 2284 } 2285 2286 /* No usable cache entry */ 2287 if (!cache) { 2288 int vif; 2289 2290 if (local) { 2291 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 2292 ip_local_deliver(skb); 2293 if (!skb2) 2294 return -ENOBUFS; 2295 skb = skb2; 2296 } 2297 2298 vif = ipmr_find_vif(mrt, dev); 2299 if (vif >= 0) 2300 return ipmr_cache_unresolved(mrt, vif, skb, dev, false); 2301 kfree_skb(skb); 2302 return -ENODEV; 2303 } 2304 2305 ip_mr_forward(net, mrt, dev, skb, cache, local); 2306 2307 if (local) 2308 return ip_local_deliver(skb); 2309 2310 return 0; 2311 2312 dont_forward: 2313 if (local) 2314 return ip_local_deliver(skb); 2315 kfree_skb(skb); 2316 return 0; 2317 } 2318 2319 static void ip_mr_output_finish(struct net *net, struct mr_table *mrt, 2320 struct net_device *dev, struct sk_buff *skb, 2321 struct mfc_cache *c) 2322 { 2323 int psend = -1; 2324 int ct; 2325 2326 atomic_long_inc(&c->_c.mfc_un.res.pkt); 2327 atomic_long_add(skb->len, &c->_c.mfc_un.res.bytes); 2328 WRITE_ONCE(c->_c.mfc_un.res.lastuse, jiffies); 2329 2330 /* Forward the frame */ 2331 if (c->mfc_origin == htonl(INADDR_ANY) && 2332 c->mfc_mcastgrp == htonl(INADDR_ANY)) { 2333 if (ip_hdr(skb)->ttl > 2334 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) { 2335 /* It's an (*,*) entry and the packet is not coming from 2336 * the upstream: forward the packet to the upstream 2337 * only. 2338 */ 2339 psend = c->_c.mfc_parent; 2340 goto last_xmit; 2341 } 2342 goto dont_xmit; 2343 } 2344 2345 for (ct = c->_c.mfc_un.res.maxvif - 1; 2346 ct >= c->_c.mfc_un.res.minvif; ct--) { 2347 if (ip_hdr(skb)->ttl > c->_c.mfc_un.res.ttls[ct]) { 2348 if (psend != -1) { 2349 struct sk_buff *skb2; 2350 2351 skb2 = skb_clone(skb, GFP_ATOMIC); 2352 if (skb2) 2353 ipmr_queue_output_xmit(net, mrt, 2354 skb2, psend); 2355 } 2356 psend = ct; 2357 } 2358 } 2359 2360 last_xmit: 2361 if (psend != -1) { 2362 ipmr_queue_output_xmit(net, mrt, skb, psend); 2363 return; 2364 } 2365 2366 dont_xmit: 2367 kfree_skb(skb); 2368 } 2369 2370 /* Multicast packets for forwarding arrive here 2371 * Called with rcu_read_lock(); 2372 */ 2373 int ip_mr_output(struct net *net, struct sock *sk, struct sk_buff *skb) 2374 { 2375 struct rtable *rt = skb_rtable(skb); 2376 struct mfc_cache *cache; 2377 struct net_device *dev; 2378 struct mr_table *mrt; 2379 int vif; 2380 2381 guard(rcu)(); 2382 2383 dev = dst_dev_rcu(&rt->dst); 2384 2385 if (IPCB(skb)->flags & IPSKB_FORWARDED) 2386 goto mc_output; 2387 if (!(IPCB(skb)->flags & IPSKB_MCROUTE)) 2388 goto mc_output; 2389 2390 skb->dev = dev; 2391 2392 mrt = ipmr_rt_fib_lookup(net, skb); 2393 if (IS_ERR(mrt)) 2394 goto mc_output; 2395 2396 cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 2397 if (!cache) { 2398 vif = ipmr_find_vif(mrt, dev); 2399 if (vif >= 0) 2400 cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr, 2401 vif); 2402 } 2403 2404 /* No usable cache entry */ 2405 if (!cache) { 2406 vif = ipmr_find_vif(mrt, dev); 2407 if (vif >= 0) 2408 return ipmr_cache_unresolved(mrt, vif, skb, dev, false); 2409 goto mc_output; 2410 } 2411 2412 vif = cache->_c.mfc_parent; 2413 if (rcu_access_pointer(mrt->vif_table[vif].dev) != dev) 2414 goto mc_output; 2415 2416 ip_mr_output_finish(net, mrt, dev, skb, cache); 2417 return 0; 2418 2419 mc_output: 2420 return ip_mc_output(net, sk, skb); 2421 } 2422 2423 #ifdef CONFIG_IP_PIMSM_V1 2424 /* Handle IGMP messages of PIMv1 */ 2425 int pim_rcv_v1(struct sk_buff *skb) 2426 { 2427 struct igmphdr *pim; 2428 struct net *net = dev_net(skb->dev); 2429 struct mr_table *mrt; 2430 2431 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 2432 goto drop; 2433 2434 pim = igmp_hdr(skb); 2435 2436 mrt = ipmr_rt_fib_lookup(net, skb); 2437 if (IS_ERR(mrt)) 2438 goto drop; 2439 if (!READ_ONCE(mrt->mroute_do_pim) || 2440 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER) 2441 goto drop; 2442 2443 if (__pim_rcv(mrt, skb, sizeof(*pim))) { 2444 drop: 2445 kfree_skb(skb); 2446 } 2447 return 0; 2448 } 2449 #endif 2450 2451 #ifdef CONFIG_IP_PIMSM_V2 2452 static int pim_rcv(struct sk_buff *skb) 2453 { 2454 struct pimreghdr *pim; 2455 struct net *net = dev_net(skb->dev); 2456 struct mr_table *mrt; 2457 2458 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 2459 goto drop; 2460 2461 pim = (struct pimreghdr *)skb_transport_header(skb); 2462 if (pim->type != ((PIM_VERSION << 4) | (PIM_TYPE_REGISTER)) || 2463 (pim->flags & PIM_NULL_REGISTER) || 2464 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 && 2465 csum_fold(skb_checksum(skb, 0, skb->len, 0)))) 2466 goto drop; 2467 2468 mrt = ipmr_rt_fib_lookup(net, skb); 2469 if (IS_ERR(mrt)) 2470 goto drop; 2471 if (__pim_rcv(mrt, skb, sizeof(*pim))) { 2472 drop: 2473 kfree_skb(skb); 2474 } 2475 return 0; 2476 } 2477 #endif 2478 2479 int ipmr_get_route(struct net *net, struct sk_buff *skb, 2480 __be32 saddr, __be32 daddr, 2481 struct rtmsg *rtm, u32 portid) 2482 { 2483 struct mfc_cache *cache; 2484 struct mr_table *mrt; 2485 int err; 2486 2487 rcu_read_lock(); 2488 mrt = __ipmr_get_table(net, RT_TABLE_DEFAULT); 2489 if (!mrt) { 2490 rcu_read_unlock(); 2491 return -ENOENT; 2492 } 2493 2494 cache = ipmr_cache_find(mrt, saddr, daddr); 2495 if (!cache && skb->dev) { 2496 int vif = ipmr_find_vif(mrt, skb->dev); 2497 2498 if (vif >= 0) 2499 cache = ipmr_cache_find_any(mrt, daddr, vif); 2500 } 2501 if (!cache) { 2502 struct sk_buff *skb2; 2503 struct iphdr *iph; 2504 struct net_device *dev; 2505 int vif = -1; 2506 2507 dev = skb->dev; 2508 if (dev) 2509 vif = ipmr_find_vif(mrt, dev); 2510 if (vif < 0) { 2511 rcu_read_unlock(); 2512 return -ENODEV; 2513 } 2514 2515 skb2 = skb_realloc_headroom(skb, sizeof(struct iphdr)); 2516 if (!skb2) { 2517 rcu_read_unlock(); 2518 return -ENOMEM; 2519 } 2520 2521 NETLINK_CB(skb2).portid = portid; 2522 skb_push(skb2, sizeof(struct iphdr)); 2523 skb_reset_network_header(skb2); 2524 iph = ip_hdr(skb2); 2525 memset(iph, 0, sizeof(*iph)); 2526 iph->ihl = sizeof(struct iphdr) >> 2; 2527 iph->saddr = saddr; 2528 iph->daddr = daddr; 2529 iph->version = 0; 2530 err = ipmr_cache_unresolved(mrt, vif, skb2, dev, true); 2531 rcu_read_unlock(); 2532 return err; 2533 } 2534 2535 err = mr_fill_mroute(mrt, skb, &cache->_c, rtm); 2536 rcu_read_unlock(); 2537 return err; 2538 } 2539 2540 static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb, 2541 u32 portid, u32 seq, struct mfc_cache *c, int cmd, 2542 int flags) 2543 { 2544 struct nlmsghdr *nlh; 2545 struct rtmsg *rtm; 2546 int err; 2547 2548 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags); 2549 if (!nlh) 2550 return -EMSGSIZE; 2551 2552 rtm = nlmsg_data(nlh); 2553 rtm->rtm_family = RTNL_FAMILY_IPMR; 2554 rtm->rtm_dst_len = 32; 2555 rtm->rtm_src_len = 32; 2556 rtm->rtm_tos = 0; 2557 rtm->rtm_table = mrt->id; 2558 if (nla_put_u32(skb, RTA_TABLE, mrt->id)) 2559 goto nla_put_failure; 2560 rtm->rtm_type = RTN_MULTICAST; 2561 rtm->rtm_scope = RT_SCOPE_UNIVERSE; 2562 if (c->_c.mfc_flags & MFC_STATIC) 2563 rtm->rtm_protocol = RTPROT_STATIC; 2564 else 2565 rtm->rtm_protocol = RTPROT_MROUTED; 2566 rtm->rtm_flags = 0; 2567 2568 if (nla_put_in_addr(skb, RTA_SRC, c->mfc_origin) || 2569 nla_put_in_addr(skb, RTA_DST, c->mfc_mcastgrp)) 2570 goto nla_put_failure; 2571 err = mr_fill_mroute(mrt, skb, &c->_c, rtm); 2572 /* do not break the dump if cache is unresolved */ 2573 if (err < 0 && err != -ENOENT) 2574 goto nla_put_failure; 2575 2576 nlmsg_end(skb, nlh); 2577 return 0; 2578 2579 nla_put_failure: 2580 nlmsg_cancel(skb, nlh); 2581 return -EMSGSIZE; 2582 } 2583 2584 static int _ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb, 2585 u32 portid, u32 seq, struct mr_mfc *c, int cmd, 2586 int flags) 2587 { 2588 return ipmr_fill_mroute(mrt, skb, portid, seq, (struct mfc_cache *)c, 2589 cmd, flags); 2590 } 2591 2592 static size_t mroute_msgsize(bool unresolved) 2593 { 2594 size_t len = 2595 NLMSG_ALIGN(sizeof(struct rtmsg)) 2596 + nla_total_size(4) /* RTA_TABLE */ 2597 + nla_total_size(4) /* RTA_SRC */ 2598 + nla_total_size(4) /* RTA_DST */ 2599 ; 2600 2601 if (!unresolved) 2602 len = len 2603 + nla_total_size(4) /* RTA_IIF */ 2604 + nla_total_size(0) /* RTA_MULTIPATH */ 2605 + MAXVIFS * NLA_ALIGN(sizeof(struct rtnexthop)) 2606 /* RTA_MFC_STATS */ 2607 + nla_total_size_64bit(sizeof(struct rta_mfc_stats)) 2608 ; 2609 2610 return len; 2611 } 2612 2613 static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc, 2614 int cmd) 2615 { 2616 struct net *net = read_pnet(&mrt->net); 2617 struct sk_buff *skb; 2618 int err = -ENOBUFS; 2619 2620 skb = nlmsg_new(mroute_msgsize(mfc->_c.mfc_parent >= MAXVIFS), 2621 GFP_ATOMIC); 2622 if (!skb) 2623 goto errout; 2624 2625 err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0); 2626 if (err < 0) 2627 goto errout; 2628 2629 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC); 2630 return; 2631 2632 errout: 2633 kfree_skb(skb); 2634 rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err); 2635 } 2636 2637 static size_t igmpmsg_netlink_msgsize(size_t payloadlen) 2638 { 2639 size_t len = 2640 NLMSG_ALIGN(sizeof(struct rtgenmsg)) 2641 + nla_total_size(1) /* IPMRA_CREPORT_MSGTYPE */ 2642 + nla_total_size(4) /* IPMRA_CREPORT_VIF_ID */ 2643 + nla_total_size(4) /* IPMRA_CREPORT_SRC_ADDR */ 2644 + nla_total_size(4) /* IPMRA_CREPORT_DST_ADDR */ 2645 + nla_total_size(4) /* IPMRA_CREPORT_TABLE */ 2646 /* IPMRA_CREPORT_PKT */ 2647 + nla_total_size(payloadlen) 2648 ; 2649 2650 return len; 2651 } 2652 2653 static void igmpmsg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt) 2654 { 2655 struct net *net = read_pnet(&mrt->net); 2656 struct nlmsghdr *nlh; 2657 struct rtgenmsg *rtgenm; 2658 struct igmpmsg *msg; 2659 struct sk_buff *skb; 2660 struct nlattr *nla; 2661 int payloadlen; 2662 2663 payloadlen = pkt->len - sizeof(struct igmpmsg); 2664 msg = (struct igmpmsg *)skb_network_header(pkt); 2665 2666 skb = nlmsg_new(igmpmsg_netlink_msgsize(payloadlen), GFP_ATOMIC); 2667 if (!skb) 2668 goto errout; 2669 2670 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT, 2671 sizeof(struct rtgenmsg), 0); 2672 if (!nlh) 2673 goto errout; 2674 rtgenm = nlmsg_data(nlh); 2675 rtgenm->rtgen_family = RTNL_FAMILY_IPMR; 2676 if (nla_put_u8(skb, IPMRA_CREPORT_MSGTYPE, msg->im_msgtype) || 2677 nla_put_u32(skb, IPMRA_CREPORT_VIF_ID, msg->im_vif | (msg->im_vif_hi << 8)) || 2678 nla_put_in_addr(skb, IPMRA_CREPORT_SRC_ADDR, 2679 msg->im_src.s_addr) || 2680 nla_put_in_addr(skb, IPMRA_CREPORT_DST_ADDR, 2681 msg->im_dst.s_addr) || 2682 nla_put_u32(skb, IPMRA_CREPORT_TABLE, mrt->id)) 2683 goto nla_put_failure; 2684 2685 nla = nla_reserve(skb, IPMRA_CREPORT_PKT, payloadlen); 2686 if (!nla || skb_copy_bits(pkt, sizeof(struct igmpmsg), 2687 nla_data(nla), payloadlen)) 2688 goto nla_put_failure; 2689 2690 nlmsg_end(skb, nlh); 2691 2692 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE_R, NULL, GFP_ATOMIC); 2693 return; 2694 2695 nla_put_failure: 2696 nlmsg_cancel(skb, nlh); 2697 errout: 2698 kfree_skb(skb); 2699 rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE_R, -ENOBUFS); 2700 } 2701 2702 static int ipmr_rtm_valid_getroute_req(struct sk_buff *skb, 2703 const struct nlmsghdr *nlh, 2704 struct nlattr **tb, 2705 struct netlink_ext_ack *extack) 2706 { 2707 struct rtmsg *rtm; 2708 int i, err; 2709 2710 rtm = nlmsg_payload(nlh, sizeof(*rtm)); 2711 if (!rtm) { 2712 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for multicast route get request"); 2713 return -EINVAL; 2714 } 2715 2716 if (!netlink_strict_get_check(skb)) 2717 return nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX, 2718 rtm_ipv4_policy, extack); 2719 2720 if ((rtm->rtm_src_len && rtm->rtm_src_len != 32) || 2721 (rtm->rtm_dst_len && rtm->rtm_dst_len != 32) || 2722 rtm->rtm_tos || rtm->rtm_table || rtm->rtm_protocol || 2723 rtm->rtm_scope || rtm->rtm_type || rtm->rtm_flags) { 2724 NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for multicast route get request"); 2725 return -EINVAL; 2726 } 2727 2728 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX, 2729 rtm_ipv4_policy, extack); 2730 if (err) 2731 return err; 2732 2733 if ((tb[RTA_SRC] && !rtm->rtm_src_len) || 2734 (tb[RTA_DST] && !rtm->rtm_dst_len)) { 2735 NL_SET_ERR_MSG(extack, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4"); 2736 return -EINVAL; 2737 } 2738 2739 for (i = 0; i <= RTA_MAX; i++) { 2740 if (!tb[i]) 2741 continue; 2742 2743 switch (i) { 2744 case RTA_SRC: 2745 case RTA_DST: 2746 case RTA_TABLE: 2747 break; 2748 default: 2749 NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in multicast route get request"); 2750 return -EINVAL; 2751 } 2752 } 2753 2754 return 0; 2755 } 2756 2757 static int ipmr_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, 2758 struct netlink_ext_ack *extack) 2759 { 2760 struct net *net = sock_net(in_skb->sk); 2761 struct nlattr *tb[RTA_MAX + 1]; 2762 struct mfc_cache *cache; 2763 struct mr_table *mrt; 2764 struct sk_buff *skb; 2765 __be32 src, grp; 2766 u32 tableid; 2767 int err; 2768 2769 err = ipmr_rtm_valid_getroute_req(in_skb, nlh, tb, extack); 2770 if (err < 0) 2771 goto errout; 2772 2773 src = nla_get_in_addr_default(tb[RTA_SRC], 0); 2774 grp = nla_get_in_addr_default(tb[RTA_DST], 0); 2775 tableid = nla_get_u32_default(tb[RTA_TABLE], 0); 2776 2777 skb = nlmsg_new(mroute_msgsize(false), GFP_KERNEL); 2778 if (!skb) { 2779 err = -ENOBUFS; 2780 goto errout; 2781 } 2782 2783 rcu_read_lock(); 2784 2785 mrt = __ipmr_get_table(net, tableid ? tableid : RT_TABLE_DEFAULT); 2786 if (!mrt) { 2787 err = -ENOENT; 2788 goto errout_unlock; 2789 } 2790 2791 cache = ipmr_cache_find(mrt, src, grp); 2792 if (!cache) { 2793 err = -ENOENT; 2794 goto errout_unlock; 2795 } 2796 2797 err = ipmr_fill_mroute(mrt, skb, NETLINK_CB(in_skb).portid, 2798 nlh->nlmsg_seq, cache, 2799 RTM_NEWROUTE, 0); 2800 if (err < 0) 2801 goto errout_unlock; 2802 2803 rcu_read_unlock(); 2804 2805 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 2806 errout: 2807 return err; 2808 2809 errout_unlock: 2810 rcu_read_unlock(); 2811 kfree_skb(skb); 2812 goto errout; 2813 } 2814 2815 static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb) 2816 { 2817 struct fib_dump_filter filter = {}; 2818 int err; 2819 2820 rcu_read_lock(); 2821 2822 if (cb->strict_check) { 2823 err = ip_valid_fib_dump_req(sock_net(skb->sk), cb->nlh, 2824 &filter, cb); 2825 if (err < 0) 2826 goto out; 2827 } 2828 2829 if (filter.table_id) { 2830 struct mr_table *mrt; 2831 2832 mrt = __ipmr_get_table(sock_net(skb->sk), filter.table_id); 2833 if (!mrt) { 2834 if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IPMR) { 2835 err = skb->len; 2836 goto out; 2837 } 2838 2839 NL_SET_ERR_MSG(cb->extack, "ipv4: MR table does not exist"); 2840 err = -ENOENT; 2841 goto out; 2842 } 2843 2844 err = mr_table_dump(mrt, skb, cb, _ipmr_fill_mroute, 2845 &mfc_unres_lock, &filter); 2846 err = skb->len ? : err; 2847 goto out; 2848 } 2849 2850 err = mr_rtm_dumproute(skb, cb, ipmr_mr_table_iter, 2851 _ipmr_fill_mroute, &mfc_unres_lock, &filter); 2852 out: 2853 rcu_read_unlock(); 2854 2855 return err; 2856 } 2857 2858 static const struct nla_policy rtm_ipmr_policy[RTA_MAX + 1] = { 2859 [RTA_SRC] = { .type = NLA_U32 }, 2860 [RTA_DST] = { .type = NLA_U32 }, 2861 [RTA_IIF] = { .type = NLA_U32 }, 2862 [RTA_TABLE] = { .type = NLA_U32 }, 2863 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) }, 2864 }; 2865 2866 static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol) 2867 { 2868 switch (rtm_protocol) { 2869 case RTPROT_STATIC: 2870 case RTPROT_MROUTED: 2871 return true; 2872 } 2873 return false; 2874 } 2875 2876 static int ipmr_nla_get_ttls(const struct nlattr *nla, struct mfcctl *mfcc) 2877 { 2878 struct rtnexthop *rtnh = nla_data(nla); 2879 int remaining = nla_len(nla), vifi = 0; 2880 2881 while (rtnh_ok(rtnh, remaining)) { 2882 mfcc->mfcc_ttls[vifi] = rtnh->rtnh_hops; 2883 if (++vifi == MAXVIFS) 2884 break; 2885 rtnh = rtnh_next(rtnh, &remaining); 2886 } 2887 2888 return remaining > 0 ? -EINVAL : vifi; 2889 } 2890 2891 /* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */ 2892 static int rtm_to_ipmr_mfcc(struct net *net, struct nlmsghdr *nlh, 2893 struct mfcctl *mfcc, int *mrtsock, 2894 struct mr_table **mrtret, 2895 struct netlink_ext_ack *extack) 2896 { 2897 struct net_device *dev = NULL; 2898 u32 tblid = RT_TABLE_DEFAULT; 2899 int ret, rem, iif = 0; 2900 struct mr_table *mrt; 2901 struct nlattr *attr; 2902 struct rtmsg *rtm; 2903 2904 ret = nlmsg_validate_deprecated(nlh, sizeof(*rtm), RTA_MAX, 2905 rtm_ipmr_policy, extack); 2906 if (ret < 0) 2907 goto out; 2908 rtm = nlmsg_data(nlh); 2909 2910 ret = -EINVAL; 2911 if (rtm->rtm_family != RTNL_FAMILY_IPMR || rtm->rtm_dst_len != 32 || 2912 rtm->rtm_type != RTN_MULTICAST || 2913 rtm->rtm_scope != RT_SCOPE_UNIVERSE || 2914 !ipmr_rtm_validate_proto(rtm->rtm_protocol)) 2915 goto out; 2916 2917 memset(mfcc, 0, sizeof(*mfcc)); 2918 mfcc->mfcc_parent = -1; 2919 ret = 0; 2920 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), rem) { 2921 switch (nla_type(attr)) { 2922 case RTA_SRC: 2923 mfcc->mfcc_origin.s_addr = nla_get_be32(attr); 2924 break; 2925 case RTA_DST: 2926 mfcc->mfcc_mcastgrp.s_addr = nla_get_be32(attr); 2927 break; 2928 case RTA_IIF: 2929 iif = nla_get_u32(attr); 2930 break; 2931 case RTA_MULTIPATH: 2932 if (ipmr_nla_get_ttls(attr, mfcc) < 0) { 2933 ret = -EINVAL; 2934 goto out; 2935 } 2936 break; 2937 case RTA_PREFSRC: 2938 ret = 1; 2939 break; 2940 case RTA_TABLE: 2941 tblid = nla_get_u32(attr); 2942 break; 2943 } 2944 } 2945 2946 rcu_read_lock(); 2947 2948 mrt = __ipmr_get_table(net, tblid); 2949 if (!mrt) { 2950 ret = -ENOENT; 2951 goto unlock; 2952 } 2953 2954 if (iif) { 2955 dev = dev_get_by_index_rcu(net, iif); 2956 if (!dev) { 2957 ret = -ENODEV; 2958 goto unlock; 2959 } 2960 2961 mfcc->mfcc_parent = ipmr_find_vif(mrt, dev); 2962 } 2963 2964 *mrtret = mrt; 2965 *mrtsock = rtm->rtm_protocol == RTPROT_MROUTED ? 1 : 0; 2966 2967 unlock: 2968 rcu_read_unlock(); 2969 out: 2970 return ret; 2971 } 2972 2973 /* takes care of both newroute and delroute */ 2974 static int ipmr_rtm_route(struct sk_buff *skb, struct nlmsghdr *nlh, 2975 struct netlink_ext_ack *extack) 2976 { 2977 struct net *net = sock_net(skb->sk); 2978 int ret, mrtsock = 0, parent; 2979 struct mr_table *tbl = NULL; 2980 struct mfcctl mfcc; 2981 2982 ret = rtm_to_ipmr_mfcc(net, nlh, &mfcc, &mrtsock, &tbl, extack); 2983 if (ret < 0) 2984 return ret; 2985 2986 parent = ret ? mfcc.mfcc_parent : -1; 2987 2988 mutex_lock(&net->ipv4.mfc_mutex); 2989 2990 if (nlh->nlmsg_type == RTM_NEWROUTE) 2991 ret = ipmr_mfc_add(net, tbl, &mfcc, mrtsock, parent); 2992 else 2993 ret = ipmr_mfc_delete(tbl, &mfcc, parent); 2994 2995 mutex_unlock(&net->ipv4.mfc_mutex); 2996 2997 return ret; 2998 } 2999 3000 static bool ipmr_fill_table(struct mr_table *mrt, struct sk_buff *skb) 3001 { 3002 if (nla_put_u32(skb, IPMRA_TABLE_ID, mrt->id) || 3003 nla_put_u32(skb, IPMRA_TABLE_CACHE_RES_QUEUE_LEN, 3004 READ_ONCE(mrt->cache_resolve_queue_len)) || 3005 nla_put_s32(skb, IPMRA_TABLE_MROUTE_REG_VIF_NUM, 3006 READ_ONCE(mrt->mroute_reg_vif_num)) || 3007 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_ASSERT, 3008 READ_ONCE(mrt->mroute_do_assert)) || 3009 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_PIM, 3010 READ_ONCE(mrt->mroute_do_pim)) || 3011 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_WRVIFWHOLE, 3012 READ_ONCE(mrt->mroute_do_wrvifwhole))) 3013 return false; 3014 3015 return true; 3016 } 3017 3018 static bool ipmr_fill_vif(struct mr_table *mrt, u32 vifid, struct sk_buff *skb) 3019 { 3020 struct net_device *vif_dev; 3021 struct nlattr *vif_nest; 3022 struct vif_device *vif; 3023 3024 vif = &mrt->vif_table[vifid]; 3025 vif_dev = vif_dev_read(vif); 3026 /* if the VIF doesn't exist just continue */ 3027 if (!vif_dev) 3028 return true; 3029 3030 vif_nest = nla_nest_start_noflag(skb, IPMRA_VIF); 3031 if (!vif_nest) 3032 return false; 3033 3034 if (nla_put_u32(skb, IPMRA_VIFA_IFINDEX, READ_ONCE(vif_dev->ifindex)) || 3035 nla_put_u32(skb, IPMRA_VIFA_VIF_ID, vifid) || 3036 nla_put_u16(skb, IPMRA_VIFA_FLAGS, vif->flags) || 3037 nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_IN, READ_ONCE(vif->bytes_in), 3038 IPMRA_VIFA_PAD) || 3039 nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_OUT, READ_ONCE(vif->bytes_out), 3040 IPMRA_VIFA_PAD) || 3041 nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_IN, READ_ONCE(vif->pkt_in), 3042 IPMRA_VIFA_PAD) || 3043 nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_OUT, READ_ONCE(vif->pkt_out), 3044 IPMRA_VIFA_PAD) || 3045 nla_put_be32(skb, IPMRA_VIFA_LOCAL_ADDR, vif->local) || 3046 nla_put_be32(skb, IPMRA_VIFA_REMOTE_ADDR, vif->remote)) { 3047 nla_nest_cancel(skb, vif_nest); 3048 return false; 3049 } 3050 nla_nest_end(skb, vif_nest); 3051 3052 return true; 3053 } 3054 3055 static int ipmr_valid_dumplink(const struct nlmsghdr *nlh, 3056 struct netlink_ext_ack *extack) 3057 { 3058 struct ifinfomsg *ifm; 3059 3060 ifm = nlmsg_payload(nlh, sizeof(*ifm)); 3061 if (!ifm) { 3062 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for ipmr link dump"); 3063 return -EINVAL; 3064 } 3065 3066 if (nlmsg_attrlen(nlh, sizeof(*ifm))) { 3067 NL_SET_ERR_MSG(extack, "Invalid data after header in ipmr link dump"); 3068 return -EINVAL; 3069 } 3070 3071 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags || 3072 ifm->ifi_change || ifm->ifi_index) { 3073 NL_SET_ERR_MSG(extack, "Invalid values in header for ipmr link dump request"); 3074 return -EINVAL; 3075 } 3076 3077 return 0; 3078 } 3079 3080 static int ipmr_rtm_dumplink(struct sk_buff *skb, struct netlink_callback *cb) 3081 { 3082 struct net *net = sock_net(skb->sk); 3083 struct nlmsghdr *nlh = NULL; 3084 unsigned int t = 0, s_t; 3085 unsigned int e = 0, s_e; 3086 struct mr_table *mrt; 3087 3088 if (cb->strict_check) { 3089 int err = ipmr_valid_dumplink(cb->nlh, cb->extack); 3090 3091 if (err < 0) 3092 return err; 3093 } 3094 3095 s_t = cb->args[0]; 3096 s_e = cb->args[1]; 3097 3098 rcu_read_lock(); 3099 3100 ipmr_for_each_table(mrt, net) { 3101 struct nlattr *vifs, *af; 3102 struct ifinfomsg *hdr; 3103 u32 i; 3104 3105 if (t < s_t) 3106 goto skip_table; 3107 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, 3108 cb->nlh->nlmsg_seq, RTM_NEWLINK, 3109 sizeof(*hdr), NLM_F_MULTI); 3110 if (!nlh) 3111 break; 3112 3113 hdr = nlmsg_data(nlh); 3114 memset(hdr, 0, sizeof(*hdr)); 3115 hdr->ifi_family = RTNL_FAMILY_IPMR; 3116 3117 af = nla_nest_start_noflag(skb, IFLA_AF_SPEC); 3118 if (!af) { 3119 nlmsg_cancel(skb, nlh); 3120 goto out; 3121 } 3122 3123 if (!ipmr_fill_table(mrt, skb)) { 3124 nlmsg_cancel(skb, nlh); 3125 goto out; 3126 } 3127 3128 vifs = nla_nest_start_noflag(skb, IPMRA_TABLE_VIFS); 3129 if (!vifs) { 3130 nla_nest_end(skb, af); 3131 nlmsg_end(skb, nlh); 3132 goto out; 3133 } 3134 for (i = 0; i < READ_ONCE(mrt->maxvif); i++) { 3135 if (e < s_e) 3136 goto skip_entry; 3137 if (!ipmr_fill_vif(mrt, i, skb)) { 3138 nla_nest_end(skb, vifs); 3139 nla_nest_end(skb, af); 3140 nlmsg_end(skb, nlh); 3141 goto out; 3142 } 3143 skip_entry: 3144 e++; 3145 } 3146 s_e = 0; 3147 e = 0; 3148 nla_nest_end(skb, vifs); 3149 nla_nest_end(skb, af); 3150 nlmsg_end(skb, nlh); 3151 skip_table: 3152 t++; 3153 } 3154 3155 out: 3156 rcu_read_unlock(); 3157 3158 cb->args[1] = e; 3159 cb->args[0] = t; 3160 3161 return skb->len; 3162 } 3163 3164 #ifdef CONFIG_PROC_FS 3165 /* The /proc interfaces to multicast routing : 3166 * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif 3167 */ 3168 3169 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos) 3170 __acquires(RCU) 3171 { 3172 struct mr_vif_iter *iter = seq->private; 3173 struct net *net = seq_file_net(seq); 3174 struct mr_table *mrt; 3175 3176 rcu_read_lock(); 3177 mrt = __ipmr_get_table(net, RT_TABLE_DEFAULT); 3178 if (!mrt) { 3179 rcu_read_unlock(); 3180 return ERR_PTR(-ENOENT); 3181 } 3182 3183 iter->mrt = mrt; 3184 3185 return mr_vif_seq_start(seq, pos); 3186 } 3187 3188 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v) 3189 __releases(RCU) 3190 { 3191 rcu_read_unlock(); 3192 } 3193 3194 static int ipmr_vif_seq_show(struct seq_file *seq, void *v) 3195 { 3196 struct mr_vif_iter *iter = seq->private; 3197 struct mr_table *mrt = iter->mrt; 3198 3199 if (v == SEQ_START_TOKEN) { 3200 seq_puts(seq, 3201 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n"); 3202 } else { 3203 const struct vif_device *vif = v; 3204 const struct net_device *vif_dev; 3205 const char *name; 3206 3207 vif_dev = vif_dev_read(vif); 3208 name = vif_dev ? vif_dev->name : "none"; 3209 seq_printf(seq, 3210 "%2td %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 3211 vif - mrt->vif_table, 3212 name, 3213 READ_ONCE(vif->bytes_in), READ_ONCE(vif->pkt_in), 3214 READ_ONCE(vif->bytes_out), READ_ONCE(vif->pkt_out), 3215 vif->flags, vif->local, vif->remote); 3216 } 3217 return 0; 3218 } 3219 3220 static const struct seq_operations ipmr_vif_seq_ops = { 3221 .start = ipmr_vif_seq_start, 3222 .next = mr_vif_seq_next, 3223 .stop = ipmr_vif_seq_stop, 3224 .show = ipmr_vif_seq_show, 3225 }; 3226 3227 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 3228 { 3229 struct net *net = seq_file_net(seq); 3230 struct mr_table *mrt; 3231 3232 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT); 3233 if (!mrt) 3234 return ERR_PTR(-ENOENT); 3235 3236 return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock); 3237 } 3238 3239 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v) 3240 { 3241 int n; 3242 3243 if (v == SEQ_START_TOKEN) { 3244 seq_puts(seq, 3245 "Group Origin Iif Pkts Bytes Wrong Oifs\n"); 3246 } else { 3247 const struct mfc_cache *mfc = v; 3248 const struct mr_mfc_iter *it = seq->private; 3249 const struct mr_table *mrt = it->mrt; 3250 3251 seq_printf(seq, "%08X %08X %-3hd", 3252 (__force u32) mfc->mfc_mcastgrp, 3253 (__force u32) mfc->mfc_origin, 3254 mfc->_c.mfc_parent); 3255 3256 if (it->cache != &mrt->mfc_unres_queue) { 3257 seq_printf(seq, " %8lu %8lu %8lu", 3258 atomic_long_read(&mfc->_c.mfc_un.res.pkt), 3259 atomic_long_read(&mfc->_c.mfc_un.res.bytes), 3260 atomic_long_read(&mfc->_c.mfc_un.res.wrong_if)); 3261 for (n = mfc->_c.mfc_un.res.minvif; 3262 n < mfc->_c.mfc_un.res.maxvif; n++) { 3263 if (VIF_EXISTS(mrt, n) && 3264 mfc->_c.mfc_un.res.ttls[n] < 255) 3265 seq_printf(seq, 3266 " %2d:%-3d", 3267 n, mfc->_c.mfc_un.res.ttls[n]); 3268 } 3269 } else { 3270 /* unresolved mfc_caches don't contain 3271 * pkt, bytes and wrong_if values 3272 */ 3273 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul); 3274 } 3275 seq_putc(seq, '\n'); 3276 } 3277 return 0; 3278 } 3279 3280 static const struct seq_operations ipmr_mfc_seq_ops = { 3281 .start = ipmr_mfc_seq_start, 3282 .next = mr_mfc_seq_next, 3283 .stop = mr_mfc_seq_stop, 3284 .show = ipmr_mfc_seq_show, 3285 }; 3286 #endif 3287 3288 #ifdef CONFIG_IP_PIMSM_V2 3289 static const struct net_protocol pim_protocol = { 3290 .handler = pim_rcv, 3291 }; 3292 #endif 3293 3294 static unsigned int ipmr_seq_read(const struct net *net) 3295 { 3296 return atomic_read(&net->ipv4.ipmr_seq) + ipmr_rules_seq_read(net); 3297 } 3298 3299 static int ipmr_dump(struct net *net, struct notifier_block *nb, 3300 struct netlink_ext_ack *extack) 3301 { 3302 return mr_dump(net, nb, RTNL_FAMILY_IPMR, ipmr_rules_dump, 3303 ipmr_mr_table_iter, extack); 3304 } 3305 3306 static const struct fib_notifier_ops ipmr_notifier_ops_template = { 3307 .family = RTNL_FAMILY_IPMR, 3308 .fib_seq_read = ipmr_seq_read, 3309 .fib_dump = ipmr_dump, 3310 .owner = THIS_MODULE, 3311 }; 3312 3313 static int __net_init ipmr_notifier_init(struct net *net) 3314 { 3315 struct fib_notifier_ops *ops; 3316 3317 atomic_set(&net->ipv4.ipmr_seq, 0); 3318 3319 ops = fib_notifier_ops_register(&ipmr_notifier_ops_template, net); 3320 if (IS_ERR(ops)) 3321 return PTR_ERR(ops); 3322 net->ipv4.ipmr_notifier_ops = ops; 3323 3324 return 0; 3325 } 3326 3327 static void __net_exit ipmr_notifier_exit(struct net *net) 3328 { 3329 fib_notifier_ops_unregister(net->ipv4.ipmr_notifier_ops); 3330 net->ipv4.ipmr_notifier_ops = NULL; 3331 } 3332 3333 /* Setup for IP multicast routing */ 3334 static int __net_init ipmr_net_init(struct net *net) 3335 { 3336 LIST_HEAD(dev_kill_list); 3337 int err; 3338 3339 mutex_init(&net->ipv4.mfc_mutex); 3340 3341 err = ipmr_notifier_init(net); 3342 if (err) 3343 goto ipmr_notifier_fail; 3344 3345 err = ipmr_rules_init(net); 3346 if (err < 0) 3347 goto ipmr_rules_fail; 3348 3349 #ifdef CONFIG_PROC_FS 3350 err = -ENOMEM; 3351 if (!proc_create_net("ip_mr_vif", 0, net->proc_net, &ipmr_vif_seq_ops, 3352 sizeof(struct mr_vif_iter))) 3353 goto proc_vif_fail; 3354 if (!proc_create_net("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops, 3355 sizeof(struct mr_mfc_iter))) 3356 goto proc_cache_fail; 3357 #endif 3358 return 0; 3359 3360 #ifdef CONFIG_PROC_FS 3361 proc_cache_fail: 3362 remove_proc_entry("ip_mr_vif", net->proc_net); 3363 proc_vif_fail: 3364 ipmr_rules_exit_rtnl(net, &dev_kill_list); 3365 ipmr_rules_exit(net); 3366 #endif 3367 ipmr_rules_fail: 3368 ipmr_notifier_exit(net); 3369 ipmr_notifier_fail: 3370 return err; 3371 } 3372 3373 static void __net_exit ipmr_net_exit(struct net *net) 3374 { 3375 #ifdef CONFIG_PROC_FS 3376 remove_proc_entry("ip_mr_cache", net->proc_net); 3377 remove_proc_entry("ip_mr_vif", net->proc_net); 3378 #endif 3379 ipmr_rules_exit(net); 3380 ipmr_notifier_exit(net); 3381 } 3382 3383 static void __net_exit ipmr_net_exit_rtnl(struct net *net, 3384 struct list_head *dev_kill_list) 3385 { 3386 ipmr_rules_exit_rtnl(net, dev_kill_list); 3387 } 3388 3389 static struct pernet_operations ipmr_net_ops = { 3390 .init = ipmr_net_init, 3391 .exit = ipmr_net_exit, 3392 .exit_rtnl = ipmr_net_exit_rtnl, 3393 }; 3394 3395 static const struct rtnl_msg_handler ipmr_rtnl_msg_handlers[] __initconst = { 3396 {.protocol = RTNL_FAMILY_IPMR, .msgtype = RTM_GETLINK, 3397 .dumpit = ipmr_rtm_dumplink, .flags = RTNL_FLAG_DUMP_UNLOCKED}, 3398 {.protocol = RTNL_FAMILY_IPMR, .msgtype = RTM_NEWROUTE, 3399 .doit = ipmr_rtm_route, .flags = RTNL_FLAG_DOIT_UNLOCKED}, 3400 {.protocol = RTNL_FAMILY_IPMR, .msgtype = RTM_DELROUTE, 3401 .doit = ipmr_rtm_route, .flags = RTNL_FLAG_DOIT_UNLOCKED}, 3402 {.protocol = RTNL_FAMILY_IPMR, .msgtype = RTM_GETROUTE, 3403 .doit = ipmr_rtm_getroute, .dumpit = ipmr_rtm_dumproute, 3404 .flags = RTNL_FLAG_DOIT_UNLOCKED | RTNL_FLAG_DUMP_UNLOCKED}, 3405 }; 3406 3407 int __init ip_mr_init(void) 3408 { 3409 int err; 3410 3411 mrt_cachep = KMEM_CACHE(mfc_cache, 3412 SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT); 3413 3414 err = register_pernet_subsys(&ipmr_net_ops); 3415 if (err) 3416 goto reg_pernet_fail; 3417 3418 err = register_netdevice_notifier(&ip_mr_notifier); 3419 if (err) 3420 goto reg_notif_fail; 3421 #ifdef CONFIG_IP_PIMSM_V2 3422 if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) { 3423 pr_err("%s: can't add PIM protocol\n", __func__); 3424 err = -EAGAIN; 3425 goto add_proto_fail; 3426 } 3427 #endif 3428 rtnl_register_many(ipmr_rtnl_msg_handlers); 3429 3430 return 0; 3431 3432 #ifdef CONFIG_IP_PIMSM_V2 3433 add_proto_fail: 3434 unregister_netdevice_notifier(&ip_mr_notifier); 3435 #endif 3436 reg_notif_fail: 3437 unregister_pernet_subsys(&ipmr_net_ops); 3438 reg_pernet_fail: 3439 kmem_cache_destroy(mrt_cachep); 3440 return err; 3441 } 3442