2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 #include "pathnames.h"
37 #elif defined(__FreeBSD__)
40 __RCSID("$Revision: 2.27 $");
41 #ident "$Revision: 2.27 $"
44 struct interface *ifnet; /* all interfaces */
46 /* hash table for all interfaces, big enough to tolerate ridiculous
47 * numbers of IP aliases. Crazy numbers of aliases such as 7000
48 * still will not do well, but not just in looking up interfaces
51 #define AHASH_LEN 211 /* must be prime */
52 #define AHASH(a) &ahash_tbl[(a)%AHASH_LEN]
53 struct interface *ahash_tbl[AHASH_LEN];
55 #define BHASH_LEN 211 /* must be prime */
56 #define BHASH(a) &bhash_tbl[(a)%BHASH_LEN]
57 struct interface *bhash_tbl[BHASH_LEN];
59 struct interface *remote_if; /* remote interfaces */
61 /* hash for physical interface names.
62 * Assume there are never more 100 or 200 real interfaces, and that
63 * aliases are put on the end of the hash chains.
66 struct interface *nhash_tbl[NHASH_LEN];
68 int tot_interfaces; /* # of remote and local interfaces */
69 int rip_interfaces; /* # of interfaces doing RIP */
70 int foundloopback; /* valid flag for loopaddr */
71 naddr loopaddr; /* our address on loopback */
72 struct rt_spare loop_rts;
74 struct timeval ifinit_timer;
75 static struct timeval last_ifinit;
76 #define IF_RESCAN_DELAY() (last_ifinit.tv_sec == now.tv_sec \
77 && last_ifinit.tv_usec == now.tv_usec \
78 && timercmp(&ifinit_timer, &now, >))
80 int have_ripv1_out; /* have a RIPv1 interface */
84 static struct interface**
89 for (i = 0; *p != '\0'; p++) {
90 i = ((i<<1) & 0x7fffffff) | ((i>>31) & 1);
93 return &nhash_tbl[i % NHASH_LEN];
97 /* Link a new interface into the lists and hash tables.
100 if_link(struct interface *ifp)
102 struct interface **hifp;
104 ifp->int_prev = &ifnet;
105 ifp->int_next = ifnet;
107 ifnet->int_prev = &ifp->int_next;
110 hifp = AHASH(ifp->int_addr);
111 ifp->int_ahash_prev = hifp;
112 if ((ifp->int_ahash = *hifp) != 0)
113 (*hifp)->int_ahash_prev = &ifp->int_ahash;
116 if (ifp->int_if_flags & IFF_BROADCAST) {
117 hifp = BHASH(ifp->int_brdaddr);
118 ifp->int_bhash_prev = hifp;
119 if ((ifp->int_bhash = *hifp) != 0)
120 (*hifp)->int_bhash_prev = &ifp->int_bhash;
124 if (ifp->int_state & IS_REMOTE) {
125 ifp->int_rlink_prev = &remote_if;
126 ifp->int_rlink = remote_if;
128 remote_if->int_rlink_prev = &ifp->int_rlink;
132 hifp = nhash(ifp->int_name);
133 if (ifp->int_state & IS_ALIAS) {
134 /* put aliases on the end of the hash chain */
136 hifp = &(*hifp)->int_nhash;
138 ifp->int_nhash_prev = hifp;
139 if ((ifp->int_nhash = *hifp) != 0)
140 (*hifp)->int_nhash_prev = &ifp->int_nhash;
145 /* Find the interface with an address
148 ifwithaddr(naddr addr,
149 int bcast, /* notice IFF_BROADCAST address */
150 int remote) /* include IS_REMOTE interfaces */
152 struct interface *ifp, *possible = 0;
154 remote = (remote == 0) ? IS_REMOTE : 0;
156 for (ifp = *AHASH(addr); ifp; ifp = ifp->int_ahash) {
157 if (ifp->int_addr != addr)
159 if ((ifp->int_state & remote) != 0)
161 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
166 if (possible || !bcast)
169 for (ifp = *BHASH(addr); ifp; ifp = ifp->int_bhash) {
170 if (ifp->int_brdaddr != addr)
172 if ((ifp->int_state & remote) != 0)
174 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
183 /* find the interface with a name
186 ifwithname(char *name, /* "ec0" or whatever */
187 naddr addr) /* 0 or network address */
189 struct interface *ifp;
192 for (ifp = *nhash(name); ifp != 0; ifp = ifp->int_nhash) {
193 /* If the network address is not specified,
194 * ignore any alias interfaces. Otherwise, look
195 * for the interface with the target name and address.
197 if (!strcmp(ifp->int_name, name)
198 && ((addr == 0 && !(ifp->int_state & IS_ALIAS))
199 || (ifp->int_addr == addr)))
203 /* If there is no known interface, maybe there is a
204 * new interface. So just once look for new interfaces.
206 if (IF_RESCAN_DELAY())
214 ifwithindex(u_short ifindex,
217 struct interface *ifp;
220 for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) {
221 if (ifp->int_index == ifindex)
225 /* If there is no known interface, maybe there is a
226 * new interface. So just once look for new interfaces.
229 || IF_RESCAN_DELAY())
236 /* Find an interface from which the specified address
237 * should have come from. Used for figuring out which
238 * interface a packet came in on.
243 struct interface *ifp, *maybe;
248 for (ifp = ifnet; ifp; ifp = ifp->int_next) {
249 if (ifp->int_if_flags & IFF_POINTOPOINT) {
250 /* finished with a match */
251 if (ifp->int_dstaddr == addr)
255 /* finished with an exact match */
256 if (ifp->int_addr == addr)
259 /* Look for the longest approximate match.
261 if (on_net(addr, ifp->int_net, ifp->int_mask)
263 || ifp->int_mask > maybe->int_mask))
268 if (maybe != 0 || once || IF_RESCAN_DELAY())
272 /* If there is no known interface, maybe there is a
273 * new interface. So just once look for new interfaces.
280 /* Return the classical netmask for an IP address.
282 naddr /* host byte order */
283 std_mask(naddr addr) /* network byte order */
285 addr = ntohl(addr); /* was a host, not a network */
287 if (addr == 0) /* default route has mask 0 */
290 return IN_CLASSA_NET;
292 return IN_CLASSB_NET;
293 return IN_CLASSC_NET;
297 /* Find the netmask that would be inferred by RIPv1 listeners
298 * on the given interface for a given network.
299 * If no interface is specified, look for the best fitting interface.
302 ripv1_mask_net(naddr addr, /* in network byte order */
303 struct interface *ifp) /* as seen on this interface */
308 if (addr == 0) /* default always has 0 mask */
311 if (ifp != 0 && ifp->int_ripv1_mask != HOST_MASK) {
312 /* If the target network is that of the associated interface
313 * on which it arrived, then use the netmask of the interface.
315 if (on_net(addr, ifp->int_net, ifp->int_std_mask))
316 mask = ifp->int_ripv1_mask;
319 /* Examine all interfaces, and if it the target seems
320 * to have the same network number of an interface, use the
321 * netmask of that interface. If there is more than one
322 * such interface, prefer the interface with the longest
325 for (ifp = ifnet; ifp != 0; ifp = ifp->int_next) {
326 if (on_net(addr, ifp->int_std_net, ifp->int_std_mask)
327 && ifp->int_ripv1_mask > mask
328 && ifp->int_ripv1_mask != HOST_MASK)
329 mask = ifp->int_ripv1_mask;
334 /* check special definitions */
336 for (r1p = r1nets; r1p != 0; r1p = r1p->r1net_next) {
337 if (on_net(addr, r1p->r1net_net, r1p->r1net_match)
338 && r1p->r1net_mask > mask)
339 mask = r1p->r1net_mask;
342 /* Otherwise, make the classic A/B/C guess.
345 mask = std_mask(addr);
353 ripv1_mask_host(naddr addr, /* in network byte order */
354 struct interface *ifp) /* as seen on this interface */
356 naddr mask = ripv1_mask_net(addr, ifp);
359 /* If the computed netmask does not mask the address,
360 * then assume it is a host address
362 if ((ntohl(addr) & ~mask) != 0)
368 /* See if an IP address looks reasonable as a destination.
371 check_dst(naddr addr)
375 if (IN_CLASSA(addr)) {
377 return 1; /* default */
379 addr >>= IN_CLASSA_NSHIFT;
380 return (addr != 0 && addr != IN_LOOPBACKNET);
383 return (IN_CLASSB(addr) || IN_CLASSC(addr));
387 /* See a new interface duplicates an existing interface.
390 check_dup(naddr addr, /* IP address, so network byte order */
391 naddr dstaddr, /* ditto */
392 naddr mask, /* mask, so host byte order */
395 struct interface *ifp;
397 for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) {
398 if (ifp->int_mask != mask)
401 if (!iff_up(ifp->int_if_flags))
404 /* The local address can only be shared with a point-to-point
407 if ((!(ifp->int_state & IS_REMOTE) || !(if_flags & IS_REMOTE))
408 && ifp->int_addr == addr
409 && (((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0))
412 if (on_net(ifp->int_dstaddr, ntohl(dstaddr),mask))
419 /* See that a remote gateway is reachable.
420 * Note that the answer can change as real interfaces come and go.
423 check_remote(struct interface *ifp)
427 /* do not worry about other kinds */
428 if (!(ifp->int_state & IS_REMOTE))
431 rt = rtfind(ifp->int_addr);
434 &&on_net(ifp->int_addr,
435 rt->rt_ifp->int_net, rt->rt_ifp->int_mask))
438 /* the gateway cannot be reached directly from one of our
441 if (!(ifp->int_state & IS_BROKE)) {
442 msglog("unreachable gateway %s in "_PATH_GATEWAYS,
443 naddr_ntoa(ifp->int_addr));
450 /* Delete an interface.
453 ifdel(struct interface *ifp)
456 struct interface *ifp1;
459 trace_if("Del", ifp);
461 ifp->int_state |= IS_BROKE;
463 /* unlink the interface
465 *ifp->int_prev = ifp->int_next;
466 if (ifp->int_next != 0)
467 ifp->int_next->int_prev = ifp->int_prev;
468 *ifp->int_ahash_prev = ifp->int_ahash;
469 if (ifp->int_ahash != 0)
470 ifp->int_ahash->int_ahash_prev = ifp->int_ahash_prev;
471 *ifp->int_nhash_prev = ifp->int_nhash;
472 if (ifp->int_nhash != 0)
473 ifp->int_nhash->int_nhash_prev = ifp->int_nhash_prev;
474 if (ifp->int_if_flags & IFF_BROADCAST) {
475 *ifp->int_bhash_prev = ifp->int_bhash;
476 if (ifp->int_bhash != 0)
477 ifp->int_bhash->int_bhash_prev = ifp->int_bhash_prev;
479 if (ifp->int_state & IS_REMOTE) {
480 *ifp->int_rlink_prev = ifp->int_rlink;
481 if (ifp->int_rlink != 0)
482 ifp->int_rlink->int_rlink_prev = ifp->int_rlink_prev;
485 if (!(ifp->int_state & IS_ALIAS)) {
486 /* delete aliases when the main interface dies
488 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) {
490 && !strcmp(ifp->int_name, ifp1->int_name))
494 if ((ifp->int_if_flags & IFF_MULTICAST)
496 && !(ifp->int_if_flags & IFF_POINTOPOINT)
499 m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP);
501 m.imr_interface.s_addr = htonl(ifp->int_index);
503 m.imr_interface.s_addr = ((ifp->int_if_flags
508 if (setsockopt(rip_sock,IPPROTO_IP,IP_DROP_MEMBERSHIP,
510 && errno != EADDRNOTAVAIL
512 LOGERR("setsockopt(IP_DROP_MEMBERSHIP RIP)");
513 if (rip_sock_mcast == ifp)
516 if (ifp->int_rip_sock >= 0) {
517 (void)close(ifp->int_rip_sock);
518 ifp->int_rip_sock = -1;
523 if (!IS_RIP_OFF(ifp->int_state))
526 /* Zap all routes associated with this interface.
527 * Assume routes just using gateways beyond this interface
528 * will timeout naturally, and have probably already died.
530 (void)rn_walktree(rhead, walk_bad, 0);
532 set_rdisc_mg(ifp, 0);
540 /* Mark an interface ill.
543 if_sick(struct interface *ifp)
545 if (0 == (ifp->int_state & (IS_SICK | IS_BROKE))) {
546 ifp->int_state |= IS_SICK;
547 ifp->int_act_time = NEVER;
548 trace_if("Chg", ifp);
550 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
555 /* Mark an interface dead.
558 if_bad(struct interface *ifp)
560 struct interface *ifp1;
563 if (ifp->int_state & IS_BROKE)
566 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
568 ifp->int_state |= (IS_BROKE | IS_SICK);
569 ifp->int_act_time = NEVER;
570 ifp->int_query_time = NEVER;
571 ifp->int_data.ts = now.tv_sec;
573 trace_if("Chg", ifp);
575 if (!(ifp->int_state & IS_ALIAS)) {
576 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) {
578 && !strcmp(ifp->int_name, ifp1->int_name))
581 (void)rn_walktree(rhead, walk_bad, 0);
587 /* Mark an interface alive
589 int /* 1=it was dead */
590 if_ok(struct interface *ifp,
593 struct interface *ifp1;
596 if (!(ifp->int_state & IS_BROKE)) {
597 if (ifp->int_state & IS_SICK) {
598 trace_act("%sinterface %s to %s working better",
600 ifp->int_name, naddr_ntoa(ifp->int_dstaddr));
601 ifp->int_state &= ~IS_SICK;
606 msglog("%sinterface %s to %s restored",
607 type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr));
608 ifp->int_state &= ~(IS_BROKE | IS_SICK);
609 ifp->int_data.ts = 0;
611 if (!(ifp->int_state & IS_ALIAS)) {
612 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) {
614 && !strcmp(ifp->int_name, ifp1->int_name))
620 if (ifp->int_state & IS_REMOTE) {
621 if (!addrouteforif(ifp))
628 /* disassemble routing message
631 rt_xaddrs(struct rt_addrinfo *info,
633 struct sockaddr *lim,
638 static struct sockaddr sa_zero;
641 memset(info, 0, sizeof(*info));
642 info->rti_addrs = addrs;
643 for (i = 0; i < RTAX_MAX && sa < lim; i++) {
644 if ((addrs & (1 << i)) == 0)
646 info->rti_info[i] = (sa->sa_len != 0) ? sa : &sa_zero;
647 sa = (struct sockaddr *)((char*)(sa) + SA_SIZE(sa));
652 /* Find the network interfaces which have configured themselves.
653 * This must be done regularly, if only for extra addresses
654 * that come and go on interfaces.
659 static char *sysctl_buf;
660 static size_t sysctl_buf_size = 0;
662 static u_int prev_complaints = 0;
663 # define COMP_NOT_INET 0x001
664 # define COMP_NOADDR 0x002
665 # define COMP_BADADDR 0x004
666 # define COMP_NODST 0x008
667 # define COMP_NOBADR 0x010
668 # define COMP_NOMASK 0x020
669 # define COMP_DUP 0x040
670 # define COMP_BAD_METRIC 0x080
671 # define COMP_NETMASK 0x100
673 struct interface ifs, ifs0, *ifp, *ifp1;
677 struct if_msghdr *ifm;
678 struct ifa_msghdr *ifam, *ifam_lim, *ifam2;
679 int in, ierr, out, oerr;
680 struct intnet *intnetp;
681 struct rt_addrinfo info;
688 ifinit_timer.tv_sec = now.tv_sec + (supplier
690 : CHECK_QUIET_INTERVAL);
692 /* mark all interfaces so we can get rid of those that disappear */
693 for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next)
694 ifp->int_state &= ~(IS_CHECKED | IS_DUP);
696 /* Fetch the interface list, without too many system calls
697 * since we do it repeatedly.
703 mib[4] = NET_RT_IFLIST;
706 if ((needed = sysctl_buf_size) != 0) {
707 if (sysctl(mib, 6, sysctl_buf,&needed, 0, 0) >= 0)
709 /* retry if the table grew */
710 if (errno != ENOMEM && errno != EFAULT)
711 BADERR(1, "ifinit: sysctl(RT_IFLIST)");
715 if (sysctl(mib, 6, 0, &needed, 0, 0) < 0)
716 BADERR(1,"ifinit: sysctl(RT_IFLIST) estimate");
717 sysctl_buf = rtmalloc(sysctl_buf_size = needed,
721 ifam_lim = (struct ifa_msghdr *)(sysctl_buf + needed);
722 for (ifam = (struct ifa_msghdr *)sysctl_buf;
726 ifam2 = (struct ifa_msghdr*)((char*)ifam + ifam->ifam_msglen);
729 if (ifam->ifam_type == RTM_OIFINFO)
730 continue; /* just ignore compat message */
732 if (ifam->ifam_type == RTM_IFINFO) {
733 struct sockaddr_dl *sdl;
735 ifm = (struct if_msghdr *)ifam;
736 /* make prototype structure for the IP aliases
738 memset(&ifs0, 0, sizeof(ifs0));
739 ifs0.int_rip_sock = -1;
740 ifs0.int_index = ifm->ifm_index;
741 ifs0.int_if_flags = ifm->ifm_flags;
742 ifs0.int_state = IS_CHECKED;
743 ifs0.int_query_time = NEVER;
744 ifs0.int_act_time = now.tv_sec;
745 ifs0.int_data.ts = now.tv_sec;
746 ifs0.int_data.ipackets = ifm->ifm_data.ifi_ipackets;
747 ifs0.int_data.ierrors = ifm->ifm_data.ifi_ierrors;
748 ifs0.int_data.opackets = ifm->ifm_data.ifi_opackets;
749 ifs0.int_data.oerrors = ifm->ifm_data.ifi_oerrors;
751 ifs0.int_data.odrops = ifm->ifm_data.ifi_odrops;
753 sdl = (struct sockaddr_dl *)(ifm + 1);
754 sdl->sdl_data[sdl->sdl_nlen] = 0;
755 strncpy(ifs0.int_name, sdl->sdl_data,
756 MIN(sizeof(ifs0.int_name), sdl->sdl_nlen));
759 if (ifam->ifam_type != RTM_NEWADDR) {
760 logbad(1,"ifinit: out of sync");
763 rt_xaddrs(&info, (struct sockaddr *)(ifam+1),
764 (struct sockaddr *)ifam2,
767 /* Prepare for the next address of this interface, which
769 * Do not output RIP or Router-Discovery packets via aliases.
771 memcpy(&ifs, &ifs0, sizeof(ifs));
772 ifs0.int_state |= (IS_ALIAS | IS_NO_RIP_OUT | IS_NO_RDISC);
774 if (INFO_IFA(&info) == 0) {
775 if (iff_up(ifs.int_if_flags)) {
776 if (!(prev_complaints & COMP_NOADDR))
777 msglog("%s has no address",
779 complaints |= COMP_NOADDR;
783 if (INFO_IFA(&info)->sa_family != AF_INET) {
784 if (iff_up(ifs.int_if_flags)) {
785 if (!(prev_complaints & COMP_NOT_INET))
786 trace_act("%s: not AF_INET",
788 complaints |= COMP_NOT_INET;
793 ifs.int_addr = S_ADDR(INFO_IFA(&info));
795 if (ntohl(ifs.int_addr)>>24 == 0
796 || ntohl(ifs.int_addr)>>24 == 0xff) {
797 if (iff_up(ifs.int_if_flags)) {
798 if (!(prev_complaints & COMP_BADADDR))
799 msglog("%s has a bad address",
801 complaints |= COMP_BADADDR;
806 if (ifs.int_if_flags & IFF_LOOPBACK) {
807 ifs.int_state |= IS_NO_RIP | IS_NO_RDISC;
808 if (ifs.int_addr == htonl(INADDR_LOOPBACK))
809 ifs.int_state |= IS_PASSIVE;
810 ifs.int_dstaddr = ifs.int_addr;
811 ifs.int_mask = HOST_MASK;
812 ifs.int_ripv1_mask = HOST_MASK;
813 ifs.int_std_mask = std_mask(ifs.int_dstaddr);
814 ifs.int_net = ntohl(ifs.int_dstaddr);
815 if (!foundloopback) {
817 loopaddr = ifs.int_addr;
818 loop_rts.rts_gate = loopaddr;
819 loop_rts.rts_router = loopaddr;
822 } else if (ifs.int_if_flags & IFF_POINTOPOINT) {
823 if (INFO_BRD(&info) == 0
824 || INFO_BRD(&info)->sa_family != AF_INET) {
825 if (iff_up(ifs.int_if_flags)) {
826 if (!(prev_complaints & COMP_NODST))
827 msglog("%s has a bad"
828 " destination address",
830 complaints |= COMP_NODST;
834 ifs.int_dstaddr = S_ADDR(INFO_BRD(&info));
835 if (ntohl(ifs.int_dstaddr)>>24 == 0
836 || ntohl(ifs.int_dstaddr)>>24 == 0xff) {
837 if (iff_up(ifs.int_if_flags)) {
838 if (!(prev_complaints & COMP_NODST))
839 msglog("%s has a bad"
840 " destination address",
842 complaints |= COMP_NODST;
846 ifs.int_mask = HOST_MASK;
847 ifs.int_ripv1_mask = ntohl(S_ADDR(INFO_MASK(&info)));
848 ifs.int_std_mask = std_mask(ifs.int_dstaddr);
849 ifs.int_net = ntohl(ifs.int_dstaddr);
852 if (INFO_MASK(&info) == 0) {
853 if (iff_up(ifs.int_if_flags)) {
854 if (!(prev_complaints & COMP_NOMASK))
855 msglog("%s has no netmask",
857 complaints |= COMP_NOMASK;
861 ifs.int_dstaddr = ifs.int_addr;
862 ifs.int_mask = ntohl(S_ADDR(INFO_MASK(&info)));
863 ifs.int_ripv1_mask = ifs.int_mask;
864 ifs.int_std_mask = std_mask(ifs.int_addr);
865 ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask;
866 if (ifs.int_mask != ifs.int_std_mask)
867 ifs.int_state |= IS_SUBNET;
869 if (ifs.int_if_flags & IFF_BROADCAST) {
870 if (INFO_BRD(&info) == 0) {
871 if (iff_up(ifs.int_if_flags)) {
872 if (!(prev_complaints
875 "no broadcast address",
877 complaints |= COMP_NOBADR;
881 ifs.int_brdaddr = S_ADDR(INFO_BRD(&info));
884 ifs.int_std_net = ifs.int_net & ifs.int_std_mask;
885 ifs.int_std_addr = htonl(ifs.int_std_net);
887 /* Use a minimum metric of one. Treat the interface metric
888 * (default 0) as an increment to the hop count of one.
890 * The metric obtained from the routing socket dump of
891 * interface addresses is wrong. It is not set by the
892 * SIOCSIFMETRIC ioctl.
895 strncpy(ifr.ifr_name, ifs.int_name, sizeof(ifr.ifr_name));
896 if (ioctl(rt_sock, SIOCGIFMETRIC, &ifr) < 0) {
897 DBGERR(1, "ioctl(SIOCGIFMETRIC)");
900 ifs.int_metric = ifr.ifr_metric;
903 ifs.int_metric = ifam->ifam_metric;
905 if (ifs.int_metric > HOPCNT_INFINITY) {
907 if (!(prev_complaints & COMP_BAD_METRIC)
908 && iff_up(ifs.int_if_flags)) {
909 complaints |= COMP_BAD_METRIC;
910 msglog("%s has a metric of %d",
911 ifs.int_name, ifs.int_metric);
915 /* See if this is a familiar interface.
916 * If so, stop worrying about it if it is the same.
917 * Start it over if it now is to somewhere else, as happens
918 * frequently with PPP and SLIP.
920 ifp = ifwithname(ifs.int_name, ((ifs.int_state & IS_ALIAS)
924 ifp->int_state |= IS_CHECKED;
926 if (0 != ((ifp->int_if_flags ^ ifs.int_if_flags)
931 || 0 != ((ifp->int_state ^ ifs.int_state)
933 || ifp->int_addr != ifs.int_addr
934 || ifp->int_brdaddr != ifs.int_brdaddr
935 || ifp->int_dstaddr != ifs.int_dstaddr
936 || ifp->int_mask != ifs.int_mask
937 || ifp->int_metric != ifs.int_metric) {
938 /* Forget old information about
939 * a changed interface.
941 trace_act("interface %s has changed",
949 /* The primary representative of an alias worries
950 * about how things are working.
952 if (ifp->int_state & IS_ALIAS)
955 /* note interfaces that have been turned off
957 if (!iff_up(ifs.int_if_flags)) {
958 if (iff_up(ifp->int_if_flags)) {
959 msglog("interface %s to %s turned off",
961 naddr_ntoa(ifp->int_dstaddr));
963 ifp->int_if_flags &= ~IFF_UP;
964 } else if (now.tv_sec>(ifp->int_data.ts
965 + CHECK_BAD_INTERVAL)) {
966 trace_act("interface %s has been off"
967 " %ld seconds; forget it",
969 now.tv_sec-ifp->int_data.ts);
974 /* or that were off and are now ok */
975 if (!iff_up(ifp->int_if_flags)) {
976 ifp->int_if_flags |= IFF_UP;
977 (void)if_ok(ifp, "");
980 /* If it has been long enough,
981 * see if the interface is broken.
983 if (now.tv_sec < ifp->int_data.ts+CHECK_BAD_INTERVAL)
986 in = ifs.int_data.ipackets - ifp->int_data.ipackets;
987 ierr = ifs.int_data.ierrors - ifp->int_data.ierrors;
988 out = ifs.int_data.opackets - ifp->int_data.opackets;
989 oerr = ifs.int_data.oerrors - ifp->int_data.oerrors;
991 /* Through at least IRIX 6.2, PPP and SLIP
992 * count packets dropped by the filters.
993 * But FDDI rings stuck non-operational count
994 * dropped packets as they wait for improvement.
996 if (!(ifp->int_if_flags & IFF_POINTOPOINT))
997 oerr += (ifs.int_data.odrops
998 - ifp->int_data.odrops);
1000 /* If the interface just awoke, restart the counters.
1002 if (ifp->int_data.ts == 0) {
1003 ifp->int_data = ifs.int_data;
1006 ifp->int_data = ifs.int_data;
1008 /* Withhold judgment when the short error
1009 * counters wrap or the interface is reset.
1011 if (ierr < 0 || in < 0 || oerr < 0 || out < 0) {
1012 LIM_SEC(ifinit_timer,
1013 now.tv_sec+CHECK_BAD_INTERVAL);
1017 /* Withhold judgement when there is no traffic
1019 if (in == 0 && out == 0 && ierr == 0 && oerr == 0)
1022 /* It is bad if input or output is not working.
1023 * Require presistent problems before marking it dead.
1025 if ((in <= ierr && ierr > 0)
1026 || (out <= oerr && oerr > 0)) {
1027 if (!(ifp->int_state & IS_SICK)) {
1028 trace_act("interface %s to %s"
1029 " sick: in=%d ierr=%d"
1032 naddr_ntoa(ifp->int_dstaddr),
1033 in, ierr, out, oerr);
1037 if (!(ifp->int_state & IS_BROKE)) {
1038 msglog("interface %s to %s broken:"
1039 " in=%d ierr=%d out=%d oerr=%d",
1041 naddr_ntoa(ifp->int_dstaddr),
1042 in, ierr, out, oerr);
1048 /* otherwise, it is active and healthy
1050 ifp->int_act_time = now.tv_sec;
1051 (void)if_ok(ifp, "");
1055 /* This is a new interface.
1056 * If it is dead, forget it.
1058 if (!iff_up(ifs.int_if_flags))
1061 /* If it duplicates an existing interface,
1062 * complain about it, mark the other one
1063 * duplicated, and forget this one.
1065 ifp = check_dup(ifs.int_addr,ifs.int_dstaddr,ifs.int_mask,
1068 /* Ignore duplicates of itself, caused by having
1069 * IP aliases on the same network.
1071 if (!strcmp(ifp->int_name, ifs.int_name))
1074 if (!(prev_complaints & COMP_DUP)) {
1075 complaints |= COMP_DUP;
1076 msglog("%s (%s%s%s) is duplicated by"
1079 addrname(ifs.int_addr,ifs.int_mask,1),
1080 ((ifs.int_if_flags & IFF_POINTOPOINT)
1082 ((ifs.int_if_flags & IFF_POINTOPOINT)
1083 ? naddr_ntoa(ifs.int_dstaddr) : ""),
1085 addrname(ifp->int_addr,ifp->int_mask,1),
1086 ((ifp->int_if_flags & IFF_POINTOPOINT)
1088 ((ifp->int_if_flags & IFF_POINTOPOINT)
1089 ? naddr_ntoa(ifp->int_dstaddr) : ""));
1091 ifp->int_state |= IS_DUP;
1095 if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT | IFF_BROADCAST | IFF_LOOPBACK))) {
1096 trace_act("%s is neither broadcast, point-to-point,"
1099 if (!(ifs.int_state & IFF_MULTICAST))
1100 ifs.int_state |= IS_NO_RDISC;
1104 /* It is new and ok. Add it to the list of interfaces
1106 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "ifinit ifp");
1107 memcpy(ifp, &ifs, sizeof(*ifp));
1110 trace_if("Add", ifp);
1112 /* Notice likely bad netmask.
1114 if (!(prev_complaints & COMP_NETMASK)
1115 && !(ifp->int_if_flags & IFF_POINTOPOINT)
1116 && ifp->int_addr != RIP_DEFAULT) {
1117 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) {
1118 if (ifp1->int_mask == ifp->int_mask)
1120 if (ifp1->int_if_flags & IFF_POINTOPOINT)
1122 if (ifp1->int_dstaddr == RIP_DEFAULT)
1124 /* ignore aliases on the right network */
1125 if (!strcmp(ifp->int_name, ifp1->int_name))
1127 if (on_net(ifp->int_dstaddr,
1128 ifp1->int_net, ifp1->int_mask)
1129 || on_net(ifp1->int_dstaddr,
1130 ifp->int_net, ifp->int_mask)) {
1131 msglog("possible netmask problem"
1132 " between %s:%s and %s:%s",
1134 addrname(htonl(ifp->int_net),
1137 addrname(htonl(ifp1->int_net),
1138 ifp1->int_mask, 1));
1139 complaints |= COMP_NETMASK;
1144 if (!(ifp->int_state & IS_ALIAS)) {
1145 /* Count the # of directly connected networks.
1147 if (!(ifp->int_if_flags & IFF_LOOPBACK))
1149 if (!IS_RIP_OFF(ifp->int_state))
1152 /* turn on router discovery and RIP If needed */
1158 /* If we are multi-homed and have at least two interfaces
1159 * listening to RIP, then output by default.
1161 if (!supplier_set && rip_interfaces > 1)
1164 /* If we are multi-homed, optionally advertise a route to
1168 || (tot_interfaces > 1
1170 && (ifp = ifwithaddr(myaddr, 0, 0)) != 0
1171 && foundloopback)) {
1172 advertise_mhome = 1;
1173 rt = rtget(myaddr, HOST_MASK);
1175 if (rt->rt_ifp != ifp
1176 || rt->rt_router != loopaddr) {
1180 loop_rts.rts_ifp = ifp;
1181 loop_rts.rts_metric = 0;
1182 loop_rts.rts_time = rt->rt_time;
1183 rtchange(rt, rt->rt_state | RS_MHOME,
1188 loop_rts.rts_ifp = ifp;
1189 loop_rts.rts_metric = 0;
1190 rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts);
1194 for (ifp = ifnet; ifp != 0; ifp = ifp1) {
1195 ifp1 = ifp->int_next; /* because we may delete it */
1197 /* Forget any interfaces that have disappeared.
1199 if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) {
1200 trace_act("interface %s has disappeared",
1206 if ((ifp->int_state & IS_BROKE)
1207 && !(ifp->int_state & IS_PASSIVE))
1208 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
1210 /* If we ever have a RIPv1 interface, assume we always will.
1211 * It might come back if it ever goes away.
1213 if (!(ifp->int_state & IS_NO_RIPV1_OUT) && supplier)
1215 if (!(ifp->int_state & IS_NO_RIPV1_IN))
1219 for (ifp = ifnet; ifp != 0; ifp = ifp->int_next) {
1220 /* Ensure there is always a network route for interfaces,
1221 * after any dead interfaces have been deleted, which
1222 * might affect routes for point-to-point links.
1224 if (!addrouteforif(ifp))
1227 /* Add routes to the local end of point-to-point interfaces
1230 if ((ifp->int_if_flags & IFF_POINTOPOINT)
1231 && !(ifp->int_state & IS_REMOTE)
1233 /* Delete any routes to the network address through
1234 * foreign routers. Remove even static routes.
1236 del_static(ifp->int_addr, HOST_MASK, 0, 0);
1237 rt = rtget(ifp->int_addr, HOST_MASK);
1238 if (rt != 0 && rt->rt_router != loopaddr) {
1243 if (!(rt->rt_state & RS_LOCAL)
1244 || rt->rt_metric > ifp->int_metric) {
1249 loop_rts.rts_ifp = ifp1;
1250 loop_rts.rts_metric = 0;
1251 loop_rts.rts_time = rt->rt_time;
1252 rtchange(rt, ((rt->rt_state & ~RS_NET_SYN)
1253 | (RS_IF|RS_LOCAL)),
1256 loop_rts.rts_ifp = ifp;
1257 loop_rts.rts_metric = 0;
1258 rtadd(ifp->int_addr, HOST_MASK,
1259 (RS_IF | RS_LOCAL), &loop_rts);
1264 /* add the authority routes */
1265 for (intnetp = intnets; intnetp!=0; intnetp = intnetp->intnet_next) {
1266 rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask);
1268 && !(rt->rt_state & RS_NO_NET_SYN)
1269 && !(rt->rt_state & RS_NET_INT)) {
1274 loop_rts.rts_ifp = 0;
1275 loop_rts.rts_metric = intnetp->intnet_metric-1;
1276 rtadd(intnetp->intnet_addr, intnetp->intnet_mask,
1277 RS_NET_SYN | RS_NET_INT, &loop_rts);
1281 prev_complaints = complaints;
1286 check_net_syn(struct interface *ifp)
1288 struct rt_entry *rt;
1289 static struct rt_spare new;
1292 /* Turn on the need to automatically synthesize a network route
1293 * for this interface only if we are running RIPv1 on some other
1294 * interface that is on a different class-A,B,or C network.
1296 if (have_ripv1_out || have_ripv1_in) {
1297 ifp->int_state |= IS_NEED_NET_SYN;
1298 rt = rtget(ifp->int_std_addr, ifp->int_std_mask);
1300 && 0 == (rt->rt_state & RS_NO_NET_SYN)
1301 && (!(rt->rt_state & RS_NET_SYN)
1302 || rt->rt_metric > ifp->int_metric)) {
1308 new.rts_gate = ifp->int_addr;
1309 new.rts_router = ifp->int_addr;
1310 new.rts_metric = ifp->int_metric;
1311 rtadd(ifp->int_std_addr, ifp->int_std_mask,
1316 ifp->int_state &= ~IS_NEED_NET_SYN;
1318 rt = rtget(ifp->int_std_addr,
1321 && (rt->rt_state & RS_NET_SYN)
1322 && rt->rt_ifp == ifp)
1328 /* Add route for interface if not currently installed.
1329 * Create route to other end if a point-to-point link,
1330 * otherwise a route to this (sub)network.
1332 int /* 0=bad interface */
1333 addrouteforif(struct interface *ifp)
1335 struct rt_entry *rt;
1336 static struct rt_spare new;
1340 /* skip sick interfaces
1342 if (ifp->int_state & IS_BROKE)
1345 /* If the interface on a subnet, then install a RIPv1 route to
1346 * the network as well (unless it is sick).
1348 if (ifp->int_state & IS_SUBNET)
1351 dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK))
1353 : htonl(ifp->int_net));
1356 new.rts_router = ifp->int_addr;
1357 new.rts_gate = ifp->int_addr;
1358 new.rts_metric = ifp->int_metric;
1359 new.rts_time = now.tv_sec;
1361 /* If we are going to send packets to the gateway,
1362 * it must be reachable using our physical interfaces
1364 if ((ifp->int_state & IS_REMOTE)
1365 && !(ifp->int_state & IS_EXTERNAL)
1366 && !check_remote(ifp))
1369 /* We are finished if the correct main interface route exists.
1370 * The right route must be for the right interface, not synthesized
1371 * from a subnet, be a "gateway" or not as appropriate, and so forth.
1373 del_static(dst, ifp->int_mask, 0, 0);
1374 rt = rtget(dst, ifp->int_mask);
1376 if ((rt->rt_ifp != ifp
1377 || rt->rt_router != ifp->int_addr)
1378 && (!(ifp->int_state & IS_DUP)
1380 || (rt->rt_ifp->int_state & IS_BROKE))) {
1384 rtchange(rt, ((rt->rt_state | RS_IF)
1385 & ~(RS_NET_SYN | RS_LOCAL)),
1390 if (ifp->int_transitions++ > 0)
1391 trace_act("re-install interface %s",
1394 rtadd(dst, ifp->int_mask, RS_IF, &new);