sbin/routed/if.c

   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 }