/* * The mrouted program is covered by the license in the accompanying file * named "LICENSE". Use of the mrouted program represents acceptance of * the terms and conditions listed in that file. * * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of * Leland Stanford Junior University. * * * vif.c,v 3.8.4.56.2.1 1999/01/20 05:18:50 fenner Exp */ #ifndef lint static const char rcsid[] = "$Id: vif.c,v 1.13 1998/06/09 05:01:38 imp Exp $"; #endif /* not lint */ #include "defs.h" #include /* * Exported variables. */ struct uvif uvifs[MAXVIFS]; /* array of virtual interfaces */ vifi_t numvifs; /* number of vifs in use */ int vifs_down; /* 1=>some interfaces are down */ int phys_vif; /* An enabled vif */ int udp_socket; /* Since the honkin' kernel doesn't support */ /* ioctls on raw IP sockets, we need a UDP */ /* socket as well as our IGMP (raw) socket. */ /* How dumb. */ int vifs_with_neighbors; /* == 1 if I am a leaf */ /* * Private variables. */ struct listaddr *nbrs[MAXNBRS]; /* array of neighbors */ typedef struct { vifi_t vifi; struct listaddr *g; int q_time; } cbk_t; /* * Forward declarations. */ static void start_vif __P((vifi_t vifi)); static void start_vif2 __P((vifi_t vifi)); static void stop_vif __P((vifi_t vifi)); static void age_old_hosts __P((void)); static void send_probe_on_vif __P((struct uvif *v)); static void send_query __P((struct uvif *v)); static int info_version __P((char *p, int plen)); static void DelVif __P((void *arg)); static int SetTimer __P((int vifi, struct listaddr *g)); static int DeleteTimer __P((int id)); static void SendQuery __P((void *arg)); static int SetQueryTimer __P((struct listaddr *g, vifi_t vifi, int to_expire, int q_time)); /* * Initialize the virtual interfaces, but do not install * them in the kernel. Start routing on all vifs that are * not down or disabled. */ void init_vifs() { vifi_t vifi; struct uvif *v; int enabled_vifs, enabled_phyints; extern char *configfilename; numvifs = 0; vifs_with_neighbors = 0; vifs_down = FALSE; /* * Configure the vifs based on the interface configuration of the * the kernel and the contents of the configuration file. * (Open a UDP socket for ioctl use in the config procedures if * the kernel can't handle IOCTL's on the IGMP socket.) */ #ifdef IOCTL_OK_ON_RAW_SOCKET udp_socket = igmp_socket; #else if ((udp_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) log(LOG_ERR, errno, "UDP socket"); #endif log(LOG_INFO,0,"Getting vifs from kernel interfaces"); config_vifs_from_kernel(); log(LOG_INFO,0,"Getting vifs from %s",configfilename); config_vifs_from_file(); /* * Quit if there are fewer than two enabled vifs. */ enabled_vifs = 0; enabled_phyints = 0; phys_vif = -1; for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { if (!(v->uv_flags & VIFF_DISABLED)) { ++enabled_vifs; if (!(v->uv_flags & VIFF_TUNNEL)) { if (phys_vif == -1) phys_vif = vifi; ++enabled_phyints; } } } if (enabled_vifs < 2) log(LOG_ERR, 0, "can't forward: %s", enabled_vifs == 0 ? "no enabled vifs" : "only one enabled vif"); if (enabled_phyints == 0) log(LOG_WARNING, 0, "no enabled interfaces, forwarding via tunnels only"); log(LOG_INFO, 0, "Installing vifs in mrouted..."); for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { if (!(v->uv_flags & VIFF_DISABLED)) { if (!(v->uv_flags & VIFF_DOWN)) { if (v->uv_flags & VIFF_TUNNEL) log(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi, inet_fmt(v->uv_lcl_addr, s1), inet_fmt(v->uv_rmt_addr, s2)); else log(LOG_INFO, 0, "vif #%d, phyint %s", vifi, inet_fmt(v->uv_lcl_addr, s1)); start_vif2(vifi); } else log(LOG_INFO, 0, "%s is not yet up; vif #%u not in service", v->uv_name, vifi); } } } /* * Initialize the passed vif with all appropriate default values. * "t" is true if a tunnel, or false if a phyint. */ void zero_vif(v, t) struct uvif *v; int t; { v->uv_flags = 0; v->uv_metric = DEFAULT_METRIC; v->uv_admetric = 0; v->uv_threshold = DEFAULT_THRESHOLD; v->uv_rate_limit = t ? DEFAULT_TUN_RATE_LIMIT : DEFAULT_PHY_RATE_LIMIT; v->uv_lcl_addr = 0; v->uv_rmt_addr = 0; v->uv_dst_addr = t ? 0 : dvmrp_group; v->uv_subnet = 0; v->uv_subnetmask = 0; v->uv_subnetbcast = 0; v->uv_name[0] = '\0'; v->uv_groups = NULL; v->uv_neighbors = NULL; NBRM_CLRALL(v->uv_nbrmap); v->uv_querier = NULL; v->uv_igmpv1_warn = 0; v->uv_prune_lifetime = 0; v->uv_leaf_timer = 0; v->uv_acl = NULL; v->uv_addrs = NULL; v->uv_filter = NULL; v->uv_blasterbuf = NULL; v->uv_blastercur = NULL; v->uv_blasterend = NULL; v->uv_blasterlen = 0; v->uv_blastertimer = 0; v->uv_nbrup = 0; v->uv_icmp_warn = 0; v->uv_nroutes = 0; } /* * Start routing on all virtual interfaces that are not down or * administratively disabled. */ void init_installvifs() { vifi_t vifi; struct uvif *v; log(LOG_INFO, 0, "Installing vifs in kernel..."); for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { if (!(v->uv_flags & VIFF_DISABLED)) { if (!(v->uv_flags & VIFF_DOWN)) { if (v->uv_flags & VIFF_TUNNEL) log(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi, inet_fmt(v->uv_lcl_addr, s1), inet_fmt(v->uv_rmt_addr, s2)); else log(LOG_INFO, 0, "vif #%d, phyint %s", vifi, inet_fmt(v->uv_lcl_addr, s1)); k_add_vif(vifi, &uvifs[vifi]); } else log(LOG_INFO, 0, "%s is not yet up; vif #%u not in service", v->uv_name, vifi); } } } /* * See if any interfaces have changed from up state to down, or vice versa, * including any non-multicast-capable interfaces that are in use as local * tunnel end-points. Ignore interfaces that have been administratively * disabled. */ void check_vif_state() { register vifi_t vifi; register struct uvif *v; struct ifreq ifr; static int checking_vifs = 0; /* * If we get an error while checking, (e.g. two interfaces go down * at once, and we decide to send a prune out one of the failed ones) * then don't go into an infinite loop! */ if (checking_vifs) return; vifs_down = FALSE; checking_vifs = 1; for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { if (v->uv_flags & VIFF_DISABLED) continue; strncpy(ifr.ifr_name, v->uv_name, IFNAMSIZ); if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ifr) < 0) log(LOG_ERR, errno, "ioctl SIOCGIFFLAGS for %s", ifr.ifr_name); if (v->uv_flags & VIFF_DOWN) { if (ifr.ifr_flags & IFF_UP) { log(LOG_NOTICE, 0, "%s has come up; vif #%u now in service", v->uv_name, vifi); v->uv_flags &= ~VIFF_DOWN; start_vif(vifi); } else vifs_down = TRUE; } else { if (!(ifr.ifr_flags & IFF_UP)) { log(LOG_NOTICE, 0, "%s has gone down; vif #%u taken out of service", v->uv_name, vifi); stop_vif(vifi); v->uv_flags |= VIFF_DOWN; vifs_down = TRUE; } } } checking_vifs = 0; } /* * Send a DVMRP message on the specified vif. If DVMRP messages are * to be encapsulated and sent "inside" the tunnel, use the special * encapsulator. If it's not a tunnel or DVMRP messages are to be * sent "beside" the tunnel, as required by earlier versions of mrouted, * then just send the message. */ void send_on_vif(v, dst, code, datalen) register struct uvif *v; u_int32 dst; int code; int datalen; { u_int32 group = htonl(MROUTED_LEVEL | ((v->uv_flags & VIFF_LEAF) ? 0 : LEAF_FLAGS)); /* * The UNIX kernel will not decapsulate unicasts. * Therefore, we don't send encapsulated unicasts. */ if ((v->uv_flags & (VIFF_TUNNEL|VIFF_OTUNNEL)) == VIFF_TUNNEL && ((dst == 0) || IN_MULTICAST(ntohl(dst)))) send_ipip(v->uv_lcl_addr, dst ? dst : dvmrp_group, IGMP_DVMRP, code, group, datalen, v); else send_igmp(v->uv_lcl_addr, dst ? dst : v->uv_dst_addr, IGMP_DVMRP, code, group, datalen); } /* * Send a probe message on vif v */ static void send_probe_on_vif(v) register struct uvif *v; { register char *p; register int datalen = 0; struct listaddr *nbr; int i; if ((v->uv_flags & VIFF_PASSIVE && v->uv_neighbors == NULL) || (v->uv_flags & VIFF_FORCE_LEAF)) return; p = send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN; for (i = 0; i < 4; i++) *p++ = ((char *)&(dvmrp_genid))[i]; datalen += 4; /* * add the neighbor list on the interface to the message */ nbr = v->uv_neighbors; while (nbr) { for (i = 0; i < 4; i++) *p++ = ((char *)&nbr->al_addr)[i]; datalen +=4; nbr = nbr->al_next; } send_on_vif(v, 0, DVMRP_PROBE, datalen); } static void send_query(v) register struct uvif *v; { IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "sending %squery on vif %d", (v->uv_flags & VIFF_IGMPV1) ? "v1 " : "", v - uvifs); send_igmp(v->uv_lcl_addr, allhosts_group, IGMP_MEMBERSHIP_QUERY, (v->uv_flags & VIFF_IGMPV1) ? 0 : IGMP_MAX_HOST_REPORT_DELAY * IGMP_TIMER_SCALE, 0, 0); } /* * Add a vifi to the kernel and start routing on it. */ static void start_vif(vifi) vifi_t vifi; { /* * Install the interface in the kernel's vif structure. */ k_add_vif(vifi, &uvifs[vifi]); start_vif2(vifi); } /* * Add a vifi to all the user-level data structures but don't add * it to the kernel yet. */ static void start_vif2(vifi) vifi_t vifi; { struct uvif *v; u_int32 src; struct phaddr *p; v = &uvifs[vifi]; src = v->uv_lcl_addr; /* * Update the existing route entries to take into account the new vif. */ add_vif_to_routes(vifi); if (!(v->uv_flags & VIFF_TUNNEL)) { /* * Join the DVMRP multicast group on the interface. * (This is not strictly necessary, since the kernel promiscuously * receives IGMP packets addressed to ANY IP multicast group while * multicast routing is enabled. However, joining the group allows * this host to receive non-IGMP packets as well, such as 'pings'.) */ k_join(dvmrp_group, src); /* * Join the ALL-ROUTERS multicast group on the interface. * This allows mtrace requests to loop back if they are run * on the multicast router. */ k_join(allrtrs_group, src); /* * Install an entry in the routing table for the subnet to which * the interface is connected. */ start_route_updates(); update_route(v->uv_subnet, v->uv_subnetmask, 0, 0, vifi, NULL); for (p = v->uv_addrs; p; p = p->pa_next) { start_route_updates(); update_route(p->pa_subnet, p->pa_subnetmask, 0, 0, vifi, NULL); } /* * Until neighbors are discovered, assume responsibility for sending * periodic group membership queries to the subnet. Send the first * query. */ v->uv_flags |= VIFF_QUERIER; IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "assuming querier duties on vif %d", vifi); send_query(v); } v->uv_leaf_timer = LEAF_CONFIRMATION_TIME; /* * Send a probe via the new vif to look for neighbors. */ send_probe_on_vif(v); } /* * Stop routing on the specified virtual interface. */ static void stop_vif(vifi) vifi_t vifi; { struct uvif *v; struct listaddr *a; struct phaddr *p; v = &uvifs[vifi]; if (!(v->uv_flags & VIFF_TUNNEL)) { /* * Depart from the DVMRP multicast group on the interface. */ k_leave(dvmrp_group, v->uv_lcl_addr); /* * Depart from the ALL-ROUTERS multicast group on the interface. */ k_leave(allrtrs_group, v->uv_lcl_addr); /* * Update the entry in the routing table for the subnet to which * the interface is connected, to take into account the interface * failure. */ start_route_updates(); update_route(v->uv_subnet, v->uv_subnetmask, UNREACHABLE, 0, vifi, NULL); for (p = v->uv_addrs; p; p = p->pa_next) { start_route_updates(); update_route(p->pa_subnet, p->pa_subnetmask, UNREACHABLE, 0, vifi, NULL); } /* * Discard all group addresses. (No need to tell kernel; * the k_del_vif() call, below, will clean up kernel state.) */ while (v->uv_groups != NULL) { a = v->uv_groups; v->uv_groups = a->al_next; free((char *)a); } IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "releasing querier duties on vif %d", vifi); v->uv_flags &= ~VIFF_QUERIER; } /* * Update the existing route entries to take into account the vif failure. */ delete_vif_from_routes(vifi); /* * Delete the interface from the kernel's vif structure. */ k_del_vif(vifi); /* * Discard all neighbor addresses. */ if (!NBRM_ISEMPTY(v->uv_nbrmap)) vifs_with_neighbors--; while (v->uv_neighbors != NULL) { a = v->uv_neighbors; v->uv_neighbors = a->al_next; nbrs[a->al_index] = NULL; free((char *)a); } NBRM_CLRALL(v->uv_nbrmap); } /* * stop routing on all vifs */ void stop_all_vifs() { vifi_t vifi; struct uvif *v; struct listaddr *a; struct vif_acl *acl; for (vifi = 0; vifi < numvifs; vifi++) { v = &uvifs[vifi]; while (v->uv_groups != NULL) { a = v->uv_groups; v->uv_groups = a->al_next; free((char *)a); } while (v->uv_neighbors != NULL) { a = v->uv_neighbors; v->uv_neighbors = a->al_next; nbrs[a->al_index] = NULL; free((char *)a); } while (v->uv_acl != NULL) { acl = v->uv_acl; v->uv_acl = acl->acl_next; free((char *)acl); } } } /* * Find the virtual interface from which an incoming packet arrived, * based on the packet's source and destination IP addresses. */ vifi_t find_vif(src, dst) register u_int32 src; register u_int32 dst; { register vifi_t vifi; register struct uvif *v; register struct phaddr *p; for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) { if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) { if (v->uv_flags & VIFF_TUNNEL) { if (src == v->uv_rmt_addr && (dst == v->uv_lcl_addr || dst == dvmrp_group)) return(vifi); } else { if ((src & v->uv_subnetmask) == v->uv_subnet && ((v->uv_subnetmask == 0xffffffff) || (src != v->uv_subnetbcast))) return(vifi); for (p=v->uv_addrs; p; p=p->pa_next) { if ((src & p->pa_subnetmask) == p->pa_subnet && ((p->pa_subnetmask == 0xffffffff) || (src != p->pa_subnetbcast))) return(vifi); } } } } return (NO_VIF); } static void age_old_hosts() { register vifi_t vifi; register struct uvif *v; register struct listaddr *g; /* * Decrement the old-hosts-present timer for each * active group on each vif. */ for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) for (g = v->uv_groups; g != NULL; g = g->al_next) if (g->al_old) g->al_old--; } /* * Send group membership queries on each interface for which I am querier. * Note that technically, there should be a timer per interface, as the * dynamics of querier election can cause the "right" time to send a * query to be different on different interfaces. However, this simple * implementation only ever sends queries sooner than the "right" time, * so can not cause loss of membership (but can send more packets than * necessary) */ void query_groups() { register vifi_t vifi; register struct uvif *v; for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { if (v->uv_flags & VIFF_QUERIER) { send_query(v); } } age_old_hosts(); } /* * Process an incoming host membership query. Warn about * IGMP version mismatches, perform querier election, and * handle group-specific queries when we're not the querier. */ void accept_membership_query(src, dst, group, tmo) u_int32 src, dst, group; int tmo; { register vifi_t vifi; register struct uvif *v; if ((vifi = find_vif(src, dst)) == NO_VIF || (uvifs[vifi].uv_flags & VIFF_TUNNEL)) { log(LOG_INFO, 0, "ignoring group membership query from non-adjacent host %s", inet_fmt(src, s1)); return; } v = &uvifs[vifi]; if ((tmo == 0 && !(v->uv_flags & VIFF_IGMPV1)) || (tmo != 0 && (v->uv_flags & VIFF_IGMPV1))) { int i; /* * Exponentially back-off warning rate */ i = ++v->uv_igmpv1_warn; while (i && !(i & 1)) i >>= 1; if (i == 1) log(LOG_WARNING, 0, "%s %s on vif %d, %s", tmo == 0 ? "Received IGMPv1 report from" : "Received IGMPv2 report from", inet_fmt(src, s1), vifi, tmo == 0 ? "please configure vif for IGMPv1" : "but I am configured for IGMPv1"); } if (v->uv_querier == NULL || v->uv_querier->al_addr != src) { /* * This might be: * - A query from a new querier, with a lower source address * than the current querier (who might be me) * - A query from a new router that just started up and doesn't * know who the querier is. */ if (ntohl(src) < (v->uv_querier ? ntohl(v->uv_querier->al_addr) : ntohl(v->uv_lcl_addr))) { IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "new querier %s (was %s) on vif %d", inet_fmt(src, s1), v->uv_querier ? inet_fmt(v->uv_querier->al_addr, s2) : "me", vifi); if (!v->uv_querier) { v->uv_querier = (struct listaddr *) malloc(sizeof(struct listaddr)); v->uv_flags &= ~VIFF_QUERIER; } time(&v->uv_querier->al_ctime); v->uv_querier->al_addr = src; } else { IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "ignoring query from %s; querier on vif %d is still %s", inet_fmt(src, s1), vifi, v->uv_querier ? inet_fmt(v->uv_querier->al_addr, s2) : "me"); return; } } /* * Reset the timer since we've received a query. */ if (v->uv_querier && src == v->uv_querier->al_addr) v->uv_querier->al_timer = 0; /* * If this is a Group-Specific query which we did not source, * we must set our membership timer to [Last Member Query Count] * * the [Max Response Time] in the packet. */ if (!(v->uv_flags & (VIFF_IGMPV1|VIFF_QUERIER)) && group != 0 && src != v->uv_lcl_addr) { register struct listaddr *g; IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "%s for %s from %s on vif %d, timer %d", "Group-specific membership query", inet_fmt(group, s2), inet_fmt(src, s1), vifi, tmo); for (g = v->uv_groups; g != NULL; g = g->al_next) { if (group == g->al_addr && g->al_query == 0) { /* setup a timeout to remove the group membership */ if (g->al_timerid) g->al_timerid = DeleteTimer(g->al_timerid); g->al_timer = IGMP_LAST_MEMBER_QUERY_COUNT * tmo / IGMP_TIMER_SCALE; /* use al_query to record our presence in last-member state */ g->al_query = -1; g->al_timerid = SetTimer(vifi, g); IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "timer for grp %s on vif %d set to %d", inet_fmt(group, s2), vifi, g->al_timer); break; } } } } /* * Process an incoming group membership report. */ void accept_group_report(src, dst, group, r_type) u_int32 src, dst, group; int r_type; { register vifi_t vifi; register struct uvif *v; register struct listaddr *g; if ((vifi = find_vif(src, dst)) == NO_VIF || (uvifs[vifi].uv_flags & VIFF_TUNNEL)) { log(LOG_INFO, 0, "ignoring group membership report from non-adjacent host %s", inet_fmt(src, s1)); return; } v = &uvifs[vifi]; /* * Look for the group in our group list; if found, reset its timer. */ for (g = v->uv_groups; g != NULL; g = g->al_next) { if (group == g->al_addr) { if (r_type == IGMP_V1_MEMBERSHIP_REPORT) g->al_old = OLD_AGE_THRESHOLD; g->al_reporter = src; /** delete old timers, set a timer for expiration **/ g->al_timer = IGMP_GROUP_MEMBERSHIP_INTERVAL; if (g->al_query) g->al_query = DeleteTimer(g->al_query); if (g->al_timerid) g->al_timerid = DeleteTimer(g->al_timerid); g->al_timerid = SetTimer(vifi, g); break; } } /* * If not found, add it to the list and update kernel cache. */ if (g == NULL) { g = (struct listaddr *)malloc(sizeof(struct listaddr)); if (g == NULL) log(LOG_ERR, 0, "ran out of memory"); /* fatal */ g->al_addr = group; if (r_type == IGMP_V1_MEMBERSHIP_REPORT) g->al_old = OLD_AGE_THRESHOLD; else g->al_old = 0; /** set a timer for expiration **/ g->al_query = 0; g->al_timer = IGMP_GROUP_MEMBERSHIP_INTERVAL; g->al_reporter = src; g->al_timerid = SetTimer(vifi, g); g->al_next = v->uv_groups; v->uv_groups = g; time(&g->al_ctime); update_lclgrp(vifi, group); } /* * Check if a graft is necessary for this group */ chkgrp_graft(vifi, group); } /* * Process an incoming IGMPv2 Leave Group message. */ void accept_leave_message(src, dst, group) u_int32 src, dst, group; { register vifi_t vifi; register struct uvif *v; register struct listaddr *g; if ((vifi = find_vif(src, dst)) == NO_VIF || (uvifs[vifi].uv_flags & VIFF_TUNNEL)) { log(LOG_INFO, 0, "ignoring group leave report from non-adjacent host %s", inet_fmt(src, s1)); return; } v = &uvifs[vifi]; if (!(v->uv_flags & VIFF_QUERIER) || (v->uv_flags & VIFF_IGMPV1)) return; /* * Look for the group in our group list in order to set up a short-timeout * query. */ for (g = v->uv_groups; g != NULL; g = g->al_next) { if (group == g->al_addr) { IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "[vif.c, _accept_leave_message] %d %d \n", g->al_old, g->al_query); /* Ignore the leave message if there are old hosts present */ if (g->al_old) return; /* still waiting for a reply to a query, ignore the leave */ if (g->al_query) return; /** delete old timer set a timer for expiration **/ if (g->al_timerid) g->al_timerid = DeleteTimer(g->al_timerid); #if IGMP_LAST_MEMBER_QUERY_COUNT != 2 This code needs to be updated to keep a counter of the number of queries remaining. #endif /** send a group specific querry **/ g->al_timer = IGMP_LAST_MEMBER_QUERY_INTERVAL * (IGMP_LAST_MEMBER_QUERY_COUNT + 1); send_igmp(v->uv_lcl_addr, g->al_addr, IGMP_MEMBERSHIP_QUERY, IGMP_LAST_MEMBER_QUERY_INTERVAL * IGMP_TIMER_SCALE, g->al_addr, 0); g->al_query = SetQueryTimer(g, vifi, IGMP_LAST_MEMBER_QUERY_INTERVAL, IGMP_LAST_MEMBER_QUERY_INTERVAL * IGMP_TIMER_SCALE); g->al_timerid = SetTimer(vifi, g); break; } } } /* * Send a periodic probe on all vifs. * Useful to determine one-way interfaces. * Detect neighbor loss faster. */ void probe_for_neighbors() { register vifi_t vifi; register struct uvif *v; for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) { send_probe_on_vif(v); } } } /* * Send a list of all of our neighbors to the requestor, `src'. */ void accept_neighbor_request(src, dst) u_int32 src, dst; { vifi_t vifi; struct uvif *v; u_char *p, *ncount; struct listaddr *la; int datalen; u_int32 temp_addr, them = src; #define PUT_ADDR(a) temp_addr = ntohl(a); \ *p++ = temp_addr >> 24; \ *p++ = (temp_addr >> 16) & 0xFF; \ *p++ = (temp_addr >> 8) & 0xFF; \ *p++ = temp_addr & 0xFF; p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); datalen = 0; for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { if (v->uv_flags & VIFF_DISABLED) continue; ncount = 0; for (la = v->uv_neighbors; la; la = la->al_next) { /* Make sure that there's room for this neighbor... */ if (datalen + (ncount == 0 ? 4 + 3 + 4 : 4) > MAX_DVMRP_DATA_LEN) { send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS, htonl(MROUTED_LEVEL), datalen); p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); datalen = 0; ncount = 0; } /* Put out the header for this neighbor list... */ if (ncount == 0) { PUT_ADDR(v->uv_lcl_addr); *p++ = v->uv_metric; *p++ = v->uv_threshold; ncount = p; *p++ = 0; datalen += 4 + 3; } PUT_ADDR(la->al_addr); datalen += 4; (*ncount)++; } } if (datalen != 0) send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS, htonl(MROUTED_LEVEL), datalen); } /* * Send a list of all of our neighbors to the requestor, `src'. */ void accept_neighbor_request2(src, dst) u_int32 src, dst; { vifi_t vifi; struct uvif *v; u_char *p, *ncount; struct listaddr *la; int datalen; u_int32 them = src; p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); datalen = 0; for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { register u_short vflags = v->uv_flags; register u_char rflags = 0; if (vflags & VIFF_TUNNEL) rflags |= DVMRP_NF_TUNNEL; if (vflags & VIFF_SRCRT) rflags |= DVMRP_NF_SRCRT; if (vflags & VIFF_DOWN) rflags |= DVMRP_NF_DOWN; if (vflags & VIFF_DISABLED) rflags |= DVMRP_NF_DISABLED; if (vflags & VIFF_QUERIER) rflags |= DVMRP_NF_QUERIER; if (vflags & VIFF_LEAF) rflags |= DVMRP_NF_LEAF; ncount = 0; la = v->uv_neighbors; if (la == NULL) { /* * include down & disabled interfaces and interfaces on * leaf nets. */ if (rflags & DVMRP_NF_TUNNEL) rflags |= DVMRP_NF_DOWN; if (datalen > MAX_DVMRP_DATA_LEN - 12) { send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, htonl(MROUTED_LEVEL), datalen); p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); datalen = 0; } *(u_int*)p = v->uv_lcl_addr; p += 4; *p++ = v->uv_metric; *p++ = v->uv_threshold; *p++ = rflags; *p++ = 1; *(u_int*)p = v->uv_rmt_addr; p += 4; datalen += 12; } else { for ( ; la; la = la->al_next) { /* Make sure that there's room for this neighbor... */ if (datalen + (ncount == 0 ? 4+4+4 : 4) > MAX_DVMRP_DATA_LEN) { send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, htonl(MROUTED_LEVEL), datalen); p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); datalen = 0; ncount = 0; } /* Put out the header for this neighbor list... */ if (ncount == 0) { /* If it's a one-way tunnel, mark it down. */ if (rflags & DVMRP_NF_TUNNEL && la->al_flags & NBRF_ONEWAY) rflags |= DVMRP_NF_DOWN; *(u_int*)p = v->uv_lcl_addr; p += 4; *p++ = v->uv_metric; *p++ = v->uv_threshold; *p++ = rflags; ncount = p; *p++ = 0; datalen += 4 + 4; } /* Don't report one-way peering on phyint at all */ if (!(rflags & DVMRP_NF_TUNNEL) && la->al_flags & NBRF_ONEWAY) continue; *(u_int*)p = la->al_addr; p += 4; datalen += 4; (*ncount)++; } if (*ncount == 0) { *(u_int*)p = v->uv_rmt_addr; p += 4; datalen += 4; (*ncount)++; } } } if (datalen != 0) send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, htonl(MROUTED_LEVEL), datalen); } void accept_info_request(src, dst, p, datalen) u_int32 src, dst; u_char *p; int datalen; { u_char *q; int len; int outlen = 0; q = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN); /* To be general, this must deal properly with breaking up over-sized * packets. That implies passing a length to each function, and * allowing each function to request to be called again. Right now, * we're only implementing the one thing we are positive will fit into * a single packet, so we wimp out. */ while (datalen > 0) { len = 0; switch (*p) { case DVMRP_INFO_VERSION: len = info_version(q, RECV_BUF_SIZE-(q-(u_char *)send_buf)); break; case DVMRP_INFO_NEIGHBORS: default: log(LOG_INFO, 0, "ignoring unknown info type %d", *p); break; } *(q+1) = len++; outlen += len * 4; q += len * 4; len = (*(p+1) + 1) * 4; p += len; datalen -= len; } if (outlen != 0) send_igmp(INADDR_ANY, src, IGMP_DVMRP, DVMRP_INFO_REPLY, htonl(MROUTED_LEVEL), outlen); } /* * Information response -- return version string */ static int info_version(p, plen) char *p; int plen; { int len; extern char versionstring[]; *p++ = DVMRP_INFO_VERSION; p++; /* skip over length */ *p++ = 0; /* zero out */ *p++ = 0; /* reserved fields */ strncpy(p, versionstring, plen - 4); p[plen-5] = '\0'; len = strlen(versionstring); return ((len + 3) / 4); } /* * Process an incoming neighbor-list message. */ void accept_neighbors(src, dst, p, datalen, level) u_int32 src, dst, level; u_char *p; int datalen; { log(LOG_INFO, 0, "ignoring spurious DVMRP neighbor list from %s to %s", inet_fmt(src, s1), inet_fmt(dst, s2)); } /* * Process an incoming neighbor-list message. */ void accept_neighbors2(src, dst, p, datalen, level) u_int32 src, dst, level; u_char *p; int datalen; { IF_DEBUG(DEBUG_PKT) log(LOG_DEBUG, 0, "ignoring spurious DVMRP neighbor list2 from %s to %s", inet_fmt(src, s1), inet_fmt(dst, s2)); } /* * Process an incoming info reply message. */ void accept_info_reply(src, dst, p, datalen) u_int32 src, dst; u_char *p; int datalen; { IF_DEBUG(DEBUG_PKT) log(LOG_DEBUG, 0, "ignoring spurious DVMRP info reply from %s to %s", inet_fmt(src, s1), inet_fmt(dst, s2)); } /* * Update the neighbor entry for neighbor 'addr' on vif 'vifi'. * 'msgtype' is the type of DVMRP message received from the neighbor. * Return the neighbor entry if 'addr' is a valid neighbor, FALSE otherwise. */ struct listaddr * update_neighbor(vifi, addr, msgtype, p, datalen, level) vifi_t vifi; u_int32 addr; int msgtype; char *p; int datalen; u_int32 level; { register struct uvif *v; register struct listaddr *n; int pv = level & 0xff; int mv = (level >> 8) & 0xff; int has_genid = 0; int in_router_list = 0; int dvmrpspec = 0; u_int32 genid; u_int32 send_tables = 0; int i; int do_reset = FALSE; v = &uvifs[vifi]; /* * Confirm that 'addr' is a valid neighbor address on vif 'vifi'. * IT IS ASSUMED that this was preceded by a call to find_vif(), which * checks that 'addr' is either a valid remote tunnel endpoint or a * non-broadcast address belonging to a directly-connected subnet. * Therefore, here we check only that 'addr' is not our own address * (due to an impostor or erroneous loopback) or an address of the form * {subnet,0} ("the unknown host"). These checks are not performed in * find_vif() because those types of address are acceptable for some * types of IGMP message (such as group membership reports). */ if (!(v->uv_flags & VIFF_TUNNEL) && (addr == v->uv_lcl_addr || addr == v->uv_subnet )) { log(LOG_WARNING, 0, "received DVMRP message from %s: %s", (addr == v->uv_lcl_addr) ? "self (check device loopback)" : "'the unknown host'", inet_fmt(addr, s1)); return NULL; } /* * Ignore all neighbors on vifs forced into leaf mode */ if (v->uv_flags & VIFF_FORCE_LEAF) { return NULL; } /* * mrouted's version 3.3 and later include the generation ID * and the list of neighbors on the vif in their probe messages. */ if (msgtype == DVMRP_PROBE && ((pv == 3 && mv > 2) || (pv > 3 && pv < 10))) { u_int32 router; IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "checking probe from %s (%d.%d) on vif %d", inet_fmt(addr, s1), pv, mv, vifi); if (datalen < 4) { log(LOG_WARNING, 0, "received truncated probe message from %s (len %d)", inet_fmt(addr, s1), datalen); return NULL; } has_genid = 1; for (i = 0; i < 4; i++) ((char *)&genid)[i] = *p++; datalen -= 4; while (datalen > 0) { if (datalen < 4) { log(LOG_WARNING, 0, "received truncated probe message from %s (len %d)", inet_fmt(addr, s1), datalen); return NULL; } for (i = 0; i < 4; i++) ((char *)&router)[i] = *p++; datalen -= 4; if (router == v->uv_lcl_addr) { in_router_list = 1; break; } } } if ((pv == 3 && mv == 255) || (pv > 3 && pv < 10)) dvmrpspec = 1; /* * Look for addr in list of neighbors. */ for (n = v->uv_neighbors; n != NULL; n = n->al_next) { if (addr == n->al_addr) { break; } } if (n == NULL) { /* * New neighbor. * * If this neighbor follows the DVMRP spec, start the probe * handshake. If not, then it doesn't require the probe * handshake, so establish the peering immediately. */ if (dvmrpspec && (msgtype != DVMRP_PROBE)) return NULL; for (i = 0; i < MAXNBRS; i++) if (nbrs[i] == NULL) break; if (i == MAXNBRS) { /* XXX This is a severe new restriction. */ /* XXX want extensible bitmaps! */ log(LOG_ERR, 0, "Can't handle %dth neighbor %s on vif %d!", MAXNBRS, inet_fmt(addr, s1), vifi); /*NOTREACHED*/ } /* * Add it to our list of neighbors. */ IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "New neighbor %s on vif %d v%d.%d nf 0x%02x idx %d", inet_fmt(addr, s1), vifi, level & 0xff, (level >> 8) & 0xff, (level >> 16) & 0xff, i); n = (struct listaddr *)malloc(sizeof(struct listaddr)); if (n == NULL) log(LOG_ERR, 0, "ran out of memory"); /* fatal */ n->al_addr = addr; n->al_pv = pv; n->al_mv = mv; n->al_genid = has_genid ? genid : 0; n->al_index = i; nbrs[i] = n; time(&n->al_ctime); n->al_timer = 0; n->al_flags = has_genid ? NBRF_GENID : 0; n->al_next = v->uv_neighbors; v->uv_neighbors = n; /* * If we are not configured to peer with non-pruning routers, * check the deprecated "I-know-how-to-prune" bit. This bit * was MBZ in early mrouted implementations (<3.5) and is required * to be set by the DVMRPv3 specification. */ if (!(v->uv_flags & VIFF_ALLOW_NONPRUNERS) && !((level & 0x020000) || (pv == 3 && mv < 5))) { n->al_flags |= NBRF_TOOOLD; } /* * If this router implements the DVMRPv3 spec, then don't peer * with him if we haven't yet established a bidirectional connection. */ if (dvmrpspec) { if (!in_router_list) { IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "waiting for probe from %s with my addr", inet_fmt(addr, s1)); n->al_flags |= NBRF_WAITING; return NULL; } } if (n->al_flags & NBRF_DONTPEER) { IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "not peering with %s on vif %d because %x", inet_fmt(addr, s1), vifi, n->al_flags & NBRF_DONTPEER); return NULL; } /* * If we thought that we had no neighbors on this vif, send a route * report to the vif. If this is just a new neighbor on the same * vif, send the route report just to the new neighbor. */ if (NBRM_ISEMPTY(v->uv_nbrmap)) { send_tables = v->uv_dst_addr; vifs_with_neighbors++; } else { send_tables = addr; } NBRM_SET(i, v->uv_nbrmap); add_neighbor_to_routes(vifi, i); } else { /* * Found it. Reset its timer. */ n->al_timer = 0; if (n->al_flags & NBRF_WAITING && msgtype == DVMRP_PROBE) { n->al_flags &= ~NBRF_WAITING; if (!in_router_list) { log(LOG_WARNING, 0, "possible one-way peering with %s on vif %d", inet_fmt(addr, s1), vifi); n->al_flags |= NBRF_ONEWAY; return NULL; } else { if (NBRM_ISEMPTY(v->uv_nbrmap)) { send_tables = v->uv_dst_addr; vifs_with_neighbors++; } else { send_tables = addr; } NBRM_SET(n->al_index, v->uv_nbrmap); add_neighbor_to_routes(vifi, n->al_index); IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "%s on vif %d exits WAITING", inet_fmt(addr, s1), vifi); } } if (n->al_flags & NBRF_ONEWAY && msgtype == DVMRP_PROBE) { if (in_router_list) { if (NBRM_ISEMPTY(v->uv_nbrmap)) vifs_with_neighbors++; NBRM_SET(n->al_index, v->uv_nbrmap); add_neighbor_to_routes(vifi, n->al_index); log(LOG_NOTICE, 0, "peering with %s on vif %d is no longer one-way", inet_fmt(addr, s1), vifi); n->al_flags &= ~NBRF_ONEWAY; } else { /* XXX rate-limited warning message? */ IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "%s on vif %d is still ONEWAY", inet_fmt(addr, s1), vifi); } } /* * When peering with a genid-capable but pre-DVMRP spec peer, * we might bring up the peering with a route report and not * remember his genid. Assume that he doesn't send a route * report and then reboot before sending a probe. */ if (has_genid && !(n->al_flags & NBRF_GENID)) { n->al_flags |= NBRF_GENID; n->al_genid = genid; } /* * update the neighbors version and protocol number and genid * if changed => router went down and came up, * so take action immediately. */ if ((n->al_pv != pv) || (n->al_mv != mv) || (has_genid && n->al_genid != genid)) { do_reset = TRUE; IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "version/genid change neighbor %s [old:%d.%d/%8x, new:%d.%d/%8x]", inet_fmt(addr, s1), n->al_pv, n->al_mv, n->al_genid, pv, mv, genid); n->al_pv = pv; n->al_mv = mv; n->al_genid = genid; time(&n->al_ctime); } if ((pv == 3 && mv > 2) || (pv > 3 && pv < 10)) { if (!(n->al_flags & VIFF_ONEWAY) && has_genid && !in_router_list && (time(NULL) - n->al_ctime > 20)) { if (NBRM_ISSET(n->al_index, v->uv_nbrmap)) { NBRM_CLR(n->al_index, v->uv_nbrmap); if (NBRM_ISEMPTY(v->uv_nbrmap)) vifs_with_neighbors--; } delete_neighbor_from_routes(addr, vifi, n->al_index); reset_neighbor_state(vifi, addr); log(LOG_WARNING, 0, "peering with %s on vif %d is one-way", inet_fmt(addr, s1), vifi); n->al_flags |= NBRF_ONEWAY; } } if (n->al_flags & NBRF_DONTPEER) { IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "not peering with %s on vif %d because %x", inet_fmt(addr, s1), vifi, n->al_flags & NBRF_DONTPEER); return NULL; } /* check "leaf" flag */ } if (do_reset) { reset_neighbor_state(vifi, addr); if (!send_tables) send_tables = addr; } if (send_tables) { send_probe_on_vif(v); report(ALL_ROUTES, vifi, send_tables); } v->uv_leaf_timer = 0; v->uv_flags &= ~VIFF_LEAF; return n; } /* * On every timer interrupt, advance the timer in each neighbor and * group entry on every vif. */ void age_vifs() { register vifi_t vifi; register struct uvif *v; register struct listaddr *a, *prev_a; register u_int32 addr; for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v ) { if (v->uv_leaf_timer && (v->uv_leaf_timer -= TIMER_INTERVAL == 0)) { v->uv_flags |= VIFF_LEAF; } for (prev_a = (struct listaddr *)&(v->uv_neighbors), a = v->uv_neighbors; a != NULL; prev_a = a, a = a->al_next) { int exp_time; int idx; if (((a->al_pv == 3) && (a->al_mv >= 3)) || ((a->al_pv > 3) && (a->al_pv < 10))) exp_time = NEIGHBOR_EXPIRE_TIME; else exp_time = OLD_NEIGHBOR_EXPIRE_TIME; if ((a->al_timer += TIMER_INTERVAL) < exp_time) continue; IF_DEBUG(DEBUG_PEER) log(LOG_DEBUG, 0, "Neighbor %s (%d.%d) expired after %d seconds", inet_fmt(a->al_addr, s1), a->al_pv, a->al_mv, exp_time); /* * Neighbor has expired; delete it from the neighbor list, * delete it from the 'dominants' and 'subordinates arrays of * any route entries. */ NBRM_CLR(a->al_index, v->uv_nbrmap); nbrs[a->al_index] = NULL; /* XXX is it a good idea to reuse indxs? */ idx = a->al_index; addr = a->al_addr; prev_a->al_next = a->al_next; free((char *)a); a = prev_a;/*XXX use ** */ delete_neighbor_from_routes(addr, vifi, idx); reset_neighbor_state(vifi, addr); if (NBRM_ISEMPTY(v->uv_nbrmap)) vifs_with_neighbors--; v->uv_leaf_timer = LEAF_CONFIRMATION_TIME; } if (v->uv_querier && (v->uv_querier->al_timer += TIMER_INTERVAL) > IGMP_OTHER_QUERIER_PRESENT_INTERVAL) { /* * The current querier has timed out. We must become the * querier. */ IF_DEBUG(DEBUG_IGMP) log(LOG_DEBUG, 0, "querier %s timed out", inet_fmt(v->uv_querier->al_addr, s1)); free(v->uv_querier); v->uv_querier = NULL; v->uv_flags |= VIFF_QUERIER; send_query(v); } } } /* * Returns the neighbor info struct for a given neighbor */ struct listaddr * neighbor_info(vifi, addr) vifi_t vifi; u_int32 addr; { struct listaddr *u; for (u = uvifs[vifi].uv_neighbors; u; u = u->al_next) if (u->al_addr == addr) return u; return NULL; } static struct vnflags { int vn_flag; char *vn_name; } vifflags[] = { { VIFF_DOWN, "down" }, { VIFF_DISABLED, "disabled" }, { VIFF_QUERIER, "querier" }, { VIFF_ONEWAY, "one-way" }, { VIFF_LEAF, "leaf" }, { VIFF_IGMPV1, "IGMPv1" }, { VIFF_REXMIT_PRUNES, "rexmit_prunes" }, { VIFF_PASSIVE, "passive" }, { VIFF_ALLOW_NONPRUNERS,"allow_nonpruners" }, { VIFF_NOFLOOD, "noflood" }, { VIFF_NOTRANSIT, "notransit" }, { VIFF_BLASTER, "blaster" }, { VIFF_FORCE_LEAF, "force_leaf" }, { VIFF_OTUNNEL, "old-tunnel" }, }; static struct vnflags nbrflags[] = { { NBRF_LEAF, "leaf" }, { NBRF_GENID, "have-genid" }, { NBRF_WAITING, "waiting" }, { NBRF_ONEWAY, "one-way" }, { NBRF_TOOOLD, "too old" }, { NBRF_TOOMANYROUTES, "too many routes" }, { NBRF_NOTPRUNING, "not pruning?" }, }; /* * Print the contents of the uvifs array on file 'fp'. */ void dump_vifs(fp) FILE *fp; { register vifi_t vifi; register struct uvif *v; register struct listaddr *a; register struct phaddr *p; register struct vif_acl *acl; int i; struct sioc_vif_req v_req; time_t now; char *label; time(&now); fprintf(fp, "vifs_with_neighbors = %d\n", vifs_with_neighbors); if (vifs_with_neighbors == 1) fprintf(fp,"[This host is a leaf]\n\n"); fprintf(fp, "\nVirtual Interface Table\n%s", "Vif Name Local-Address "); fprintf(fp, "M Thr Rate Flags\n"); for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) { fprintf(fp, "%2u %6s %-15s %6s: %-18s %2u %3u %5u ", vifi, v->uv_name, inet_fmt(v->uv_lcl_addr, s1), (v->uv_flags & VIFF_TUNNEL) ? "tunnel": "subnet", (v->uv_flags & VIFF_TUNNEL) ? inet_fmt(v->uv_rmt_addr, s2) : inet_fmts(v->uv_subnet, v->uv_subnetmask, s3), v->uv_metric, v->uv_threshold, v->uv_rate_limit); for (i = 0; i < sizeof(vifflags) / sizeof(struct vnflags); i++) if (v->uv_flags & vifflags[i].vn_flag) fprintf(fp, " %s", vifflags[i].vn_name); fprintf(fp, "\n"); /* fprintf(fp, " #routes: %d\n", v->uv_nroutes); */ if (v->uv_admetric != 0) fprintf(fp, " advert-metric %2u\n", v->uv_admetric); label = "alternate subnets:"; for (p = v->uv_addrs; p; p = p->pa_next) { fprintf(fp, " %18s %s\n", label, inet_fmts(p->pa_subnet, p->pa_subnetmask, s1)); label = ""; } label = "peers:"; for (a = v->uv_neighbors; a != NULL; a = a->al_next) { fprintf(fp, " %6s %s (%d.%d) [%d]", label, inet_fmt(a->al_addr, s1), a->al_pv, a->al_mv, a->al_index); for (i = 0; i < sizeof(nbrflags) / sizeof(struct vnflags); i++) if (a->al_flags & nbrflags[i].vn_flag) fprintf(fp, " %s", nbrflags[i].vn_name); fprintf(fp, " up %s\n", scaletime(now - a->al_ctime)); /*fprintf(fp, " #routes %d\n", a->al_nroutes);*/ label = ""; } label = "group host (time left):"; for (a = v->uv_groups; a != NULL; a = a->al_next) { fprintf(fp, " %23s %-15s %-15s (%s)\n", label, inet_fmt(a->al_addr, s1), inet_fmt(a->al_reporter, s2), scaletime(timer_leftTimer(a->al_timerid))); label = ""; } label = "boundaries:"; for (acl = v->uv_acl; acl != NULL; acl = acl->acl_next) { fprintf(fp, " %11s %-18s\n", label, inet_fmts(acl->acl_addr, acl->acl_mask, s1)); label = ""; } if (v->uv_filter) { struct vf_element *vfe; char lbuf[100]; sprintf(lbuf, "%5s %7s filter:", v->uv_filter->vf_flags & VFF_BIDIR ? "bidir" : " ", v->uv_filter->vf_type == VFT_ACCEPT ? "accept" : "deny"); label = lbuf; for (vfe = v->uv_filter->vf_filter; vfe != NULL; vfe = vfe->vfe_next) { fprintf(fp, " %23s %-18s%s\n", label, inet_fmts(vfe->vfe_addr, vfe->vfe_mask, s1), vfe->vfe_flags & VFEF_EXACT ? " (exact)" : ""); label = ""; } } if (!(v->uv_flags & (VIFF_TUNNEL|VIFF_DOWN|VIFF_DISABLED))) { fprintf(fp, " IGMP querier: "); if (v->uv_querier == NULL) if (v->uv_flags & VIFF_QUERIER) fprintf(fp, "%-18s (this system)\n", inet_fmt(v->uv_lcl_addr, s1)); else fprintf(fp, "NONE - querier election failure?\n"); else fprintf(fp, "%-18s up %s last heard %s ago\n", inet_fmt(v->uv_querier->al_addr, s1), scaletime(now - v->uv_querier->al_ctime), scaletime(v->uv_querier->al_timer)); } if (v->uv_flags & VIFF_BLASTER) fprintf(fp, " blasterbuf size: %dk\n", v->uv_blasterlen / 1024); fprintf(fp, " Nbr bitmaps: 0x%08lx%08lx\n",/*XXX*/ v->uv_nbrmap.hi, v->uv_nbrmap.lo); if (v->uv_prune_lifetime != 0) fprintf(fp, " Prune Lifetime: %d seconds\n", v->uv_prune_lifetime); v_req.vifi = vifi; if (did_final_init) if (ioctl(udp_socket, SIOCGETVIFCNT, (char *)&v_req) < 0) { log(LOG_WARNING, errno, "SIOCGETVIFCNT fails on vif %d", vifi); } else { fprintf(fp, " pkts/bytes in : %lu/%lu\n", v_req.icount, v_req.ibytes); fprintf(fp, " pkts/bytes out: %lu/%lu\n", v_req.ocount, v_req.obytes); } fprintf(fp, "\n"); } fprintf(fp, "\n"); } /* * Time out record of a group membership on a vif */ static void DelVif(arg) void *arg; { cbk_t *cbk = (cbk_t *)arg; vifi_t vifi = cbk->vifi; struct uvif *v = &uvifs[vifi]; struct listaddr *a, **anp, *g = cbk->g; /* * Group has expired * delete all kernel cache entries with this group */ if (g->al_query) DeleteTimer(g->al_query); delete_lclgrp(vifi, g->al_addr); anp = &(v->uv_groups); while ((a = *anp) != NULL) { if (a == g) { *anp = a->al_next; free((char *)a); } else { anp = &a->al_next; } } free(cbk); } /* * Set a timer to delete the record of a group membership on a vif. */ static int SetTimer(vifi, g) vifi_t vifi; struct listaddr *g; { cbk_t *cbk; cbk = (cbk_t *) malloc(sizeof(cbk_t)); cbk->g = g; cbk->vifi = vifi; return timer_setTimer(g->al_timer, DelVif, cbk); } /* * Delete a timer that was set above. */ static int DeleteTimer(id) int id; { timer_clearTimer(id); return 0; } /* * Send a group-specific query. */ static void SendQuery(arg) void *arg; { cbk_t *cbk = (cbk_t *)arg; register struct uvif *v = &uvifs[cbk->vifi]; send_igmp(v->uv_lcl_addr, cbk->g->al_addr, IGMP_MEMBERSHIP_QUERY, cbk->q_time, cbk->g->al_addr, 0); cbk->g->al_query = 0; free(cbk); } /* * Set a timer to send a group-specific query. */ static int SetQueryTimer(g, vifi, to_expire, q_time) struct listaddr *g; vifi_t vifi; int to_expire, q_time; { cbk_t *cbk; cbk = (cbk_t *) malloc(sizeof(cbk_t)); cbk->g = g; cbk->q_time = q_time; cbk->vifi = vifi; return timer_setTimer(to_expire, SendQuery, cbk); }