1 /* $NetBSD: vif.c,v 1.6 1995/12/10 10:07:19 mycroft Exp $ */ 2 3 /* 4 * The mrouted program is covered by the license in the accompanying file 5 * named "LICENSE". Use of the mrouted program represents acceptance of 6 * the terms and conditions listed in that file. 7 * 8 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of 9 * Leland Stanford Junior University. 10 */ 11 12 13 #include "defs.h" 14 #include <fcntl.h> 15 16 /* 17 * Exported variables. 18 */ 19 struct uvif uvifs[MAXVIFS]; /* array of virtual interfaces */ 20 vifi_t numvifs; /* number of vifs in use */ 21 int vifs_down; /* 1=>some interfaces are down */ 22 int phys_vif; /* An enabled vif */ 23 int udp_socket; /* Since the honkin' kernel doesn't support */ 24 /* ioctls on raw IP sockets, we need a UDP */ 25 /* socket as well as our IGMP (raw) socket. */ 26 /* How dumb. */ 27 int vifs_with_neighbors; /* == 1 if I am a leaf */ 28 29 typedef struct { 30 vifi_t vifi; 31 struct listaddr *g; 32 int q_time; 33 } cbk_t; 34 35 /* 36 * Forward declarations. 37 */ 38 static void start_vif(vifi_t vifi); 39 static void start_vif2(vifi_t vifi); 40 static void stop_vif(vifi_t vifi); 41 static void age_old_hosts(void); 42 static void send_probe_on_vif(struct uvif *v); 43 static int info_version(char *p, int); 44 static void DelVif(void *arg); 45 static int SetTimer(int vifi, struct listaddr *g); 46 static int DeleteTimer(int id); 47 static void SendQuery(void *arg); 48 static int SetQueryTimer(struct listaddr *g, vifi_t vifi, int to_expire, 49 int q_time); 50 51 52 /* 53 * Initialize the virtual interfaces, but do not install 54 * them in the kernel. Start routing on all vifs that are 55 * not down or disabled. 56 */ 57 void 58 init_vifs(void) 59 { 60 vifi_t vifi; 61 struct uvif *v; 62 int enabled_vifs, enabled_phyints; 63 extern char *configfilename; 64 65 numvifs = 0; 66 vifs_with_neighbors = 0; 67 vifs_down = FALSE; 68 69 /* 70 * Configure the vifs based on the interface configuration of the 71 * the kernel and the contents of the configuration file. 72 * (Open a UDP socket for ioctl use in the config procedures.) 73 */ 74 if ((udp_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) 75 log(LOG_ERR, errno, "UDP socket"); 76 log(LOG_INFO,0,"Getting vifs from kernel interfaces"); 77 config_vifs_from_kernel(); 78 log(LOG_INFO,0,"Getting vifs from %s",configfilename); 79 config_vifs_from_file(); 80 81 /* 82 * Quit if there are fewer than two enabled vifs. 83 */ 84 enabled_vifs = 0; 85 enabled_phyints = 0; 86 phys_vif = -1; 87 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { 88 if (!(v->uv_flags & VIFF_DISABLED)) { 89 ++enabled_vifs; 90 if (!(v->uv_flags & VIFF_TUNNEL)) { 91 if (phys_vif == -1) 92 phys_vif = vifi; 93 ++enabled_phyints; 94 } 95 } 96 } 97 if (enabled_vifs < 2) 98 log(LOG_ERR, 0, "can't forward: %s", 99 enabled_vifs == 0 ? "no enabled vifs" : "only one enabled vif"); 100 101 if (enabled_phyints == 0) 102 log(LOG_WARNING, 0, 103 "no enabled interfaces, forwarding via tunnels only"); 104 105 log(LOG_INFO, 0, "Installing vifs in mrouted..."); 106 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { 107 if (!(v->uv_flags & VIFF_DISABLED)) { 108 if (!(v->uv_flags & VIFF_DOWN)) { 109 if (v->uv_flags & VIFF_TUNNEL) 110 log(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi, 111 inet_fmt(v->uv_lcl_addr, s1), 112 inet_fmt(v->uv_rmt_addr, s2)); 113 else 114 log(LOG_INFO, 0, "vif #%d, phyint %s", vifi, 115 inet_fmt(v->uv_lcl_addr, s1)); 116 start_vif2(vifi); 117 } else log(LOG_INFO, 0, 118 "%s is not yet up; vif #%u not in service", 119 v->uv_name, vifi); 120 } 121 } 122 } 123 124 /* 125 * Start routing on all virtual interfaces that are not down or 126 * administratively disabled. 127 */ 128 void 129 init_installvifs(void) 130 { 131 vifi_t vifi; 132 struct uvif *v; 133 134 log(LOG_INFO, 0, "Installing vifs in kernel..."); 135 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { 136 if (!(v->uv_flags & VIFF_DISABLED)) { 137 if (!(v->uv_flags & VIFF_DOWN)) { 138 if (v->uv_flags & VIFF_TUNNEL) 139 log(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi, 140 inet_fmt(v->uv_lcl_addr, s1), 141 inet_fmt(v->uv_rmt_addr, s2)); 142 else 143 log(LOG_INFO, 0, "vif #%d, phyint %s", vifi, 144 inet_fmt(v->uv_lcl_addr, s1)); 145 k_add_vif(vifi, &uvifs[vifi]); 146 } else log(LOG_INFO, 0, 147 "%s is not yet up; vif #%u not in service", 148 v->uv_name, vifi); 149 } 150 } 151 } 152 153 /* 154 * See if any interfaces have changed from up state to down, or vice versa, 155 * including any non-multicast-capable interfaces that are in use as local 156 * tunnel end-points. Ignore interfaces that have been administratively 157 * disabled. 158 */ 159 void 160 check_vif_state(void) 161 { 162 register vifi_t vifi; 163 register struct uvif *v; 164 struct ifreq ifr; 165 166 vifs_down = FALSE; 167 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { 168 169 if (v->uv_flags & VIFF_DISABLED) continue; 170 171 strncpy(ifr.ifr_name, v->uv_name, IFNAMSIZ); 172 if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ifr) < 0) 173 log(LOG_ERR, errno, 174 "ioctl SIOCGIFFLAGS for %s", ifr.ifr_name); 175 176 if (v->uv_flags & VIFF_DOWN) { 177 if (ifr.ifr_flags & IFF_UP) { 178 v->uv_flags &= ~VIFF_DOWN; 179 start_vif(vifi); 180 log(LOG_INFO, 0, 181 "%s has come up; vif #%u now in service", 182 v->uv_name, vifi); 183 } 184 else vifs_down = TRUE; 185 } 186 else { 187 if (!(ifr.ifr_flags & IFF_UP)) { 188 stop_vif(vifi); 189 v->uv_flags |= VIFF_DOWN; 190 log(LOG_INFO, 0, 191 "%s has gone down; vif #%u taken out of service", 192 v->uv_name, vifi); 193 vifs_down = TRUE; 194 } 195 } 196 } 197 } 198 199 /* 200 * Send a probe message on vif v 201 */ 202 static void 203 send_probe_on_vif(struct uvif *v) 204 { 205 register char *p; 206 register int datalen = 0; 207 struct listaddr *nbr; 208 int i; 209 210 p = send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN; 211 212 for (i = 0; i < 4; i++) 213 *p++ = ((char *)&(dvmrp_genid))[i]; 214 datalen += 4; 215 216 /* 217 * add the neighbor list on the interface to the message 218 */ 219 nbr = v->uv_neighbors; 220 221 while (nbr) { 222 for (i = 0; i < 4; i++) 223 *p++ = ((char *)&nbr->al_addr)[i]; 224 datalen +=4; 225 nbr = nbr->al_next; 226 } 227 228 send_igmp(v->uv_lcl_addr, 229 (v->uv_flags & VIFF_TUNNEL) ? v->uv_rmt_addr 230 : dvmrp_group, 231 IGMP_DVMRP, DVMRP_PROBE, 232 htonl(MROUTED_LEVEL | 233 ((v->uv_flags & VIFF_LEAF) ? 0 : LEAF_FLAGS)), 234 datalen); 235 } 236 237 /* 238 * Add a vifi to the kernel and start routing on it. 239 */ 240 static void 241 start_vif(vifi_t vifi) 242 { 243 /* 244 * Install the interface in the kernel's vif structure. 245 */ 246 k_add_vif(vifi, &uvifs[vifi]); 247 248 start_vif2(vifi); 249 } 250 251 /* 252 * Add a vifi to all the user-level data structures but don't add 253 * it to the kernel yet. 254 */ 255 static void 256 start_vif2(vifi_t vifi) 257 { 258 struct uvif *v; 259 u_int32_t src; 260 struct phaddr *p; 261 262 v = &uvifs[vifi]; 263 src = v->uv_lcl_addr; 264 265 /* 266 * Update the existing route entries to take into account the new vif. 267 */ 268 add_vif_to_routes(vifi); 269 270 if (!(v->uv_flags & VIFF_TUNNEL)) { 271 /* 272 * Join the DVMRP multicast group on the interface. 273 * (This is not strictly necessary, since the kernel promiscuously 274 * receives IGMP packets addressed to ANY IP multicast group while 275 * multicast routing is enabled. However, joining the group allows 276 * this host to receive non-IGMP packets as well, such as 'pings'.) 277 */ 278 k_join(dvmrp_group, src); 279 280 /* 281 * Join the ALL-ROUTERS multicast group on the interface. 282 * This allows mtrace requests to loop back if they are run 283 * on the multicast router. 284 */ 285 k_join(allrtrs_group, src); 286 287 /* 288 * Install an entry in the routing table for the subnet to which 289 * the interface is connected. 290 */ 291 start_route_updates(); 292 update_route(v->uv_subnet, v->uv_subnetmask, 0, 0, vifi); 293 for (p = v->uv_addrs; p; p = p->pa_next) { 294 start_route_updates(); 295 update_route(p->pa_subnet, p->pa_subnetmask, 0, 0, vifi); 296 } 297 298 /* 299 * Until neighbors are discovered, assume responsibility for sending 300 * periodic group membership queries to the subnet. Send the first 301 * query. 302 */ 303 v->uv_flags |= VIFF_QUERIER; 304 send_igmp(src, allhosts_group, IGMP_HOST_MEMBERSHIP_QUERY, 305 (v->uv_flags & VIFF_IGMPV1) ? 0 : 306 IGMP_MAX_HOST_REPORT_DELAY * IGMP_TIMER_SCALE, 0, 0); 307 age_old_hosts(); 308 } 309 310 v->uv_leaf_timer = LEAF_CONFIRMATION_TIME; 311 312 /* 313 * Send a probe via the new vif to look for neighbors. 314 */ 315 send_probe_on_vif(v); 316 } 317 318 /* 319 * Stop routing on the specified virtual interface. 320 */ 321 static void 322 stop_vif(vifi_t vifi) 323 { 324 struct uvif *v; 325 struct listaddr *a; 326 struct phaddr *p; 327 328 v = &uvifs[vifi]; 329 330 if (!(v->uv_flags & VIFF_TUNNEL)) { 331 /* 332 * Depart from the DVMRP multicast group on the interface. 333 */ 334 k_leave(dvmrp_group, v->uv_lcl_addr); 335 336 /* 337 * Depart from the ALL-ROUTERS multicast group on the interface. 338 */ 339 k_leave(allrtrs_group, v->uv_lcl_addr); 340 341 /* 342 * Update the entry in the routing table for the subnet to which 343 * the interface is connected, to take into account the interface 344 * failure. 345 */ 346 start_route_updates(); 347 update_route(v->uv_subnet, v->uv_subnetmask, UNREACHABLE, 0, vifi); 348 for (p = v->uv_addrs; p; p = p->pa_next) { 349 start_route_updates(); 350 update_route(p->pa_subnet, p->pa_subnetmask, UNREACHABLE, 0, vifi); 351 } 352 353 /* 354 * Discard all group addresses. (No need to tell kernel; 355 * the k_del_vif() call, below, will clean up kernel state.) 356 */ 357 while (v->uv_groups != NULL) { 358 a = v->uv_groups; 359 v->uv_groups = a->al_next; 360 free((char *)a); 361 } 362 363 v->uv_flags &= ~VIFF_QUERIER; 364 } 365 366 /* 367 * Update the existing route entries to take into account the vif failure. 368 */ 369 delete_vif_from_routes(vifi); 370 371 /* 372 * Delete the interface from the kernel's vif structure. 373 */ 374 k_del_vif(vifi); 375 376 /* 377 * Discard all neighbor addresses. 378 */ 379 if (v->uv_neighbors) 380 vifs_with_neighbors--; 381 382 while (v->uv_neighbors != NULL) { 383 a = v->uv_neighbors; 384 v->uv_neighbors = a->al_next; 385 free((char *)a); 386 } 387 } 388 389 390 /* 391 * stop routing on all vifs 392 */ 393 void 394 stop_all_vifs(void) 395 { 396 vifi_t vifi; 397 struct uvif *v; 398 struct listaddr *a; 399 struct vif_acl *acl; 400 401 for (vifi = 0; vifi < numvifs; vifi++) { 402 v = &uvifs[vifi]; 403 while (v->uv_groups != NULL) { 404 a = v->uv_groups; 405 v->uv_groups = a->al_next; 406 free((char *)a); 407 } 408 while (v->uv_neighbors != NULL) { 409 a = v->uv_neighbors; 410 v->uv_neighbors = a->al_next; 411 free((char *)a); 412 } 413 while (v->uv_acl != NULL) { 414 acl = v->uv_acl; 415 v->uv_acl = acl->acl_next; 416 free((char *)acl); 417 } 418 } 419 } 420 421 422 /* 423 * Find the virtual interface from which an incoming packet arrived, 424 * based on the packet's source and destination IP addresses. 425 */ 426 vifi_t 427 find_vif(u_int32_t src, u_int32_t dst) 428 { 429 register vifi_t vifi; 430 register struct uvif *v; 431 register struct phaddr *p; 432 433 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { 434 if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) { 435 if (v->uv_flags & VIFF_TUNNEL) { 436 if (src == v->uv_rmt_addr && dst == v->uv_lcl_addr) 437 return(vifi); 438 } 439 else { 440 if ((src & v->uv_subnetmask) == v->uv_subnet && 441 ((v->uv_subnetmask == 0xffffffff) || 442 (src != v->uv_subnetbcast))) 443 return(vifi); 444 for (p=v->uv_addrs; p; p=p->pa_next) { 445 if ((src & p->pa_subnetmask) == p->pa_subnet && 446 ((p->pa_subnetmask == 0xffffffff) || 447 (src != p->pa_subnetbcast))) 448 return(vifi); 449 } 450 } 451 } 452 } 453 return (NO_VIF); 454 } 455 456 static void 457 age_old_hosts(void) 458 { 459 register vifi_t vifi; 460 register struct uvif *v; 461 register struct listaddr *g; 462 463 /* 464 * Decrement the old-hosts-present timer for each 465 * active group on each vif. 466 */ 467 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) 468 for (g = v->uv_groups; g != NULL; g = g->al_next) 469 if (g->al_old) 470 g->al_old--; 471 } 472 473 474 /* 475 * Send group membership queries to all subnets for which I am querier. 476 */ 477 void 478 query_groups(void) 479 { 480 register vifi_t vifi; 481 register struct uvif *v; 482 483 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { 484 if (v->uv_flags & VIFF_QUERIER) { 485 send_igmp(v->uv_lcl_addr, allhosts_group, 486 IGMP_HOST_MEMBERSHIP_QUERY, 487 (v->uv_flags & VIFF_IGMPV1) ? 0 : 488 IGMP_MAX_HOST_REPORT_DELAY * IGMP_TIMER_SCALE, 0, 0); 489 } 490 } 491 age_old_hosts(); 492 } 493 494 /* 495 * Process an incoming host membership query 496 */ 497 void 498 accept_membership_query(u_int32_t src, u_int32_t dst, u_int32_t group, 499 int tmo) 500 { 501 register vifi_t vifi; 502 register struct uvif *v; 503 504 if ((vifi = find_vif(src, dst)) == NO_VIF || 505 (uvifs[vifi].uv_flags & VIFF_TUNNEL)) { 506 log(LOG_INFO, 0, 507 "ignoring group membership query from non-adjacent host %s", 508 inet_fmt(src, s1)); 509 return; 510 } 511 512 v = &uvifs[vifi]; 513 514 /* 515 * If we consider ourselves the querier for this vif, but hear a 516 * query from a router with a lower IP address, yield to them. 517 * 518 * This is done here as well as in the neighbor discovery in case 519 * there is a querier that doesn't speak DVMRP. 520 * 521 * XXX If this neighbor doesn't speak DVMRP, then we need to create 522 * some neighbor state for him so that we can time him out! 523 */ 524 if ((v->uv_flags & VIFF_QUERIER) && 525 (ntohl(src) < ntohl(v->uv_lcl_addr))) { 526 v->uv_flags &= ~VIFF_QUERIER; 527 528 } 529 } 530 531 /* 532 * Process an incoming group membership report. 533 */ 534 void 535 accept_group_report(u_int32_t src, u_int32_t dst, u_int32_t group, 536 int r_type) 537 { 538 register vifi_t vifi; 539 register struct uvif *v; 540 register struct listaddr *g; 541 542 if ((vifi = find_vif(src, dst)) == NO_VIF || 543 (uvifs[vifi].uv_flags & VIFF_TUNNEL)) { 544 log(LOG_INFO, 0, 545 "ignoring group membership report from non-adjacent host %s", 546 inet_fmt(src, s1)); 547 return; 548 } 549 550 v = &uvifs[vifi]; 551 552 /* 553 * Look for the group in our group list; if found, reset its timer. 554 */ 555 for (g = v->uv_groups; g != NULL; g = g->al_next) { 556 if (group == g->al_addr) { 557 if (r_type == IGMP_v1_HOST_MEMBERSHIP_REPORT) 558 g->al_old = OLD_AGE_THRESHOLD; 559 #ifdef SNMP 560 g->al_genid = src; 561 #endif /* SNMP */ 562 563 /** delete old timers, set a timer for expiration **/ 564 g->al_timer = GROUP_EXPIRE_TIME; 565 if (g->al_query) 566 g->al_query = DeleteTimer(g->al_query); 567 if (g->al_timerid) 568 g->al_timerid = DeleteTimer(g->al_timerid); 569 g->al_timerid = SetTimer(vifi, g); 570 break; 571 } 572 } 573 574 /* 575 * If not found, add it to the list and update kernel cache. 576 */ 577 if (g == NULL) { 578 g = (struct listaddr *)malloc(sizeof(struct listaddr)); 579 if (g == NULL) 580 log(LOG_ERR, 0, "ran out of memory"); /* fatal */ 581 582 g->al_addr = group; 583 if (r_type == IGMP_v2_HOST_MEMBERSHIP_REPORT) 584 g->al_old = 0; 585 else 586 g->al_old = OLD_AGE_THRESHOLD; 587 #ifdef SNMP 588 g->al_genid = src; 589 #endif 590 591 /** set a timer for expiration **/ 592 g->al_query = 0; 593 g->al_timer = GROUP_EXPIRE_TIME; 594 time(&g->al_ctime); 595 g->al_timerid = SetTimer(vifi, g); 596 g->al_next = v->uv_groups; 597 v->uv_groups = g; 598 599 update_lclgrp(vifi, group); 600 } 601 602 /* 603 * Check if a graft is necessary for this group 604 */ 605 chkgrp_graft(vifi, group); 606 } 607 608 609 void 610 accept_leave_message(u_int32_t src, u_int32_t dst, u_int32_t group) 611 { 612 register vifi_t vifi; 613 register struct uvif *v; 614 register struct listaddr *g; 615 616 if ((vifi = find_vif(src, dst)) == NO_VIF || 617 (uvifs[vifi].uv_flags & VIFF_TUNNEL)) { 618 log(LOG_INFO, 0, 619 "ignoring group leave report from non-adjacent host %s", 620 inet_fmt(src, s1)); 621 return; 622 } 623 624 v = &uvifs[vifi]; 625 626 if (!(v->uv_flags & VIFF_QUERIER) || (v->uv_flags & VIFF_IGMPV1)) 627 return; 628 629 /* 630 * Look for the group in our group list in order to set up a short-timeout 631 * query. 632 */ 633 for (g = v->uv_groups; g != NULL; g = g->al_next) { 634 if (group == g->al_addr) { 635 log(LOG_DEBUG, 0, 636 "[vif.c, _accept_leave_message] %d %d \n", 637 g->al_old, g->al_query); 638 639 /* Ignore the leave message if there are old hosts present */ 640 if (g->al_old) 641 return; 642 643 /* still waiting for a reply to a query, ignore the leave */ 644 if (g->al_query) 645 return; 646 647 /** delete old timer set a timer for expiration **/ 648 if (g->al_timerid) 649 g->al_timerid = DeleteTimer(g->al_timerid); 650 651 /** send a group specific querry **/ 652 g->al_timer = LEAVE_EXPIRE_TIME; 653 send_igmp(v->uv_lcl_addr, g->al_addr, 654 IGMP_HOST_MEMBERSHIP_QUERY, 655 LEAVE_EXPIRE_TIME / 3 * IGMP_TIMER_SCALE, 656 g->al_addr, 0); 657 g->al_query = SetQueryTimer(g, vifi, g->al_timer / 3, 658 LEAVE_EXPIRE_TIME / 3 * IGMP_TIMER_SCALE); 659 g->al_timerid = SetTimer(vifi, g); 660 break; 661 } 662 } 663 } 664 665 666 /* 667 * Send a periodic probe on all vifs. 668 * Useful to determine one-way interfaces. 669 * Detect neighbor loss faster. 670 */ 671 void 672 probe_for_neighbors(void) 673 { 674 register vifi_t vifi; 675 register struct uvif *v; 676 677 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { 678 if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) { 679 send_probe_on_vif(v); 680 } 681 } 682 } 683 684 685 /* 686 * Send a list of all of our neighbors to the requestor, `src'. 687 */ 688 void 689 accept_neighbor_request(u_int32_t src, u_int32_t dst) 690 { 691 vifi_t vifi; 692 struct uvif *v; 693 u_char *p, *ncount; 694 struct listaddr *la; 695 int datalen; 696 u_int32_t temp_addr, us, them = src; 697 698 /* Determine which of our addresses to use as the source of our response 699 * to this query. 700 */ 701 if (IN_MULTICAST(ntohl(dst))) { /* query sent to a multicast group */ 702 int udp; /* find best interface to reply on */ 703 struct sockaddr_in addr; 704 int addrlen = sizeof(addr); 705 706 memset(&addr, 0, sizeof addr); 707 addr.sin_family = AF_INET; 708 #if (defined(BSD) && (BSD >= 199103)) 709 addr.sin_len = sizeof addr; 710 #endif 711 addr.sin_addr.s_addr = dst; 712 addr.sin_port = htons(2000); /* any port over 1024 will do... */ 713 if ((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0 714 || connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0 715 || getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) { 716 log(LOG_WARNING, errno, "Determining local address"); 717 close(udp); 718 return; 719 } 720 close(udp); 721 us = addr.sin_addr.s_addr; 722 } else /* query sent to us alone */ 723 us = dst; 724 725 #define PUT_ADDR(a) temp_addr = ntohl(a); \ 726 *p++ = temp_addr >> 24; \ 727 *p++ = (temp_addr >> 16) & 0xFF; \ 728 *p++ = (temp_addr >> 8) & 0xFF; \ 729 *p++ = temp_addr & 0xFF; 730 731 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); 732 datalen = 0; 733 734 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { 735 if (v->uv_flags & VIFF_DISABLED) 736 continue; 737 738 ncount = 0; 739 740 for (la = v->uv_neighbors; la; la = la->al_next) { 741 742 /* Make sure that there's room for this neighbor... */ 743 if (datalen + (ncount == 0 ? 4 + 3 + 4 : 4) > MAX_DVMRP_DATA_LEN) { 744 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS, 745 htonl(MROUTED_LEVEL), datalen); 746 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); 747 datalen = 0; 748 ncount = 0; 749 } 750 751 /* Put out the header for this neighbor list... */ 752 if (ncount == 0) { 753 PUT_ADDR(v->uv_lcl_addr); 754 *p++ = v->uv_metric; 755 *p++ = v->uv_threshold; 756 ncount = p; 757 *p++ = 0; 758 datalen += 4 + 3; 759 } 760 761 PUT_ADDR(la->al_addr); 762 datalen += 4; 763 (*ncount)++; 764 } 765 } 766 767 if (datalen != 0) 768 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS, htonl(MROUTED_LEVEL), 769 datalen); 770 } 771 772 /* 773 * Send a list of all of our neighbors to the requestor, `src'. 774 */ 775 void 776 accept_neighbor_request2(u_int32_t src, u_int32_t dst) 777 { 778 vifi_t vifi; 779 struct uvif *v; 780 u_char *p, *ncount; 781 struct listaddr *la; 782 int datalen; 783 u_int32_t us, them = src; 784 785 /* Determine which of our addresses to use as the source of our response 786 * to this query. 787 */ 788 if (IN_MULTICAST(ntohl(dst))) { /* query sent to a multicast group */ 789 int udp; /* find best interface to reply on */ 790 struct sockaddr_in addr; 791 int addrlen = sizeof(addr); 792 793 memset(&addr, 0, sizeof addr); 794 addr.sin_family = AF_INET; 795 #if (defined(BSD) && (BSD >= 199103)) 796 addr.sin_len = sizeof addr; 797 #endif 798 addr.sin_addr.s_addr = dst; 799 addr.sin_port = htons(2000); /* any port over 1024 will do... */ 800 if ((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0 801 || connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0 802 || getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) { 803 log(LOG_WARNING, errno, "Determining local address"); 804 close(udp); 805 return; 806 } 807 close(udp); 808 us = addr.sin_addr.s_addr; 809 } else /* query sent to us alone */ 810 us = dst; 811 812 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); 813 datalen = 0; 814 815 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { 816 register u_short vflags = v->uv_flags; 817 register u_char rflags = 0; 818 if (vflags & VIFF_TUNNEL) 819 rflags |= DVMRP_NF_TUNNEL; 820 if (vflags & VIFF_SRCRT) 821 rflags |= DVMRP_NF_SRCRT; 822 if (vflags & VIFF_DOWN) 823 rflags |= DVMRP_NF_DOWN; 824 if (vflags & VIFF_DISABLED) 825 rflags |= DVMRP_NF_DISABLED; 826 if (vflags & VIFF_QUERIER) 827 rflags |= DVMRP_NF_QUERIER; 828 if (vflags & VIFF_LEAF) 829 rflags |= DVMRP_NF_LEAF; 830 ncount = 0; 831 la = v->uv_neighbors; 832 if (la == NULL) { 833 /* 834 * include down & disabled interfaces and interfaces on 835 * leaf nets. 836 */ 837 if (rflags & DVMRP_NF_TUNNEL) 838 rflags |= DVMRP_NF_DOWN; 839 if (datalen > MAX_DVMRP_DATA_LEN - 12) { 840 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, 841 htonl(MROUTED_LEVEL), datalen); 842 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); 843 datalen = 0; 844 } 845 *(u_int*)p = v->uv_lcl_addr; 846 p += 4; 847 *p++ = v->uv_metric; 848 *p++ = v->uv_threshold; 849 *p++ = rflags; 850 *p++ = 1; 851 *(u_int*)p = v->uv_rmt_addr; 852 p += 4; 853 datalen += 12; 854 } else { 855 for ( ; la; la = la->al_next) { 856 /* Make sure that there's room for this neighbor... */ 857 if (datalen + (ncount == 0 ? 4+4+4 : 4) > MAX_DVMRP_DATA_LEN) { 858 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, 859 htonl(MROUTED_LEVEL), datalen); 860 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); 861 datalen = 0; 862 ncount = 0; 863 } 864 /* Put out the header for this neighbor list... */ 865 if (ncount == 0) { 866 *(u_int*)p = v->uv_lcl_addr; 867 p += 4; 868 *p++ = v->uv_metric; 869 *p++ = v->uv_threshold; 870 *p++ = rflags; 871 ncount = p; 872 *p++ = 0; 873 datalen += 4 + 4; 874 } 875 *(u_int*)p = la->al_addr; 876 p += 4; 877 datalen += 4; 878 (*ncount)++; 879 } 880 } 881 } 882 if (datalen != 0) 883 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, htonl(MROUTED_LEVEL), 884 datalen); 885 } 886 887 void 888 accept_info_request(u_int32_t src, u_int32_t dst, u_char *p, int datalen) 889 { 890 u_char *q; 891 int len; 892 int outlen = 0; 893 894 q = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); 895 896 /* To be general, this must deal properly with breaking up over-sized 897 * packets. That implies passing a length to each function, and 898 * allowing each function to request to be called again. Right now, 899 * we're only implementing the one thing we are positive will fit into 900 * a single packet, so we wimp out. 901 */ 902 while (datalen > 0) { 903 len = 0; 904 switch (*p) { 905 case DVMRP_INFO_VERSION: 906 len = info_version(q, (u_char *)send_buf + RECV_BUF_SIZE - q); 907 break; 908 909 case DVMRP_INFO_NEIGHBORS: 910 default: 911 log(LOG_INFO, 0, "ignoring unknown info type %d", *p); 912 break; 913 } 914 *(q+1) = len++; 915 outlen += len * 4; 916 q += len * 4; 917 len = (*(p+1) + 1) * 4; 918 p += len; 919 datalen -= len; 920 } 921 922 if (outlen != 0) 923 send_igmp(INADDR_ANY, src, IGMP_DVMRP, DVMRP_INFO_REPLY, 924 htonl(MROUTED_LEVEL), outlen); 925 } 926 927 /* 928 * Information response -- return version string 929 */ 930 static int 931 info_version(char *p, int len) 932 { 933 extern char versionstring[]; 934 935 if (len < 5) 936 return (0); 937 *p++ = DVMRP_INFO_VERSION; 938 p++; /* skip over length */ 939 *p++ = 0; /* zero out */ 940 *p++ = 0; /* reserved fields */ 941 strlcpy(p, versionstring, len - 4); 942 943 len = strlen(p); 944 return ((len + 3) / 4); 945 } 946 947 /* 948 * Process an incoming neighbor-list message. 949 */ 950 void 951 accept_neighbors(u_int32_t src, u_int32_t dst, u_char *p, int datalen, 952 u_int32_t level) 953 { 954 log(LOG_INFO, 0, "ignoring spurious DVMRP neighbor list from %s to %s", 955 inet_fmt(src, s1), inet_fmt(dst, s2)); 956 } 957 958 959 /* 960 * Process an incoming neighbor-list message. 961 */ 962 void 963 accept_neighbors2(u_int32_t src, u_int32_t dst, u_char *p, int datalen, 964 u_int32_t level) 965 { 966 log(LOG_INFO, 0, "ignoring spurious DVMRP neighbor list2 from %s to %s", 967 inet_fmt(src, s1), inet_fmt(dst, s2)); 968 } 969 970 /* 971 * Process an incoming info reply message. 972 */ 973 void 974 accept_info_reply(u_int32_t src, u_int32_t dst, u_char *p, int datalen) 975 { 976 log(LOG_INFO, 0, "ignoring spurious DVMRP info reply from %s to %s", 977 inet_fmt(src, s1), inet_fmt(dst, s2)); 978 } 979 980 981 /* 982 * Update the neighbor entry for neighbor 'addr' on vif 'vifi'. 983 * 'msgtype' is the type of DVMRP message received from the neighbor. 984 * Return TRUE if 'addr' is a valid neighbor, FALSE otherwise. 985 */ 986 int 987 update_neighbor(vifi_t vifi, u_int32_t addr, int msgtype, char *p, 988 int datalen, u_int32_t level) 989 { 990 register struct uvif *v; 991 register struct listaddr *n; 992 u_int32_t genid = 0; 993 u_int32_t router; 994 u_int32_t send_tables = 0; 995 int do_reset = FALSE; 996 int nflags; 997 998 v = &uvifs[vifi]; 999 nflags = (level >> 16) & 0xff; 1000 1001 /* 1002 * Confirm that 'addr' is a valid neighbor address on vif 'vifi'. 1003 * IT IS ASSUMED that this was preceded by a call to find_vif(), which 1004 * checks that 'addr' is either a valid remote tunnel endpoint or a 1005 * non-broadcast address belonging to a directly-connected subnet. 1006 * Therefore, here we check only that 'addr' is not our own address 1007 * (due to an impostor or erroneous loopback) or an address of the form 1008 * {subnet,0} ("the unknown host"). These checks are not performed in 1009 * find_vif() because those types of address are acceptable for some 1010 * types of IGMP message (such as group membership reports). 1011 */ 1012 if (!(v->uv_flags & VIFF_TUNNEL) && 1013 (addr == v->uv_lcl_addr || 1014 addr == v->uv_subnet )) { 1015 log(LOG_WARNING, 0, 1016 "received DVMRP message from 'the unknown host' or self: %s", 1017 inet_fmt(addr, s1)); 1018 return (FALSE); 1019 } 1020 1021 /* 1022 * Look for addr in list of neighbors. 1023 */ 1024 for (n = v->uv_neighbors; n != NULL; n = n->al_next) { 1025 if (addr == n->al_addr) { 1026 break; 1027 } 1028 } 1029 1030 /* 1031 * Found it. Reset its timer, and check for a version change 1032 */ 1033 if (n) { 1034 n->al_timer = 0; 1035 1036 /* 1037 * update the neighbors version and protocol number 1038 * if changed => router went down and came up, 1039 * so take action immediately. 1040 */ 1041 if ((n->al_pv != (level & 0xff)) || 1042 (n->al_mv != ((level >> 8) & 0xff))) { 1043 1044 do_reset = TRUE; 1045 log(LOG_DEBUG, 0, 1046 "version change neighbor %s [old:%d.%d, new:%d.%d]", 1047 inet_fmt(addr, s1), 1048 n->al_pv, n->al_mv, level&0xff, (level >> 8) & 0xff); 1049 1050 n->al_pv = level & 0xff; 1051 n->al_mv = (level >> 8) & 0xff; 1052 } 1053 } else { 1054 /* 1055 * If not found, add it to the list. If the neighbor has a lower 1056 * IP address than me, yield querier duties to it. 1057 */ 1058 log(LOG_DEBUG, 0, "New neighbor %s on vif %d v%d.%d nf 0x%02x", 1059 inet_fmt(addr, s1), vifi, level & 0xff, (level >> 8) & 0xff, 1060 (level >> 16) & 0xff); 1061 1062 n = (struct listaddr *)malloc(sizeof(struct listaddr)); 1063 if (n == NULL) 1064 log(LOG_ERR, 0, "ran out of memory"); /* fatal */ 1065 1066 n->al_addr = addr; 1067 n->al_pv = level & 0xff; 1068 n->al_mv = (level >> 8) & 0xff; 1069 n->al_genid = 0; 1070 1071 time(&n->al_ctime); 1072 n->al_timer = 0; 1073 n->al_next = v->uv_neighbors; 1074 1075 /* 1076 * If we thought that we had no neighbors on this vif, send a route 1077 * report to the vif. If this is just a new neighbor on the same 1078 * vif, send the route report just to the new neighbor. 1079 */ 1080 if (v->uv_neighbors == NULL) { 1081 send_tables = (v->uv_flags & VIFF_TUNNEL) ? addr : dvmrp_group; 1082 vifs_with_neighbors++; 1083 } else { 1084 send_tables = addr; 1085 } 1086 1087 v->uv_neighbors = n; 1088 1089 if (!(v->uv_flags & VIFF_TUNNEL) && 1090 ntohl(addr) < ntohl(v->uv_lcl_addr)) 1091 v->uv_flags &= ~VIFF_QUERIER; 1092 } 1093 1094 /* 1095 * Check if the router gen-ids are the same. 1096 * Need to reset the prune state of the router if not. 1097 * Also check for one-way interfaces by seeing if we are in our 1098 * neighbor's list of known routers. 1099 */ 1100 if (msgtype == DVMRP_PROBE) { 1101 1102 /* Check genid neighbor flag. Also check version number; 3.3 and 1103 * 3.4 didn't set this flag. */ 1104 if ((((level >> 16) & 0xff) & NF_GENID) || 1105 (((level & 0xff) == 3) && (((level >> 8) & 0xff) > 2))) { 1106 1107 int i; 1108 1109 if (datalen < 4) { 1110 log(LOG_WARNING, 0, 1111 "received truncated probe message from %s (len %d)", 1112 inet_fmt(addr, s1), datalen); 1113 return (FALSE); 1114 } 1115 1116 for (i = 0; i < 4; i++) 1117 ((char *)&genid)[i] = *p++; 1118 datalen -= 4; 1119 1120 if (n->al_genid == 0) 1121 n->al_genid = genid; 1122 else if (n->al_genid != genid) { 1123 log(LOG_DEBUG, 0, 1124 "new genid neigbor %s on vif %d [old:%x, new:%x]", 1125 inet_fmt(addr, s1), vifi, n->al_genid, genid); 1126 1127 n->al_genid = genid; 1128 do_reset = TRUE; 1129 } 1130 1131 /* 1132 * loop through router list and check for one-way ifs. 1133 */ 1134 1135 v->uv_flags |= VIFF_ONEWAY; 1136 1137 while (datalen > 0) { 1138 if (datalen < 4) { 1139 log(LOG_WARNING, 0, 1140 "received truncated probe message from %s (len %d)", 1141 inet_fmt(addr, s1), datalen); 1142 return (FALSE); 1143 } 1144 for (i = 0; i < 4; i++) 1145 ((char *)&router)[i] = *p++; 1146 datalen -= 4; 1147 if (router == v->uv_lcl_addr) { 1148 v->uv_flags &= ~VIFF_ONEWAY; 1149 break; 1150 } 1151 } 1152 } 1153 } 1154 if (n->al_flags != nflags) { 1155 n->al_flags = nflags; 1156 1157 if (n->al_flags & NF_LEAF) { 1158 /*XXX If we have non-leaf neighbors then we know we shouldn't 1159 * mark this vif as a leaf. For now we just count on other 1160 * probes and/or reports resetting the timer. */ 1161 if (!v->uv_leaf_timer) 1162 v->uv_leaf_timer = LEAF_CONFIRMATION_TIME; 1163 } else { 1164 /* If we get a leaf to non-leaf transition, we *must* update 1165 * the routing table. */ 1166 if (v->uv_flags & VIFF_LEAF && send_tables == 0) 1167 send_tables = addr; 1168 v->uv_flags &= ~VIFF_LEAF; 1169 v->uv_leaf_timer = 0; 1170 } 1171 } 1172 if (do_reset) { 1173 reset_neighbor_state(vifi, addr); 1174 if (!send_tables) 1175 send_tables = addr; 1176 } 1177 if (send_tables) 1178 report(ALL_ROUTES, vifi, send_tables); 1179 1180 return (TRUE); 1181 } 1182 1183 1184 /* 1185 * On every timer interrupt, advance the timer in each neighbor and 1186 * group entry on every vif. 1187 */ 1188 void 1189 age_vifs(void) 1190 { 1191 register vifi_t vifi; 1192 register struct uvif *v; 1193 register struct listaddr *a, *prev_a, *n; 1194 register u_int32_t addr; 1195 1196 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v ) { 1197 if (v->uv_leaf_timer && (v->uv_leaf_timer -= TIMER_INTERVAL == 0)) { 1198 v->uv_flags |= VIFF_LEAF; 1199 } 1200 1201 for (prev_a = (struct listaddr *)&(v->uv_neighbors), 1202 a = v->uv_neighbors; 1203 a != NULL; 1204 prev_a = a, a = a->al_next) { 1205 1206 if ((a->al_timer += TIMER_INTERVAL) < NEIGHBOR_EXPIRE_TIME) 1207 continue; 1208 1209 /* 1210 * Neighbor has expired; delete it from the neighbor list, 1211 * delete it from the 'dominants' and 'subordinates arrays of 1212 * any route entries and assume querier duties unless there is 1213 * another neighbor with a lower IP address than mine. 1214 */ 1215 addr = a->al_addr; 1216 prev_a->al_next = a->al_next; 1217 free((char *)a); 1218 a = prev_a; 1219 1220 delete_neighbor_from_routes(addr, vifi); 1221 1222 if (v->uv_neighbors == NULL) 1223 vifs_with_neighbors--; 1224 1225 v->uv_leaf_timer = LEAF_CONFIRMATION_TIME; 1226 1227 if (!(v->uv_flags & VIFF_TUNNEL)) { 1228 v->uv_flags |= VIFF_QUERIER; 1229 for (n = v->uv_neighbors; n != NULL; n = n->al_next) { 1230 if (ntohl(n->al_addr) < ntohl(v->uv_lcl_addr)) { 1231 v->uv_flags &= ~VIFF_QUERIER; 1232 } 1233 if (!(n->al_flags & NF_LEAF)) { 1234 v->uv_leaf_timer = 0; 1235 } 1236 } 1237 } 1238 } 1239 } 1240 } 1241 1242 /* 1243 * Returns the neighbor info struct for a given neighbor 1244 */ 1245 struct listaddr * 1246 neighbor_info(vifi_t vifi, u_int32_t addr) 1247 { 1248 struct listaddr *u; 1249 1250 for (u = uvifs[vifi].uv_neighbors; u; u = u->al_next) 1251 if (u->al_addr == addr) 1252 return u; 1253 1254 return NULL; 1255 } 1256 1257 /* 1258 * Print the contents of the uvifs array on file 'fp'. 1259 */ 1260 void 1261 dump_vifs(FILE *fp) 1262 { 1263 register vifi_t vifi; 1264 register struct uvif *v; 1265 register struct listaddr *a; 1266 register struct phaddr *p; 1267 struct sioc_vif_req v_req; 1268 1269 fprintf(fp, "vifs_with_neighbors = %d\n", vifs_with_neighbors); 1270 1271 if (vifs_with_neighbors == 1) 1272 fprintf(fp,"[This host is a leaf]\n\n"); 1273 1274 fprintf(fp, 1275 "\nVirtual Interface Table\n%s", 1276 "Vif Name Local-Address "); 1277 fprintf(fp, 1278 "M Thr Rate Flags\n"); 1279 1280 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { 1281 1282 fprintf(fp, "%2u %6s %-15s %6s: %-18s %2u %3u %5u ", 1283 vifi, 1284 v->uv_name, 1285 inet_fmt(v->uv_lcl_addr, s1), 1286 (v->uv_flags & VIFF_TUNNEL) ? 1287 "tunnel": 1288 "subnet", 1289 (v->uv_flags & VIFF_TUNNEL) ? 1290 inet_fmt(v->uv_rmt_addr, s2) : 1291 inet_fmts(v->uv_subnet, v->uv_subnetmask, s3), 1292 v->uv_metric, 1293 v->uv_threshold, 1294 v->uv_rate_limit); 1295 1296 if (v->uv_flags & VIFF_ONEWAY) fprintf(fp, " one-way"); 1297 if (v->uv_flags & VIFF_DOWN) fprintf(fp, " down"); 1298 if (v->uv_flags & VIFF_DISABLED) fprintf(fp, " disabled"); 1299 if (v->uv_flags & VIFF_QUERIER) fprintf(fp, " querier"); 1300 if (v->uv_flags & VIFF_SRCRT) fprintf(fp, " src-rt"); 1301 if (v->uv_flags & VIFF_LEAF) fprintf(fp, " leaf"); 1302 if (v->uv_flags & VIFF_IGMPV1) fprintf(fp, " IGMPv1"); 1303 fprintf(fp, "\n"); 1304 1305 if (v->uv_addrs != NULL) { 1306 fprintf(fp, " alternate subnets: %s\n", 1307 inet_fmts(v->uv_addrs->pa_subnet, v->uv_addrs->pa_subnetmask, s1)); 1308 for (p = v->uv_addrs->pa_next; p; p = p->pa_next) { 1309 fprintf(fp, " %s\n", 1310 inet_fmts(p->pa_subnet, p->pa_subnetmask, s1)); 1311 } 1312 } 1313 1314 if (v->uv_neighbors != NULL) { 1315 fprintf(fp, " peers: %s (%d.%d) (0x%x)\n", 1316 inet_fmt(v->uv_neighbors->al_addr, s1), 1317 v->uv_neighbors->al_pv, v->uv_neighbors->al_mv, 1318 v->uv_neighbors->al_flags); 1319 for (a = v->uv_neighbors->al_next; a != NULL; a = a->al_next) { 1320 fprintf(fp, " %s (%d.%d) (0x%x)\n", 1321 inet_fmt(a->al_addr, s1), a->al_pv, a->al_mv, 1322 a->al_flags); 1323 } 1324 } 1325 1326 if (v->uv_groups != NULL) { 1327 fprintf(fp, " groups: %-15s\n", 1328 inet_fmt(v->uv_groups->al_addr, s1)); 1329 for (a = v->uv_groups->al_next; a != NULL; a = a->al_next) { 1330 fprintf(fp, " %-15s\n", 1331 inet_fmt(a->al_addr, s1)); 1332 } 1333 } 1334 if (v->uv_acl != NULL) { 1335 struct vif_acl *acl; 1336 1337 fprintf(fp, " boundaries: %-18s\n", 1338 inet_fmts(v->uv_acl->acl_addr, v->uv_acl->acl_mask, s1)); 1339 for (acl = v->uv_acl->acl_next; acl != NULL; acl = acl->acl_next) { 1340 fprintf(fp, " : %-18s\n", 1341 inet_fmts(acl->acl_addr, acl->acl_mask, s1)); 1342 } 1343 } 1344 v_req.vifi = vifi; 1345 if (ioctl(udp_socket, SIOCGETVIFCNT, (char *)&v_req) < 0) { 1346 log(LOG_WARNING, 0, 1347 "SIOCGETVIFCNT fails"); 1348 } 1349 else { 1350 fprintf(fp, " pkts in : %ld\n", 1351 v_req.icount); 1352 fprintf(fp, " pkts out: %ld\n", 1353 v_req.ocount); 1354 } 1355 fprintf(fp, "\n"); 1356 } 1357 fprintf(fp, "\n"); 1358 } 1359 1360 /* 1361 * Time out record of a group membership on a vif 1362 */ 1363 static void 1364 DelVif(void *arg) 1365 { 1366 cbk_t *cbk = (cbk_t *)arg; 1367 vifi_t vifi = cbk->vifi; 1368 struct uvif *v = &uvifs[vifi]; 1369 struct listaddr *a, **anp, *g = cbk->g; 1370 1371 /* 1372 * Group has expired 1373 * delete all kernel cache entries with this group 1374 */ 1375 if (g->al_query) 1376 DeleteTimer(g->al_query); 1377 1378 delete_lclgrp(vifi, g->al_addr); 1379 1380 anp = &(v->uv_groups); 1381 while ((a = *anp) != NULL) { 1382 if (a == g) { 1383 *anp = a->al_next; 1384 free((char *)a); 1385 } else { 1386 anp = &a->al_next; 1387 } 1388 } 1389 1390 free(cbk); 1391 } 1392 1393 /* 1394 * Set a timer to delete the record of a group membership on a vif. 1395 */ 1396 static int 1397 SetTimer(int vifi, struct listaddr *g) 1398 { 1399 cbk_t *cbk; 1400 1401 cbk = (cbk_t *) malloc(sizeof(cbk_t)); 1402 cbk->g = g; 1403 cbk->vifi = vifi; 1404 return timer_setTimer(g->al_timer, (cfunc_t)DelVif, (void *)cbk); 1405 } 1406 1407 /* 1408 * Delete a timer that was set above. 1409 */ 1410 static int 1411 DeleteTimer(int id) 1412 { 1413 timer_clearTimer(id); 1414 return 0; 1415 } 1416 1417 /* 1418 * Send a group-specific query. 1419 */ 1420 static void 1421 SendQuery(void *arg) 1422 { 1423 cbk_t *cbk = (cbk_t *)arg; 1424 register struct uvif *v = &uvifs[cbk->vifi]; 1425 1426 send_igmp(v->uv_lcl_addr, cbk->g->al_addr, 1427 IGMP_HOST_MEMBERSHIP_QUERY, 1428 cbk->q_time, cbk->g->al_addr, 0); 1429 cbk->g->al_query = 0; 1430 free(cbk); 1431 } 1432 1433 /* 1434 * Set a timer to send a group-specific query. 1435 */ 1436 static int 1437 SetQueryTimer(struct listaddr *g, vifi_t vifi, int to_expire, int q_time) 1438 { 1439 cbk_t *cbk; 1440 1441 cbk = (cbk_t *) malloc(sizeof(cbk_t)); 1442 cbk->g = g; 1443 cbk->q_time = q_time; 1444 cbk->vifi = vifi; 1445 return timer_setTimer(to_expire, (cfunc_t)SendQuery, (void *)cbk); 1446 } 1447