1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 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. 16 * 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 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 */ 31 32 #include "defs.h" 33 #include "pathnames.h" 34 35 #ifdef __NetBSD__ 36 __RCSID("$NetBSD$"); 37 #elif defined(__FreeBSD__) 38 __RCSID("$FreeBSD$"); 39 #else 40 __RCSID("$Revision: 2.27 $"); 41 #ident "$Revision: 2.27 $" 42 #endif 43 44 struct interface *ifnet; /* all interfaces */ 45 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 49 * by name or address. 50 */ 51 #define AHASH_LEN 211 /* must be prime */ 52 #define AHASH(a) &ahash_tbl[(a)%AHASH_LEN] 53 struct interface *ahash_tbl[AHASH_LEN]; 54 55 #define BHASH_LEN 211 /* must be prime */ 56 #define BHASH(a) &bhash_tbl[(a)%BHASH_LEN] 57 struct interface *bhash_tbl[BHASH_LEN]; 58 59 struct interface *remote_if; /* remote interfaces */ 60 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. 64 */ 65 #define NHASH_LEN 97 66 struct interface *nhash_tbl[NHASH_LEN]; 67 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; 73 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, >)) 79 80 int have_ripv1_out; /* have a RIPv1 interface */ 81 int have_ripv1_in; 82 83 84 static struct interface** 85 nhash(char *p) 86 { 87 u_int i; 88 89 for (i = 0; *p != '\0'; p++) { 90 i = ((i<<1) & 0x7fffffff) | ((i>>31) & 1); 91 i ^= *p; 92 } 93 return &nhash_tbl[i % NHASH_LEN]; 94 } 95 96 97 /* Link a new interface into the lists and hash tables. 98 */ 99 void 100 if_link(struct interface *ifp) 101 { 102 struct interface **hifp; 103 104 ifp->int_prev = &ifnet; 105 ifp->int_next = ifnet; 106 if (ifnet != 0) 107 ifnet->int_prev = &ifp->int_next; 108 ifnet = ifp; 109 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; 114 *hifp = ifp; 115 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; 121 *hifp = ifp; 122 } 123 124 if (ifp->int_state & IS_REMOTE) { 125 ifp->int_rlink_prev = &remote_if; 126 ifp->int_rlink = remote_if; 127 if (remote_if != 0) 128 remote_if->int_rlink_prev = &ifp->int_rlink; 129 remote_if = ifp; 130 } 131 132 hifp = nhash(ifp->int_name); 133 if (ifp->int_state & IS_ALIAS) { 134 /* put aliases on the end of the hash chain */ 135 while (*hifp != 0) 136 hifp = &(*hifp)->int_nhash; 137 } 138 ifp->int_nhash_prev = hifp; 139 if ((ifp->int_nhash = *hifp) != 0) 140 (*hifp)->int_nhash_prev = &ifp->int_nhash; 141 *hifp = ifp; 142 } 143 144 145 /* Find the interface with an address 146 */ 147 struct interface * 148 ifwithaddr(naddr addr, 149 int bcast, /* notice IFF_BROADCAST address */ 150 int remote) /* include IS_REMOTE interfaces */ 151 { 152 struct interface *ifp, *possible = 0; 153 154 remote = (remote == 0) ? IS_REMOTE : 0; 155 156 for (ifp = *AHASH(addr); ifp; ifp = ifp->int_ahash) { 157 if (ifp->int_addr != addr) 158 continue; 159 if ((ifp->int_state & remote) != 0) 160 continue; 161 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0) 162 return ifp; 163 possible = ifp; 164 } 165 166 if (possible || !bcast) 167 return possible; 168 169 for (ifp = *BHASH(addr); ifp; ifp = ifp->int_bhash) { 170 if (ifp->int_brdaddr != addr) 171 continue; 172 if ((ifp->int_state & remote) != 0) 173 continue; 174 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0) 175 return ifp; 176 possible = ifp; 177 } 178 179 return possible; 180 } 181 182 183 /* find the interface with a name 184 */ 185 struct interface * 186 ifwithname(char *name, /* "ec0" or whatever */ 187 naddr addr) /* 0 or network address */ 188 { 189 struct interface *ifp; 190 191 for (;;) { 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. 196 */ 197 if (!strcmp(ifp->int_name, name) 198 && ((addr == 0 && !(ifp->int_state & IS_ALIAS)) 199 || (ifp->int_addr == addr))) 200 return ifp; 201 } 202 203 /* If there is no known interface, maybe there is a 204 * new interface. So just once look for new interfaces. 205 */ 206 if (IF_RESCAN_DELAY()) 207 return 0; 208 ifinit(); 209 } 210 } 211 212 213 struct interface * 214 ifwithindex(u_short ifindex, 215 int rescan_ok) 216 { 217 struct interface *ifp; 218 219 for (;;) { 220 for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) { 221 if (ifp->int_index == ifindex) 222 return ifp; 223 } 224 225 /* If there is no known interface, maybe there is a 226 * new interface. So just once look for new interfaces. 227 */ 228 if (!rescan_ok 229 || IF_RESCAN_DELAY()) 230 return 0; 231 ifinit(); 232 } 233 } 234 235 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. 239 */ 240 struct interface * 241 iflookup(naddr addr) 242 { 243 struct interface *ifp, *maybe; 244 int once = 0; 245 246 maybe = 0; 247 for (;;) { 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) 252 return ifp; 253 254 } else { 255 /* finished with an exact match */ 256 if (ifp->int_addr == addr) 257 return ifp; 258 259 /* Look for the longest approximate match. 260 */ 261 if (on_net(addr, ifp->int_net, ifp->int_mask) 262 && (maybe == 0 263 || ifp->int_mask > maybe->int_mask)) 264 maybe = ifp; 265 } 266 } 267 268 if (maybe != 0 || once || IF_RESCAN_DELAY()) 269 return maybe; 270 once = 1; 271 272 /* If there is no known interface, maybe there is a 273 * new interface. So just once look for new interfaces. 274 */ 275 ifinit(); 276 } 277 } 278 279 280 /* Return the classical netmask for an IP address. 281 */ 282 naddr /* host byte order */ 283 std_mask(naddr addr) /* network byte order */ 284 { 285 addr = ntohl(addr); /* was a host, not a network */ 286 287 if (addr == 0) /* default route has mask 0 */ 288 return 0; 289 if (IN_CLASSA(addr)) 290 return IN_CLASSA_NET; 291 if (IN_CLASSB(addr)) 292 return IN_CLASSB_NET; 293 return IN_CLASSC_NET; 294 } 295 296 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. 300 */ 301 naddr 302 ripv1_mask_net(naddr addr, /* in network byte order */ 303 struct interface *ifp) /* as seen on this interface */ 304 { 305 struct r1net *r1p; 306 naddr mask = 0; 307 308 if (addr == 0) /* default always has 0 mask */ 309 return mask; 310 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. 314 */ 315 if (on_net(addr, ifp->int_net, ifp->int_std_mask)) 316 mask = ifp->int_ripv1_mask; 317 318 } else { 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 323 * match. 324 */ 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; 330 } 331 332 } 333 334 /* check special definitions */ 335 if (mask == 0) { 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; 340 } 341 342 /* Otherwise, make the classic A/B/C guess. 343 */ 344 if (mask == 0) 345 mask = std_mask(addr); 346 } 347 348 return mask; 349 } 350 351 352 naddr 353 ripv1_mask_host(naddr addr, /* in network byte order */ 354 struct interface *ifp) /* as seen on this interface */ 355 { 356 naddr mask = ripv1_mask_net(addr, ifp); 357 358 359 /* If the computed netmask does not mask the address, 360 * then assume it is a host address 361 */ 362 if ((ntohl(addr) & ~mask) != 0) 363 mask = HOST_MASK; 364 return mask; 365 } 366 367 368 /* See if an IP address looks reasonable as a destination. 369 */ 370 int /* 0=bad */ 371 check_dst(naddr addr) 372 { 373 addr = ntohl(addr); 374 375 if (IN_CLASSA(addr)) { 376 if (addr == 0) 377 return 1; /* default */ 378 379 addr >>= IN_CLASSA_NSHIFT; 380 return (addr != 0 && addr != IN_LOOPBACKNET); 381 } 382 383 return (IN_CLASSB(addr) || IN_CLASSC(addr)); 384 } 385 386 387 /* See a new interface duplicates an existing interface. 388 */ 389 struct interface * 390 check_dup(naddr addr, /* IP address, so network byte order */ 391 naddr dstaddr, /* ditto */ 392 naddr mask, /* mask, so host byte order */ 393 int if_flags) 394 { 395 struct interface *ifp; 396 397 for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) { 398 if (ifp->int_mask != mask) 399 continue; 400 401 if (!iff_up(ifp->int_if_flags)) 402 continue; 403 404 /* The local address can only be shared with a point-to-point 405 * link. 406 */ 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)) 410 return ifp; 411 412 if (on_net(ifp->int_dstaddr, ntohl(dstaddr),mask)) 413 return ifp; 414 } 415 return 0; 416 } 417 418 419 /* See that a remote gateway is reachable. 420 * Note that the answer can change as real interfaces come and go. 421 */ 422 int /* 0=bad */ 423 check_remote(struct interface *ifp) 424 { 425 struct rt_entry *rt; 426 427 /* do not worry about other kinds */ 428 if (!(ifp->int_state & IS_REMOTE)) 429 return 1; 430 431 rt = rtfind(ifp->int_addr); 432 if (rt != 0 433 && rt->rt_ifp != 0 434 &&on_net(ifp->int_addr, 435 rt->rt_ifp->int_net, rt->rt_ifp->int_mask)) 436 return 1; 437 438 /* the gateway cannot be reached directly from one of our 439 * interfaces 440 */ 441 if (!(ifp->int_state & IS_BROKE)) { 442 msglog("unreachable gateway %s in "_PATH_GATEWAYS, 443 naddr_ntoa(ifp->int_addr)); 444 if_bad(ifp); 445 } 446 return 0; 447 } 448 449 450 /* Delete an interface. 451 */ 452 static void 453 ifdel(struct interface *ifp) 454 { 455 struct ip_mreq m; 456 struct interface *ifp1; 457 458 459 trace_if("Del", ifp); 460 461 ifp->int_state |= IS_BROKE; 462 463 /* unlink the interface 464 */ 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; 478 } 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; 483 } 484 485 if (!(ifp->int_state & IS_ALIAS)) { 486 /* delete aliases when the main interface dies 487 */ 488 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) { 489 if (ifp1 != ifp 490 && !strcmp(ifp->int_name, ifp1->int_name)) 491 ifdel(ifp1); 492 } 493 494 if ((ifp->int_if_flags & IFF_MULTICAST) 495 #ifdef MCAST_PPP_BUG 496 && !(ifp->int_if_flags & IFF_POINTOPOINT) 497 #endif 498 && rip_sock >= 0) { 499 m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP); 500 #ifdef MCAST_IFINDEX 501 m.imr_interface.s_addr = htonl(ifp->int_index); 502 #else 503 m.imr_interface.s_addr = ((ifp->int_if_flags 504 & IFF_POINTOPOINT) 505 ? ifp->int_dstaddr 506 : ifp->int_addr); 507 #endif 508 if (setsockopt(rip_sock,IPPROTO_IP,IP_DROP_MEMBERSHIP, 509 &m, sizeof(m)) < 0 510 && errno != EADDRNOTAVAIL 511 && !TRACEACTIONS) 512 LOGERR("setsockopt(IP_DROP_MEMBERSHIP RIP)"); 513 if (rip_sock_mcast == ifp) 514 rip_sock_mcast = 0; 515 } 516 if (ifp->int_rip_sock >= 0) { 517 (void)close(ifp->int_rip_sock); 518 ifp->int_rip_sock = -1; 519 fix_select(); 520 } 521 522 tot_interfaces--; 523 if (!IS_RIP_OFF(ifp->int_state)) 524 rip_interfaces--; 525 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. 529 */ 530 (void)rn_walktree(rhead, walk_bad, 0); 531 532 set_rdisc_mg(ifp, 0); 533 if_bad_rdisc(ifp); 534 } 535 536 free(ifp); 537 } 538 539 540 /* Mark an interface ill. 541 */ 542 void 543 if_sick(struct interface *ifp) 544 { 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); 549 550 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL); 551 } 552 } 553 554 555 /* Mark an interface dead. 556 */ 557 void 558 if_bad(struct interface *ifp) 559 { 560 struct interface *ifp1; 561 562 563 if (ifp->int_state & IS_BROKE) 564 return; 565 566 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL); 567 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; 572 573 trace_if("Chg", ifp); 574 575 if (!(ifp->int_state & IS_ALIAS)) { 576 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) { 577 if (ifp1 != ifp 578 && !strcmp(ifp->int_name, ifp1->int_name)) 579 if_bad(ifp1); 580 } 581 (void)rn_walktree(rhead, walk_bad, 0); 582 if_bad_rdisc(ifp); 583 } 584 } 585 586 587 /* Mark an interface alive 588 */ 589 int /* 1=it was dead */ 590 if_ok(struct interface *ifp, 591 const char *type) 592 { 593 struct interface *ifp1; 594 595 596 if (!(ifp->int_state & IS_BROKE)) { 597 if (ifp->int_state & IS_SICK) { 598 trace_act("%sinterface %s to %s working better", 599 type, 600 ifp->int_name, naddr_ntoa(ifp->int_dstaddr)); 601 ifp->int_state &= ~IS_SICK; 602 } 603 return 0; 604 } 605 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; 610 611 if (!(ifp->int_state & IS_ALIAS)) { 612 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) { 613 if (ifp1 != ifp 614 && !strcmp(ifp->int_name, ifp1->int_name)) 615 if_ok(ifp1, type); 616 } 617 if_ok_rdisc(ifp); 618 } 619 620 if (ifp->int_state & IS_REMOTE) { 621 if (!addrouteforif(ifp)) 622 return 0; 623 } 624 return 1; 625 } 626 627 628 /* disassemble routing message 629 */ 630 void 631 rt_xaddrs(struct rt_addrinfo *info, 632 struct sockaddr *sa, 633 struct sockaddr *lim, 634 int addrs) 635 { 636 int i; 637 #ifdef _HAVE_SA_LEN 638 static struct sockaddr sa_zero; 639 #endif 640 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) 645 continue; 646 info->rti_info[i] = (sa->sa_len != 0) ? sa : &sa_zero; 647 sa = (struct sockaddr *)((char*)(sa) + SA_SIZE(sa)); 648 } 649 } 650 651 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. 655 */ 656 void 657 ifinit(void) 658 { 659 static char *sysctl_buf; 660 static size_t sysctl_buf_size = 0; 661 uint complaints = 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 672 673 struct interface ifs, ifs0, *ifp, *ifp1; 674 struct rt_entry *rt; 675 size_t needed; 676 int mib[6]; 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; 682 #ifdef SIOCGIFMETRIC 683 struct ifreq ifr; 684 #endif 685 686 687 last_ifinit = now; 688 ifinit_timer.tv_sec = now.tv_sec + (supplier 689 ? CHECK_ACT_INTERVAL 690 : CHECK_QUIET_INTERVAL); 691 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); 695 696 /* Fetch the interface list, without too many system calls 697 * since we do it repeatedly. 698 */ 699 mib[0] = CTL_NET; 700 mib[1] = PF_ROUTE; 701 mib[2] = 0; 702 mib[3] = AF_INET; 703 mib[4] = NET_RT_IFLIST; 704 mib[5] = 0; 705 for (;;) { 706 if ((needed = sysctl_buf_size) != 0) { 707 if (sysctl(mib, 6, sysctl_buf,&needed, 0, 0) >= 0) 708 break; 709 /* retry if the table grew */ 710 if (errno != ENOMEM && errno != EFAULT) 711 BADERR(1, "ifinit: sysctl(RT_IFLIST)"); 712 free(sysctl_buf); 713 needed = 0; 714 } 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, 718 "ifinit sysctl"); 719 } 720 721 ifam_lim = (struct ifa_msghdr *)(sysctl_buf + needed); 722 for (ifam = (struct ifa_msghdr *)sysctl_buf; 723 ifam < ifam_lim; 724 ifam = ifam2) { 725 726 ifam2 = (struct ifa_msghdr*)((char*)ifam + ifam->ifam_msglen); 727 728 #ifdef RTM_OIFINFO 729 if (ifam->ifam_type == RTM_OIFINFO) 730 continue; /* just ignore compat message */ 731 #endif 732 if (ifam->ifam_type == RTM_IFINFO) { 733 struct sockaddr_dl *sdl; 734 735 ifm = (struct if_msghdr *)ifam; 736 /* make prototype structure for the IP aliases 737 */ 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; 750 #ifdef sgi 751 ifs0.int_data.odrops = ifm->ifm_data.ifi_odrops; 752 #endif 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)); 757 continue; 758 } 759 if (ifam->ifam_type != RTM_NEWADDR) { 760 logbad(1,"ifinit: out of sync"); 761 continue; 762 } 763 rt_xaddrs(&info, (struct sockaddr *)(ifam+1), 764 (struct sockaddr *)ifam2, 765 ifam->ifam_addrs); 766 767 /* Prepare for the next address of this interface, which 768 * will be an alias. 769 * Do not output RIP or Router-Discovery packets via aliases. 770 */ 771 memcpy(&ifs, &ifs0, sizeof(ifs)); 772 ifs0.int_state |= (IS_ALIAS | IS_NO_RIP_OUT | IS_NO_RDISC); 773 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", 778 ifs.int_name); 779 complaints |= COMP_NOADDR; 780 } 781 continue; 782 } 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", 787 ifs.int_name); 788 complaints |= COMP_NOT_INET; 789 } 790 continue; 791 } 792 793 ifs.int_addr = S_ADDR(INFO_IFA(&info)); 794 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", 800 ifs.int_name); 801 complaints |= COMP_BADADDR; 802 } 803 continue; 804 } 805 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) { 816 foundloopback = 1; 817 loopaddr = ifs.int_addr; 818 loop_rts.rts_gate = loopaddr; 819 loop_rts.rts_router = loopaddr; 820 } 821 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", 829 ifs.int_name); 830 complaints |= COMP_NODST; 831 } 832 continue; 833 } 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", 841 ifs.int_name); 842 complaints |= COMP_NODST; 843 } 844 continue; 845 } 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); 850 851 } else { 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", 856 ifs.int_name); 857 complaints |= COMP_NOMASK; 858 } 859 continue; 860 } 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; 868 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 873 & COMP_NOBADR)) 874 msglog("%s has" 875 "no broadcast address", 876 ifs.int_name); 877 complaints |= COMP_NOBADR; 878 } 879 continue; 880 } 881 ifs.int_brdaddr = S_ADDR(INFO_BRD(&info)); 882 } 883 } 884 ifs.int_std_net = ifs.int_net & ifs.int_std_mask; 885 ifs.int_std_addr = htonl(ifs.int_std_net); 886 887 /* Use a minimum metric of one. Treat the interface metric 888 * (default 0) as an increment to the hop count of one. 889 * 890 * The metric obtained from the routing socket dump of 891 * interface addresses is wrong. It is not set by the 892 * SIOCSIFMETRIC ioctl. 893 */ 894 #ifdef SIOCGIFMETRIC 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)"); 898 ifs.int_metric = 0; 899 } else { 900 ifs.int_metric = ifr.ifr_metric; 901 } 902 #else 903 ifs.int_metric = ifam->ifam_metric; 904 #endif 905 if (ifs.int_metric > HOPCNT_INFINITY) { 906 ifs.int_metric = 0; 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); 912 } 913 } 914 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. 919 */ 920 ifp = ifwithname(ifs.int_name, ((ifs.int_state & IS_ALIAS) 921 ? ifs.int_addr 922 : 0)); 923 if (ifp != 0) { 924 ifp->int_state |= IS_CHECKED; 925 926 if (0 != ((ifp->int_if_flags ^ ifs.int_if_flags) 927 & (IFF_BROADCAST 928 | IFF_LOOPBACK 929 | IFF_POINTOPOINT 930 | IFF_MULTICAST)) 931 || 0 != ((ifp->int_state ^ ifs.int_state) 932 & IS_ALIAS) 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. 940 */ 941 trace_act("interface %s has changed", 942 ifp->int_name); 943 ifdel(ifp); 944 ifp = 0; 945 } 946 } 947 948 if (ifp != 0) { 949 /* The primary representative of an alias worries 950 * about how things are working. 951 */ 952 if (ifp->int_state & IS_ALIAS) 953 continue; 954 955 /* note interfaces that have been turned off 956 */ 957 if (!iff_up(ifs.int_if_flags)) { 958 if (iff_up(ifp->int_if_flags)) { 959 msglog("interface %s to %s turned off", 960 ifp->int_name, 961 naddr_ntoa(ifp->int_dstaddr)); 962 if_bad(ifp); 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", 968 ifp->int_name, 969 now.tv_sec-ifp->int_data.ts); 970 ifdel(ifp); 971 } 972 continue; 973 } 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, ""); 978 } 979 980 /* If it has been long enough, 981 * see if the interface is broken. 982 */ 983 if (now.tv_sec < ifp->int_data.ts+CHECK_BAD_INTERVAL) 984 continue; 985 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; 990 #ifdef sgi 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. 995 */ 996 if (!(ifp->int_if_flags & IFF_POINTOPOINT)) 997 oerr += (ifs.int_data.odrops 998 - ifp->int_data.odrops); 999 #endif 1000 /* If the interface just awoke, restart the counters. 1001 */ 1002 if (ifp->int_data.ts == 0) { 1003 ifp->int_data = ifs.int_data; 1004 continue; 1005 } 1006 ifp->int_data = ifs.int_data; 1007 1008 /* Withhold judgment when the short error 1009 * counters wrap or the interface is reset. 1010 */ 1011 if (ierr < 0 || in < 0 || oerr < 0 || out < 0) { 1012 LIM_SEC(ifinit_timer, 1013 now.tv_sec+CHECK_BAD_INTERVAL); 1014 continue; 1015 } 1016 1017 /* Withhold judgement when there is no traffic 1018 */ 1019 if (in == 0 && out == 0 && ierr == 0 && oerr == 0) 1020 continue; 1021 1022 /* It is bad if input or output is not working. 1023 * Require presistent problems before marking it dead. 1024 */ 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" 1030 " out=%d oerr=%d", 1031 ifp->int_name, 1032 naddr_ntoa(ifp->int_dstaddr), 1033 in, ierr, out, oerr); 1034 if_sick(ifp); 1035 continue; 1036 } 1037 if (!(ifp->int_state & IS_BROKE)) { 1038 msglog("interface %s to %s broken:" 1039 " in=%d ierr=%d out=%d oerr=%d", 1040 ifp->int_name, 1041 naddr_ntoa(ifp->int_dstaddr), 1042 in, ierr, out, oerr); 1043 if_bad(ifp); 1044 } 1045 continue; 1046 } 1047 1048 /* otherwise, it is active and healthy 1049 */ 1050 ifp->int_act_time = now.tv_sec; 1051 (void)if_ok(ifp, ""); 1052 continue; 1053 } 1054 1055 /* This is a new interface. 1056 * If it is dead, forget it. 1057 */ 1058 if (!iff_up(ifs.int_if_flags)) 1059 continue; 1060 1061 /* If it duplicates an existing interface, 1062 * complain about it, mark the other one 1063 * duplicated, and forget this one. 1064 */ 1065 ifp = check_dup(ifs.int_addr,ifs.int_dstaddr,ifs.int_mask, 1066 ifs.int_if_flags); 1067 if (ifp != 0) { 1068 /* Ignore duplicates of itself, caused by having 1069 * IP aliases on the same network. 1070 */ 1071 if (!strcmp(ifp->int_name, ifs.int_name)) 1072 continue; 1073 1074 if (!(prev_complaints & COMP_DUP)) { 1075 complaints |= COMP_DUP; 1076 msglog("%s (%s%s%s) is duplicated by" 1077 " %s (%s%s%s)", 1078 ifs.int_name, 1079 addrname(ifs.int_addr,ifs.int_mask,1), 1080 ((ifs.int_if_flags & IFF_POINTOPOINT) 1081 ? "-->" : ""), 1082 ((ifs.int_if_flags & IFF_POINTOPOINT) 1083 ? naddr_ntoa(ifs.int_dstaddr) : ""), 1084 ifp->int_name, 1085 addrname(ifp->int_addr,ifp->int_mask,1), 1086 ((ifp->int_if_flags & IFF_POINTOPOINT) 1087 ? "-->" : ""), 1088 ((ifp->int_if_flags & IFF_POINTOPOINT) 1089 ? naddr_ntoa(ifp->int_dstaddr) : "")); 1090 } 1091 ifp->int_state |= IS_DUP; 1092 continue; 1093 } 1094 1095 if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT | IFF_BROADCAST | IFF_LOOPBACK))) { 1096 trace_act("%s is neither broadcast, point-to-point," 1097 " nor loopback", 1098 ifs.int_name); 1099 if (!(ifs.int_state & IFF_MULTICAST)) 1100 ifs.int_state |= IS_NO_RDISC; 1101 } 1102 1103 1104 /* It is new and ok. Add it to the list of interfaces 1105 */ 1106 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "ifinit ifp"); 1107 memcpy(ifp, &ifs, sizeof(*ifp)); 1108 get_parms(ifp); 1109 if_link(ifp); 1110 trace_if("Add", ifp); 1111 1112 /* Notice likely bad netmask. 1113 */ 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) 1119 continue; 1120 if (ifp1->int_if_flags & IFF_POINTOPOINT) 1121 continue; 1122 if (ifp1->int_dstaddr == RIP_DEFAULT) 1123 continue; 1124 /* ignore aliases on the right network */ 1125 if (!strcmp(ifp->int_name, ifp1->int_name)) 1126 continue; 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", 1133 ifp->int_name, 1134 addrname(htonl(ifp->int_net), 1135 ifp->int_mask, 1), 1136 ifp1->int_name, 1137 addrname(htonl(ifp1->int_net), 1138 ifp1->int_mask, 1)); 1139 complaints |= COMP_NETMASK; 1140 } 1141 } 1142 } 1143 1144 if (!(ifp->int_state & IS_ALIAS)) { 1145 /* Count the # of directly connected networks. 1146 */ 1147 if (!(ifp->int_if_flags & IFF_LOOPBACK)) 1148 tot_interfaces++; 1149 if (!IS_RIP_OFF(ifp->int_state)) 1150 rip_interfaces++; 1151 1152 /* turn on router discovery and RIP If needed */ 1153 if_ok_rdisc(ifp); 1154 rip_on(ifp); 1155 } 1156 } 1157 1158 /* If we are multi-homed and have at least two interfaces 1159 * listening to RIP, then output by default. 1160 */ 1161 if (!supplier_set && rip_interfaces > 1) 1162 set_supplier(); 1163 1164 /* If we are multi-homed, optionally advertise a route to 1165 * our main address. 1166 */ 1167 if (advertise_mhome 1168 || (tot_interfaces > 1 1169 && mhome 1170 && (ifp = ifwithaddr(myaddr, 0, 0)) != 0 1171 && foundloopback)) { 1172 advertise_mhome = 1; 1173 rt = rtget(myaddr, HOST_MASK); 1174 if (rt != 0) { 1175 if (rt->rt_ifp != ifp 1176 || rt->rt_router != loopaddr) { 1177 rtdelete(rt); 1178 rt = 0; 1179 } else { 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, 1184 &loop_rts, 0); 1185 } 1186 } 1187 if (rt == 0) { 1188 loop_rts.rts_ifp = ifp; 1189 loop_rts.rts_metric = 0; 1190 rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts); 1191 } 1192 } 1193 1194 for (ifp = ifnet; ifp != 0; ifp = ifp1) { 1195 ifp1 = ifp->int_next; /* because we may delete it */ 1196 1197 /* Forget any interfaces that have disappeared. 1198 */ 1199 if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) { 1200 trace_act("interface %s has disappeared", 1201 ifp->int_name); 1202 ifdel(ifp); 1203 continue; 1204 } 1205 1206 if ((ifp->int_state & IS_BROKE) 1207 && !(ifp->int_state & IS_PASSIVE)) 1208 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL); 1209 1210 /* If we ever have a RIPv1 interface, assume we always will. 1211 * It might come back if it ever goes away. 1212 */ 1213 if (!(ifp->int_state & IS_NO_RIPV1_OUT) && supplier) 1214 have_ripv1_out = 1; 1215 if (!(ifp->int_state & IS_NO_RIPV1_IN)) 1216 have_ripv1_in = 1; 1217 } 1218 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. 1223 */ 1224 if (!addrouteforif(ifp)) 1225 continue; 1226 1227 /* Add routes to the local end of point-to-point interfaces 1228 * using loopback. 1229 */ 1230 if ((ifp->int_if_flags & IFF_POINTOPOINT) 1231 && !(ifp->int_state & IS_REMOTE) 1232 && foundloopback) { 1233 /* Delete any routes to the network address through 1234 * foreign routers. Remove even static routes. 1235 */ 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) { 1239 rtdelete(rt); 1240 rt = 0; 1241 } 1242 if (rt != 0) { 1243 if (!(rt->rt_state & RS_LOCAL) 1244 || rt->rt_metric > ifp->int_metric) { 1245 ifp1 = ifp; 1246 } else { 1247 ifp1 = rt->rt_ifp; 1248 } 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)), 1254 &loop_rts, 0); 1255 } else { 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); 1260 } 1261 } 1262 } 1263 1264 /* add the authority routes */ 1265 for (intnetp = intnets; intnetp!=0; intnetp = intnetp->intnet_next) { 1266 rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask); 1267 if (rt != 0 1268 && !(rt->rt_state & RS_NO_NET_SYN) 1269 && !(rt->rt_state & RS_NET_INT)) { 1270 rtdelete(rt); 1271 rt = 0; 1272 } 1273 if (rt == 0) { 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); 1278 } 1279 } 1280 1281 prev_complaints = complaints; 1282 } 1283 1284 1285 static void 1286 check_net_syn(struct interface *ifp) 1287 { 1288 struct rt_entry *rt; 1289 static struct rt_spare new; 1290 1291 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. 1295 */ 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); 1299 if (rt != 0 1300 && 0 == (rt->rt_state & RS_NO_NET_SYN) 1301 && (!(rt->rt_state & RS_NET_SYN) 1302 || rt->rt_metric > ifp->int_metric)) { 1303 rtdelete(rt); 1304 rt = 0; 1305 } 1306 if (rt == 0) { 1307 new.rts_ifp = ifp; 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, 1312 RS_NET_SYN, &new); 1313 } 1314 1315 } else { 1316 ifp->int_state &= ~IS_NEED_NET_SYN; 1317 1318 rt = rtget(ifp->int_std_addr, 1319 ifp->int_std_mask); 1320 if (rt != 0 1321 && (rt->rt_state & RS_NET_SYN) 1322 && rt->rt_ifp == ifp) 1323 rtbad_sub(rt); 1324 } 1325 } 1326 1327 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. 1331 */ 1332 int /* 0=bad interface */ 1333 addrouteforif(struct interface *ifp) 1334 { 1335 struct rt_entry *rt; 1336 static struct rt_spare new; 1337 naddr dst; 1338 1339 1340 /* skip sick interfaces 1341 */ 1342 if (ifp->int_state & IS_BROKE) 1343 return 0; 1344 1345 /* If the interface on a subnet, then install a RIPv1 route to 1346 * the network as well (unless it is sick). 1347 */ 1348 if (ifp->int_state & IS_SUBNET) 1349 check_net_syn(ifp); 1350 1351 dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) 1352 ? ifp->int_dstaddr 1353 : htonl(ifp->int_net)); 1354 1355 new.rts_ifp = ifp; 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; 1360 1361 /* If we are going to send packets to the gateway, 1362 * it must be reachable using our physical interfaces 1363 */ 1364 if ((ifp->int_state & IS_REMOTE) 1365 && !(ifp->int_state & IS_EXTERNAL) 1366 && !check_remote(ifp)) 1367 return 0; 1368 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. 1372 */ 1373 del_static(dst, ifp->int_mask, 0, 0); 1374 rt = rtget(dst, ifp->int_mask); 1375 if (rt != 0) { 1376 if ((rt->rt_ifp != ifp 1377 || rt->rt_router != ifp->int_addr) 1378 && (!(ifp->int_state & IS_DUP) 1379 || rt->rt_ifp == 0 1380 || (rt->rt_ifp->int_state & IS_BROKE))) { 1381 rtdelete(rt); 1382 rt = 0; 1383 } else { 1384 rtchange(rt, ((rt->rt_state | RS_IF) 1385 & ~(RS_NET_SYN | RS_LOCAL)), 1386 &new, 0); 1387 } 1388 } 1389 if (rt == 0) { 1390 if (ifp->int_transitions++ > 0) 1391 trace_act("re-install interface %s", 1392 ifp->int_name); 1393 1394 rtadd(dst, ifp->int_mask, RS_IF, &new); 1395 } 1396 1397 return 1; 1398 } 1399