1 /* $FreeBSD$ */ 2 /* $KAME: ip6_mroute.c,v 1.58 2001/12/18 02:36:31 itojun Exp $ */ 3 4 /*- 5 * Copyright (C) 1998 WIDE Project. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the project nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 /* BSDI ip_mroute.c,v 2.10 1996/11/14 00:29:52 jch Exp */ 34 35 /*- 36 * Copyright (c) 1989 Stephen Deering 37 * Copyright (c) 1992, 1993 38 * The Regents of the University of California. All rights reserved. 39 * 40 * This code is derived from software contributed to Berkeley by 41 * Stephen Deering of Stanford University. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 4. Neither the name of the University nor the names of its contributors 52 * may be used to endorse or promote products derived from this software 53 * without specific prior written permission. 54 * 55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 65 * SUCH DAMAGE. 66 * 67 * @(#)ip_mroute.c 8.2 (Berkeley) 11/15/93 68 */ 69 70 /* 71 * IP multicast forwarding procedures 72 * 73 * Written by David Waitzman, BBN Labs, August 1988. 74 * Modified by Steve Deering, Stanford, February 1989. 75 * Modified by Mark J. Steiglitz, Stanford, May, 1991 76 * Modified by Van Jacobson, LBL, January 1993 77 * Modified by Ajit Thyagarajan, PARC, August 1993 78 * Modified by Bill Fenner, PARC, April 1994 79 * 80 * MROUTING Revision: 3.5.1.2 + PIM-SMv2 (pimd) Support 81 */ 82 83 #include "opt_inet.h" 84 #include "opt_inet6.h" 85 86 #include <sys/param.h> 87 #include <sys/callout.h> 88 #include <sys/errno.h> 89 #include <sys/kernel.h> 90 #include <sys/lock.h> 91 #include <sys/malloc.h> 92 #include <sys/mbuf.h> 93 #include <sys/protosw.h> 94 #include <sys/signalvar.h> 95 #include <sys/socket.h> 96 #include <sys/socketvar.h> 97 #include <sys/sockio.h> 98 #include <sys/sx.h> 99 #include <sys/syslog.h> 100 #include <sys/systm.h> 101 #include <sys/time.h> 102 103 #include <net/if.h> 104 #include <net/if_types.h> 105 #include <net/raw_cb.h> 106 #include <net/route.h> 107 108 #include <netinet/in.h> 109 #include <netinet/in_var.h> 110 #include <netinet/icmp6.h> 111 112 #include <netinet/ip6.h> 113 #include <netinet6/ip6_var.h> 114 #include <netinet6/scope6_var.h> 115 #include <netinet6/nd6.h> 116 #include <netinet6/ip6_mroute.h> 117 #include <netinet6/pim6.h> 118 #include <netinet6/pim6_var.h> 119 120 static MALLOC_DEFINE(M_MRTABLE6, "mf6c", "multicast forwarding cache entry"); 121 122 #define M_HASCL(m) ((m)->m_flags & M_EXT) 123 124 static int ip6_mdq __P((struct mbuf *, struct ifnet *, struct mf6c *)); 125 static void phyint_send __P((struct ip6_hdr *, struct mif6 *, struct mbuf *)); 126 127 static int set_pim6 __P((int *)); 128 static int socket_send __P((struct socket *, struct mbuf *, 129 struct sockaddr_in6 *)); 130 static int register_send __P((struct ip6_hdr *, struct mif6 *, 131 struct mbuf *)); 132 133 /* 134 * Globals. All but ip6_mrouter, ip6_mrtproto and mrt6stat could be static, 135 * except for netstat or debugging purposes. 136 */ 137 struct socket *ip6_mrouter = NULL; 138 int ip6_mrouter_ver = 0; 139 int ip6_mrtproto = IPPROTO_PIM; /* for netstat only */ 140 struct mrt6stat mrt6stat; 141 142 #define NO_RTE_FOUND 0x1 143 #define RTE_FOUND 0x2 144 145 struct mf6c *mf6ctable[MF6CTBLSIZ]; 146 u_char n6expire[MF6CTBLSIZ]; 147 static struct mif6 mif6table[MAXMIFS]; 148 #ifdef MRT6DEBUG 149 u_int mrt6debug = 0; /* debug level */ 150 #define DEBUG_MFC 0x02 151 #define DEBUG_FORWARD 0x04 152 #define DEBUG_EXPIRE 0x08 153 #define DEBUG_XMIT 0x10 154 #define DEBUG_REG 0x20 155 #define DEBUG_PIM 0x40 156 #endif 157 158 static void expire_upcalls __P((void *)); 159 #define EXPIRE_TIMEOUT (hz / 4) /* 4x / second */ 160 #define UPCALL_EXPIRE 6 /* number of timeouts */ 161 162 #ifdef INET 163 #ifdef MROUTING 164 extern struct socket *ip_mrouter; 165 #endif 166 #endif 167 168 /* 169 * 'Interfaces' associated with decapsulator (so we can tell 170 * packets that went through it from ones that get reflected 171 * by a broken gateway). Different from IPv4 register_if, 172 * these interfaces are linked into the system ifnet list, 173 * because per-interface IPv6 statistics are maintained in 174 * ifp->if_afdata. But it does not have any routes point 175 * to them. I.e., packets can't be sent this way. They 176 * only exist as a placeholder for multicast source 177 * verification. 178 */ 179 static struct ifnet *multicast_register_if6; 180 181 #define ENCAP_HOPS 64 182 183 /* 184 * Private variables. 185 */ 186 static mifi_t nummifs = 0; 187 static mifi_t reg_mif_num = (mifi_t)-1; 188 189 static struct pim6stat pim6stat; 190 static int pim6; 191 192 /* 193 * Hash function for a source, group entry 194 */ 195 #define MF6CHASH(a, g) MF6CHASHMOD((a).s6_addr32[0] ^ (a).s6_addr32[1] ^ \ 196 (a).s6_addr32[2] ^ (a).s6_addr32[3] ^ \ 197 (g).s6_addr32[0] ^ (g).s6_addr32[1] ^ \ 198 (g).s6_addr32[2] ^ (g).s6_addr32[3]) 199 200 /* 201 * Find a route for a given origin IPv6 address and Multicast group address. 202 * Quality of service parameter to be added in the future!!! 203 */ 204 205 #define MF6CFIND(o, g, rt) do { \ 206 struct mf6c *_rt = mf6ctable[MF6CHASH(o,g)]; \ 207 rt = NULL; \ 208 mrt6stat.mrt6s_mfc_lookups++; \ 209 while (_rt) { \ 210 if (IN6_ARE_ADDR_EQUAL(&_rt->mf6c_origin.sin6_addr, &(o)) && \ 211 IN6_ARE_ADDR_EQUAL(&_rt->mf6c_mcastgrp.sin6_addr, &(g)) && \ 212 (_rt->mf6c_stall == NULL)) { \ 213 rt = _rt; \ 214 break; \ 215 } \ 216 _rt = _rt->mf6c_next; \ 217 } \ 218 if (rt == NULL) { \ 219 mrt6stat.mrt6s_mfc_misses++; \ 220 } \ 221 } while (/*CONSTCOND*/ 0) 222 223 /* 224 * Macros to compute elapsed time efficiently 225 * Borrowed from Van Jacobson's scheduling code 226 */ 227 #define TV_DELTA(a, b, delta) do { \ 228 int xxs; \ 229 \ 230 delta = (a).tv_usec - (b).tv_usec; \ 231 if ((xxs = (a).tv_sec - (b).tv_sec)) { \ 232 switch (xxs) { \ 233 case 2: \ 234 delta += 1000000; \ 235 /* FALLTHROUGH */ \ 236 case 1: \ 237 delta += 1000000; \ 238 break; \ 239 default: \ 240 delta += (1000000 * xxs); \ 241 } \ 242 } \ 243 } while (/*CONSTCOND*/ 0) 244 245 #define TV_LT(a, b) (((a).tv_usec < (b).tv_usec && \ 246 (a).tv_sec <= (b).tv_sec) || (a).tv_sec < (b).tv_sec) 247 248 #ifdef UPCALL_TIMING 249 #define UPCALL_MAX 50 250 u_long upcall_data[UPCALL_MAX + 1]; 251 static void collate(); 252 #endif /* UPCALL_TIMING */ 253 254 static int get_sg_cnt __P((struct sioc_sg_req6 *)); 255 static int get_mif6_cnt __P((struct sioc_mif_req6 *)); 256 static int ip6_mrouter_init __P((struct socket *, int, int)); 257 static int add_m6if __P((struct mif6ctl *)); 258 static int del_m6if __P((mifi_t *)); 259 static int add_m6fc __P((struct mf6cctl *)); 260 static int del_m6fc __P((struct mf6cctl *)); 261 262 static struct callout expire_upcalls_ch; 263 264 /* 265 * Handle MRT setsockopt commands to modify the multicast routing tables. 266 */ 267 int 268 ip6_mrouter_set(so, sopt) 269 struct socket *so; 270 struct sockopt *sopt; 271 { 272 int error = 0; 273 int optval; 274 struct mif6ctl mifc; 275 struct mf6cctl mfcc; 276 mifi_t mifi; 277 278 if (so != ip6_mrouter && sopt->sopt_name != MRT6_INIT) 279 return (EACCES); 280 281 switch (sopt->sopt_name) { 282 case MRT6_INIT: 283 #ifdef MRT6_OINIT 284 case MRT6_OINIT: 285 #endif 286 error = sooptcopyin(sopt, &optval, sizeof(optval), 287 sizeof(optval)); 288 if (error) 289 break; 290 error = ip6_mrouter_init(so, optval, sopt->sopt_name); 291 break; 292 case MRT6_DONE: 293 error = ip6_mrouter_done(); 294 break; 295 case MRT6_ADD_MIF: 296 error = sooptcopyin(sopt, &mifc, sizeof(mifc), sizeof(mifc)); 297 if (error) 298 break; 299 error = add_m6if(&mifc); 300 break; 301 case MRT6_ADD_MFC: 302 error = sooptcopyin(sopt, &mfcc, sizeof(mfcc), sizeof(mfcc)); 303 if (error) 304 break; 305 error = add_m6fc(&mfcc); 306 break; 307 case MRT6_DEL_MFC: 308 error = sooptcopyin(sopt, &mfcc, sizeof(mfcc), sizeof(mfcc)); 309 if (error) 310 break; 311 error = del_m6fc(&mfcc); 312 break; 313 case MRT6_DEL_MIF: 314 error = sooptcopyin(sopt, &mifi, sizeof(mifi), sizeof(mifi)); 315 if (error) 316 break; 317 error = del_m6if(&mifi); 318 break; 319 case MRT6_PIM: 320 error = sooptcopyin(sopt, &optval, sizeof(optval), 321 sizeof(optval)); 322 if (error) 323 break; 324 error = set_pim6(&optval); 325 break; 326 default: 327 error = EOPNOTSUPP; 328 break; 329 } 330 331 return (error); 332 } 333 334 /* 335 * Handle MRT getsockopt commands 336 */ 337 int 338 ip6_mrouter_get(so, sopt) 339 struct socket *so; 340 struct sockopt *sopt; 341 { 342 int error = 0; 343 344 if (so != ip6_mrouter) 345 return (EACCES); 346 347 switch (sopt->sopt_name) { 348 case MRT6_PIM: 349 error = sooptcopyout(sopt, &pim6, sizeof(pim6)); 350 break; 351 } 352 return (error); 353 } 354 355 /* 356 * Handle ioctl commands to obtain information from the cache 357 */ 358 int 359 mrt6_ioctl(cmd, data) 360 int cmd; 361 caddr_t data; 362 { 363 switch (cmd) { 364 case SIOCGETSGCNT_IN6: 365 return (get_sg_cnt((struct sioc_sg_req6 *)data)); 366 case SIOCGETMIFCNT_IN6: 367 return (get_mif6_cnt((struct sioc_mif_req6 *)data)); 368 default: 369 return (EINVAL); 370 } 371 } 372 373 /* 374 * returns the packet, byte, rpf-failure count for the source group provided 375 */ 376 static int 377 get_sg_cnt(req) 378 struct sioc_sg_req6 *req; 379 { 380 struct mf6c *rt; 381 int s; 382 383 s = splnet(); 384 MF6CFIND(req->src.sin6_addr, req->grp.sin6_addr, rt); 385 splx(s); 386 if (rt != NULL) { 387 req->pktcnt = rt->mf6c_pkt_cnt; 388 req->bytecnt = rt->mf6c_byte_cnt; 389 req->wrong_if = rt->mf6c_wrong_if; 390 } else 391 return (ESRCH); 392 #if 0 393 req->pktcnt = req->bytecnt = req->wrong_if = 0xffffffff; 394 #endif 395 396 return (0); 397 } 398 399 /* 400 * returns the input and output packet and byte counts on the mif provided 401 */ 402 static int 403 get_mif6_cnt(req) 404 struct sioc_mif_req6 *req; 405 { 406 mifi_t mifi = req->mifi; 407 408 if (mifi >= nummifs) 409 return (EINVAL); 410 411 req->icount = mif6table[mifi].m6_pkt_in; 412 req->ocount = mif6table[mifi].m6_pkt_out; 413 req->ibytes = mif6table[mifi].m6_bytes_in; 414 req->obytes = mif6table[mifi].m6_bytes_out; 415 416 return (0); 417 } 418 419 static int 420 set_pim6(i) 421 int *i; 422 { 423 if ((*i != 1) && (*i != 0)) 424 return (EINVAL); 425 426 pim6 = *i; 427 428 return (0); 429 } 430 431 /* 432 * Enable multicast routing 433 */ 434 static int 435 ip6_mrouter_init(so, v, cmd) 436 struct socket *so; 437 int v; 438 int cmd; 439 { 440 #ifdef MRT6DEBUG 441 if (mrt6debug) 442 log(LOG_DEBUG, 443 "ip6_mrouter_init: so_type = %d, pr_protocol = %d\n", 444 so->so_type, so->so_proto->pr_protocol); 445 #endif 446 447 if (so->so_type != SOCK_RAW || 448 so->so_proto->pr_protocol != IPPROTO_ICMPV6) 449 return (EOPNOTSUPP); 450 451 if (v != 1) 452 return (ENOPROTOOPT); 453 454 if (ip6_mrouter != NULL) 455 return (EADDRINUSE); 456 457 ip6_mrouter = so; 458 ip6_mrouter_ver = cmd; 459 460 bzero((caddr_t)mf6ctable, sizeof(mf6ctable)); 461 bzero((caddr_t)n6expire, sizeof(n6expire)); 462 463 pim6 = 0;/* used for stubbing out/in pim stuff */ 464 465 callout_init(&expire_upcalls_ch, 0); 466 callout_reset(&expire_upcalls_ch, EXPIRE_TIMEOUT, 467 expire_upcalls, NULL); 468 469 #ifdef MRT6DEBUG 470 if (mrt6debug) 471 log(LOG_DEBUG, "ip6_mrouter_init\n"); 472 #endif 473 474 return (0); 475 } 476 477 /* 478 * Disable multicast routing 479 */ 480 int 481 ip6_mrouter_done() 482 { 483 mifi_t mifi; 484 int i; 485 struct mf6c *rt; 486 struct rtdetq *rte; 487 int s; 488 489 s = splnet(); 490 491 /* 492 * For each phyint in use, disable promiscuous reception of all IPv6 493 * multicasts. 494 */ 495 #ifdef INET 496 #ifdef MROUTING 497 /* 498 * If there is still IPv4 multicast routing daemon, 499 * we remain interfaces to receive all muliticasted packets. 500 * XXX: there may be an interface in which the IPv4 multicast 501 * daemon is not interested... 502 */ 503 if (!ip_mrouter) 504 #endif 505 #endif 506 { 507 for (mifi = 0; mifi < nummifs; mifi++) { 508 if (mif6table[mifi].m6_ifp && 509 !(mif6table[mifi].m6_flags & MIFF_REGISTER)) { 510 if_allmulti(mif6table[mifi].m6_ifp, 0); 511 } 512 } 513 } 514 #ifdef notyet 515 bzero((caddr_t)qtable, sizeof(qtable)); 516 bzero((caddr_t)tbftable, sizeof(tbftable)); 517 #endif 518 bzero((caddr_t)mif6table, sizeof(mif6table)); 519 nummifs = 0; 520 521 pim6 = 0; /* used to stub out/in pim specific code */ 522 523 callout_stop(&expire_upcalls_ch); 524 525 /* 526 * Free all multicast forwarding cache entries. 527 */ 528 for (i = 0; i < MF6CTBLSIZ; i++) { 529 rt = mf6ctable[i]; 530 while (rt) { 531 struct mf6c *frt; 532 533 for (rte = rt->mf6c_stall; rte != NULL; ) { 534 struct rtdetq *n = rte->next; 535 536 m_free(rte->m); 537 free(rte, M_MRTABLE6); 538 rte = n; 539 } 540 frt = rt; 541 rt = rt->mf6c_next; 542 free(frt, M_MRTABLE6); 543 } 544 } 545 546 bzero((caddr_t)mf6ctable, sizeof(mf6ctable)); 547 548 /* 549 * Reset register interface 550 */ 551 if (reg_mif_num != (mifi_t)-1 && multicast_register_if6 != NULL) { 552 if_detach(multicast_register_if6); 553 if_free(multicast_register_if6); 554 reg_mif_num = (mifi_t)-1; 555 multicast_register_if6 = NULL; 556 } 557 558 ip6_mrouter = NULL; 559 ip6_mrouter_ver = 0; 560 561 splx(s); 562 563 #ifdef MRT6DEBUG 564 if (mrt6debug) 565 log(LOG_DEBUG, "ip6_mrouter_done\n"); 566 #endif 567 568 return (0); 569 } 570 571 static struct sockaddr_in6 sin6 = { sizeof(sin6), AF_INET6 }; 572 573 /* 574 * Add a mif to the mif table 575 */ 576 static int 577 add_m6if(mifcp) 578 struct mif6ctl *mifcp; 579 { 580 struct mif6 *mifp; 581 struct ifnet *ifp; 582 int error, s; 583 #ifdef notyet 584 struct tbf *m_tbf = tbftable + mifcp->mif6c_mifi; 585 #endif 586 587 if (mifcp->mif6c_mifi >= MAXMIFS) 588 return (EINVAL); 589 mifp = mif6table + mifcp->mif6c_mifi; 590 if (mifp->m6_ifp) 591 return (EADDRINUSE); /* XXX: is it appropriate? */ 592 if (mifcp->mif6c_pifi == 0 || mifcp->mif6c_pifi > if_index) 593 return (ENXIO); 594 ifp = ifnet_byindex(mifcp->mif6c_pifi); 595 596 if (mifcp->mif6c_flags & MIFF_REGISTER) { 597 if (reg_mif_num == (mifi_t)-1) { 598 ifp = if_alloc(IFT_OTHER); 599 600 if_initname(ifp, "register_mif", 0); 601 ifp->if_flags |= IFF_LOOPBACK; 602 if_attach(ifp); 603 multicast_register_if6 = ifp; 604 reg_mif_num = mifcp->mif6c_mifi; 605 /* 606 * it is impossible to guess the ifindex of the 607 * register interface. So mif6c_pifi is automatically 608 * calculated. 609 */ 610 mifcp->mif6c_pifi = ifp->if_index; 611 } else { 612 ifp = multicast_register_if6; 613 } 614 615 } /* if REGISTER */ 616 else { 617 /* Make sure the interface supports multicast */ 618 if ((ifp->if_flags & IFF_MULTICAST) == 0) 619 return (EOPNOTSUPP); 620 621 s = splnet(); 622 error = if_allmulti(ifp, 1); 623 splx(s); 624 if (error) 625 return (error); 626 } 627 628 s = splnet(); 629 mifp->m6_flags = mifcp->mif6c_flags; 630 mifp->m6_ifp = ifp; 631 #ifdef notyet 632 /* scaling up here allows division by 1024 in critical code */ 633 mifp->m6_rate_limit = mifcp->mif6c_rate_limit * 1024 / 1000; 634 #endif 635 /* initialize per mif pkt counters */ 636 mifp->m6_pkt_in = 0; 637 mifp->m6_pkt_out = 0; 638 mifp->m6_bytes_in = 0; 639 mifp->m6_bytes_out = 0; 640 splx(s); 641 642 /* Adjust nummifs up if the mifi is higher than nummifs */ 643 if (nummifs <= mifcp->mif6c_mifi) 644 nummifs = mifcp->mif6c_mifi + 1; 645 646 #ifdef MRT6DEBUG 647 if (mrt6debug) 648 log(LOG_DEBUG, 649 "add_mif #%d, phyint %s\n", 650 mifcp->mif6c_mifi, 651 ifp->if_xname); 652 #endif 653 654 return (0); 655 } 656 657 /* 658 * Delete a mif from the mif table 659 */ 660 static int 661 del_m6if(mifip) 662 mifi_t *mifip; 663 { 664 struct mif6 *mifp = mif6table + *mifip; 665 mifi_t mifi; 666 struct ifnet *ifp; 667 int s; 668 669 if (*mifip >= nummifs) 670 return (EINVAL); 671 if (mifp->m6_ifp == NULL) 672 return (EINVAL); 673 674 s = splnet(); 675 676 if (!(mifp->m6_flags & MIFF_REGISTER)) { 677 /* 678 * XXX: what if there is yet IPv4 multicast daemon 679 * using the interface? 680 */ 681 ifp = mifp->m6_ifp; 682 683 if_allmulti(ifp, 0); 684 } else { 685 if (reg_mif_num != (mifi_t)-1 && 686 multicast_register_if6 != NULL) { 687 if_detach(multicast_register_if6); 688 if_free(multicast_register_if6); 689 reg_mif_num = (mifi_t)-1; 690 multicast_register_if6 = NULL; 691 } 692 } 693 694 #ifdef notyet 695 bzero((caddr_t)qtable[*mifip], sizeof(qtable[*mifip])); 696 bzero((caddr_t)mifp->m6_tbf, sizeof(*(mifp->m6_tbf))); 697 #endif 698 bzero((caddr_t)mifp, sizeof(*mifp)); 699 700 /* Adjust nummifs down */ 701 for (mifi = nummifs; mifi > 0; mifi--) 702 if (mif6table[mifi - 1].m6_ifp) 703 break; 704 nummifs = mifi; 705 706 splx(s); 707 708 #ifdef MRT6DEBUG 709 if (mrt6debug) 710 log(LOG_DEBUG, "del_m6if %d, nummifs %d\n", *mifip, nummifs); 711 #endif 712 713 return (0); 714 } 715 716 /* 717 * Add an mfc entry 718 */ 719 static int 720 add_m6fc(mfccp) 721 struct mf6cctl *mfccp; 722 { 723 struct mf6c *rt; 724 u_long hash; 725 struct rtdetq *rte; 726 u_short nstl; 727 int s; 728 729 MF6CFIND(mfccp->mf6cc_origin.sin6_addr, 730 mfccp->mf6cc_mcastgrp.sin6_addr, rt); 731 732 /* If an entry already exists, just update the fields */ 733 if (rt) { 734 #ifdef MRT6DEBUG 735 if (mrt6debug & DEBUG_MFC) 736 log(LOG_DEBUG, 737 "add_m6fc no upcall h %d o %s g %s p %x\n", 738 ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr), 739 ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr), 740 mfccp->mf6cc_parent); 741 #endif 742 743 s = splnet(); 744 rt->mf6c_parent = mfccp->mf6cc_parent; 745 rt->mf6c_ifset = mfccp->mf6cc_ifset; 746 splx(s); 747 return (0); 748 } 749 750 /* 751 * Find the entry for which the upcall was made and update 752 */ 753 s = splnet(); 754 hash = MF6CHASH(mfccp->mf6cc_origin.sin6_addr, 755 mfccp->mf6cc_mcastgrp.sin6_addr); 756 for (rt = mf6ctable[hash], nstl = 0; rt; rt = rt->mf6c_next) { 757 if (IN6_ARE_ADDR_EQUAL(&rt->mf6c_origin.sin6_addr, 758 &mfccp->mf6cc_origin.sin6_addr) && 759 IN6_ARE_ADDR_EQUAL(&rt->mf6c_mcastgrp.sin6_addr, 760 &mfccp->mf6cc_mcastgrp.sin6_addr) && 761 (rt->mf6c_stall != NULL)) { 762 763 if (nstl++) 764 log(LOG_ERR, 765 "add_m6fc: %s o %s g %s p %x dbx %p\n", 766 "multiple kernel entries", 767 ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr), 768 ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr), 769 mfccp->mf6cc_parent, rt->mf6c_stall); 770 771 #ifdef MRT6DEBUG 772 if (mrt6debug & DEBUG_MFC) 773 log(LOG_DEBUG, 774 "add_m6fc o %s g %s p %x dbg %x\n", 775 ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr), 776 ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr), 777 mfccp->mf6cc_parent, rt->mf6c_stall); 778 #endif 779 780 rt->mf6c_origin = mfccp->mf6cc_origin; 781 rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp; 782 rt->mf6c_parent = mfccp->mf6cc_parent; 783 rt->mf6c_ifset = mfccp->mf6cc_ifset; 784 /* initialize pkt counters per src-grp */ 785 rt->mf6c_pkt_cnt = 0; 786 rt->mf6c_byte_cnt = 0; 787 rt->mf6c_wrong_if = 0; 788 789 rt->mf6c_expire = 0; /* Don't clean this guy up */ 790 n6expire[hash]--; 791 792 /* free packets Qed at the end of this entry */ 793 for (rte = rt->mf6c_stall; rte != NULL; ) { 794 struct rtdetq *n = rte->next; 795 ip6_mdq(rte->m, rte->ifp, rt); 796 m_freem(rte->m); 797 #ifdef UPCALL_TIMING 798 collate(&(rte->t)); 799 #endif /* UPCALL_TIMING */ 800 free(rte, M_MRTABLE6); 801 rte = n; 802 } 803 rt->mf6c_stall = NULL; 804 } 805 } 806 807 /* 808 * It is possible that an entry is being inserted without an upcall 809 */ 810 if (nstl == 0) { 811 #ifdef MRT6DEBUG 812 if (mrt6debug & DEBUG_MFC) 813 log(LOG_DEBUG, 814 "add_mfc no upcall h %d o %s g %s p %x\n", 815 hash, 816 ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr), 817 ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr), 818 mfccp->mf6cc_parent); 819 #endif 820 821 for (rt = mf6ctable[hash]; rt; rt = rt->mf6c_next) { 822 823 if (IN6_ARE_ADDR_EQUAL(&rt->mf6c_origin.sin6_addr, 824 &mfccp->mf6cc_origin.sin6_addr)&& 825 IN6_ARE_ADDR_EQUAL(&rt->mf6c_mcastgrp.sin6_addr, 826 &mfccp->mf6cc_mcastgrp.sin6_addr)) { 827 828 rt->mf6c_origin = mfccp->mf6cc_origin; 829 rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp; 830 rt->mf6c_parent = mfccp->mf6cc_parent; 831 rt->mf6c_ifset = mfccp->mf6cc_ifset; 832 /* initialize pkt counters per src-grp */ 833 rt->mf6c_pkt_cnt = 0; 834 rt->mf6c_byte_cnt = 0; 835 rt->mf6c_wrong_if = 0; 836 837 if (rt->mf6c_expire) 838 n6expire[hash]--; 839 rt->mf6c_expire = 0; 840 } 841 } 842 if (rt == NULL) { 843 /* no upcall, so make a new entry */ 844 rt = (struct mf6c *)malloc(sizeof(*rt), M_MRTABLE6, 845 M_NOWAIT); 846 if (rt == NULL) { 847 splx(s); 848 return (ENOBUFS); 849 } 850 851 /* insert new entry at head of hash chain */ 852 rt->mf6c_origin = mfccp->mf6cc_origin; 853 rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp; 854 rt->mf6c_parent = mfccp->mf6cc_parent; 855 rt->mf6c_ifset = mfccp->mf6cc_ifset; 856 /* initialize pkt counters per src-grp */ 857 rt->mf6c_pkt_cnt = 0; 858 rt->mf6c_byte_cnt = 0; 859 rt->mf6c_wrong_if = 0; 860 rt->mf6c_expire = 0; 861 rt->mf6c_stall = NULL; 862 863 /* link into table */ 864 rt->mf6c_next = mf6ctable[hash]; 865 mf6ctable[hash] = rt; 866 } 867 } 868 splx(s); 869 return (0); 870 } 871 872 #ifdef UPCALL_TIMING 873 /* 874 * collect delay statistics on the upcalls 875 */ 876 static void 877 collate(t) 878 struct timeval *t; 879 { 880 u_long d; 881 struct timeval tp; 882 u_long delta; 883 884 GET_TIME(tp); 885 886 if (TV_LT(*t, tp)) 887 { 888 TV_DELTA(tp, *t, delta); 889 890 d = delta >> 10; 891 if (d > UPCALL_MAX) 892 d = UPCALL_MAX; 893 894 ++upcall_data[d]; 895 } 896 } 897 #endif /* UPCALL_TIMING */ 898 899 /* 900 * Delete an mfc entry 901 */ 902 static int 903 del_m6fc(mfccp) 904 struct mf6cctl *mfccp; 905 { 906 struct sockaddr_in6 origin; 907 struct sockaddr_in6 mcastgrp; 908 struct mf6c *rt; 909 struct mf6c **nptr; 910 u_long hash; 911 int s; 912 913 origin = mfccp->mf6cc_origin; 914 mcastgrp = mfccp->mf6cc_mcastgrp; 915 hash = MF6CHASH(origin.sin6_addr, mcastgrp.sin6_addr); 916 917 #ifdef MRT6DEBUG 918 if (mrt6debug & DEBUG_MFC) 919 log(LOG_DEBUG,"del_m6fc orig %s mcastgrp %s\n", 920 ip6_sprintf(&origin.sin6_addr), 921 ip6_sprintf(&mcastgrp.sin6_addr)); 922 #endif 923 924 s = splnet(); 925 926 nptr = &mf6ctable[hash]; 927 while ((rt = *nptr) != NULL) { 928 if (IN6_ARE_ADDR_EQUAL(&origin.sin6_addr, 929 &rt->mf6c_origin.sin6_addr) && 930 IN6_ARE_ADDR_EQUAL(&mcastgrp.sin6_addr, 931 &rt->mf6c_mcastgrp.sin6_addr) && 932 rt->mf6c_stall == NULL) 933 break; 934 935 nptr = &rt->mf6c_next; 936 } 937 if (rt == NULL) { 938 splx(s); 939 return (EADDRNOTAVAIL); 940 } 941 942 *nptr = rt->mf6c_next; 943 free(rt, M_MRTABLE6); 944 945 splx(s); 946 947 return (0); 948 } 949 950 static int 951 socket_send(s, mm, src) 952 struct socket *s; 953 struct mbuf *mm; 954 struct sockaddr_in6 *src; 955 { 956 if (s) { 957 if (sbappendaddr(&s->so_rcv, 958 (struct sockaddr *)src, 959 mm, (struct mbuf *)0) != 0) { 960 sorwakeup(s); 961 return (0); 962 } 963 } 964 m_freem(mm); 965 return (-1); 966 } 967 968 /* 969 * IPv6 multicast forwarding function. This function assumes that the packet 970 * pointed to by "ip6" has arrived on (or is about to be sent to) the interface 971 * pointed to by "ifp", and the packet is to be relayed to other networks 972 * that have members of the packet's destination IPv6 multicast group. 973 * 974 * The packet is returned unscathed to the caller, unless it is 975 * erroneous, in which case a non-zero return value tells the caller to 976 * discard it. 977 * 978 * NOTE: this implementation assumes that m->m_pkthdr.rcvif is NULL iff 979 * this function is called in the originating context (i.e., not when 980 * forwarding a packet from other node). ip6_output(), which is currently the 981 * only function that calls this function is called in the originating context, 982 * explicitly ensures this condition. It is caller's responsibility to ensure 983 * that if this function is called from somewhere else in the originating 984 * context in the future. 985 */ 986 987 int 988 ip6_mforward(ip6, ifp, m) 989 struct ip6_hdr *ip6; 990 struct ifnet *ifp; 991 struct mbuf *m; 992 { 993 struct mf6c *rt; 994 struct mif6 *mifp; 995 struct mbuf *mm; 996 int s; 997 mifi_t mifi; 998 999 #ifdef MRT6DEBUG 1000 if (mrt6debug & DEBUG_FORWARD) 1001 log(LOG_DEBUG, "ip6_mforward: src %s, dst %s, ifindex %d\n", 1002 ip6_sprintf(&ip6->ip6_src), ip6_sprintf(&ip6->ip6_dst), 1003 ifp->if_index); 1004 #endif 1005 1006 /* 1007 * Don't forward a packet with Hop limit of zero or one, 1008 * or a packet destined to a local-only group. 1009 */ 1010 if (ip6->ip6_hlim <= 1 || IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst) || 1011 IN6_IS_ADDR_MC_LINKLOCAL(&ip6->ip6_dst)) 1012 return (0); 1013 ip6->ip6_hlim--; 1014 1015 /* 1016 * Source address check: do not forward packets with unspecified 1017 * source. It was discussed in July 2000, on ipngwg mailing list. 1018 * This is rather more serious than unicast cases, because some 1019 * MLD packets can be sent with the unspecified source address 1020 * (although such packets must normally set 1 to the hop limit field). 1021 */ 1022 if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) { 1023 ip6stat.ip6s_cantforward++; 1024 if (ip6_log_time + ip6_log_interval < time_second) { 1025 ip6_log_time = time_second; 1026 log(LOG_DEBUG, 1027 "cannot forward " 1028 "from %s to %s nxt %d received on %s\n", 1029 ip6_sprintf(&ip6->ip6_src), 1030 ip6_sprintf(&ip6->ip6_dst), 1031 ip6->ip6_nxt, 1032 if_name(m->m_pkthdr.rcvif)); 1033 } 1034 return (0); 1035 } 1036 1037 /* 1038 * Determine forwarding mifs from the forwarding cache table 1039 */ 1040 s = splnet(); 1041 MF6CFIND(ip6->ip6_src, ip6->ip6_dst, rt); 1042 1043 /* Entry exists, so forward if necessary */ 1044 if (rt) { 1045 splx(s); 1046 return (ip6_mdq(m, ifp, rt)); 1047 } else { 1048 /* 1049 * If we don't have a route for packet's origin, 1050 * Make a copy of the packet & 1051 * send message to routing daemon 1052 */ 1053 1054 struct mbuf *mb0; 1055 struct rtdetq *rte; 1056 u_long hash; 1057 /* int i, npkts;*/ 1058 #ifdef UPCALL_TIMING 1059 struct timeval tp; 1060 1061 GET_TIME(tp); 1062 #endif /* UPCALL_TIMING */ 1063 1064 mrt6stat.mrt6s_no_route++; 1065 #ifdef MRT6DEBUG 1066 if (mrt6debug & (DEBUG_FORWARD | DEBUG_MFC)) 1067 log(LOG_DEBUG, "ip6_mforward: no rte s %s g %s\n", 1068 ip6_sprintf(&ip6->ip6_src), 1069 ip6_sprintf(&ip6->ip6_dst)); 1070 #endif 1071 1072 /* 1073 * Allocate mbufs early so that we don't do extra work if we 1074 * are just going to fail anyway. 1075 */ 1076 rte = (struct rtdetq *)malloc(sizeof(*rte), M_MRTABLE6, 1077 M_NOWAIT); 1078 if (rte == NULL) { 1079 splx(s); 1080 return (ENOBUFS); 1081 } 1082 mb0 = m_copy(m, 0, M_COPYALL); 1083 /* 1084 * Pullup packet header if needed before storing it, 1085 * as other references may modify it in the meantime. 1086 */ 1087 if (mb0 && 1088 (M_HASCL(mb0) || mb0->m_len < sizeof(struct ip6_hdr))) 1089 mb0 = m_pullup(mb0, sizeof(struct ip6_hdr)); 1090 if (mb0 == NULL) { 1091 free(rte, M_MRTABLE6); 1092 splx(s); 1093 return (ENOBUFS); 1094 } 1095 1096 /* is there an upcall waiting for this packet? */ 1097 hash = MF6CHASH(ip6->ip6_src, ip6->ip6_dst); 1098 for (rt = mf6ctable[hash]; rt; rt = rt->mf6c_next) { 1099 if (IN6_ARE_ADDR_EQUAL(&ip6->ip6_src, 1100 &rt->mf6c_origin.sin6_addr) && 1101 IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, 1102 &rt->mf6c_mcastgrp.sin6_addr) && 1103 (rt->mf6c_stall != NULL)) 1104 break; 1105 } 1106 1107 if (rt == NULL) { 1108 struct mrt6msg *im; 1109 #ifdef MRT6_OINIT 1110 struct omrt6msg *oim; 1111 #endif 1112 1113 /* no upcall, so make a new entry */ 1114 rt = (struct mf6c *)malloc(sizeof(*rt), M_MRTABLE6, 1115 M_NOWAIT); 1116 if (rt == NULL) { 1117 free(rte, M_MRTABLE6); 1118 m_freem(mb0); 1119 splx(s); 1120 return (ENOBUFS); 1121 } 1122 /* 1123 * Make a copy of the header to send to the user 1124 * level process 1125 */ 1126 mm = m_copy(mb0, 0, sizeof(struct ip6_hdr)); 1127 1128 if (mm == NULL) { 1129 free(rte, M_MRTABLE6); 1130 m_freem(mb0); 1131 free(rt, M_MRTABLE6); 1132 splx(s); 1133 return (ENOBUFS); 1134 } 1135 1136 /* 1137 * Send message to routing daemon 1138 */ 1139 sin6.sin6_addr = ip6->ip6_src; 1140 1141 im = NULL; 1142 #ifdef MRT6_OINIT 1143 oim = NULL; 1144 #endif 1145 switch (ip6_mrouter_ver) { 1146 #ifdef MRT6_OINIT 1147 case MRT6_OINIT: 1148 oim = mtod(mm, struct omrt6msg *); 1149 oim->im6_msgtype = MRT6MSG_NOCACHE; 1150 oim->im6_mbz = 0; 1151 break; 1152 #endif 1153 case MRT6_INIT: 1154 im = mtod(mm, struct mrt6msg *); 1155 im->im6_msgtype = MRT6MSG_NOCACHE; 1156 im->im6_mbz = 0; 1157 break; 1158 default: 1159 free(rte, M_MRTABLE6); 1160 m_freem(mb0); 1161 free(rt, M_MRTABLE6); 1162 splx(s); 1163 return (EINVAL); 1164 } 1165 1166 #ifdef MRT6DEBUG 1167 if (mrt6debug & DEBUG_FORWARD) 1168 log(LOG_DEBUG, 1169 "getting the iif info in the kernel\n"); 1170 #endif 1171 1172 for (mifp = mif6table, mifi = 0; 1173 mifi < nummifs && mifp->m6_ifp != ifp; 1174 mifp++, mifi++) 1175 ; 1176 1177 switch (ip6_mrouter_ver) { 1178 #ifdef MRT6_OINIT 1179 case MRT6_OINIT: 1180 oim->im6_mif = mifi; 1181 break; 1182 #endif 1183 case MRT6_INIT: 1184 im->im6_mif = mifi; 1185 break; 1186 } 1187 1188 if (socket_send(ip6_mrouter, mm, &sin6) < 0) { 1189 log(LOG_WARNING, "ip6_mforward: ip6_mrouter " 1190 "socket queue full\n"); 1191 mrt6stat.mrt6s_upq_sockfull++; 1192 free(rte, M_MRTABLE6); 1193 m_freem(mb0); 1194 free(rt, M_MRTABLE6); 1195 splx(s); 1196 return (ENOBUFS); 1197 } 1198 1199 mrt6stat.mrt6s_upcalls++; 1200 1201 /* insert new entry at head of hash chain */ 1202 bzero(rt, sizeof(*rt)); 1203 rt->mf6c_origin.sin6_family = AF_INET6; 1204 rt->mf6c_origin.sin6_len = sizeof(struct sockaddr_in6); 1205 rt->mf6c_origin.sin6_addr = ip6->ip6_src; 1206 rt->mf6c_mcastgrp.sin6_family = AF_INET6; 1207 rt->mf6c_mcastgrp.sin6_len = sizeof(struct sockaddr_in6); 1208 rt->mf6c_mcastgrp.sin6_addr = ip6->ip6_dst; 1209 rt->mf6c_expire = UPCALL_EXPIRE; 1210 n6expire[hash]++; 1211 rt->mf6c_parent = MF6C_INCOMPLETE_PARENT; 1212 1213 /* link into table */ 1214 rt->mf6c_next = mf6ctable[hash]; 1215 mf6ctable[hash] = rt; 1216 /* Add this entry to the end of the queue */ 1217 rt->mf6c_stall = rte; 1218 } else { 1219 /* determine if q has overflowed */ 1220 struct rtdetq **p; 1221 int npkts = 0; 1222 1223 for (p = &rt->mf6c_stall; *p != NULL; p = &(*p)->next) 1224 if (++npkts > MAX_UPQ6) { 1225 mrt6stat.mrt6s_upq_ovflw++; 1226 free(rte, M_MRTABLE6); 1227 m_freem(mb0); 1228 splx(s); 1229 return (0); 1230 } 1231 1232 /* Add this entry to the end of the queue */ 1233 *p = rte; 1234 } 1235 1236 rte->next = NULL; 1237 rte->m = mb0; 1238 rte->ifp = ifp; 1239 #ifdef UPCALL_TIMING 1240 rte->t = tp; 1241 #endif /* UPCALL_TIMING */ 1242 1243 splx(s); 1244 1245 return (0); 1246 } 1247 } 1248 1249 /* 1250 * Clean up cache entries if upcalls are not serviced 1251 * Call from the Slow Timeout mechanism, every half second. 1252 */ 1253 static void 1254 expire_upcalls(unused) 1255 void *unused; 1256 { 1257 struct rtdetq *rte; 1258 struct mf6c *mfc, **nptr; 1259 int i; 1260 int s; 1261 1262 s = splnet(); 1263 for (i = 0; i < MF6CTBLSIZ; i++) { 1264 if (n6expire[i] == 0) 1265 continue; 1266 nptr = &mf6ctable[i]; 1267 while ((mfc = *nptr) != NULL) { 1268 rte = mfc->mf6c_stall; 1269 /* 1270 * Skip real cache entries 1271 * Make sure it wasn't marked to not expire (shouldn't happen) 1272 * If it expires now 1273 */ 1274 if (rte != NULL && 1275 mfc->mf6c_expire != 0 && 1276 --mfc->mf6c_expire == 0) { 1277 #ifdef MRT6DEBUG 1278 if (mrt6debug & DEBUG_EXPIRE) 1279 log(LOG_DEBUG, "expire_upcalls: expiring (%s %s)\n", 1280 ip6_sprintf(&mfc->mf6c_origin.sin6_addr), 1281 ip6_sprintf(&mfc->mf6c_mcastgrp.sin6_addr)); 1282 #endif 1283 /* 1284 * drop all the packets 1285 * free the mbuf with the pkt, if, timing info 1286 */ 1287 do { 1288 struct rtdetq *n = rte->next; 1289 m_freem(rte->m); 1290 free(rte, M_MRTABLE6); 1291 rte = n; 1292 } while (rte != NULL); 1293 mrt6stat.mrt6s_cache_cleanups++; 1294 n6expire[i]--; 1295 1296 *nptr = mfc->mf6c_next; 1297 free(mfc, M_MRTABLE6); 1298 } else { 1299 nptr = &mfc->mf6c_next; 1300 } 1301 } 1302 } 1303 splx(s); 1304 callout_reset(&expire_upcalls_ch, EXPIRE_TIMEOUT, 1305 expire_upcalls, NULL); 1306 } 1307 1308 /* 1309 * Packet forwarding routine once entry in the cache is made 1310 */ 1311 static int 1312 ip6_mdq(m, ifp, rt) 1313 struct mbuf *m; 1314 struct ifnet *ifp; 1315 struct mf6c *rt; 1316 { 1317 struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); 1318 mifi_t mifi, iif; 1319 struct mif6 *mifp; 1320 int plen = m->m_pkthdr.len; 1321 struct in6_addr src0, dst0; /* copies for local work */ 1322 u_int32_t iszone, idzone, oszone, odzone; 1323 int error = 0; 1324 1325 /* 1326 * Macro to send packet on mif. Since RSVP packets don't get counted on 1327 * input, they shouldn't get counted on output, so statistics keeping is 1328 * separate. 1329 */ 1330 1331 #define MC6_SEND(ip6, mifp, m) do { \ 1332 if ((mifp)->m6_flags & MIFF_REGISTER) \ 1333 register_send((ip6), (mifp), (m)); \ 1334 else \ 1335 phyint_send((ip6), (mifp), (m)); \ 1336 } while (/*CONSTCOND*/ 0) 1337 1338 /* 1339 * Don't forward if it didn't arrive from the parent mif 1340 * for its origin. 1341 */ 1342 mifi = rt->mf6c_parent; 1343 if ((mifi >= nummifs) || (mif6table[mifi].m6_ifp != ifp)) { 1344 /* came in the wrong interface */ 1345 #ifdef MRT6DEBUG 1346 if (mrt6debug & DEBUG_FORWARD) 1347 log(LOG_DEBUG, 1348 "wrong if: ifid %d mifi %d mififid %x\n", 1349 ifp->if_index, mifi, 1350 mif6table[mifi].m6_ifp->if_index); 1351 #endif 1352 mrt6stat.mrt6s_wrong_if++; 1353 rt->mf6c_wrong_if++; 1354 /* 1355 * If we are doing PIM processing, and we are forwarding 1356 * packets on this interface, send a message to the 1357 * routing daemon. 1358 */ 1359 /* have to make sure this is a valid mif */ 1360 if (mifi < nummifs && mif6table[mifi].m6_ifp) 1361 if (pim6 && (m->m_flags & M_LOOP) == 0) { 1362 /* 1363 * Check the M_LOOP flag to avoid an 1364 * unnecessary PIM assert. 1365 * XXX: M_LOOP is an ad-hoc hack... 1366 */ 1367 static struct sockaddr_in6 sin6 = 1368 { sizeof(sin6), AF_INET6 }; 1369 1370 struct mbuf *mm; 1371 struct mrt6msg *im; 1372 #ifdef MRT6_OINIT 1373 struct omrt6msg *oim; 1374 #endif 1375 1376 mm = m_copy(m, 0, sizeof(struct ip6_hdr)); 1377 if (mm && 1378 (M_HASCL(mm) || 1379 mm->m_len < sizeof(struct ip6_hdr))) 1380 mm = m_pullup(mm, sizeof(struct ip6_hdr)); 1381 if (mm == NULL) 1382 return (ENOBUFS); 1383 1384 #ifdef MRT6_OINIT 1385 oim = NULL; 1386 #endif 1387 im = NULL; 1388 switch (ip6_mrouter_ver) { 1389 #ifdef MRT6_OINIT 1390 case MRT6_OINIT: 1391 oim = mtod(mm, struct omrt6msg *); 1392 oim->im6_msgtype = MRT6MSG_WRONGMIF; 1393 oim->im6_mbz = 0; 1394 break; 1395 #endif 1396 case MRT6_INIT: 1397 im = mtod(mm, struct mrt6msg *); 1398 im->im6_msgtype = MRT6MSG_WRONGMIF; 1399 im->im6_mbz = 0; 1400 break; 1401 default: 1402 m_freem(mm); 1403 return (EINVAL); 1404 } 1405 1406 for (mifp = mif6table, iif = 0; 1407 iif < nummifs && mifp && 1408 mifp->m6_ifp != ifp; 1409 mifp++, iif++) 1410 ; 1411 1412 switch (ip6_mrouter_ver) { 1413 #ifdef MRT6_OINIT 1414 case MRT6_OINIT: 1415 oim->im6_mif = iif; 1416 sin6.sin6_addr = oim->im6_src; 1417 break; 1418 #endif 1419 case MRT6_INIT: 1420 im->im6_mif = iif; 1421 sin6.sin6_addr = im->im6_src; 1422 break; 1423 } 1424 1425 mrt6stat.mrt6s_upcalls++; 1426 1427 if (socket_send(ip6_mrouter, mm, &sin6) < 0) { 1428 #ifdef MRT6DEBUG 1429 if (mrt6debug) 1430 log(LOG_WARNING, "mdq, ip6_mrouter socket queue full\n"); 1431 #endif 1432 ++mrt6stat.mrt6s_upq_sockfull; 1433 return (ENOBUFS); 1434 } /* if socket Q full */ 1435 } /* if PIM */ 1436 return (0); 1437 } /* if wrong iif */ 1438 1439 /* If I sourced this packet, it counts as output, else it was input. */ 1440 if (m->m_pkthdr.rcvif == NULL) { 1441 /* XXX: is rcvif really NULL when output?? */ 1442 mif6table[mifi].m6_pkt_out++; 1443 mif6table[mifi].m6_bytes_out += plen; 1444 } else { 1445 mif6table[mifi].m6_pkt_in++; 1446 mif6table[mifi].m6_bytes_in += plen; 1447 } 1448 rt->mf6c_pkt_cnt++; 1449 rt->mf6c_byte_cnt += plen; 1450 1451 /* 1452 * For each mif, forward a copy of the packet if there are group 1453 * members downstream on the interface. 1454 */ 1455 src0 = ip6->ip6_src; 1456 dst0 = ip6->ip6_dst; 1457 if ((error = in6_setscope(&src0, ifp, &iszone)) != 0 || 1458 (error = in6_setscope(&dst0, ifp, &idzone)) != 0) { 1459 ip6stat.ip6s_badscope++; 1460 return (error); 1461 } 1462 for (mifp = mif6table, mifi = 0; mifi < nummifs; mifp++, mifi++) { 1463 if (IF_ISSET(mifi, &rt->mf6c_ifset)) { 1464 /* 1465 * check if the outgoing packet is going to break 1466 * a scope boundary. 1467 * XXX For packets through PIM register tunnel 1468 * interface, we believe a routing daemon. 1469 */ 1470 if (!(mif6table[rt->mf6c_parent].m6_flags & 1471 MIFF_REGISTER) && 1472 !(mif6table[mifi].m6_flags & MIFF_REGISTER)) { 1473 if (in6_setscope(&src0, mif6table[mifi].m6_ifp, 1474 &oszone) || 1475 in6_setscope(&dst0, mif6table[mifi].m6_ifp, 1476 &odzone) || 1477 iszone != oszone || 1478 idzone != odzone) { 1479 ip6stat.ip6s_badscope++; 1480 continue; 1481 } 1482 } 1483 1484 mifp->m6_pkt_out++; 1485 mifp->m6_bytes_out += plen; 1486 MC6_SEND(ip6, mifp, m); 1487 } 1488 } 1489 return (0); 1490 } 1491 1492 static void 1493 phyint_send(ip6, mifp, m) 1494 struct ip6_hdr *ip6; 1495 struct mif6 *mifp; 1496 struct mbuf *m; 1497 { 1498 struct mbuf *mb_copy; 1499 struct ifnet *ifp = mifp->m6_ifp; 1500 int error = 0; 1501 int s = splnet(); /* needs to protect static "ro" below. */ 1502 static struct route_in6 ro; 1503 struct in6_multi *in6m; 1504 struct sockaddr_in6 *dst6; 1505 u_long linkmtu; 1506 1507 /* 1508 * Make a new reference to the packet; make sure that 1509 * the IPv6 header is actually copied, not just referenced, 1510 * so that ip6_output() only scribbles on the copy. 1511 */ 1512 mb_copy = m_copy(m, 0, M_COPYALL); 1513 if (mb_copy && 1514 (M_HASCL(mb_copy) || mb_copy->m_len < sizeof(struct ip6_hdr))) 1515 mb_copy = m_pullup(mb_copy, sizeof(struct ip6_hdr)); 1516 if (mb_copy == NULL) { 1517 splx(s); 1518 return; 1519 } 1520 /* set MCAST flag to the outgoing packet */ 1521 mb_copy->m_flags |= M_MCAST; 1522 1523 /* 1524 * If we sourced the packet, call ip6_output since we may devide 1525 * the packet into fragments when the packet is too big for the 1526 * outgoing interface. 1527 * Otherwise, we can simply send the packet to the interface 1528 * sending queue. 1529 */ 1530 if (m->m_pkthdr.rcvif == NULL) { 1531 struct ip6_moptions im6o; 1532 1533 im6o.im6o_multicast_ifp = ifp; 1534 /* XXX: ip6_output will override ip6->ip6_hlim */ 1535 im6o.im6o_multicast_hlim = ip6->ip6_hlim; 1536 im6o.im6o_multicast_loop = 1; 1537 error = ip6_output(mb_copy, NULL, &ro, 1538 IPV6_FORWARDING, &im6o, NULL, NULL); 1539 1540 #ifdef MRT6DEBUG 1541 if (mrt6debug & DEBUG_XMIT) 1542 log(LOG_DEBUG, "phyint_send on mif %d err %d\n", 1543 mifp - mif6table, error); 1544 #endif 1545 splx(s); 1546 return; 1547 } 1548 1549 /* 1550 * If we belong to the destination multicast group 1551 * on the outgoing interface, loop back a copy. 1552 */ 1553 dst6 = (struct sockaddr_in6 *)&ro.ro_dst; 1554 IN6_LOOKUP_MULTI(ip6->ip6_dst, ifp, in6m); 1555 if (in6m != NULL) { 1556 dst6->sin6_len = sizeof(struct sockaddr_in6); 1557 dst6->sin6_family = AF_INET6; 1558 dst6->sin6_addr = ip6->ip6_dst; 1559 ip6_mloopback(ifp, m, (struct sockaddr_in6 *)&ro.ro_dst); 1560 } 1561 /* 1562 * Put the packet into the sending queue of the outgoing interface 1563 * if it would fit in the MTU of the interface. 1564 */ 1565 linkmtu = IN6_LINKMTU(ifp); 1566 if (mb_copy->m_pkthdr.len <= linkmtu || linkmtu < IPV6_MMTU) { 1567 dst6->sin6_len = sizeof(struct sockaddr_in6); 1568 dst6->sin6_family = AF_INET6; 1569 dst6->sin6_addr = ip6->ip6_dst; 1570 /* 1571 * We just call if_output instead of nd6_output here, since 1572 * we need no ND for a multicast forwarded packet...right? 1573 */ 1574 error = (*ifp->if_output)(ifp, mb_copy, 1575 (struct sockaddr *)&ro.ro_dst, NULL); 1576 #ifdef MRT6DEBUG 1577 if (mrt6debug & DEBUG_XMIT) 1578 log(LOG_DEBUG, "phyint_send on mif %d err %d\n", 1579 mifp - mif6table, error); 1580 #endif 1581 } else { 1582 /* 1583 * pMTU discovery is intentionally disabled by default, since 1584 * various router may notify pMTU in multicast, which can be 1585 * a DDoS to a router 1586 */ 1587 if (ip6_mcast_pmtu) 1588 icmp6_error(mb_copy, ICMP6_PACKET_TOO_BIG, 0, linkmtu); 1589 else { 1590 #ifdef MRT6DEBUG 1591 if (mrt6debug & DEBUG_XMIT) 1592 log(LOG_DEBUG, 1593 "phyint_send: packet too big on %s o %s " 1594 "g %s size %d(discarded)\n", 1595 if_name(ifp), 1596 ip6_sprintf(&ip6->ip6_src), 1597 ip6_sprintf(&ip6->ip6_dst), 1598 mb_copy->m_pkthdr.len); 1599 #endif /* MRT6DEBUG */ 1600 m_freem(mb_copy); /* simply discard the packet */ 1601 } 1602 } 1603 1604 splx(s); 1605 } 1606 1607 static int 1608 register_send(ip6, mif, m) 1609 struct ip6_hdr *ip6; 1610 struct mif6 *mif; 1611 struct mbuf *m; 1612 { 1613 struct mbuf *mm; 1614 int i, len = m->m_pkthdr.len; 1615 static struct sockaddr_in6 sin6 = { sizeof(sin6), AF_INET6 }; 1616 struct mrt6msg *im6; 1617 1618 #ifdef MRT6DEBUG 1619 if (mrt6debug) 1620 log(LOG_DEBUG, "** IPv6 register_send **\n src %s dst %s\n", 1621 ip6_sprintf(&ip6->ip6_src), ip6_sprintf(&ip6->ip6_dst)); 1622 #endif 1623 ++pim6stat.pim6s_snd_registers; 1624 1625 /* Make a copy of the packet to send to the user level process */ 1626 MGETHDR(mm, M_DONTWAIT, MT_HEADER); 1627 if (mm == NULL) 1628 return (ENOBUFS); 1629 mm->m_pkthdr.rcvif = NULL; 1630 mm->m_data += max_linkhdr; 1631 mm->m_len = sizeof(struct ip6_hdr); 1632 1633 if ((mm->m_next = m_copy(m, 0, M_COPYALL)) == NULL) { 1634 m_freem(mm); 1635 return (ENOBUFS); 1636 } 1637 i = MHLEN - M_LEADINGSPACE(mm); 1638 if (i > len) 1639 i = len; 1640 mm = m_pullup(mm, i); 1641 if (mm == NULL) 1642 return (ENOBUFS); 1643 /* TODO: check it! */ 1644 mm->m_pkthdr.len = len + sizeof(struct ip6_hdr); 1645 1646 /* 1647 * Send message to routing daemon 1648 */ 1649 sin6.sin6_addr = ip6->ip6_src; 1650 1651 im6 = mtod(mm, struct mrt6msg *); 1652 im6->im6_msgtype = MRT6MSG_WHOLEPKT; 1653 im6->im6_mbz = 0; 1654 1655 im6->im6_mif = mif - mif6table; 1656 1657 /* iif info is not given for reg. encap.n */ 1658 mrt6stat.mrt6s_upcalls++; 1659 1660 if (socket_send(ip6_mrouter, mm, &sin6) < 0) { 1661 #ifdef MRT6DEBUG 1662 if (mrt6debug) 1663 log(LOG_WARNING, 1664 "register_send: ip6_mrouter socket queue full\n"); 1665 #endif 1666 ++mrt6stat.mrt6s_upq_sockfull; 1667 return (ENOBUFS); 1668 } 1669 return (0); 1670 } 1671 1672 /* 1673 * PIM sparse mode hook 1674 * Receives the pim control messages, and passes them up to the listening 1675 * socket, using rip6_input. 1676 * The only message processed is the REGISTER pim message; the pim header 1677 * is stripped off, and the inner packet is passed to register_mforward. 1678 */ 1679 int 1680 pim6_input(mp, offp, proto) 1681 struct mbuf **mp; 1682 int *offp, proto; 1683 { 1684 struct pim *pim; /* pointer to a pim struct */ 1685 struct ip6_hdr *ip6; 1686 int pimlen; 1687 struct mbuf *m = *mp; 1688 int minlen; 1689 int off = *offp; 1690 1691 ++pim6stat.pim6s_rcv_total; 1692 1693 ip6 = mtod(m, struct ip6_hdr *); 1694 pimlen = m->m_pkthdr.len - *offp; 1695 1696 /* 1697 * Validate lengths 1698 */ 1699 if (pimlen < PIM_MINLEN) { 1700 ++pim6stat.pim6s_rcv_tooshort; 1701 #ifdef MRT6DEBUG 1702 if (mrt6debug & DEBUG_PIM) 1703 log(LOG_DEBUG,"pim6_input: PIM packet too short\n"); 1704 #endif 1705 m_freem(m); 1706 return (IPPROTO_DONE); 1707 } 1708 1709 /* 1710 * if the packet is at least as big as a REGISTER, go ahead 1711 * and grab the PIM REGISTER header size, to avoid another 1712 * possible m_pullup() later. 1713 * 1714 * PIM_MINLEN == pimhdr + u_int32 == 8 1715 * PIM6_REG_MINLEN == pimhdr + reghdr + eip6hdr == 4 + 4 + 40 1716 */ 1717 minlen = (pimlen >= PIM6_REG_MINLEN) ? PIM6_REG_MINLEN : PIM_MINLEN; 1718 1719 /* 1720 * Make sure that the IP6 and PIM headers in contiguous memory, and 1721 * possibly the PIM REGISTER header 1722 */ 1723 #ifndef PULLDOWN_TEST 1724 IP6_EXTHDR_CHECK(m, off, minlen, IPPROTO_DONE); 1725 /* adjust pointer */ 1726 ip6 = mtod(m, struct ip6_hdr *); 1727 1728 /* adjust mbuf to point to the PIM header */ 1729 pim = (struct pim *)((caddr_t)ip6 + off); 1730 #else 1731 IP6_EXTHDR_GET(pim, struct pim *, m, off, minlen); 1732 if (pim == NULL) { 1733 pim6stat.pim6s_rcv_tooshort++; 1734 return (IPPROTO_DONE); 1735 } 1736 #endif 1737 1738 #define PIM6_CHECKSUM 1739 #ifdef PIM6_CHECKSUM 1740 { 1741 int cksumlen; 1742 1743 /* 1744 * Validate checksum. 1745 * If PIM REGISTER, exclude the data packet 1746 */ 1747 if (pim->pim_type == PIM_REGISTER) 1748 cksumlen = PIM_MINLEN; 1749 else 1750 cksumlen = pimlen; 1751 1752 if (in6_cksum(m, IPPROTO_PIM, off, cksumlen)) { 1753 ++pim6stat.pim6s_rcv_badsum; 1754 #ifdef MRT6DEBUG 1755 if (mrt6debug & DEBUG_PIM) 1756 log(LOG_DEBUG, 1757 "pim6_input: invalid checksum\n"); 1758 #endif 1759 m_freem(m); 1760 return (IPPROTO_DONE); 1761 } 1762 } 1763 #endif /* PIM_CHECKSUM */ 1764 1765 /* PIM version check */ 1766 if (pim->pim_ver != PIM_VERSION) { 1767 ++pim6stat.pim6s_rcv_badversion; 1768 #ifdef MRT6DEBUG 1769 log(LOG_ERR, 1770 "pim6_input: incorrect version %d, expecting %d\n", 1771 pim->pim_ver, PIM_VERSION); 1772 #endif 1773 m_freem(m); 1774 return (IPPROTO_DONE); 1775 } 1776 1777 if (pim->pim_type == PIM_REGISTER) { 1778 /* 1779 * since this is a REGISTER, we'll make a copy of the register 1780 * headers ip6+pim+u_int32_t+encap_ip6, to be passed up to the 1781 * routing daemon. 1782 */ 1783 static struct sockaddr_in6 dst = { sizeof(dst), AF_INET6 }; 1784 1785 struct mbuf *mcp; 1786 struct ip6_hdr *eip6; 1787 u_int32_t *reghdr; 1788 int rc; 1789 1790 ++pim6stat.pim6s_rcv_registers; 1791 1792 if ((reg_mif_num >= nummifs) || (reg_mif_num == (mifi_t) -1)) { 1793 #ifdef MRT6DEBUG 1794 if (mrt6debug & DEBUG_PIM) 1795 log(LOG_DEBUG, 1796 "pim6_input: register mif not set: %d\n", 1797 reg_mif_num); 1798 #endif 1799 m_freem(m); 1800 return (IPPROTO_DONE); 1801 } 1802 1803 reghdr = (u_int32_t *)(pim + 1); 1804 1805 if ((ntohl(*reghdr) & PIM_NULL_REGISTER)) 1806 goto pim6_input_to_daemon; 1807 1808 /* 1809 * Validate length 1810 */ 1811 if (pimlen < PIM6_REG_MINLEN) { 1812 ++pim6stat.pim6s_rcv_tooshort; 1813 ++pim6stat.pim6s_rcv_badregisters; 1814 #ifdef MRT6DEBUG 1815 log(LOG_ERR, 1816 "pim6_input: register packet size too " 1817 "small %d from %s\n", 1818 pimlen, ip6_sprintf(&ip6->ip6_src)); 1819 #endif 1820 m_freem(m); 1821 return (IPPROTO_DONE); 1822 } 1823 1824 eip6 = (struct ip6_hdr *) (reghdr + 1); 1825 #ifdef MRT6DEBUG 1826 if (mrt6debug & DEBUG_PIM) 1827 log(LOG_DEBUG, 1828 "pim6_input[register], eip6: %s -> %s, " 1829 "eip6 plen %d\n", 1830 ip6_sprintf(&eip6->ip6_src), 1831 ip6_sprintf(&eip6->ip6_dst), 1832 ntohs(eip6->ip6_plen)); 1833 #endif 1834 1835 /* verify the version number of the inner packet */ 1836 if ((eip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) { 1837 ++pim6stat.pim6s_rcv_badregisters; 1838 #ifdef MRT6DEBUG 1839 log(LOG_DEBUG, "pim6_input: invalid IP version (%d) " 1840 "of the inner packet\n", 1841 (eip6->ip6_vfc & IPV6_VERSION)); 1842 #endif 1843 m_freem(m); 1844 return (IPPROTO_NONE); 1845 } 1846 1847 /* verify the inner packet is destined to a mcast group */ 1848 if (!IN6_IS_ADDR_MULTICAST(&eip6->ip6_dst)) { 1849 ++pim6stat.pim6s_rcv_badregisters; 1850 #ifdef MRT6DEBUG 1851 if (mrt6debug & DEBUG_PIM) 1852 log(LOG_DEBUG, 1853 "pim6_input: inner packet of register " 1854 "is not multicast %s\n", 1855 ip6_sprintf(&eip6->ip6_dst)); 1856 #endif 1857 m_freem(m); 1858 return (IPPROTO_DONE); 1859 } 1860 1861 /* 1862 * make a copy of the whole header to pass to the daemon later. 1863 */ 1864 mcp = m_copy(m, 0, off + PIM6_REG_MINLEN); 1865 if (mcp == NULL) { 1866 #ifdef MRT6DEBUG 1867 log(LOG_ERR, 1868 "pim6_input: pim register: " 1869 "could not copy register head\n"); 1870 #endif 1871 m_freem(m); 1872 return (IPPROTO_DONE); 1873 } 1874 1875 /* 1876 * forward the inner ip6 packet; point m_data at the inner ip6. 1877 */ 1878 m_adj(m, off + PIM_MINLEN); 1879 #ifdef MRT6DEBUG 1880 if (mrt6debug & DEBUG_PIM) { 1881 log(LOG_DEBUG, 1882 "pim6_input: forwarding decapsulated register: " 1883 "src %s, dst %s, mif %d\n", 1884 ip6_sprintf(&eip6->ip6_src), 1885 ip6_sprintf(&eip6->ip6_dst), 1886 reg_mif_num); 1887 } 1888 #endif 1889 1890 rc = if_simloop(mif6table[reg_mif_num].m6_ifp, m, 1891 dst.sin6_family, 0); 1892 1893 /* prepare the register head to send to the mrouting daemon */ 1894 m = mcp; 1895 } 1896 1897 /* 1898 * Pass the PIM message up to the daemon; if it is a register message 1899 * pass the 'head' only up to the daemon. This includes the 1900 * encapsulator ip6 header, pim header, register header and the 1901 * encapsulated ip6 header. 1902 */ 1903 pim6_input_to_daemon: 1904 rip6_input(&m, offp, proto); 1905 return (IPPROTO_DONE); 1906 } 1907