1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * $FreeBSD$ 32 */ 33 34 #include <stdint.h> 35 36 #include "defs.h" 37 #include "pathnames.h" 38 39 #ifdef __NetBSD__ 40 __RCSID("$NetBSD$"); 41 #elif defined(__FreeBSD__) 42 __RCSID("$FreeBSD$"); 43 #else 44 __RCSID("$Revision: 2.27 $"); 45 #ident "$Revision: 2.27 $" 46 #endif 47 48 struct ifhead ifnet = LIST_HEAD_INITIALIZER(ifnet); /* all interfaces */ 49 struct ifhead remote_if = LIST_HEAD_INITIALIZER(remote_if); /* remote interfaces */ 50 51 /* hash table for all interfaces, big enough to tolerate ridiculous 52 * numbers of IP aliases. Crazy numbers of aliases such as 7000 53 * still will not do well, but not just in looking up interfaces 54 * by name or address. 55 */ 56 #define AHASH_LEN 211 /* must be prime */ 57 #define AHASH(a) &ahash_tbl[(a)%AHASH_LEN] 58 static struct interface *ahash_tbl[AHASH_LEN]; 59 60 #define BHASH_LEN 211 /* must be prime */ 61 #define BHASH(a) &bhash_tbl[(a)%BHASH_LEN] 62 static struct interface *bhash_tbl[BHASH_LEN]; 63 64 65 /* hash for physical interface names. 66 * Assume there are never more 100 or 200 real interfaces, and that 67 * aliases are put on the end of the hash chains. 68 */ 69 #define NHASH_LEN 97 70 static struct interface *nhash_tbl[NHASH_LEN]; 71 72 int tot_interfaces; /* # of remote and local interfaces */ 73 int rip_interfaces; /* # of interfaces doing RIP */ 74 static int foundloopback; /* valid flag for loopaddr */ 75 naddr loopaddr; /* our address on loopback */ 76 static struct rt_spare loop_rts; 77 78 struct timeval ifinit_timer; 79 static struct timeval last_ifinit; 80 #define IF_RESCAN_DELAY() (last_ifinit.tv_sec == now.tv_sec \ 81 && last_ifinit.tv_usec == now.tv_usec \ 82 && timercmp(&ifinit_timer, &now, >)) 83 84 int have_ripv1_out; /* have a RIPv1 interface */ 85 static int have_ripv1_in; 86 87 88 static void if_bad(struct interface *); 89 static int addrouteforif(struct interface *); 90 91 static struct interface** 92 nhash(char *p) 93 { 94 u_int i; 95 96 for (i = 0; *p != '\0'; p++) { 97 i = ((i<<1) & 0x7fffffff) | ((i>>31) & 1); 98 i ^= *p; 99 } 100 return &nhash_tbl[i % NHASH_LEN]; 101 } 102 103 104 /* Link a new interface into the lists and hash tables. 105 */ 106 void 107 if_link(struct interface *ifp) 108 { 109 struct interface **hifp; 110 111 LIST_INSERT_HEAD(&ifnet, ifp, int_list); 112 113 hifp = AHASH(ifp->int_addr); 114 ifp->int_ahash_prev = hifp; 115 if ((ifp->int_ahash = *hifp) != NULL) 116 (*hifp)->int_ahash_prev = &ifp->int_ahash; 117 *hifp = ifp; 118 119 if (ifp->int_if_flags & IFF_BROADCAST) { 120 hifp = BHASH(ifp->int_brdaddr); 121 ifp->int_bhash_prev = hifp; 122 if ((ifp->int_bhash = *hifp) != NULL) 123 (*hifp)->int_bhash_prev = &ifp->int_bhash; 124 *hifp = ifp; 125 } 126 127 if (ifp->int_state & IS_REMOTE) 128 LIST_INSERT_HEAD(&remote_if, ifp, remote_list); 129 130 hifp = nhash(ifp->int_name); 131 if (ifp->int_state & IS_ALIAS) { 132 /* put aliases on the end of the hash chain */ 133 while (*hifp != NULL) 134 hifp = &(*hifp)->int_nhash; 135 } 136 ifp->int_nhash_prev = hifp; 137 if ((ifp->int_nhash = *hifp) != NULL) 138 (*hifp)->int_nhash_prev = &ifp->int_nhash; 139 *hifp = ifp; 140 } 141 142 143 /* Find the interface with an address 144 */ 145 struct interface * 146 ifwithaddr(naddr addr, 147 int bcast, /* notice IFF_BROADCAST address */ 148 int remote) /* include IS_REMOTE interfaces */ 149 { 150 struct interface *ifp, *possible = NULL; 151 152 remote = (remote == 0) ? IS_REMOTE : 0; 153 154 for (ifp = *AHASH(addr); ifp; ifp = ifp->int_ahash) { 155 if (ifp->int_addr != addr) 156 continue; 157 if ((ifp->int_state & remote) != 0) 158 continue; 159 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0) 160 return ifp; 161 possible = ifp; 162 } 163 164 if (possible || !bcast) 165 return possible; 166 167 for (ifp = *BHASH(addr); ifp; ifp = ifp->int_bhash) { 168 if (ifp->int_brdaddr != addr) 169 continue; 170 if ((ifp->int_state & remote) != 0) 171 continue; 172 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0) 173 return ifp; 174 possible = ifp; 175 } 176 177 return possible; 178 } 179 180 181 /* find the interface with a name 182 */ 183 static struct interface * 184 ifwithname(char *name, /* "ec0" or whatever */ 185 naddr addr) /* 0 or network address */ 186 { 187 struct interface *ifp; 188 189 for (;;) { 190 for (ifp = *nhash(name); ifp != NULL; ifp = ifp->int_nhash) { 191 /* If the network address is not specified, 192 * ignore any alias interfaces. Otherwise, look 193 * for the interface with the target name and address. 194 */ 195 if (!strcmp(ifp->int_name, name) 196 && ((addr == 0 && !(ifp->int_state & IS_ALIAS)) 197 || (ifp->int_addr == addr))) 198 return ifp; 199 } 200 201 /* If there is no known interface, maybe there is a 202 * new interface. So just once look for new interfaces. 203 */ 204 if (IF_RESCAN_DELAY()) 205 return 0; 206 ifinit(); 207 } 208 } 209 210 211 struct interface * 212 ifwithindex(u_short ifindex, 213 int rescan_ok) 214 { 215 struct interface *ifp; 216 217 for (;;) { 218 LIST_FOREACH(ifp, &ifnet, int_list) { 219 if (ifp->int_index == ifindex) 220 return ifp; 221 } 222 223 /* If there is no known interface, maybe there is a 224 * new interface. So just once look for new interfaces. 225 */ 226 if (!rescan_ok 227 || IF_RESCAN_DELAY()) 228 return 0; 229 ifinit(); 230 } 231 } 232 233 234 /* Find an interface from which the specified address 235 * should have come from. Used for figuring out which 236 * interface a packet came in on. 237 */ 238 struct interface * 239 iflookup(naddr addr) 240 { 241 struct interface *ifp, *maybe; 242 int once = 0; 243 244 maybe = NULL; 245 for (;;) { 246 LIST_FOREACH(ifp, &ifnet, int_list) { 247 if (ifp->int_if_flags & IFF_POINTOPOINT) { 248 /* finished with a match */ 249 if (ifp->int_dstaddr == addr) 250 return ifp; 251 252 } else { 253 /* finished with an exact match */ 254 if (ifp->int_addr == addr) 255 return ifp; 256 257 /* Look for the longest approximate match. 258 */ 259 if (on_net(addr, ifp->int_net, ifp->int_mask) 260 && (maybe == NULL 261 || ifp->int_mask > maybe->int_mask)) 262 maybe = ifp; 263 } 264 } 265 266 if (maybe != NULL || once || IF_RESCAN_DELAY()) 267 return maybe; 268 once = 1; 269 270 /* If there is no known interface, maybe there is a 271 * new interface. So just once look for new interfaces. 272 */ 273 ifinit(); 274 } 275 } 276 277 278 /* Return the classical netmask for an IP address. 279 */ 280 naddr /* host byte order */ 281 std_mask(naddr addr) /* network byte order */ 282 { 283 addr = ntohl(addr); /* was a host, not a network */ 284 285 if (addr == 0) /* default route has mask 0 */ 286 return 0; 287 if (IN_CLASSA(addr)) 288 return IN_CLASSA_NET; 289 if (IN_CLASSB(addr)) 290 return IN_CLASSB_NET; 291 return IN_CLASSC_NET; 292 } 293 294 295 /* Find the netmask that would be inferred by RIPv1 listeners 296 * on the given interface for a given network. 297 * If no interface is specified, look for the best fitting interface. 298 */ 299 naddr 300 ripv1_mask_net(naddr addr, /* in network byte order */ 301 struct interface *ifp) /* as seen on this interface */ 302 { 303 struct r1net *r1p; 304 naddr mask = 0; 305 306 if (addr == 0) /* default always has 0 mask */ 307 return mask; 308 309 if (ifp != NULL && ifp->int_ripv1_mask != HOST_MASK) { 310 /* If the target network is that of the associated interface 311 * on which it arrived, then use the netmask of the interface. 312 */ 313 if (on_net(addr, ifp->int_net, ifp->int_std_mask)) 314 mask = ifp->int_ripv1_mask; 315 316 } else { 317 /* Examine all interfaces, and if it the target seems 318 * to have the same network number of an interface, use the 319 * netmask of that interface. If there is more than one 320 * such interface, prefer the interface with the longest 321 * match. 322 */ 323 LIST_FOREACH(ifp, &ifnet, int_list) { 324 if (on_net(addr, ifp->int_std_net, ifp->int_std_mask) 325 && ifp->int_ripv1_mask > mask 326 && ifp->int_ripv1_mask != HOST_MASK) 327 mask = ifp->int_ripv1_mask; 328 } 329 330 } 331 332 /* check special definitions */ 333 if (mask == 0) { 334 for (r1p = r1nets; r1p != NULL; r1p = r1p->r1net_next) { 335 if (on_net(addr, r1p->r1net_net, r1p->r1net_match) 336 && r1p->r1net_mask > mask) 337 mask = r1p->r1net_mask; 338 } 339 340 /* Otherwise, make the classic A/B/C guess. 341 */ 342 if (mask == 0) 343 mask = std_mask(addr); 344 } 345 346 return mask; 347 } 348 349 350 naddr 351 ripv1_mask_host(naddr addr, /* in network byte order */ 352 struct interface *ifp) /* as seen on this interface */ 353 { 354 naddr mask = ripv1_mask_net(addr, ifp); 355 356 357 /* If the computed netmask does not mask the address, 358 * then assume it is a host address 359 */ 360 if ((ntohl(addr) & ~mask) != 0) 361 mask = HOST_MASK; 362 return mask; 363 } 364 365 366 /* See if an IP address looks reasonable as a destination. 367 */ 368 int /* 0=bad */ 369 check_dst(naddr addr) 370 { 371 addr = ntohl(addr); 372 373 if (IN_CLASSA(addr)) { 374 if (addr == 0) 375 return 1; /* default */ 376 377 addr >>= IN_CLASSA_NSHIFT; 378 return (addr != 0 && addr != IN_LOOPBACKNET); 379 } 380 381 return (IN_CLASSB(addr) || IN_CLASSC(addr)); 382 } 383 384 385 /* See a new interface duplicates an existing interface. 386 */ 387 struct interface * 388 check_dup(naddr addr, /* IP address, so network byte order */ 389 naddr dstaddr, /* ditto */ 390 naddr mask, /* mask, so host byte order */ 391 int if_flags) 392 { 393 struct interface *ifp; 394 395 LIST_FOREACH(ifp, &ifnet, int_list) { 396 if (ifp->int_mask != mask) 397 continue; 398 399 if (!iff_up(ifp->int_if_flags)) 400 continue; 401 402 /* The local address can only be shared with a point-to-point 403 * link. 404 */ 405 if ((!(ifp->int_state & IS_REMOTE) || !(if_flags & IS_REMOTE)) 406 && ifp->int_addr == addr 407 && (((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0)) 408 return ifp; 409 410 if (on_net(ifp->int_dstaddr, ntohl(dstaddr),mask)) 411 return ifp; 412 } 413 return 0; 414 } 415 416 417 /* See that a remote gateway is reachable. 418 * Note that the answer can change as real interfaces come and go. 419 */ 420 int /* 0=bad */ 421 check_remote(struct interface *ifp) 422 { 423 struct rt_entry *rt; 424 425 /* do not worry about other kinds */ 426 if (!(ifp->int_state & IS_REMOTE)) 427 return 1; 428 429 rt = rtfind(ifp->int_addr); 430 if (rt != NULL 431 && rt->rt_ifp != 0 432 &&on_net(ifp->int_addr, 433 rt->rt_ifp->int_net, rt->rt_ifp->int_mask)) 434 return 1; 435 436 /* the gateway cannot be reached directly from one of our 437 * interfaces 438 */ 439 if (!(ifp->int_state & IS_BROKE)) { 440 msglog("unreachable gateway %s in "_PATH_GATEWAYS, 441 naddr_ntoa(ifp->int_addr)); 442 if_bad(ifp); 443 } 444 return 0; 445 } 446 447 448 /* Delete an interface. 449 */ 450 static void 451 ifdel(struct interface *ifp) 452 { 453 struct interface *ifp1; 454 455 456 trace_if("Del", ifp); 457 458 ifp->int_state |= IS_BROKE; 459 460 LIST_REMOVE(ifp, int_list); 461 *ifp->int_ahash_prev = ifp->int_ahash; 462 if (ifp->int_ahash != 0) 463 ifp->int_ahash->int_ahash_prev = ifp->int_ahash_prev; 464 *ifp->int_nhash_prev = ifp->int_nhash; 465 if (ifp->int_nhash != 0) 466 ifp->int_nhash->int_nhash_prev = ifp->int_nhash_prev; 467 if (ifp->int_if_flags & IFF_BROADCAST) { 468 *ifp->int_bhash_prev = ifp->int_bhash; 469 if (ifp->int_bhash != 0) 470 ifp->int_bhash->int_bhash_prev = ifp->int_bhash_prev; 471 } 472 if (ifp->int_state & IS_REMOTE) 473 LIST_REMOVE(ifp, remote_list); 474 475 if (!(ifp->int_state & IS_ALIAS)) { 476 /* delete aliases when the main interface dies 477 */ 478 LIST_FOREACH(ifp1, &ifnet, int_list) { 479 if (ifp1 != ifp 480 && !strcmp(ifp->int_name, ifp1->int_name)) 481 ifdel(ifp1); 482 } 483 484 if ((ifp->int_if_flags & IFF_MULTICAST) && rip_sock >= 0) { 485 struct group_req gr; 486 struct sockaddr_in *sin; 487 488 memset(&gr, 0, sizeof(gr)); 489 gr.gr_interface = ifp->int_index; 490 sin = (struct sockaddr_in *)&gr.gr_group; 491 sin->sin_family = AF_INET; 492 #ifdef _HAVE_SIN_LEN 493 sin->sin_len = sizeof(struct sockaddr_in); 494 #endif 495 sin->sin_addr.s_addr = htonl(INADDR_RIP_GROUP); 496 if (setsockopt(rip_sock, IPPROTO_IP, MCAST_LEAVE_GROUP, 497 &gr, sizeof(gr)) < 0 498 && errno != EADDRNOTAVAIL 499 && !TRACEACTIONS) 500 LOGERR("setsockopt(MCAST_LEAVE_GROUP RIP)"); 501 if (rip_sock_mcast == ifp) 502 rip_sock_mcast = NULL; 503 } 504 if (ifp->int_rip_sock >= 0) { 505 (void)close(ifp->int_rip_sock); 506 ifp->int_rip_sock = -1; 507 fix_select(); 508 } 509 510 tot_interfaces--; 511 if (!IS_RIP_OFF(ifp->int_state)) 512 rip_interfaces--; 513 514 /* Zap all routes associated with this interface. 515 * Assume routes just using gateways beyond this interface 516 * will timeout naturally, and have probably already died. 517 */ 518 (void)rn_walktree(rhead, walk_bad, 0); 519 520 set_rdisc_mg(ifp, 0); 521 if_bad_rdisc(ifp); 522 } 523 524 free(ifp); 525 } 526 527 528 /* Mark an interface ill. 529 */ 530 void 531 if_sick(struct interface *ifp) 532 { 533 if (0 == (ifp->int_state & (IS_SICK | IS_BROKE))) { 534 ifp->int_state |= IS_SICK; 535 ifp->int_act_time = NEVER; 536 trace_if("Chg", ifp); 537 538 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL); 539 } 540 } 541 542 543 /* Mark an interface dead. 544 */ 545 static void 546 if_bad(struct interface *ifp) 547 { 548 struct interface *ifp1; 549 550 551 if (ifp->int_state & IS_BROKE) 552 return; 553 554 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL); 555 556 ifp->int_state |= (IS_BROKE | IS_SICK); 557 ifp->int_act_time = NEVER; 558 ifp->int_query_time = NEVER; 559 ifp->int_data.ts = now.tv_sec; 560 561 trace_if("Chg", ifp); 562 563 if (!(ifp->int_state & IS_ALIAS)) { 564 LIST_FOREACH(ifp1, &ifnet, int_list) { 565 if (ifp1 != ifp 566 && !strcmp(ifp->int_name, ifp1->int_name)) 567 if_bad(ifp1); 568 } 569 (void)rn_walktree(rhead, walk_bad, 0); 570 if_bad_rdisc(ifp); 571 } 572 } 573 574 575 /* Mark an interface alive 576 */ 577 int /* 1=it was dead */ 578 if_ok(struct interface *ifp, 579 const char *type) 580 { 581 struct interface *ifp1; 582 583 584 if (!(ifp->int_state & IS_BROKE)) { 585 if (ifp->int_state & IS_SICK) { 586 trace_act("%sinterface %s to %s working better", 587 type, 588 ifp->int_name, naddr_ntoa(ifp->int_dstaddr)); 589 ifp->int_state &= ~IS_SICK; 590 } 591 return 0; 592 } 593 594 msglog("%sinterface %s to %s restored", 595 type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr)); 596 ifp->int_state &= ~(IS_BROKE | IS_SICK); 597 ifp->int_data.ts = 0; 598 599 if (!(ifp->int_state & IS_ALIAS)) { 600 LIST_FOREACH(ifp1, &ifnet, int_list) { 601 if (ifp1 != ifp 602 && !strcmp(ifp->int_name, ifp1->int_name)) 603 if_ok(ifp1, type); 604 } 605 if_ok_rdisc(ifp); 606 } 607 608 if (ifp->int_state & IS_REMOTE) { 609 if (!addrouteforif(ifp)) 610 return 0; 611 } 612 return 1; 613 } 614 615 616 /* disassemble routing message 617 */ 618 void 619 rt_xaddrs(struct rt_addrinfo *info, 620 struct sockaddr *sa, 621 struct sockaddr *lim, 622 int addrs) 623 { 624 int i; 625 #ifdef _HAVE_SA_LEN 626 static struct sockaddr sa_zero; 627 #endif 628 629 memset(info, 0, sizeof(*info)); 630 info->rti_addrs = addrs; 631 for (i = 0; i < RTAX_MAX && sa < lim; i++) { 632 if ((addrs & (1 << i)) == 0) 633 continue; 634 info->rti_info[i] = (sa->sa_len != 0) ? sa : &sa_zero; 635 sa = (struct sockaddr *)((char*)(sa) + SA_SIZE(sa)); 636 } 637 } 638 639 640 /* Find the network interfaces which have configured themselves. 641 * This must be done regularly, if only for extra addresses 642 * that come and go on interfaces. 643 */ 644 void 645 ifinit(void) 646 { 647 static struct ifa_msghdr *sysctl_buf; 648 static size_t sysctl_buf_size = 0; 649 uint complaints = 0; 650 static u_int prev_complaints = 0; 651 # define COMP_NOT_INET 0x001 652 # define COMP_NOADDR 0x002 653 # define COMP_BADADDR 0x004 654 # define COMP_NODST 0x008 655 # define COMP_NOBADR 0x010 656 # define COMP_NOMASK 0x020 657 # define COMP_DUP 0x040 658 # define COMP_BAD_METRIC 0x080 659 # define COMP_NETMASK 0x100 660 661 struct interface ifs, ifs0, *ifp, *ifp1; 662 struct rt_entry *rt; 663 size_t needed; 664 int mib[6]; 665 struct if_msghdr *ifm; 666 void *ifam_lim; 667 struct ifa_msghdr *ifam, *ifam2; 668 int in, ierr, out, oerr; 669 struct intnet *intnetp; 670 struct rt_addrinfo info; 671 #ifdef SIOCGIFMETRIC 672 struct ifreq ifr; 673 #endif 674 675 676 last_ifinit = now; 677 ifinit_timer.tv_sec = now.tv_sec + (supplier 678 ? CHECK_ACT_INTERVAL 679 : CHECK_QUIET_INTERVAL); 680 681 /* mark all interfaces so we can get rid of those that disappear */ 682 LIST_FOREACH(ifp, &ifnet, int_list) 683 ifp->int_state &= ~(IS_CHECKED | IS_DUP); 684 685 /* Fetch the interface list, without too many system calls 686 * since we do it repeatedly. 687 */ 688 mib[0] = CTL_NET; 689 mib[1] = PF_ROUTE; 690 mib[2] = 0; 691 mib[3] = AF_INET; 692 mib[4] = NET_RT_IFLIST; 693 mib[5] = 0; 694 for (;;) { 695 if ((needed = sysctl_buf_size) != 0) { 696 if (sysctl(mib, 6, sysctl_buf,&needed, 0, 0) >= 0) 697 break; 698 /* retry if the table grew */ 699 if (errno != ENOMEM && errno != EFAULT) 700 BADERR(1, "ifinit: sysctl(RT_IFLIST)"); 701 free(sysctl_buf); 702 needed = 0; 703 } 704 if (sysctl(mib, 6, 0, &needed, 0, 0) < 0) 705 BADERR(1,"ifinit: sysctl(RT_IFLIST) estimate"); 706 sysctl_buf = rtmalloc(sysctl_buf_size = needed, 707 "ifinit sysctl"); 708 } 709 710 /* XXX: thanks to malloc(3), alignment can be presumed OK */ 711 ifam_lim = (char *)sysctl_buf + needed; 712 for (ifam = sysctl_buf; (void *)ifam < ifam_lim; ifam = ifam2) { 713 714 ifam2 = (struct ifa_msghdr*)((char*)ifam + ifam->ifam_msglen); 715 716 #ifdef RTM_OIFINFO 717 if (ifam->ifam_type == RTM_OIFINFO) 718 continue; /* just ignore compat message */ 719 #endif 720 if (ifam->ifam_type == RTM_IFINFO) { 721 struct sockaddr_dl *sdl; 722 723 ifm = (struct if_msghdr *)ifam; 724 /* make prototype structure for the IP aliases 725 */ 726 memset(&ifs0, 0, sizeof(ifs0)); 727 ifs0.int_rip_sock = -1; 728 ifs0.int_index = ifm->ifm_index; 729 ifs0.int_if_flags = ifm->ifm_flags; 730 ifs0.int_state = IS_CHECKED; 731 ifs0.int_query_time = NEVER; 732 ifs0.int_act_time = now.tv_sec; 733 ifs0.int_data.ts = now.tv_sec; 734 ifs0.int_data.ipackets = ifm->ifm_data.ifi_ipackets; 735 ifs0.int_data.ierrors = ifm->ifm_data.ifi_ierrors; 736 ifs0.int_data.opackets = ifm->ifm_data.ifi_opackets; 737 ifs0.int_data.oerrors = ifm->ifm_data.ifi_oerrors; 738 #ifdef sgi 739 ifs0.int_data.odrops = ifm->ifm_data.ifi_odrops; 740 #endif 741 sdl = (struct sockaddr_dl *)(ifm + 1); 742 sdl->sdl_data[sdl->sdl_nlen] = 0; 743 strncpy(ifs0.int_name, sdl->sdl_data, 744 MIN(sizeof(ifs0.int_name), sdl->sdl_nlen)); 745 continue; 746 } 747 if (ifam->ifam_type != RTM_NEWADDR) { 748 logbad(1,"ifinit: out of sync"); 749 continue; 750 } 751 rt_xaddrs(&info, (struct sockaddr *)(ifam+1), 752 (struct sockaddr *)ifam2, 753 ifam->ifam_addrs); 754 755 /* Prepare for the next address of this interface, which 756 * will be an alias. 757 * Do not output RIP or Router-Discovery packets via aliases. 758 */ 759 memcpy(&ifs, &ifs0, sizeof(ifs)); 760 ifs0.int_state |= (IS_ALIAS | IS_NO_RIP_OUT | IS_NO_RDISC); 761 762 if (INFO_IFA(&info) == 0) { 763 if (iff_up(ifs.int_if_flags)) { 764 if (!(prev_complaints & COMP_NOADDR)) 765 msglog("%s has no address", 766 ifs.int_name); 767 complaints |= COMP_NOADDR; 768 } 769 continue; 770 } 771 if (INFO_IFA(&info)->sa_family != AF_INET) { 772 if (iff_up(ifs.int_if_flags)) { 773 if (!(prev_complaints & COMP_NOT_INET)) 774 trace_act("%s: not AF_INET", 775 ifs.int_name); 776 complaints |= COMP_NOT_INET; 777 } 778 continue; 779 } 780 781 ifs.int_addr = S_ADDR(INFO_IFA(&info)); 782 783 if (ntohl(ifs.int_addr)>>24 == 0 784 || ntohl(ifs.int_addr)>>24 == 0xff) { 785 if (iff_up(ifs.int_if_flags)) { 786 if (!(prev_complaints & COMP_BADADDR)) 787 msglog("%s has a bad address", 788 ifs.int_name); 789 complaints |= COMP_BADADDR; 790 } 791 continue; 792 } 793 794 if (ifs.int_if_flags & IFF_LOOPBACK) { 795 ifs.int_state |= IS_NO_RIP | IS_NO_RDISC; 796 if (ifs.int_addr == htonl(INADDR_LOOPBACK)) 797 ifs.int_state |= IS_PASSIVE; 798 ifs.int_dstaddr = ifs.int_addr; 799 ifs.int_mask = HOST_MASK; 800 ifs.int_ripv1_mask = HOST_MASK; 801 ifs.int_std_mask = std_mask(ifs.int_dstaddr); 802 ifs.int_net = ntohl(ifs.int_dstaddr); 803 if (!foundloopback) { 804 foundloopback = 1; 805 loopaddr = ifs.int_addr; 806 loop_rts.rts_gate = loopaddr; 807 loop_rts.rts_router = loopaddr; 808 } 809 810 } else if (ifs.int_if_flags & IFF_POINTOPOINT) { 811 if (INFO_BRD(&info) == 0 812 || INFO_BRD(&info)->sa_family != AF_INET) { 813 if (iff_up(ifs.int_if_flags)) { 814 if (!(prev_complaints & COMP_NODST)) 815 msglog("%s has a bad" 816 " destination address", 817 ifs.int_name); 818 complaints |= COMP_NODST; 819 } 820 continue; 821 } 822 ifs.int_dstaddr = S_ADDR(INFO_BRD(&info)); 823 if (ntohl(ifs.int_dstaddr)>>24 == 0 824 || ntohl(ifs.int_dstaddr)>>24 == 0xff) { 825 if (iff_up(ifs.int_if_flags)) { 826 if (!(prev_complaints & COMP_NODST)) 827 msglog("%s has a bad" 828 " destination address", 829 ifs.int_name); 830 complaints |= COMP_NODST; 831 } 832 continue; 833 } 834 ifs.int_mask = HOST_MASK; 835 ifs.int_ripv1_mask = ntohl(S_ADDR(INFO_MASK(&info))); 836 ifs.int_std_mask = std_mask(ifs.int_dstaddr); 837 ifs.int_net = ntohl(ifs.int_dstaddr); 838 839 } else { 840 if (INFO_MASK(&info) == 0) { 841 if (iff_up(ifs.int_if_flags)) { 842 if (!(prev_complaints & COMP_NOMASK)) 843 msglog("%s has no netmask", 844 ifs.int_name); 845 complaints |= COMP_NOMASK; 846 } 847 continue; 848 } 849 ifs.int_dstaddr = ifs.int_addr; 850 ifs.int_mask = ntohl(S_ADDR(INFO_MASK(&info))); 851 ifs.int_ripv1_mask = ifs.int_mask; 852 ifs.int_std_mask = std_mask(ifs.int_addr); 853 ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask; 854 if (ifs.int_mask != ifs.int_std_mask) 855 ifs.int_state |= IS_SUBNET; 856 857 if (ifs.int_if_flags & IFF_BROADCAST) { 858 if (INFO_BRD(&info) == 0) { 859 if (iff_up(ifs.int_if_flags)) { 860 if (!(prev_complaints 861 & COMP_NOBADR)) 862 msglog("%s has" 863 "no broadcast address", 864 ifs.int_name); 865 complaints |= COMP_NOBADR; 866 } 867 continue; 868 } 869 ifs.int_brdaddr = S_ADDR(INFO_BRD(&info)); 870 } 871 } 872 ifs.int_std_net = ifs.int_net & ifs.int_std_mask; 873 ifs.int_std_addr = htonl(ifs.int_std_net); 874 875 /* Use a minimum metric of one. Treat the interface metric 876 * (default 0) as an increment to the hop count of one. 877 * 878 * The metric obtained from the routing socket dump of 879 * interface addresses is wrong. It is not set by the 880 * SIOCSIFMETRIC ioctl. 881 */ 882 #ifdef SIOCGIFMETRIC 883 strncpy(ifr.ifr_name, ifs.int_name, sizeof(ifr.ifr_name)); 884 if (ioctl(rt_sock, SIOCGIFMETRIC, &ifr) < 0) { 885 DBGERR(1, "ioctl(SIOCGIFMETRIC)"); 886 ifs.int_metric = 0; 887 } else { 888 ifs.int_metric = ifr.ifr_metric; 889 } 890 #else 891 ifs.int_metric = ifam->ifam_metric; 892 #endif 893 if (ifs.int_metric > HOPCNT_INFINITY) { 894 ifs.int_metric = 0; 895 if (!(prev_complaints & COMP_BAD_METRIC) 896 && iff_up(ifs.int_if_flags)) { 897 complaints |= COMP_BAD_METRIC; 898 msglog("%s has a metric of %d", 899 ifs.int_name, ifs.int_metric); 900 } 901 } 902 903 /* See if this is a familiar interface. 904 * If so, stop worrying about it if it is the same. 905 * Start it over if it now is to somewhere else, as happens 906 * frequently with PPP and SLIP. 907 */ 908 ifp = ifwithname(ifs.int_name, ((ifs.int_state & IS_ALIAS) 909 ? ifs.int_addr 910 : 0)); 911 if (ifp != NULL) { 912 ifp->int_state |= IS_CHECKED; 913 914 if (0 != ((ifp->int_if_flags ^ ifs.int_if_flags) 915 & (IFF_BROADCAST 916 | IFF_LOOPBACK 917 | IFF_POINTOPOINT 918 | IFF_MULTICAST)) 919 || 0 != ((ifp->int_state ^ ifs.int_state) 920 & IS_ALIAS) 921 || ifp->int_addr != ifs.int_addr 922 || ifp->int_brdaddr != ifs.int_brdaddr 923 || ifp->int_dstaddr != ifs.int_dstaddr 924 || ifp->int_mask != ifs.int_mask 925 || ifp->int_metric != ifs.int_metric) { 926 /* Forget old information about 927 * a changed interface. 928 */ 929 trace_act("interface %s has changed", 930 ifp->int_name); 931 ifdel(ifp); 932 ifp = NULL; 933 } 934 } 935 936 if (ifp != NULL) { 937 /* The primary representative of an alias worries 938 * about how things are working. 939 */ 940 if (ifp->int_state & IS_ALIAS) 941 continue; 942 943 /* note interfaces that have been turned off 944 */ 945 if (!iff_up(ifs.int_if_flags)) { 946 if (iff_up(ifp->int_if_flags)) { 947 msglog("interface %s to %s turned off", 948 ifp->int_name, 949 naddr_ntoa(ifp->int_dstaddr)); 950 if_bad(ifp); 951 ifp->int_if_flags &= ~IFF_UP; 952 } else if (now.tv_sec>(ifp->int_data.ts 953 + CHECK_BAD_INTERVAL)) { 954 trace_act("interface %s has been off" 955 " %jd seconds; forget it", 956 ifp->int_name, 957 (intmax_t)now.tv_sec - 958 ifp->int_data.ts); 959 ifdel(ifp); 960 ifp = NULL; 961 } 962 continue; 963 } 964 /* or that were off and are now ok */ 965 if (!iff_up(ifp->int_if_flags)) { 966 ifp->int_if_flags |= IFF_UP; 967 (void)if_ok(ifp, ""); 968 } 969 970 /* If it has been long enough, 971 * see if the interface is broken. 972 */ 973 if (now.tv_sec < ifp->int_data.ts+CHECK_BAD_INTERVAL) 974 continue; 975 976 in = ifs.int_data.ipackets - ifp->int_data.ipackets; 977 ierr = ifs.int_data.ierrors - ifp->int_data.ierrors; 978 out = ifs.int_data.opackets - ifp->int_data.opackets; 979 oerr = ifs.int_data.oerrors - ifp->int_data.oerrors; 980 #ifdef sgi 981 /* Through at least IRIX 6.2, PPP and SLIP 982 * count packets dropped by the filters. 983 * But FDDI rings stuck non-operational count 984 * dropped packets as they wait for improvement. 985 */ 986 if (!(ifp->int_if_flags & IFF_POINTOPOINT)) 987 oerr += (ifs.int_data.odrops 988 - ifp->int_data.odrops); 989 #endif 990 /* If the interface just awoke, restart the counters. 991 */ 992 if (ifp->int_data.ts == 0) { 993 ifp->int_data = ifs.int_data; 994 continue; 995 } 996 ifp->int_data = ifs.int_data; 997 998 /* Withhold judgment when the short error 999 * counters wrap or the interface is reset. 1000 */ 1001 if (ierr < 0 || in < 0 || oerr < 0 || out < 0) { 1002 LIM_SEC(ifinit_timer, 1003 now.tv_sec+CHECK_BAD_INTERVAL); 1004 continue; 1005 } 1006 1007 /* Withhold judgement when there is no traffic 1008 */ 1009 if (in == 0 && out == 0 && ierr == 0 && oerr == 0) 1010 continue; 1011 1012 /* It is bad if input or output is not working. 1013 * Require presistent problems before marking it dead. 1014 */ 1015 if ((in <= ierr && ierr > 0) 1016 || (out <= oerr && oerr > 0)) { 1017 if (!(ifp->int_state & IS_SICK)) { 1018 trace_act("interface %s to %s" 1019 " sick: in=%d ierr=%d" 1020 " out=%d oerr=%d", 1021 ifp->int_name, 1022 naddr_ntoa(ifp->int_dstaddr), 1023 in, ierr, out, oerr); 1024 if_sick(ifp); 1025 continue; 1026 } 1027 if (!(ifp->int_state & IS_BROKE)) { 1028 msglog("interface %s to %s broken:" 1029 " in=%d ierr=%d out=%d oerr=%d", 1030 ifp->int_name, 1031 naddr_ntoa(ifp->int_dstaddr), 1032 in, ierr, out, oerr); 1033 if_bad(ifp); 1034 } 1035 continue; 1036 } 1037 1038 /* otherwise, it is active and healthy 1039 */ 1040 ifp->int_act_time = now.tv_sec; 1041 (void)if_ok(ifp, ""); 1042 continue; 1043 } 1044 1045 /* This is a new interface. 1046 * If it is dead, forget it. 1047 */ 1048 if (!iff_up(ifs.int_if_flags)) 1049 continue; 1050 1051 /* If it duplicates an existing interface, 1052 * complain about it, mark the other one 1053 * duplicated, and forget this one. 1054 */ 1055 ifp = check_dup(ifs.int_addr,ifs.int_dstaddr,ifs.int_mask, 1056 ifs.int_if_flags); 1057 if (ifp != NULL) { 1058 /* Ignore duplicates of itself, caused by having 1059 * IP aliases on the same network. 1060 */ 1061 if (!strcmp(ifp->int_name, ifs.int_name)) 1062 continue; 1063 1064 if (!(prev_complaints & COMP_DUP)) { 1065 complaints |= COMP_DUP; 1066 msglog("%s (%s%s%s) is duplicated by" 1067 " %s (%s%s%s)", 1068 ifs.int_name, 1069 addrname(ifs.int_addr,ifs.int_mask,1), 1070 ((ifs.int_if_flags & IFF_POINTOPOINT) 1071 ? "-->" : ""), 1072 ((ifs.int_if_flags & IFF_POINTOPOINT) 1073 ? naddr_ntoa(ifs.int_dstaddr) : ""), 1074 ifp->int_name, 1075 addrname(ifp->int_addr,ifp->int_mask,1), 1076 ((ifp->int_if_flags & IFF_POINTOPOINT) 1077 ? "-->" : ""), 1078 ((ifp->int_if_flags & IFF_POINTOPOINT) 1079 ? naddr_ntoa(ifp->int_dstaddr) : "")); 1080 } 1081 ifp->int_state |= IS_DUP; 1082 continue; 1083 } 1084 1085 if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT | IFF_BROADCAST | IFF_LOOPBACK))) { 1086 trace_act("%s is neither broadcast, point-to-point," 1087 " nor loopback", 1088 ifs.int_name); 1089 if (!(ifs.int_state & IFF_MULTICAST)) 1090 ifs.int_state |= IS_NO_RDISC; 1091 } 1092 1093 1094 /* It is new and ok. Add it to the list of interfaces 1095 */ 1096 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "ifinit ifp"); 1097 memcpy(ifp, &ifs, sizeof(*ifp)); 1098 get_parms(ifp); 1099 if_link(ifp); 1100 trace_if("Add", ifp); 1101 1102 /* Notice likely bad netmask. 1103 */ 1104 if (!(prev_complaints & COMP_NETMASK) 1105 && !(ifp->int_if_flags & IFF_POINTOPOINT) 1106 && ifp->int_addr != RIP_DEFAULT) { 1107 LIST_FOREACH(ifp1, &ifnet, int_list) { 1108 if (ifp1->int_mask == ifp->int_mask) 1109 continue; 1110 if (ifp1->int_if_flags & IFF_POINTOPOINT) 1111 continue; 1112 if (ifp1->int_dstaddr == RIP_DEFAULT) 1113 continue; 1114 /* ignore aliases on the right network */ 1115 if (!strcmp(ifp->int_name, ifp1->int_name)) 1116 continue; 1117 if (on_net(ifp->int_dstaddr, 1118 ifp1->int_net, ifp1->int_mask) 1119 || on_net(ifp1->int_dstaddr, 1120 ifp->int_net, ifp->int_mask)) { 1121 msglog("possible netmask problem" 1122 " between %s:%s and %s:%s", 1123 ifp->int_name, 1124 addrname(htonl(ifp->int_net), 1125 ifp->int_mask, 1), 1126 ifp1->int_name, 1127 addrname(htonl(ifp1->int_net), 1128 ifp1->int_mask, 1)); 1129 complaints |= COMP_NETMASK; 1130 } 1131 } 1132 } 1133 1134 if (!(ifp->int_state & IS_ALIAS)) { 1135 /* Count the # of directly connected networks. 1136 */ 1137 if (!(ifp->int_if_flags & IFF_LOOPBACK)) 1138 tot_interfaces++; 1139 if (!IS_RIP_OFF(ifp->int_state)) 1140 rip_interfaces++; 1141 1142 /* turn on router discovery and RIP If needed */ 1143 if_ok_rdisc(ifp); 1144 rip_on(ifp); 1145 } 1146 } 1147 1148 /* If we are multi-homed and have at least two interfaces 1149 * listening to RIP, then output by default. 1150 */ 1151 if (!supplier_set && rip_interfaces > 1) 1152 set_supplier(); 1153 1154 /* If we are multi-homed, optionally advertise a route to 1155 * our main address. 1156 */ 1157 if ((advertise_mhome && ifp) 1158 || (tot_interfaces > 1 1159 && mhome 1160 && (ifp = ifwithaddr(myaddr, 0, 0)) != NULL 1161 && foundloopback)) { 1162 advertise_mhome = 1; 1163 rt = rtget(myaddr, HOST_MASK); 1164 if (rt != NULL) { 1165 if (rt->rt_ifp != ifp 1166 || rt->rt_router != loopaddr) { 1167 rtdelete(rt); 1168 rt = NULL; 1169 } else { 1170 loop_rts.rts_ifp = ifp; 1171 loop_rts.rts_metric = 0; 1172 loop_rts.rts_time = rt->rt_time; 1173 rtchange(rt, rt->rt_state | RS_MHOME, 1174 &loop_rts, 0); 1175 } 1176 } 1177 if (rt == NULL) { 1178 loop_rts.rts_ifp = ifp; 1179 loop_rts.rts_metric = 0; 1180 rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts); 1181 } 1182 } 1183 1184 LIST_FOREACH_SAFE(ifp, &ifnet, int_list, ifp1) { 1185 /* Forget any interfaces that have disappeared. 1186 */ 1187 if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) { 1188 trace_act("interface %s has disappeared", 1189 ifp->int_name); 1190 ifdel(ifp); 1191 continue; 1192 } 1193 1194 if ((ifp->int_state & IS_BROKE) 1195 && !(ifp->int_state & IS_PASSIVE)) 1196 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL); 1197 1198 /* If we ever have a RIPv1 interface, assume we always will. 1199 * It might come back if it ever goes away. 1200 */ 1201 if (!(ifp->int_state & IS_NO_RIPV1_OUT) && supplier) 1202 have_ripv1_out = 1; 1203 if (!(ifp->int_state & IS_NO_RIPV1_IN)) 1204 have_ripv1_in = 1; 1205 } 1206 1207 LIST_FOREACH(ifp, &ifnet, int_list) { 1208 /* Ensure there is always a network route for interfaces, 1209 * after any dead interfaces have been deleted, which 1210 * might affect routes for point-to-point links. 1211 */ 1212 if (!addrouteforif(ifp)) 1213 continue; 1214 1215 /* Add routes to the local end of point-to-point interfaces 1216 * using loopback. 1217 */ 1218 if ((ifp->int_if_flags & IFF_POINTOPOINT) 1219 && !(ifp->int_state & IS_REMOTE) 1220 && foundloopback) { 1221 /* Delete any routes to the network address through 1222 * foreign routers. Remove even static routes. 1223 */ 1224 del_static(ifp->int_addr, HOST_MASK, 0, 0); 1225 rt = rtget(ifp->int_addr, HOST_MASK); 1226 if (rt != NULL && rt->rt_router != loopaddr) { 1227 rtdelete(rt); 1228 rt = NULL; 1229 } 1230 if (rt != NULL) { 1231 if (!(rt->rt_state & RS_LOCAL) 1232 || rt->rt_metric > ifp->int_metric) { 1233 ifp1 = ifp; 1234 } else { 1235 ifp1 = rt->rt_ifp; 1236 } 1237 loop_rts.rts_ifp = ifp1; 1238 loop_rts.rts_metric = 0; 1239 loop_rts.rts_time = rt->rt_time; 1240 rtchange(rt, ((rt->rt_state & ~RS_NET_SYN) 1241 | (RS_IF|RS_LOCAL)), 1242 &loop_rts, 0); 1243 } else { 1244 loop_rts.rts_ifp = ifp; 1245 loop_rts.rts_metric = 0; 1246 rtadd(ifp->int_addr, HOST_MASK, 1247 (RS_IF | RS_LOCAL), &loop_rts); 1248 } 1249 } 1250 } 1251 1252 /* add the authority routes */ 1253 for (intnetp = intnets; intnetp != NULL; 1254 intnetp = intnetp->intnet_next) { 1255 rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask); 1256 if (rt != NULL 1257 && !(rt->rt_state & RS_NO_NET_SYN) 1258 && !(rt->rt_state & RS_NET_INT)) { 1259 rtdelete(rt); 1260 rt = NULL; 1261 } 1262 if (rt == NULL) { 1263 loop_rts.rts_ifp = NULL; 1264 loop_rts.rts_metric = intnetp->intnet_metric-1; 1265 rtadd(intnetp->intnet_addr, intnetp->intnet_mask, 1266 RS_NET_SYN | RS_NET_INT, &loop_rts); 1267 } 1268 } 1269 1270 prev_complaints = complaints; 1271 } 1272 1273 1274 static void 1275 check_net_syn(struct interface *ifp) 1276 { 1277 struct rt_entry *rt; 1278 static struct rt_spare new; 1279 1280 1281 /* Turn on the need to automatically synthesize a network route 1282 * for this interface only if we are running RIPv1 on some other 1283 * interface that is on a different class-A,B,or C network. 1284 */ 1285 if (have_ripv1_out || have_ripv1_in) { 1286 ifp->int_state |= IS_NEED_NET_SYN; 1287 rt = rtget(ifp->int_std_addr, ifp->int_std_mask); 1288 if (rt != NULL 1289 && 0 == (rt->rt_state & RS_NO_NET_SYN) 1290 && (!(rt->rt_state & RS_NET_SYN) 1291 || rt->rt_metric > ifp->int_metric)) { 1292 rtdelete(rt); 1293 rt = NULL; 1294 } 1295 if (rt == NULL) { 1296 new.rts_ifp = ifp; 1297 new.rts_gate = ifp->int_addr; 1298 new.rts_router = ifp->int_addr; 1299 new.rts_metric = ifp->int_metric; 1300 rtadd(ifp->int_std_addr, ifp->int_std_mask, 1301 RS_NET_SYN, &new); 1302 } 1303 1304 } else { 1305 ifp->int_state &= ~IS_NEED_NET_SYN; 1306 1307 rt = rtget(ifp->int_std_addr, 1308 ifp->int_std_mask); 1309 if (rt != NULL 1310 && (rt->rt_state & RS_NET_SYN) 1311 && rt->rt_ifp == ifp) 1312 rtbad_sub(rt); 1313 } 1314 } 1315 1316 1317 /* Add route for interface if not currently installed. 1318 * Create route to other end if a point-to-point link, 1319 * otherwise a route to this (sub)network. 1320 */ 1321 static int /* 0=bad interface */ 1322 addrouteforif(struct interface *ifp) 1323 { 1324 struct rt_entry *rt; 1325 static struct rt_spare new; 1326 naddr dst; 1327 1328 1329 /* skip sick interfaces 1330 */ 1331 if (ifp->int_state & IS_BROKE) 1332 return 0; 1333 1334 /* If the interface on a subnet, then install a RIPv1 route to 1335 * the network as well (unless it is sick). 1336 */ 1337 if (ifp->int_state & IS_SUBNET) 1338 check_net_syn(ifp); 1339 1340 dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) 1341 ? ifp->int_dstaddr 1342 : htonl(ifp->int_net)); 1343 1344 new.rts_ifp = ifp; 1345 new.rts_router = ifp->int_addr; 1346 new.rts_gate = ifp->int_addr; 1347 new.rts_metric = ifp->int_metric; 1348 new.rts_time = now.tv_sec; 1349 1350 /* If we are going to send packets to the gateway, 1351 * it must be reachable using our physical interfaces 1352 */ 1353 if ((ifp->int_state & IS_REMOTE) 1354 && !(ifp->int_state & IS_EXTERNAL) 1355 && !check_remote(ifp)) 1356 return 0; 1357 1358 /* We are finished if the correct main interface route exists. 1359 * The right route must be for the right interface, not synthesized 1360 * from a subnet, be a "gateway" or not as appropriate, and so forth. 1361 */ 1362 del_static(dst, ifp->int_mask, 0, 0); 1363 rt = rtget(dst, ifp->int_mask); 1364 if (rt != NULL) { 1365 if ((rt->rt_ifp != ifp 1366 || rt->rt_router != ifp->int_addr) 1367 && (!(ifp->int_state & IS_DUP) 1368 || rt->rt_ifp == 0 1369 || (rt->rt_ifp->int_state & IS_BROKE))) { 1370 rtdelete(rt); 1371 rt = NULL; 1372 } else { 1373 rtchange(rt, ((rt->rt_state | RS_IF) 1374 & ~(RS_NET_SYN | RS_LOCAL)), 1375 &new, 0); 1376 } 1377 } 1378 if (rt == NULL) { 1379 if (ifp->int_transitions++ > 0) 1380 trace_act("re-install interface %s", 1381 ifp->int_name); 1382 1383 rtadd(dst, ifp->int_mask, RS_IF, &new); 1384 } 1385 1386 return 1; 1387 } 1388