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