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