/* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgment: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD: src/sbin/routed/if.c,v 1.8 2000/08/11 08:24:38 sheldonh Exp $ */ #include "defs.h" #include "pathnames.h" #include #include #include #include #include #include #include /* linked list of all interfaces */ struct interface *ifnet; /* * Acceptable sizes (in number of interfaces) for the interface hash * tables. These must all be prime. The interface hash tables all * start with a size of hash_table_sizes[0], and increase as needed. */ size_t hash_table_sizes[] = { 67, 131, 257, 521, 1031, 2053, 4099, 0 }; struct htbl { void **htbl_ptrs; uint_t (*htbl_hash)(const void *, size_t); size_t htbl_link_off; /* offset of the linkage structure */ size_t htbl_key_off; /* offset of the key value (rehash) */ size_t htbl_size; /* size of the hash */ uint_t htbl_size_index; uint_t htbl_ifcount; /* count of entries */ boolean_t htbl_grow; /* growth allowed */ }; /* Get first element -- for iteration */ #define HFIRST(htbl, arg) \ ((htbl)->htbl_ptrs[(htbl)->htbl_hash((arg), 0) % (htbl)->htbl_size]) /* Add an element to a hash */ #define HADD(htbl, strp) \ hash_link((htbl), (htbl)->htbl_hash((strp), (htbl)->htbl_key_off), \ (strp)) uint_t tot_interfaces; /* # of remote and local interfaces */ uint_t rip_interfaces; /* # of interfaces doing RIP */ uint_t ripout_interfaces; /* # of interfaces advertising RIP */ uint_t fwd_interfaces; /* # of interfaces ip_forwarding=1 */ static boolean_t foundloopback; /* valid flag for loopaddr */ in_addr_t loopaddr; /* our address on loopback */ static struct rt_spare loop_rts; struct timeval ifscan_timer; static struct timeval last_ifscan; #define IF_RESCAN_DELAY() \ (last_ifscan.tv_sec == now.tv_sec && \ last_ifscan.tv_usec == now.tv_usec && \ timercmp(&ifscan_timer, &now, > /* */)) boolean_t have_ripv1_out; /* have a RIPv1 interface */ static boolean_t have_ripv1_in; static void if_bad(struct interface *, boolean_t); static boolean_t addrouteforif(struct interface *); static int get_if_kstats(struct interface *, struct phyi_data *); static uint_t ahash(const void *, uint_t); static uint_t ihash(const void *, uint_t); static uint_t nhash(const void *, uint_t); static void htbl_grow(struct htbl *); /* * Table of all interfaces, hashed by interface address. For remote * interfaces, the gateway address is used. */ static struct htbl ahash_tbl = { NULL, ahash, offsetof(struct interface, int_ahash), offsetof(struct interface, int_addr), 0, 0, 0, _B_TRUE }; /* * Table of broadcast capable interfaces, hashed by interface broadcast * address. */ static struct htbl bhash_tbl = { NULL, ahash, offsetof(struct interface, int_bhash), offsetof(struct interface, int_brdaddr), 0, 0, 0, _B_TRUE }; /* * Table of physical_interface structures (lists of interfaces by ifIndex), * hashed by interface index. */ static struct htbl ihash_tbl = { NULL, ihash, offsetof(struct physical_interface, phyi_link), offsetof(struct physical_interface, phyi_index), 0, 0, 0, _B_TRUE }; /* * Table of all interfaces, hashed by interface name. */ static struct htbl nhash_tbl = { NULL, nhash, offsetof(struct interface, int_nhash), offsetof(struct interface, int_name), 0, 0, 0, _B_TRUE }; static struct physical_interface dummy_phyi; struct interface dummy_ifp; /* Hash based on an IP address. */ static uint_t ahash(const void *arg, size_t voffs) { /* LINTED */ return ((uint_t)*(const in_addr_t *)((const char *)arg + voffs)); } static uint_t ihash(const void *arg, size_t voffs) { /* LINTED */ return ((uint_t)*(const uint32_t *)((const char *)arg + voffs)); } static uint_t nhash(const void *arg, size_t voffs) { const char *cp = (const char *)arg + voffs; uint_t i; for (i = 0; *cp != '\0'; cp++) { i = ((i<<1) & 0x7fffffff) | ((i>>30) & 0x00000003); i ^= *cp; } return (i); } /* * Add an element to the head of the list. */ static void link_in(void **head, void *strp, size_t loffs) { struct hlinkage *hlp; /* LINTED: alignment known to be good. */ hlp = (struct hlinkage *)((char *)strp + loffs); hlp->hl_prev = head; if ((hlp->hl_next = *head) != NULL) { /* LINTED */ ((struct hlinkage *)((char *)*head + loffs))->hl_prev = &hlp->hl_next; } *head = strp; } /* Remove from a list */ static void link_out(void *strp, size_t loffs) { struct hlinkage *hlp; /* LINTED: alignment known to be good. */ hlp = (struct hlinkage *)((char *)strp + loffs); if ((*hlp->hl_prev = hlp->hl_next) != NULL) { /* LINTED */ ((struct hlinkage *)((char *)hlp->hl_next + loffs))->hl_prev = hlp->hl_prev; } } /* Add to a hash */ static void hash_link(struct htbl *htbl, uint_t hval, void *strp) { void **hep; if (htbl->htbl_grow && htbl->htbl_ifcount >= htbl->htbl_size * 5) htbl_grow(htbl); hep = &htbl->htbl_ptrs[hval % htbl->htbl_size]; link_in(hep, strp, htbl->htbl_link_off); htbl->htbl_ifcount++; } /* Remove from a hash */ static void hash_unlink(struct htbl *htbl, void *strp) { link_out(strp, htbl->htbl_link_off); htbl->htbl_ifcount--; } static void dummy_ifp_init(void) { dummy_phyi.phyi_interface = &dummy_ifp; dummy_ifp.int_phys = &dummy_phyi; (void) strcpy(dummy_phyi.phyi_name, "wildcard"); (void) strcpy(dummy_ifp.int_name, "wildcard"); dummy_ifp.int_dstaddr = dummy_ifp.int_addr = INADDR_NONE; dummy_ifp.int_mask = IP_HOST_MASK; dummy_ifp.int_metric = HOPCNT_INFINITY; dummy_ifp.int_state = (IS_BROKE|IS_PASSIVE|IS_NO_RIP|IS_NO_RDISC); dummy_ifp.int_std_mask = std_mask(dummy_ifp.int_addr); dummy_ifp.int_std_net = dummy_ifp.int_net & dummy_ifp.int_std_mask; dummy_ifp.int_std_addr = htonl(dummy_ifp.int_std_net); } /* allocate the interface hash tables */ void iftbl_alloc(void) { size_t initial_size = hash_table_sizes[0]; errno = 0; ahash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *)); bhash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *)); ihash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *)); nhash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *)); if (errno != 0) BADERR(_B_FALSE, "Unable to allocate interface tables"); ahash_tbl.htbl_size = initial_size; bhash_tbl.htbl_size = initial_size; ihash_tbl.htbl_size = initial_size; nhash_tbl.htbl_size = initial_size; dummy_ifp_init(); } static void htbl_grow(struct htbl *htbl) { void *strp; void **new_ptrs, **saved_old_ptrs, **old_ptrs; size_t new_size, old_size; static uint_t failed_count; if ((new_size = hash_table_sizes[htbl->htbl_size_index + 1]) == 0) return; if ((new_ptrs = calloc(new_size, sizeof (void *))) == NULL) { /* * This is not fatal since we already have a * functional, yet crowded, interface table. */ if (++failed_count % 100 == 1) msglog("%sunable to grow interface hash table: %s", failed_count > 1 ? "Still " : "", rip_strerror(errno)); return; } failed_count = 0; saved_old_ptrs = old_ptrs = htbl->htbl_ptrs; old_size = htbl->htbl_size; htbl->htbl_ptrs = new_ptrs; htbl->htbl_size = new_size; htbl->htbl_size_index++; htbl->htbl_ifcount = 0; /* * Go through the list of structures, and re-link each into * this new table. */ htbl->htbl_grow = _B_FALSE; while (old_size-- > 0) { strp = *old_ptrs++; HADD(htbl, strp); } htbl->htbl_grow = _B_TRUE; free(saved_old_ptrs); } /* Link a new interface into the lists and hash tables. */ void if_link(struct interface *ifp, uint32_t ifindex) { struct physical_interface *phyi; link_in((void **)&ifnet, ifp, offsetof(struct interface, int_link)); HADD(&ahash_tbl, ifp); HADD(&nhash_tbl, ifp); if (ifp->int_if_flags & IFF_BROADCAST) HADD(&bhash_tbl, ifp); if (ifindex != 0) { for (phyi = HFIRST(&ihash_tbl, &ifindex); phyi != NULL; phyi = phyi->phyi_link.hl_next) { if (phyi->phyi_index == ifindex) break; } if (phyi == NULL) { size_t size; phyi = rtmalloc(sizeof (*phyi), "physical_interface"); (void) memset(phyi, 0, sizeof (*phyi)); phyi->phyi_index = ifindex; /* LINTED */ assert(IF_NAME_LEN >= IF_NAMESIZE); size = strcspn(ifp->int_name, ":"); (void) strncpy(phyi->phyi_name, ifp->int_name, size); phyi->phyi_name[size] = '\0'; HADD(&ihash_tbl, phyi); } link_in((void **)&phyi->phyi_interface, ifp, offsetof(struct interface, int_ilist)); ifp->int_phys = phyi; } } /* Find the interface with an address */ struct interface * ifwithaddr(in_addr_t addr, boolean_t bcast, /* notice IFF_BROADCAST address */ boolean_t remote) /* include IS_REMOTE interfaces */ { struct interface *ifp, *possible = NULL; uint32_t remote_state; remote_state = (!remote ? IS_REMOTE : 0); for (ifp = HFIRST(&ahash_tbl, &addr); ifp != NULL; ifp = ifp->int_ahash.hl_next) { if (ifp->int_addr != addr) continue; if (ifp->int_state & remote_state) continue; if (!(ifp->int_state & (IS_BROKE | IS_PASSIVE))) return (ifp); possible = ifp; } if (possible != NULL || !bcast) return (possible); for (ifp = HFIRST(&bhash_tbl, &addr); ifp != NULL; ifp = ifp->int_bhash.hl_next) { if (ifp->int_brdaddr != addr) continue; if (ifp->int_state & remote_state) continue; if (!(ifp->int_state & (IS_BROKE | IS_PASSIVE))) return (ifp); possible = ifp; } return (possible); } /* find the interface with the specified name ("hme0" for example) */ struct interface * ifwithname(const char *name) { struct interface *ifp; for (;;) { for (ifp = HFIRST(&nhash_tbl, name); ifp != NULL; ifp = ifp->int_nhash.hl_next) { if (strcmp(ifp->int_name, name) == 0) return (ifp); } /* * If there is no known interface, maybe there is a * new interface. So just once look for new interfaces. */ if (IF_RESCAN_DELAY()) return (NULL); ifscan(); } } /* Return physical interface with the specified name */ struct physical_interface * phys_byname(const char *name) { int nlen; size_t i; struct physical_interface *phyi; nlen = strcspn(name, ":"); for (i = 0; i < ihash_tbl.htbl_size; i++) { for (phyi = ihash_tbl.htbl_ptrs[i]; phyi != NULL; phyi = phyi->phyi_link.hl_next) { if (strncmp(phyi->phyi_name, name, nlen) == 0 && phyi->phyi_name[nlen] == '\0') return (phyi); } } return (NULL); } struct interface * findremoteif(in_addr_t addr) { struct interface *ifp; for (ifp = HFIRST(&ahash_tbl, &addr); ifp != NULL; ifp = ifp->int_ahash.hl_next) { if ((ifp->int_state & IS_REMOTE) && ifp->int_addr == addr) return (ifp); } return (NULL); } struct interface * findifaddr(in_addr_t addr) { struct interface *ifp; for (ifp = HFIRST(&ahash_tbl, &addr); ifp != NULL; ifp = ifp->int_ahash.hl_next) { if (ifp->int_addr == addr) return (ifp); } return (NULL); } /* * Return the first interface with the given index. */ struct interface * ifwithindex(ulong_t index, boolean_t rescan_ok) { struct physical_interface *phyi; for (;;) { for (phyi = HFIRST(&ihash_tbl, &index); phyi != NULL; phyi = phyi->phyi_link.hl_next) { if (phyi->phyi_index == index) return (phyi->phyi_interface); } /* * If there is no known interface, maybe there is a * new interface. So just once look for new interfaces. */ if (!rescan_ok || IF_RESCAN_DELAY()) return (NULL); rescan_ok = _B_FALSE; ifscan(); } } /* * Returns true only if given ifp has the exact address else returns * false and sets best if an ifp matches partially and is a better * match than the previous one passed via best. */ boolean_t addr_on_ifp(in_addr_t addr, struct interface *ifp, struct interface **best) { struct interface *p_best = *best; /* * Don't use a duplicate interface since it is unusable for output. */ if (ifp->int_state & IS_DUP) return (_B_FALSE); if (ifp->int_if_flags & IFF_POINTOPOINT) { if (ifp->int_dstaddr == addr) { *best = NULL; return (_B_TRUE); } } else { if (ifp->int_addr == addr) { if (IS_PASSIVE_IFP(ifp)) trace_misc("addr_on_ifp " "returning passive intf %s", ifp->int_name); *best = NULL; return (_B_TRUE); } /* Look for the longest approximate match. */ if (on_net(addr, ifp->int_net, ifp->int_mask) && (p_best == NULL || ifp->int_mask > p_best->int_mask)) { *best = ifp; } } return (_B_FALSE); } /* * Find an interface which should be receiving packets sent from the * given address. Used as a last ditch effort for figuring out which * interface a packet came in on. Also used for finding out which * interface points towards the gateway of static routes learned from * the kernel. */ struct interface * iflookup(in_addr_t addr) { struct interface *ifp, *maybe; maybe = NULL; for (;;) { for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { /* Exact match found */ if (addr_on_ifp(addr, ifp, &maybe)) return (ifp); } /* * If there is no known interface, maybe there is a * new interface. So just once look for new interfaces. */ if (maybe == NULL && !IF_RESCAN_DELAY()) ifscan(); else break; } if (maybe != NULL && IS_PASSIVE_IFP(maybe)) { trace_misc("iflookup returning passive intf %s", maybe->int_name); } return (maybe); } /* * Find the netmask that would be inferred by RIPv1 listeners * on the given interface for a given network. * If no interface is specified, look for the best fitting interface. */ in_addr_t ripv1_mask_net(in_addr_t addr, /* in network byte order */ const struct interface *ifp) /* as seen on this interface */ { const struct r1net *r1p; in_addr_t mask = 0; if (addr == 0) /* default always has 0 mask */ return (mask); if (ifp != NULL && ifp->int_ripv1_mask != HOST_MASK) { /* * If the target network is that of the associated interface * on which it arrived, then use the netmask of the interface. */ if (on_net(addr, ifp->int_net, ifp->int_std_mask)) mask = ifp->int_ripv1_mask; } else { /* * Examine all interfaces, and if it the target seems * to have the same network number of an interface, use the * netmask of that interface. If there is more than one * such interface, prefer the interface with the longest * match. */ for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { if (on_net(addr, ifp->int_std_net, ifp->int_std_mask) && ifp->int_ripv1_mask > mask && ifp->int_ripv1_mask != HOST_MASK) mask = ifp->int_ripv1_mask; } } if (mask == 0) { /* * Check to see if the user has supplied an applicable * netmask as a ripv1_mask option in /etc/gateways. */ for (r1p = r1nets; r1p != NULL; r1p = r1p->r1net_next) { /* * If the address is is on a matching network * and we haven't already found a longer match, * use the matching netmask. */ if (on_net(addr, r1p->r1net_net, r1p->r1net_match) && r1p->r1net_mask > mask) mask = r1p->r1net_mask; } /* Otherwise, make the classic A/B/C guess. */ if (mask == 0) mask = std_mask(addr); } return (mask); } in_addr_t ripv1_mask_host(in_addr_t addr, /* in network byte order */ const struct interface *ifp) /* as seen on this interface */ { in_addr_t mask = ripv1_mask_net(addr, ifp); /* * If the computed netmask does not mask all of the set bits * in the address, then assume it is a host address */ if ((ntohl(addr) & ~mask) != 0) mask = HOST_MASK; return (mask); } /* See if a IP address looks reasonable as a destination */ boolean_t /* _B_FALSE=bad _B_TRUE=good */ check_dst(in_addr_t addr) { addr = ntohl(addr); if (IN_CLASSA(addr)) { if (addr == 0) return (_B_TRUE); /* default */ addr >>= IN_CLASSA_NSHIFT; return (addr != 0 && addr != IN_LOOPBACKNET); } /* Must not allow destination to be link local address. */ if (IN_LINKLOCAL(addr)) return (_B_FALSE); if (IN_CLASSB(addr) || IN_CLASSC(addr)) return (_B_TRUE); if (IN_CLASSD(addr)) return (_B_FALSE); return (_B_TRUE); } /* * Find an existing interface which has the given parameters, but don't * return the interface with name "name" if "name" is specified. */ struct interface * check_dup(const char *name, /* Don't return this interface */ in_addr_t addr, /* IP address, so network byte order */ in_addr_t dstaddr, /* ditto */ in_addr_t mask, /* mask, so host byte order */ uint64_t if_flags, /* set IFF_POINTOPOINT to ignore local int_addr */ boolean_t allowdups) /* set true to include duplicates */ { struct interface *best_ifp = NULL; struct interface *ifp; in_addr_t dstaddr_h = ntohl(dstaddr); int best_pref = 0; int pref; for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { /* This interface, not a duplicate. */ if (name != NULL && strcmp(name, ifp->int_name) == 0) continue; /* * Find an interface which isn't already a duplicate to * avoid cyclical duplication. (i.e. qfe0:1 is a duplicate * of qfe0, and qfe0 is a duplicate of qfe0:1. That would * be bad) */ if (!allowdups && (ifp->int_state & IS_DUP)) continue; if (ifp->int_mask != mask) continue; if (!IS_IFF_UP(ifp->int_if_flags)) continue; /* * The local address can only be shared with a point-to-point * link. */ if ((ifp->int_addr == addr && ((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0) || on_net(ifp->int_dstaddr, dstaddr_h, mask)) { pref = 0; if (!(ifp->int_state & IS_ALIAS)) pref++; if (!IS_RIP_OUT_OFF(ifp->int_state)) pref += 2; if (IS_IFF_ROUTING(ifp->int_if_flags)) pref += 4; if (pref > best_pref) { best_pref = pref; best_ifp = ifp; } } } return (best_ifp); } /* * See that a remote gateway is reachable. * Note that the answer can change as real interfaces come and go. */ boolean_t /* _B_FALSE=bad _B_TRUE=good */ check_remote(struct interface *ifp) { struct rt_entry *rt; /* do not worry about other kinds */ if (!(ifp->int_state & IS_REMOTE)) return (_B_TRUE); rt = rtfind(ifp->int_addr); if (rt != NULL && rt->rt_ifp != NULL && on_net(ifp->int_addr, rt->rt_ifp->int_net, rt->rt_ifp->int_mask)) { return (_B_TRUE); } /* * the gateway cannot be reached directly from one of our * interfaces */ if (!(ifp->int_state & IS_BROKE)) { msglog("unreachable gateway %s in "PATH_GATEWAYS, naddr_ntoa(ifp->int_addr)); if_bad(ifp, _B_FALSE); } return (_B_FALSE); } /* Delete an interface. */ static void ifdel(struct interface *ifp) { struct rewire_data wire; boolean_t resurrected; struct physical_interface *phyi; trace_if("Del", ifp); ifp->int_state |= IS_BROKE; /* unlink the interface */ link_out(ifp, offsetof(struct interface, int_link)); hash_unlink(&ahash_tbl, ifp); hash_unlink(&nhash_tbl, ifp); if (ifp->int_if_flags & IFF_BROADCAST) hash_unlink(&bhash_tbl, ifp); /* Remove from list of interfaces with this ifIndex */ if ((phyi = ifp->int_phys) != NULL) { link_out(ifp, offsetof(struct interface, int_ilist)); if (phyi->phyi_interface == NULL) { hash_unlink(&ihash_tbl, phyi); free(phyi); } } /* * If this is a lead interface, then check first for * duplicates of this interface with an eye towards promoting * one of them. */ resurrected = _B_FALSE; if (!(ifp->int_state & IS_DUP) && (wire.if_new = check_dup(ifp->int_name, ifp->int_addr, ifp->int_dstaddr, ifp->int_mask, ifp->int_if_flags, _B_TRUE)) != NULL && !IS_IFF_QUIET(wire.if_new->int_if_flags)) { trace_act("promoting duplicate %s in place of %s", wire.if_new->int_name, ifp->int_name); /* Rewire routes with the replacement interface */ wire.if_old = ifp; wire.metric_delta = wire.if_new->int_metric - ifp->int_metric; (void) rn_walktree(rhead, walk_rewire, &wire); kern_rewire_ifp(wire.if_old, wire.if_new); if_rewire_rdisc(wire.if_old, wire.if_new); /* Mark the replacement as being no longer a duplicate */ wire.if_new->int_state &= ~IS_DUP; tot_interfaces++; if (!IS_RIP_OFF(wire.if_new->int_state)) rip_interfaces++; if (!IS_RIP_OUT_OFF(wire.if_new->int_state)) ripout_interfaces++; if (IS_IFF_ROUTING(wire.if_new->int_if_flags)) fwd_interfaces++; set_rdisc_mg(wire.if_new, 1); rip_mcast_on(wire.if_new); /* We came out ok; no need to clobber routes over this. */ resurrected = _B_TRUE; } rip_mcast_off(ifp); if (rip_sock_interface == ifp) rip_sock_interface = NULL; set_rdisc_mg(ifp, 0); /* * Note that duplicates are not counted in the total number of * interfaces. */ if (!(ifp->int_state & IS_DUP) && !IS_IFF_QUIET(ifp->int_if_flags)) { tot_interfaces--; if (!IS_RIP_OFF(ifp->int_state)) rip_interfaces--; if (!IS_RIP_OUT_OFF(ifp->int_state)) ripout_interfaces--; if (IS_IFF_ROUTING(ifp->int_if_flags)) fwd_interfaces--; } if (!resurrected) { /* * Zap all routes associated with this interface. * Assume routes just using gateways beyond this interface * will timeout naturally, and have probably already died. */ (void) rn_walktree(rhead, walk_bad, ifp); kern_flush_ifp(ifp); if_bad_rdisc(ifp); } free(ifp); } /* Mark an interface ill. */ void if_sick(struct interface *ifp, boolean_t recurse) { struct interface *ifp1; if (0 == (ifp->int_state & (IS_SICK | IS_BROKE))) { ifp->int_state |= IS_SICK; ifp->int_act_time = NEVER; trace_if("Chg", ifp); LIM_SEC(ifscan_timer, now.tv_sec+CHECK_BAD_INTERVAL); if (recurse && ifp->int_phys != NULL) { /* If an interface is sick, so are its aliases. */ for (ifp1 = ifp->int_phys->phyi_interface; ifp1 != NULL; ifp1 = ifp1->int_ilist.hl_next) { if (ifp1 != ifp) if_sick(ifp1, _B_FALSE); } } } } /* Mark an interface dead. */ static void if_bad(struct interface *ifp, boolean_t recurse) { struct interface *ifp1; struct rewire_data wire; if (ifp->int_state & IS_BROKE) return; LIM_SEC(ifscan_timer, now.tv_sec+CHECK_BAD_INTERVAL); ifp->int_state |= (IS_BROKE | IS_SICK); ifp->int_act_time = NEVER; ifp->int_query_time = NEVER; /* Note: don't reset the stats timestamp here */ trace_if("Chg", ifp); if (recurse && ifp->int_phys != NULL) { /* If an interface is bad, so are its aliases. */ for (ifp1 = ifp->int_phys->phyi_interface; ifp1 != NULL; ifp1 = ifp1->int_ilist.hl_next) { if (ifp1 != ifp) if_bad(ifp1, _B_FALSE); } } /* If we can find a replacement, then pick it up. */ if (!(ifp->int_state & IS_DUP) && (wire.if_new = check_dup(ifp->int_name, ifp->int_addr, ifp->int_dstaddr, ifp->int_mask, ifp->int_if_flags, _B_TRUE)) != NULL && !IS_IFF_QUIET(wire.if_new->int_if_flags)) { trace_act("promoting duplicate %s in place of %s", wire.if_new->int_name, ifp->int_name); wire.if_old = ifp; wire.metric_delta = wire.if_new->int_metric - ifp->int_metric; (void) rn_walktree(rhead, walk_rewire, &wire); if_rewire_rdisc(wire.if_old, wire.if_new); /* The broken guy becomes the duplicate */ wire.if_new->int_state &= ~IS_DUP; set_rdisc_mg(ifp, 0); rip_mcast_off(ifp); ifp->int_state |= IS_DUP; /* join the mcast groups for the replacement */ set_rdisc_mg(wire.if_new, 1); rip_mcast_on(wire.if_new); if (rip_sock_interface == ifp) rip_sock_interface = NULL; } else { (void) rn_walktree(rhead, walk_bad, ifp); if_bad_rdisc(ifp); } } /* Mark an interface alive */ void if_ok(struct interface *ifp, const char *type, boolean_t recurse) { struct interface *ifp1; boolean_t wasbroken = _B_FALSE; if (ifp->int_state & IS_BROKE) { writelog(LOG_WARNING, "%sinterface %s to %s restored", type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr)); ifp->int_state &= ~(IS_BROKE | IS_SICK); wasbroken = _B_TRUE; } else if (ifp->int_state & IS_SICK) { trace_act("%sinterface %s to %s working better", type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr)); ifp->int_state &= ~IS_SICK; } if (recurse && ifp->int_phys != NULL && IS_IFF_UP(ifp->int_if_flags)) { ifp->int_phys->phyi_data.ts = 0; /* Also mark all aliases of this interface as ok */ for (ifp1 = ifp->int_phys->phyi_interface; ifp1 != NULL; ifp1 = ifp1->int_ilist.hl_next) { if (ifp1 != ifp) if_ok(ifp1, type, _B_FALSE); } } if (wasbroken) { if (!(ifp->int_state & IS_DUP)) if_ok_rdisc(ifp); if (ifp->int_state & IS_REMOTE) (void) addrouteforif(ifp); } } boolean_t remote_address_ok(struct interface *ifp, in_addr_t addr) { if (ifp->int_if_flags & IFF_POINTOPOINT) { if (addr == ifp->int_dstaddr) return (_B_TRUE); } else if (on_net(addr, ifp->int_net, ifp->int_mask)) { return (_B_TRUE); } return (_B_FALSE); } /* * Find the network interfaces which have configured themselves. * This must be done regularly, if only for extra addresses * that come and go on interfaces. */ void ifscan(void) { uint_t complaints = 0; static uint_t prev_complaints = 0; #define COMP_BADADDR 0x001 #define COMP_NODST 0x002 #define COMP_NOBADDR 0x004 #define COMP_NOMASK 0x008 #define COMP_BAD_METRIC 0x010 #define COMP_NETMASK 0x020 #define COMP_NO_INDEX 0x040 #define COMP_BAD_FLAGS 0x080 #define COMP_NO_KSTATS 0x100 #define COMP_IPFORWARD 0x200 struct interface ifs, *ifp, *ifp1; struct rt_entry *rt; size_t needed; static size_t lastneeded = 0; char *buf; static char *lastbuf = NULL; int32_t in, ierr, out, oerr; struct intnet *intnetp; int sock; struct lifnum lifn; struct lifconf lifc; struct lifreq *lifrp, *lifrp_lim; struct sockaddr_in *sinp; in_addr_t haddr; static in_addr_t myaddr = 0; uint32_t ifindex; struct phyi_data newstats; struct physical_interface *phyi; last_ifscan = now; ifscan_timer.tv_sec = now.tv_sec + (supplier || tot_interfaces != 1 ? CHECK_ACT_INTERVAL : CHECK_QUIET_INTERVAL); /* mark all interfaces so we can get rid of those that disappear */ for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) ifp->int_state &= ~IS_CHECKED; /* Fetch the size of the current interface list */ if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) BADERR(_B_TRUE, "ifscan: socket(SOCK_DGRAM)"); lifn.lifn_family = AF_INET; /* Only count IPv4 interfaces */ /* * Include IFF_NOXMIT interfaces. Such interfaces are exluded * from protocol operations, but their inclusion in the * internal table enables us to know when packets arrive on * such interfaces. */ lifn.lifn_flags = LIFC_NOXMIT; calculate_lifc_len: if (ioctl(sock, SIOCGLIFNUM, &lifn) == -1) { BADERR(_B_TRUE, "ifscan: ioctl(SIOCGLIFNUM)"); } /* * When calculating the buffer size needed, add a small number * of interfaces to those we counted. We do this to capture * the interface status of potential interfaces which may have * been plumbed between the SIOCGLIFNUM and the SIOCGLIFCONF. * Try to reuse the buffer we already have to avoid heap * thrash. */ needed = (lifn.lifn_count + 4) * sizeof (struct lifreq); if (needed > lastneeded || needed < lastneeded/2) { if (lastbuf != NULL) free(lastbuf); if ((buf = malloc(needed)) == NULL) { lastbuf = NULL; msglog("ifscan: malloc: %s", rip_strerror(errno)); return; } } else { buf = lastbuf; } lastbuf = buf; lastneeded = needed; /* Get the list */ lifc.lifc_family = AF_INET; /* We only need IPv4 interfaces */ lifc.lifc_flags = LIFC_NOXMIT; lifc.lifc_len = needed; lifc.lifc_buf = buf; if (ioctl(sock, SIOCGLIFCONF, &lifc) == -1) { /* * IP returns EINVAL if the lifc_len we passed in is * too small. If that's the case, we need to go back * and recalculate it. */ if (errno == EINVAL) goto calculate_lifc_len; BADERR(_B_TRUE, "ifscan: ioctl(SIOCGLIFCONF)"); } /* * If the returned lifc_len is within one lifreq of the * requested ammount, we may have used a buffer which * was too small to hold all of the interfaces. In that * case go back and recalculate needed. */ if (lifc.lifc_len >= needed - sizeof (struct lifreq)) goto calculate_lifc_len; lifrp = lifc.lifc_req; lifrp_lim = lifrp + lifc.lifc_len / sizeof (*lifrp); for (; lifrp < lifrp_lim; lifrp++) { (void) memset(&ifs, 0, sizeof (ifs)); (void) strlcpy(ifs.int_name, lifrp->lifr_name, sizeof (ifs.int_name)); /* SIOCGLIFCONF fills in the lifr_addr of each lifreq */ ifs.int_addr = ((struct sockaddr_in *)&lifrp->lifr_addr)-> sin_addr.s_addr; if (ioctl(sock, SIOCGLIFFLAGS, lifrp) == -1) { if (!(prev_complaints & COMP_BAD_FLAGS)) writelog(LOG_NOTICE, "unable to get interface flags for %s: %s", ifs.int_name, rip_strerror(errno)); complaints |= COMP_BAD_FLAGS; ifs.int_if_flags = 0; } else { ifs.int_if_flags = lifrp->lifr_flags; } if (IN_CLASSD(ntohl(ifs.int_addr)) || (ntohl(ifs.int_addr) & IN_CLASSA_NET) == 0) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_BADADDR)) writelog(LOG_NOTICE, "%s has a bad address %s", ifs.int_name, naddr_ntoa(ifs.int_addr)); complaints |= COMP_BADADDR; } continue; } /* Ignore interface with IPv4 link local address. */ if (IN_LINKLOCAL(ntohl(ifs.int_addr))) continue; /* Get the interface index. */ if (ioctl(sock, SIOCGLIFINDEX, lifrp) == -1) { ifindex = 0; ifs.int_if_flags &= ~IFF_UP; if (!(prev_complaints & COMP_NO_INDEX)) writelog(LOG_NOTICE, "%s has no ifIndex: %s", ifs.int_name, rip_strerror(errno)); complaints |= COMP_NO_INDEX; } else { ifindex = lifrp->lifr_index; } /* * Get the destination address for point-to-point * interfaces. */ if (ifs.int_if_flags & IFF_POINTOPOINT) { sinp = (struct sockaddr_in *)&lifrp->lifr_dstaddr; if (ioctl(sock, SIOCGLIFDSTADDR, lifrp) == -1) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_NODST)) writelog(LOG_NOTICE, "%s has no destination " "address : %s", ifs.int_name, rip_strerror(errno)); complaints |= COMP_NODST; } continue; } ifs.int_net = ntohl(sinp->sin_addr.s_addr); if (IN_CLASSD(ntohl(ifs.int_net)) || (ifs.int_net != 0 && (ifs.int_net & IN_CLASSA_NET) == 0)) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_NODST)) writelog(LOG_NOTICE, "%s has a bad " "destination address %s", ifs.int_name, naddr_ntoa(ifs.int_net)); complaints |= COMP_NODST; } continue; } ifs.int_dstaddr = sinp->sin_addr.s_addr; } /* Get the subnet mask */ sinp = (struct sockaddr_in *)&lifrp->lifr_addr; if (ioctl(sock, SIOCGLIFNETMASK, lifrp) == -1) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_NOMASK)) writelog(LOG_NOTICE, "%s has no netmask: %s", ifs.int_name, rip_strerror(errno)); complaints |= COMP_NOMASK; } continue; } if (sinp->sin_addr.s_addr == INADDR_ANY) { if (!(ifs.int_if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK))) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_NOMASK)) writelog(LOG_NOTICE, "%s has all-zero netmask", ifs.int_name); complaints |= COMP_NOMASK; } continue; } ifs.int_mask = IP_HOST_MASK; } else { ifs.int_mask = ntohl(sinp->sin_addr.s_addr); } /* * Get the broadcast address on broadcast capable * interfaces. */ if (ifs.int_if_flags & IFF_BROADCAST) { if (ioctl(sock, SIOCGLIFBRDADDR, lifrp) == -1) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_NOBADDR)) writelog(LOG_NOTICE, "%s has no broadcast " "address: %s", ifs.int_name, rip_strerror(errno)); complaints |= COMP_NOBADDR; } continue; } haddr = ntohl(sinp->sin_addr.s_addr); if (IN_CLASSD(haddr) || (haddr & IN_CLASSA_NET) == 0) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_NOBADDR)) writelog(LOG_NOTICE, "%s has a bad broadcast " "address %s", ifs.int_name, naddr_ntoa(haddr)); complaints |= COMP_NOBADDR; } continue; } } ifs.int_brdaddr = sinp->sin_addr.s_addr; /* Get interface metric, if possible. */ if (ioctl(sock, SIOCGLIFMETRIC, lifrp) == -1) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_BAD_METRIC)) writelog(LOG_NOTICE, "%s has no metric: %s", ifs.int_name, rip_strerror(errno)); complaints |= COMP_BAD_METRIC; } } else { ifs.int_metric = lifrp->lifr_metric; if (ifs.int_metric > HOPCNT_INFINITY) { if (IS_IFF_UP(ifs.int_if_flags)) { if (!(prev_complaints & COMP_BAD_METRIC)) writelog(LOG_NOTICE, "%s has a metric of %d, " "defaulting to %d", ifs.int_name, ifs.int_metric, HOPCNT_INFINITY); complaints |= COMP_BAD_METRIC; } ifs.int_metric = HOPCNT_INFINITY; } } ifs.int_state |= IS_CHECKED; ifs.int_query_time = NEVER; /* * If this is an alias, then mark it appropriately. * Do not output RIP or Router-Discovery packets via * aliases. */ if (strchr(ifs.int_name, ':') != NULL) ifs.int_state |= IS_ALIAS; if (ifs.int_if_flags & IFF_LOOPBACK) { ifs.int_state |= IS_PASSIVE | IS_NO_RIP | IS_NO_RDISC; ifs.int_dstaddr = ifs.int_addr; ifs.int_mask = HOST_MASK; ifs.int_ripv1_mask = HOST_MASK; ifs.int_std_mask = std_mask(ifs.int_dstaddr); ifs.int_net = ntohl(ifs.int_dstaddr); if (!foundloopback) { foundloopback = _B_TRUE; loopaddr = ifs.int_addr; loop_rts.rts_gate = loopaddr; loop_rts.rts_router = loopaddr; } } else if (ifs.int_if_flags & IFF_POINTOPOINT) { ifs.int_ripv1_mask = ifs.int_mask; ifs.int_mask = HOST_MASK; ifs.int_std_mask = std_mask(ifs.int_dstaddr); } else { ifs.int_dstaddr = ifs.int_addr; ifs.int_ripv1_mask = ifs.int_mask; ifs.int_std_mask = std_mask(ifs.int_addr); ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask; if (ifs.int_mask != ifs.int_std_mask) ifs.int_state |= IS_SUBNET; } ifs.int_std_net = ifs.int_net & ifs.int_std_mask; ifs.int_std_addr = htonl(ifs.int_std_net); /* * If this interface duplicates another, mark it * appropriately so that we don't generate duplicate * packets. */ ifp = check_dup(ifs.int_name, ifs.int_addr, ifs.int_dstaddr, ifs.int_mask, ifs.int_if_flags, _B_FALSE); if (ifp != NULL) { trace_misc("%s (%s%s%s) is a duplicate of %s (%s%s%s)", ifs.int_name, addrname(ifs.int_addr, ifs.int_mask, 1), ((ifs.int_if_flags & IFF_POINTOPOINT) ? "-->" : ""), ((ifs.int_if_flags & IFF_POINTOPOINT) ? naddr_ntoa(ifs.int_dstaddr) : ""), ifp->int_name, addrname(ifp->int_addr, ifp->int_mask, 1), ((ifp->int_if_flags & IFF_POINTOPOINT) ? "-->" : ""), ((ifp->int_if_flags & IFF_POINTOPOINT) ? naddr_ntoa(ifp->int_dstaddr) : "")); ifs.int_state |= IS_DUP; } else { ifs.int_state &= ~IS_DUP; } /* * See if this is a familiar interface. * If so, stop worrying about it if it is the same. * Start it over if it now is to somewhere else, as happens * frequently with PPP and SLIP, or if its forwarding * status has changed. */ ifp = ifwithname(ifs.int_name); if (ifp != NULL) { ifp->int_state |= IS_CHECKED; ifp->int_state = (ifp->int_state & ~IS_DUP) | (ifs.int_state & IS_DUP); if ((ifp->int_phys == NULL && ifindex != 0) || (ifp->int_phys != NULL && ifp->int_phys->phyi_index != ifindex) || 0 != ((ifp->int_if_flags ^ ifs.int_if_flags) & (IFF_BROADCAST | IFF_LOOPBACK | IFF_POINTOPOINT | IFF_MULTICAST | IFF_ROUTER | IFF_NORTEXCH | IFF_NOXMIT)) || ifp->int_addr != ifs.int_addr || ifp->int_brdaddr != ifs.int_brdaddr || ifp->int_dstaddr != ifs.int_dstaddr || ifp->int_mask != ifs.int_mask || ifp->int_metric != ifs.int_metric) { /* * Forget old information about * a changed interface. */ trace_act("interface %s has changed", ifp->int_name); ifdel(ifp); ifp = NULL; } } if (ifp != NULL) { /* note interfaces that have been turned off */ if (!IS_IFF_UP(ifs.int_if_flags)) { if (IS_IFF_UP(ifp->int_if_flags)) { writelog(LOG_WARNING, "interface %s to %s turned off", ifp->int_name, naddr_ntoa(ifp->int_dstaddr)); if_bad(ifp, _B_FALSE); ifp->int_if_flags &= ~IFF_UP; } else if (ifp->int_phys != NULL && now.tv_sec > (ifp->int_phys->phyi_data.ts + CHECK_BAD_INTERVAL)) { trace_act("interface %s has been off" " %ld seconds; forget it", ifp->int_name, now.tv_sec - ifp->int_phys->phyi_data.ts); ifdel(ifp); } continue; } /* or that were off and are now ok */ if (!IS_IFF_UP(ifp->int_if_flags)) { ifp->int_if_flags |= IFF_UP; if_ok(ifp, "", _B_FALSE); } /* * If it has been long enough, * see if the interface is broken. */ if ((phyi = ifp->int_phys) == NULL || now.tv_sec < phyi->phyi_data.ts + CHECK_BAD_INTERVAL) continue; (void) memset(&newstats, 0, sizeof (newstats)); if (get_if_kstats(ifp, &newstats) == -1) { if (!(prev_complaints & COMP_NO_KSTATS)) writelog(LOG_WARNING, "unable to obtain kstats for %s", phyi->phyi_name); complaints |= COMP_NO_KSTATS; } /* * If the interface just awoke, restart the counters. */ if (phyi->phyi_data.ts == 0) { phyi->phyi_data = newstats; continue; } in = newstats.ipackets - phyi->phyi_data.ipackets; ierr = newstats.ierrors - phyi->phyi_data.ierrors; out = newstats.opackets - phyi->phyi_data.opackets; oerr = newstats.oerrors - phyi->phyi_data.oerrors; phyi->phyi_data = newstats; /* * Withhold judgment when the short error counters * wrap, the interface is reset, or if there are * no kstats. */ if (ierr < 0 || in < 0 || oerr < 0 || out < 0 || newstats.ts == 0) { LIM_SEC(ifscan_timer, now.tv_sec + CHECK_BAD_INTERVAL); continue; } /* Withhold judgement when there is no traffic */ if (in == 0 && out == 0 && ierr == 0 && oerr == 0) continue; /* * It is bad if at least 25% of input or output on * an interface results in errors. Require * presistent problems before marking it dead. */ if ((ierr > 0 && ierr >= in/4) || (oerr > 0 && oerr >= out/4)) { if (!(ifp->int_state & IS_SICK)) { trace_act("interface %s to %s" " sick: in=%d ierr=%d" " out=%d oerr=%d", ifp->int_name, naddr_ntoa(ifp->int_dstaddr), in, ierr, out, oerr); if_sick(ifp, _B_TRUE); continue; } if (!(ifp->int_state & IS_BROKE)) { writelog(LOG_WARNING, "interface %s to %s broken:" " in=%d ierr=%d out=%d oerr=%d", ifp->int_name, naddr_ntoa(ifp->int_dstaddr), in, ierr, out, oerr); if_bad(ifp, _B_TRUE); } continue; } /* otherwise, it is active and healthy */ ifp->int_act_time = now.tv_sec; if_ok(ifp, "", _B_TRUE); continue; } /* * This is a new interface. * If it is dead, forget it. */ if (!IS_IFF_UP(ifs.int_if_flags)) continue; if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT | IFF_BROADCAST | IFF_LOOPBACK)) && !(ifs.int_state & IS_PASSIVE)) { if (!(prev_complaints & COMP_BAD_FLAGS)) trace_act("%s is neither broadcast, " "point-to-point, nor loopback", ifs.int_name); complaints |= COMP_BAD_FLAGS; if (!(ifs.int_if_flags & IFF_MULTICAST)) ifs.int_state |= IS_NO_RDISC; } /* * It is new and ok. Add it to the list of interfaces */ ifp = rtmalloc(sizeof (*ifp), "ifscan ifp"); (void) memcpy(ifp, &ifs, sizeof (*ifp)); get_parms(ifp); if_link(ifp, ifindex); trace_if("Add", ifp); if (ifp->int_phys != NULL && get_if_kstats(ifp, &ifp->int_phys->phyi_data) == -1) { if (!(prev_complaints & COMP_NO_KSTATS)) writelog(LOG_NOTICE, "unable to obtain kstats for %s", ifp->int_phys->phyi_name); complaints |= COMP_NO_KSTATS; } /* Detect interfaces that have conflicting netmasks. */ if (!(ifp->int_if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK))) { for (ifp1 = ifnet; ifp1 != NULL; ifp1 = ifp1->int_next) { if (ifp1->int_mask == ifp->int_mask) continue; /* * we don't care about point-to-point * or loopback aliases */ if (ifp1->int_if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) { continue; } /* ignore aliases on the same network */ if (ifp->int_phys == ifp1->int_phys) continue; if (on_net(ifp->int_addr, ifp1->int_net, ifp1->int_mask) || on_net(ifp1->int_addr, ifp->int_net, ifp->int_mask)) { writelog(LOG_INFO, "possible netmask problem" " between %s:%s and %s:%s", ifp->int_name, addrname(htonl(ifp->int_net), ifp->int_mask, 1), ifp1->int_name, addrname(htonl(ifp1->int_net), ifp1->int_mask, 1)); complaints |= COMP_NETMASK; } } } if (!(ifp->int_state & IS_DUP) && !IS_IFF_QUIET(ifp->int_if_flags)) { /* Count the # of directly connected networks. */ tot_interfaces++; if (!IS_RIP_OFF(ifp->int_state)) rip_interfaces++; if (!IS_RIP_OUT_OFF(ifp->int_state)) ripout_interfaces++; if (IS_IFF_ROUTING(ifp->int_if_flags)) fwd_interfaces++; if_ok_rdisc(ifp); rip_on(ifp); } } (void) close(sock); /* * If we are multi-homed and have at least two interfaces that * are able to forward, then output RIP by default. */ if (!supplier_set) set_supplier(); /* * If we are multi-homed, optionally advertise a route to * our main address. */ if (advertise_mhome || (tot_interfaces > 1 && mhome)) { /* lookup myaddr if we haven't done so already */ if (myaddr == 0) { char myname[MAXHOSTNAMELEN+1]; /* * If we are unable to resolve our hostname, don't * bother trying again. */ if (gethostname(myname, MAXHOSTNAMELEN) == -1) { msglog("gethostname: %s", rip_strerror(errno)); advertise_mhome = _B_FALSE; mhome = _B_FALSE; } else if (gethost(myname, &myaddr) == 0) { writelog(LOG_WARNING, "unable to resolve local hostname %s", myname); advertise_mhome = _B_FALSE; mhome = _B_FALSE; } } if (myaddr != 0 && (ifp = ifwithaddr(myaddr, _B_FALSE, _B_FALSE)) != NULL && foundloopback) { advertise_mhome = _B_TRUE; rt = rtget(myaddr, HOST_MASK); if (rt != NULL) { if (rt->rt_ifp != ifp || rt->rt_router != loopaddr) { rtdelete(rt); rt = NULL; } else { loop_rts.rts_ifp = ifp; loop_rts.rts_metric = 0; loop_rts.rts_time = rt->rt_time; loop_rts.rts_origin = RO_LOOPBCK; rtchange(rt, rt->rt_state | RS_MHOME, &loop_rts, NULL); } } if (rt == NULL) { loop_rts.rts_ifp = ifp; loop_rts.rts_metric = 0; loop_rts.rts_origin = RO_LOOPBCK; rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts); } } } for (ifp = ifnet; ifp != NULL; ifp = ifp1) { ifp1 = ifp->int_next; /* because we may delete it */ /* Forget any interfaces that have disappeared. */ if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) { trace_act("interface %s has disappeared", ifp->int_name); ifdel(ifp); continue; } if ((ifp->int_state & IS_BROKE) && !(ifp->int_state & IS_PASSIVE)) LIM_SEC(ifscan_timer, now.tv_sec+CHECK_BAD_INTERVAL); /* * If we ever have a RIPv1 interface, assume we always will. * It might come back if it ever goes away. */ if (!(ifp->int_state & (IS_NO_RIPV1_OUT | IS_DUP)) && should_supply(ifp)) have_ripv1_out = _B_TRUE; if (!(ifp->int_state & IS_NO_RIPV1_IN)) have_ripv1_in = _B_TRUE; } for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) { /* * Ensure there is always a network route for interfaces, * after any dead interfaces have been deleted, which * might affect routes for point-to-point links. */ if (addrouteforif(ifp) == 0) continue; /* * Add routes to the local end of point-to-point interfaces * using loopback. */ if ((ifp->int_if_flags & IFF_POINTOPOINT) && !(ifp->int_state & IS_REMOTE) && foundloopback) { /* * Delete any routes to the network address through * foreign routers. Remove even static routes. */ del_static(ifp->int_addr, HOST_MASK, 0, ifp, 0); rt = rtget(ifp->int_addr, HOST_MASK); if (rt != NULL && rt->rt_router != loopaddr) { rtdelete(rt); rt = NULL; } if (rt != NULL) { if (!(rt->rt_state & RS_LOCAL) || rt->rt_metric > ifp->int_metric) { ifp1 = ifp; } else { ifp1 = rt->rt_ifp; } loop_rts.rts_ifp = ifp1; loop_rts.rts_metric = 0; loop_rts.rts_time = rt->rt_time; loop_rts.rts_origin = RO_LOOPBCK; rtchange(rt, ((rt->rt_state & ~RS_NET_SYN) | (RS_IF|RS_LOCAL)), &loop_rts, 0); } else { loop_rts.rts_ifp = ifp; loop_rts.rts_metric = 0; loop_rts.rts_origin = RO_LOOPBCK; rtadd(ifp->int_addr, HOST_MASK, (RS_IF | RS_LOCAL), &loop_rts); } } } /* add the authority routes */ for (intnetp = intnets; intnetp != NULL; intnetp = intnetp->intnet_next) { rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask); if (rt != NULL && !(rt->rt_state & RS_NO_NET_SYN) && !(rt->rt_state & RS_NET_INT)) { rtdelete(rt); rt = NULL; } if (rt == NULL) { loop_rts.rts_ifp = NULL; loop_rts.rts_metric = intnetp->intnet_metric-1; loop_rts.rts_origin = RO_LOOPBCK; rtadd(intnetp->intnet_addr, intnetp->intnet_mask, RS_NET_SYN | RS_NET_INT, &loop_rts); } } prev_complaints = complaints; } static void check_net_syn(struct interface *ifp) { struct rt_entry *rt; struct rt_spare new; /* * Turn on the need to automatically synthesize a network route * for this interface only if we are running RIPv1 on some other * interface that is on a different class-A,B,or C network. */ if (have_ripv1_out || have_ripv1_in) { ifp->int_state |= IS_NEED_NET_SYN; rt = rtget(ifp->int_std_addr, ifp->int_std_mask); if (rt != NULL && 0 == (rt->rt_state & RS_NO_NET_SYN) && (!(rt->rt_state & RS_NET_SYN) || rt->rt_metric > ifp->int_metric)) { rtdelete(rt); rt = NULL; } if (rt == NULL) { (void) memset(&new, 0, sizeof (new)); new.rts_ifp = ifp; new.rts_gate = ifp->int_addr; new.rts_router = ifp->int_addr; new.rts_metric = ifp->int_metric; new.rts_origin = RO_NET_SYN; rtadd(ifp->int_std_addr, ifp->int_std_mask, RS_NET_SYN, &new); } } else { ifp->int_state &= ~IS_NEED_NET_SYN; rt = rtget(ifp->int_std_addr, ifp->int_std_mask); if (rt != NULL && (rt->rt_state & RS_NET_SYN) && rt->rt_ifp == ifp) rtbad_sub(rt, NULL); } } /* * Add route for interface if not currently installed. * Create route to other end if a point-to-point link, * otherwise a route to this (sub)network. */ static boolean_t /* _B_FALSE=bad interface */ addrouteforif(struct interface *ifp) { struct rt_entry *rt; struct rt_spare new; in_addr_t dst; uint16_t rt_newstate = RS_IF; /* skip sick interfaces */ if (ifp->int_state & IS_BROKE) return (_B_FALSE); /* * don't install routes for duplicate interfaces, or * unnumbered point-to-point interfaces. */ if ((ifp->int_state & IS_DUP) || ((ifp->int_if_flags & IFF_POINTOPOINT) && ifp->int_dstaddr == 0)) return (_B_TRUE); /* * If the interface on a subnet, then install a RIPv1 route to * the network as well (unless it is sick). */ if (ifp->int_state & IS_SUBNET) check_net_syn(ifp); dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) ? ifp->int_dstaddr : htonl(ifp->int_net)); (void) memset(&new, 0, sizeof (new)); new.rts_ifp = ifp; new.rts_router = ifp->int_addr; new.rts_gate = ifp->int_addr; new.rts_metric = ifp->int_metric; new.rts_time = now.tv_sec; if (ifp->int_if_flags & IFF_POINTOPOINT) new.rts_origin = RO_PTOPT; else if (ifp->int_if_flags & IFF_LOOPBACK) new.rts_origin = RO_LOOPBCK; else new.rts_origin = RO_IF; /* * If we are going to send packets to the gateway, * it must be reachable using our physical interfaces */ if ((ifp->int_state & IS_REMOTE) && !(ifp->int_state & IS_EXTERNAL) && !check_remote(ifp)) return (_B_FALSE); /* * We are finished if the correct main interface route exists. * The right route must be for the right interface, not synthesized * from a subnet, be a "gateway" or not as appropriate, and so forth. */ del_static(dst, ifp->int_mask, 0, ifp, 0); rt = rtget(dst, ifp->int_mask); if (!IS_IFF_ROUTING(ifp->int_if_flags)) rt_newstate |= RS_NOPROPAGATE; if (rt != NULL) { if ((rt->rt_ifp != ifp || rt->rt_router != ifp->int_addr) && (rt->rt_ifp == NULL || (rt->rt_ifp->int_state & IS_BROKE))) { rtdelete(rt); rt = NULL; } else { rtchange(rt, ((rt->rt_state | rt_newstate) & ~(RS_NET_SYN | RS_LOCAL)), &new, 0); } } if (rt == NULL) { if (ifp->int_transitions++ > 0) trace_act("re-installing interface %s;" " went up %d times", ifp->int_name, ifp->int_transitions); rtadd(dst, ifp->int_mask, rt_newstate, &new); } return (_B_TRUE); } /* * Obtains the named kstat, and places its value in *value. It * returns 0 for success, -1 for failure. */ static int kstat_named_value(kstat_t *ksp, char *name, uint32_t *value) { kstat_named_t *knp; if (ksp == NULL) return (-1); if ((knp = kstat_data_lookup(ksp, name)) == NULL) { return (-1); } else if (knp->data_type != KSTAT_DATA_UINT32) { return (-1); } else { *value = knp->value.ui32; return (0); } } static int get_if_kstats(struct interface *ifp, struct phyi_data *newdata) { struct physical_interface *phyi = ifp->int_phys; kstat_ctl_t *kc; kstat_t *ksp; /* We did this recently; don't do it again. */ if (phyi->phyi_data.ts == now.tv_sec) { if (newdata != &phyi->phyi_data) *newdata = phyi->phyi_data; return (0); } if ((kc = kstat_open()) == NULL) return (-1); /* * First we try to query the "link" kstats in case the link is renamed. * If that fails, fallback to legacy ktats for those non-GLDv3 links. */ if (((ksp = kstat_lookup(kc, "link", 0, phyi->phyi_name)) == NULL) && ((ksp = kstat_lookup(kc, NULL, -1, phyi->phyi_name)) == NULL)) { (void) kstat_close(kc); return (-1); } if (kstat_read(kc, ksp, NULL) == -1) { (void) kstat_close(kc); return (-1); } if ((kstat_named_value(ksp, "ipackets", &newdata->ipackets) == -1) || (kstat_named_value(ksp, "opackets", &newdata->opackets) == -1)) { newdata->ts = 0; (void) kstat_close(kc); return (-1); } /* The loopback interface does not keep track of errors */ if (!(ifp->int_if_flags & IFF_LOOPBACK)) { if ((kstat_named_value(ksp, "ierrors", &newdata->ierrors) == -1) || (kstat_named_value(ksp, "oerrors", &newdata->oerrors) == -1)) { newdata->ts = 0; (void) kstat_close(kc); return (-1); } } newdata->ts = now.tv_sec; (void) kstat_close(kc); return (0); } /* * Returns true if we should supply routes to other systems. If the * user has forced us to be a supplier (by the command line) or if we * have more than one forwarding interface and this is one of the * forwarding interfaces, then behave as a RIP supplier (supply rdisc * advertisements and RIP responses). */ boolean_t should_supply(struct interface *ifp) { if (ifp != NULL && !IS_IFF_ROUTING(ifp->int_if_flags)) return (_B_FALSE); return ((supplier_set && supplier) || (!supplier_set && fwd_interfaces > 1)); }