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