sbin/routed/rdisc.c

   1 /*
   2  * Copyright (c) 1995
   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  * 3. 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: src/sbin/routed/rdisc.c,v 1.5.2.1 2000/08/14 17:00:04 sheldonh Exp $
  30  */
  31
  32 #include "defs.h"
  33 #include <netinet/in_systm.h>
  34 #include <netinet/ip.h>
  35 #include <netinet/ip_icmp.h>
  36
  37 #if !defined(sgi) && !defined(__NetBSD__)
  38 static char sccsid[] __attribute__((unused)) = "@(#)rdisc.c     8.1 (Berkeley) x/y/95";
  39 #elif defined(__NetBSD__)
  40 __RCSID("$NetBSD$");
  41 #endif
  42
  43 /* router advertisement ICMP packet */
  44 struct icmp_ad {
  45         u_int8_t    icmp_type;          /* type of message */
  46         u_int8_t    icmp_code;          /* type sub code */
  47         u_int16_t   icmp_cksum;         /* ones complement cksum of struct */
  48         u_int8_t    icmp_ad_num;        /* # of following router addresses */
  49         u_int8_t    icmp_ad_asize;      /* 2--words in each advertisement */
  50         u_int16_t   icmp_ad_life;       /* seconds of validity */
  51         struct icmp_ad_info {
  52             n_long  icmp_ad_addr;
  53             n_long  icmp_ad_pref;
  54         } icmp_ad_info[1];
  55 };
  56
  57 /* router solicitation ICMP packet */
  58 struct icmp_so {
  59         u_int8_t    icmp_type;          /* type of message */
  60         u_int8_t    icmp_code;          /* type sub code */
  61         u_int16_t   icmp_cksum;         /* ones complement cksum of struct */
  62         n_long      icmp_so_rsvd;
  63 };
  64
  65 union ad_u {
  66         struct icmp icmp;
  67         struct icmp_ad ad;
  68         struct icmp_so so;
  69 };
  70
  71
  72 int     rdisc_sock = -1;                /* router-discovery raw socket */
  73 struct interface *rdisc_sock_mcast;     /* current multicast interface */
  74
  75 struct timeval rdisc_timer;
  76 int rdisc_ok;                           /* using solicited route */
  77
  78
  79 #define MAX_ADS 16                      /* at least one per interface */
  80 struct dr {                             /* accumulated advertisements */
  81     struct interface *dr_ifp;
  82     naddr   dr_gate;                    /* gateway */
  83     time_t  dr_ts;                      /* when received */
  84     time_t  dr_life;                    /* lifetime in host byte order */
  85     n_long  dr_recv_pref;               /* received but biased preference */
  86     n_long  dr_pref;                    /* preference adjusted by metric */
  87 } *cur_drp, drs[MAX_ADS];
  88
  89 /* convert between signed, balanced around zero,
  90  * and unsigned zero-based preferences */
  91 #define SIGN_PREF(p) ((p) ^ MIN_PreferenceLevel)
  92 #define UNSIGN_PREF(p) SIGN_PREF(p)
  93 /* adjust unsigned preference by interface metric,
  94  * without driving it to infinity */
  95 #define PREF(p, ifp) ((int)(p) <= (ifp)->int_metric ? ((p) != 0 ? 1 : 0) \
  96                       : (p) - ((ifp)->int_metric))
  97
  98 static void rdisc_sort(void);
  99
 100
 101 /* dump an ICMP Router Discovery Advertisement Message
 102  */
 103 static void
 104 trace_rdisc(const char  *act,
 105             naddr       from,
 106             naddr       to,
 107             struct interface *ifp,
 108             union ad_u  *p,
 109             u_int       len)
 110 {
 111         int i;
 112         n_long *wp, *lim;
 113
 114
 115         if (!TRACEPACKETS || ftrace == 0)
 116                 return;
 117
 118         lastlog();
 119
 120         if (p->icmp.icmp_type == ICMP_ROUTERADVERT) {
 121                 fprintf(ftrace, "%s Router Ad"
 122                         " from %s to %s via %s life=%d\n",
 123                         act, naddr_ntoa(from), naddr_ntoa(to),
 124                         ifp ? ifp->int_name : "?",
 125                         ntohs(p->ad.icmp_ad_life));
 126                 if (!TRACECONTENTS)
 127                         return;
 128
 129                 wp = &p->ad.icmp_ad_info[0].icmp_ad_addr;
 130                 lim = &wp[(len - sizeof(p->ad)) / sizeof(*wp)];
 131                 for (i = 0; i < p->ad.icmp_ad_num && wp <= lim; i++) {
 132                         fprintf(ftrace, "\t%s preference=%d",
 133                                 naddr_ntoa(wp[0]), (int)ntohl(wp[1]));
 134                         wp += p->ad.icmp_ad_asize;
 135                 }
 136                 fputc('\n',ftrace);
 137
 138         } else {
 139                 trace_act("%s Router Solic. from %s to %s via %s value=%#x",
 140                           act, naddr_ntoa(from), naddr_ntoa(to),
 141                           ifp ? ifp->int_name : "?",
 142                           (int)ntohl(p->so.icmp_so_rsvd));
 143         }
 144 }
 145
 146 /* prepare Router Discovery socket.
 147  */
 148 static void
 149 get_rdisc_sock(void)
 150 {
 151         if (rdisc_sock < 0) {
 152                 rdisc_sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
 153                 if (rdisc_sock < 0)
 154                         BADERR(1,"rdisc_sock = socket()");
 155                 fix_sock(rdisc_sock,"rdisc_sock");
 156                 fix_select();
 157         }
 158 }
 159
 160
 161 /* Pick multicast group for router-discovery socket
 162  */
 163 void
 164 set_rdisc_mg(struct interface *ifp,
 165              int on)                    /* 0=turn it off */
 166 {
 167         struct ip_mreq m;
 168
 169         if (rdisc_sock < 0) {
 170                 /* Create the raw socket so that we can hear at least
 171                  * broadcast router discovery packets.
 172                  */
 173                 if ((ifp->int_state & IS_NO_RDISC) == IS_NO_RDISC
 174                     || !on)
 175                         return;
 176                 get_rdisc_sock();
 177         }
 178
 179         if (!(ifp->int_if_flags & IFF_MULTICAST)) {
 180                 ifp->int_state &= ~(IS_ALL_HOSTS | IS_ALL_ROUTERS);
 181                 return;
 182         }
 183
 184 #ifdef MCAST_PPP_BUG
 185         if (ifp->int_if_flags & IFF_POINTOPOINT)
 186                 return;
 187 #endif
 188         memset(&m, 0, sizeof(m));
 189         m.imr_interface.s_addr = ((ifp->int_if_flags & IFF_POINTOPOINT)
 190                                   ? ifp->int_dstaddr
 191                                   : ifp->int_addr);
 192         if (supplier
 193             || (ifp->int_state & IS_NO_ADV_IN)
 194             || !on) {
 195                 /* stop listening to advertisements
 196                  */
 197                 if (ifp->int_state & IS_ALL_HOSTS) {
 198                         m.imr_multiaddr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
 199                         if (setsockopt(rdisc_sock, IPPROTO_IP,
 200                                        IP_DROP_MEMBERSHIP,
 201                                        &m, sizeof(m)) < 0)
 202                                 LOGERR("IP_DROP_MEMBERSHIP ALLHOSTS");
 203                         ifp->int_state &= ~IS_ALL_HOSTS;
 204                 }
 205
 206         } else if (!(ifp->int_state & IS_ALL_HOSTS)) {
 207                 /* start listening to advertisements
 208                  */
 209                 m.imr_multiaddr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
 210                 if (setsockopt(rdisc_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 211                                &m, sizeof(m)) < 0) {
 212                         LOGERR("IP_ADD_MEMBERSHIP ALLHOSTS");
 213                 } else {
 214                         ifp->int_state |= IS_ALL_HOSTS;
 215                 }
 216         }
 217
 218         if (!supplier
 219             || (ifp->int_state & IS_NO_ADV_OUT)
 220             || !on) {
 221                 /* stop listening to solicitations
 222                  */
 223                 if (ifp->int_state & IS_ALL_ROUTERS) {
 224                         m.imr_multiaddr.s_addr=htonl(INADDR_ALLROUTERS_GROUP);
 225                         if (setsockopt(rdisc_sock, IPPROTO_IP,
 226                                        IP_DROP_MEMBERSHIP,
 227                                        &m, sizeof(m)) < 0)
 228                                 LOGERR("IP_DROP_MEMBERSHIP ALLROUTERS");
 229                         ifp->int_state &= ~IS_ALL_ROUTERS;
 230                 }
 231
 232         } else if (!(ifp->int_state & IS_ALL_ROUTERS)) {
 233                 /* start hearing solicitations
 234                  */
 235                 m.imr_multiaddr.s_addr=htonl(INADDR_ALLROUTERS_GROUP);
 236                 if (setsockopt(rdisc_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 237                                &m, sizeof(m)) < 0) {
 238                         LOGERR("IP_ADD_MEMBERSHIP ALLROUTERS");
 239                 } else {
 240                         ifp->int_state |= IS_ALL_ROUTERS;
 241                 }
 242         }
 243 }
 244
 245
 246 /* start supplying routes
 247  */
 248 void
 249 set_supplier(void)
 250 {
 251         struct interface *ifp;
 252         struct dr *drp;
 253
 254         if (supplier_set)
 255                 return;
 256
 257         trace_act("start supplying routes");
 258
 259         /* Forget discovered routes.
 260          */
 261         for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
 262                 drp->dr_recv_pref = 0;
 263                 drp->dr_life = 0;
 264         }
 265         rdisc_age(0);
 266
 267         supplier_set = 1;
 268         supplier = 1;
 269
 270         /* Do not start advertising until we have heard some RIP routes */
 271         LIM_SEC(rdisc_timer, now.tv_sec+MIN_WAITTIME);
 272
 273         /* Switch router discovery multicast groups from soliciting
 274          * to advertising.
 275          */
 276         for (ifp = ifnet; ifp; ifp = ifp->int_next) {
 277                 if (ifp->int_state & IS_BROKE)
 278                         continue;
 279                 ifp->int_rdisc_cnt = 0;
 280                 ifp->int_rdisc_timer.tv_usec = rdisc_timer.tv_usec;
 281                 ifp->int_rdisc_timer.tv_sec = now.tv_sec+MIN_WAITTIME;
 282                 set_rdisc_mg(ifp, 1);
 283         }
 284
 285         /* get rid of any redirects */
 286         del_redirects(0,0);
 287 }
 288
 289
 290 /* age discovered routes and find the best one
 291  */
 292 void
 293 rdisc_age(naddr bad_gate)
 294 {
 295         time_t sec;
 296         struct dr *drp;
 297
 298
 299         /* If only advertising, then do only that. */
 300         if (supplier) {
 301                 /* If switching from client to server, get rid of old
 302                  * default routes.
 303                  */
 304                 if (cur_drp != NULL)
 305                         rdisc_sort();
 306                 rdisc_adv();
 307                 return;
 308         }
 309
 310         /* If we are being told about a bad router,
 311          * then age the discovered default route, and if there is
 312          * no alternative, solicit a replacement.
 313          */
 314         if (bad_gate != 0) {
 315                 /* Look for the bad discovered default route.
 316                  * Age it and note its interface.
 317                  */
 318                 for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
 319                         if (drp->dr_ts == 0)
 320                                 continue;
 321
 322                         /* When we find the bad router, then age the route
 323                          * to at most SUPPLY_INTERVAL.
 324                          * This is contrary to RFC 1256, but defends against
 325                          * black holes.
 326                          */
 327                         if (drp->dr_gate == bad_gate) {
 328                                 sec = (now.tv_sec - drp->dr_life
 329                                        + SUPPLY_INTERVAL);
 330                                 if (drp->dr_ts > sec) {
 331                                         trace_act("age 0.0.0.0 --> %s via %s",
 332                                                   naddr_ntoa(drp->dr_gate),
 333                                                   drp->dr_ifp->int_name);
 334                                         drp->dr_ts = sec;
 335                                 }
 336                                 break;
 337                         }
 338                 }
 339         }
 340
 341         rdisc_sol();
 342         rdisc_sort();
 343
 344         /* Delete old redirected routes to keep the kernel table small,
 345          * and to prevent black holes.  Check that the kernel table
 346          * matches the daemon table (i.e. has the default route).
 347          * But only if RIP is not running and we are not dealing with
 348          * a bad gateway, since otherwise age() will be called.
 349          */
 350         if (rip_sock < 0 && bad_gate == 0)
 351                 age(0);
 352 }
 353
 354
 355 /* Zap all routes discovered via an interface that has gone bad
 356  *      This should only be called when !(ifp->int_state & IS_ALIAS)
 357  */
 358 void
 359 if_bad_rdisc(struct interface *ifp)
 360 {
 361         struct dr *drp;
 362
 363         for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
 364                 if (drp->dr_ifp != ifp)
 365                         continue;
 366                 drp->dr_recv_pref = 0;
 367                 drp->dr_ts = 0;
 368                 drp->dr_life = 0;
 369         }
 370
 371         /* make a note to re-solicit, turn RIP on or off, etc. */
 372         rdisc_timer.tv_sec = 0;
 373 }
 374
 375
 376 /* mark an interface ok for router discovering.
 377  */
 378 void
 379 if_ok_rdisc(struct interface *ifp)
 380 {
 381         set_rdisc_mg(ifp, 1);
 382
 383         ifp->int_rdisc_cnt = 0;
 384         ifp->int_rdisc_timer.tv_sec = now.tv_sec + (supplier
 385                                                     ? MIN_WAITTIME
 386                                                     : MAX_SOLICITATION_DELAY);
 387         if (timercmp(&rdisc_timer, &ifp->int_rdisc_timer, >))
 388                 rdisc_timer = ifp->int_rdisc_timer;
 389 }
 390
 391
 392 /* get rid of a dead discovered router
 393  */
 394 static void
 395 del_rdisc(struct dr *drp)
 396 {
 397         struct interface *ifp;
 398         naddr gate;
 399         int i;
 400
 401
 402         del_redirects(gate = drp->dr_gate, 0);
 403         drp->dr_ts = 0;
 404         drp->dr_life = 0;
 405
 406
 407         /* Count the other discovered routes on the interface.
 408          */
 409         i = 0;
 410         ifp = drp->dr_ifp;
 411         for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
 412                 if (drp->dr_ts != 0
 413                     && drp->dr_ifp == ifp)
 414                         i++;
 415         }
 416
 417         /* If that was the last good discovered router on the interface,
 418          * then solicit a new one.
 419          * This is contrary to RFC 1256, but defends against black holes.
 420          */
 421         if (i != 0) {
 422                 trace_act("discovered router %s via %s"
 423                           " is bad--have %d remaining",
 424                           naddr_ntoa(gate), ifp->int_name, i);
 425         } else if (ifp->int_rdisc_cnt >= MAX_SOLICITATIONS) {
 426                 trace_act("last discovered router %s via %s"
 427                           " is bad--re-solicit",
 428                           naddr_ntoa(gate), ifp->int_name);
 429                 ifp->int_rdisc_cnt = 0;
 430                 ifp->int_rdisc_timer.tv_sec = 0;
 431                 rdisc_sol();
 432         } else {
 433                 trace_act("last discovered router %s via %s"
 434                           " is bad--wait to solicit",
 435                           naddr_ntoa(gate), ifp->int_name);
 436         }
 437 }
 438
 439
 440 /* Find the best discovered route,
 441  * and discard stale routers.
 442  */
 443 static void
 444 rdisc_sort(void)
 445 {
 446         struct dr *drp, *new_drp;
 447         struct rt_entry *rt;
 448         struct rt_spare new;
 449         struct interface *ifp;
 450         u_int new_st = 0;
 451         n_long new_pref = 0;
 452
 453
 454         /* Find the best discovered route.
 455          */
 456         new_drp = NULL;
 457         for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
 458                 if (drp->dr_ts == 0)
 459                         continue;
 460                 ifp = drp->dr_ifp;
 461
 462                 /* Get rid of expired discovered routers.
 463                  */
 464                 if (drp->dr_ts + drp->dr_life <= now.tv_sec) {
 465                         del_rdisc(drp);
 466                         continue;
 467                 }
 468
 469                 LIM_SEC(rdisc_timer, drp->dr_ts+drp->dr_life+1);
 470
 471                 /* Update preference with possibly changed interface
 472                  * metric.
 473                  */
 474                 drp->dr_pref = PREF(drp->dr_recv_pref, ifp);
 475
 476                 /* Prefer the current route to prevent thrashing.
 477                  * Prefer shorter lifetimes to speed the detection of
 478                  * bad routers.
 479                  * Avoid sick interfaces.
 480                  */
 481                 if (new_drp == NULL
 482                     || (!((new_st ^ drp->dr_ifp->int_state) & IS_SICK)
 483                         && (new_pref < drp->dr_pref
 484                             || (new_pref == drp->dr_pref
 485                                 && (drp == cur_drp
 486                                     || (new_drp != cur_drp
 487                                         && new_drp->dr_life > drp->dr_life)))))
 488                     || ((new_st & IS_SICK)
 489                         && !(drp->dr_ifp->int_state & IS_SICK))) {
 490                             new_drp = drp;
 491                             new_st = drp->dr_ifp->int_state;
 492                             new_pref = drp->dr_pref;
 493                 }
 494         }
 495
 496         /* switch to a better default route
 497          */
 498         if (new_drp != cur_drp) {
 499                 rt = rtget(RIP_DEFAULT, 0);
 500
 501                 /* Stop using discovered routes if they are all bad
 502                  */
 503                 if (new_drp == NULL) {
 504                         trace_act("turn off Router Discovery client");
 505                         rdisc_ok = 0;
 506
 507                         if (rt != NULL
 508                             && (rt->rt_state & RS_RDISC)) {
 509                                 new = rt->rt_spares[0];
 510                                 new.rts_metric = HOPCNT_INFINITY;
 511                                 new.rts_time = now.tv_sec - GARBAGE_TIME;
 512                                 rtchange(rt, rt->rt_state & ~RS_RDISC,
 513                                          &new, 0);
 514                                 rtswitch(rt, 0);
 515                         }
 516
 517                 } else {
 518                         if (cur_drp == NULL) {
 519                                 trace_act("turn on Router Discovery client"
 520                                           " using %s via %s",
 521                                           naddr_ntoa(new_drp->dr_gate),
 522                                           new_drp->dr_ifp->int_name);
 523                                 rdisc_ok = 1;
 524
 525                         } else {
 526                                 trace_act("switch Router Discovery from"
 527                                           " %s via %s to %s via %s",
 528                                           naddr_ntoa(cur_drp->dr_gate),
 529                                           cur_drp->dr_ifp->int_name,
 530                                           naddr_ntoa(new_drp->dr_gate),
 531                                           new_drp->dr_ifp->int_name);
 532                         }
 533
 534                         memset(&new, 0, sizeof(new));
 535                         new.rts_ifp = new_drp->dr_ifp;
 536                         new.rts_gate = new_drp->dr_gate;
 537                         new.rts_router = new_drp->dr_gate;
 538                         new.rts_metric = HOPCNT_INFINITY-1;
 539                         new.rts_time = now.tv_sec;
 540                         if (rt != NULL) {
 541                                 rtchange(rt, rt->rt_state | RS_RDISC, &new, 0);
 542                         } else {
 543                                 rtadd(RIP_DEFAULT, 0, RS_RDISC, &new);
 544                         }
 545                 }
 546
 547                 cur_drp = new_drp;
 548         }
 549
 550         /* turn RIP on or off */
 551         if (!rdisc_ok || rip_interfaces > 1) {
 552                 rip_on(0);
 553         } else {
 554                 rip_off();
 555         }
 556 }
 557
 558
 559 /* handle a single address in an advertisement
 560  */
 561 static void
 562 parse_ad(naddr from,
 563          naddr gate,
 564          n_long pref,                   /* signed and in network order */
 565          u_short life,                  /* in host byte order */
 566          struct interface *ifp)
 567 {
 568         static struct msg_limit bad_gate;
 569         struct dr *drp, *new_drp;
 570
 571
 572         if (gate == RIP_DEFAULT
 573             || !check_dst(gate)) {
 574                 msglim(&bad_gate, from,"router %s advertising bad gateway %s",
 575                        naddr_ntoa(from),
 576                        naddr_ntoa(gate));
 577                 return;
 578         }
 579
 580         /* ignore pointers to ourself and routes via unreachable networks
 581          */
 582         if (ifwithaddr(gate, 1, 0) != 0) {
 583                 trace_pkt("    discard Router Discovery Ad pointing at us");
 584                 return;
 585         }
 586         if (!on_net(gate, ifp->int_net, ifp->int_mask)) {
 587                 trace_pkt("    discard Router Discovery Ad"
 588                           " toward unreachable net");
 589                 return;
 590         }
 591
 592         /* Convert preference to an unsigned value
 593          * and later bias it by the metric of the interface.
 594          */
 595         pref = UNSIGN_PREF(ntohl(pref));
 596
 597         if (pref == 0 || life < MinMaxAdvertiseInterval) {
 598                 pref = 0;
 599                 life = 0;
 600         }
 601
 602         for (new_drp = NULL, drp = drs; drp < &drs[MAX_ADS]; drp++) {
 603                 /* accept new info for a familiar entry
 604                  */
 605                 if (drp->dr_gate == gate) {
 606                         new_drp = drp;
 607                         break;
 608                 }
 609
 610                 if (life == 0)
 611                         continue;       /* do not worry about dead ads */
 612
 613                 if (drp->dr_ts == 0) {
 614                         new_drp = drp;  /* use unused entry */
 615
 616                 } else if (new_drp == NULL) {
 617                         /* look for an entry worse than the new one to
 618                          * reuse.
 619                          */
 620                         if ((!(ifp->int_state & IS_SICK)
 621                              && (drp->dr_ifp->int_state & IS_SICK))
 622                             || (pref > drp->dr_pref
 623                                 && !((ifp->int_state ^ drp->dr_ifp->int_state)
 624                                      & IS_SICK)))
 625                                 new_drp = drp;
 626
 627                 } else if (new_drp->dr_ts != 0) {
 628                         /* look for the least valuable entry to reuse
 629                          */
 630                         if ((!(new_drp->dr_ifp->int_state & IS_SICK)
 631                              && (drp->dr_ifp->int_state & IS_SICK))
 632                             || (new_drp->dr_pref > drp->dr_pref
 633                                 && !((new_drp->dr_ifp->int_state
 634                                       ^ drp->dr_ifp->int_state)
 635                                      & IS_SICK)))
 636                                 new_drp = drp;
 637                 }
 638         }
 639
 640         /* forget it if all of the current entries are better */
 641         if (new_drp == NULL)
 642                 return;
 643
 644         new_drp->dr_ifp = ifp;
 645         new_drp->dr_gate = gate;
 646         new_drp->dr_ts = now.tv_sec;
 647         new_drp->dr_life = life;
 648         new_drp->dr_recv_pref = pref;
 649         /* bias functional preference by metric of the interface */
 650         new_drp->dr_pref = PREF(pref,ifp);
 651
 652         /* after hearing a good advertisement, stop asking
 653          */
 654         if (!(ifp->int_state & IS_SICK))
 655                 ifp->int_rdisc_cnt = MAX_SOLICITATIONS;
 656 }
 657
 658
 659 /* Compute the IP checksum
 660  *      This assumes the packet is less than 32K long.
 661  */
 662 static u_short
 663 in_cksum(u_short *p,
 664          u_int len)
 665 {
 666         u_int sum = 0;
 667         int nwords = len >> 1;
 668
 669         while (nwords-- != 0)
 670                 sum += *p++;
 671
 672         if (len & 1)
 673                 sum += *(u_char *)p;
 674
 675         /* end-around-carry */
 676         sum = (sum >> 16) + (sum & 0xffff);
 677         sum += (sum >> 16);
 678         return (~sum);
 679 }
 680
 681
 682 /* Send a router discovery advertisement or solicitation ICMP packet.
 683  */
 684 static void
 685 send_rdisc(union ad_u *p,
 686            int p_size,
 687            struct interface *ifp,
 688            naddr dst,                   /* 0 or unicast destination */
 689            int  type)                   /* 0=unicast, 1=bcast, 2=mcast */
 690 {
 691         struct sockaddr_in in;
 692         int flags;
 693         const char *msg;
 694         naddr tgt_mcast;
 695
 696
 697         memset(&in, 0, sizeof(in));
 698         in.sin_addr.s_addr = dst;
 699         in.sin_family = AF_INET;
 700 #ifdef _HAVE_SIN_LEN
 701         in.sin_len = sizeof(in);
 702 #endif
 703         flags = MSG_DONTROUTE;
 704
 705         switch (type) {
 706         case 0:                         /* unicast */
 707         default:
 708                 msg = "Send";
 709                 break;
 710
 711         case 1:                         /* broadcast */
 712                 if (ifp->int_if_flags & IFF_POINTOPOINT) {
 713                         msg = "Send pt-to-pt";
 714                         in.sin_addr.s_addr = ifp->int_dstaddr;
 715                 } else {
 716                         msg = "Send broadcast";
 717                         in.sin_addr.s_addr = ifp->int_brdaddr;
 718                 }
 719                 break;
 720
 721         case 2:                         /* multicast */
 722                 msg = "Send multicast";
 723                 if (ifp->int_state & IS_DUP) {
 724                         trace_act("abort multicast output via %s"
 725                                   " with duplicate address",
 726                                   ifp->int_name);
 727                         return;
 728                 }
 729                 if (rdisc_sock_mcast != ifp) {
 730                         /* select the right interface. */
 731 #ifdef MCAST_PPP_BUG
 732                         /* Do not specify the primary interface explicitly
 733                          * if we have the multicast point-to-point kernel
 734                          * bug, since the kernel will do the wrong thing
 735                          * if the local address of a point-to-point link
 736                          * is the same as the address of an ordinary
 737                          * interface.
 738                          */
 739                         if (ifp->int_addr == myaddr) {
 740                                 tgt_mcast = 0;
 741                         } else
 742 #endif
 743                         tgt_mcast = ifp->int_addr;
 744                         if (0 > setsockopt(rdisc_sock,
 745                                            IPPROTO_IP, IP_MULTICAST_IF,
 746                                            &tgt_mcast, sizeof(tgt_mcast))) {
 747                                 LOGERR("setsockopt(rdisc_sock,"
 748                                        "IP_MULTICAST_IF)");
 749                                 rdisc_sock_mcast = NULL;
 750                                 return;
 751                         }
 752                         rdisc_sock_mcast = ifp;
 753                 }
 754                 flags = 0;
 755                 break;
 756         }
 757
 758         if (rdisc_sock < 0)
 759                 get_rdisc_sock();
 760
 761         trace_rdisc(msg, ifp->int_addr, in.sin_addr.s_addr, ifp,
 762                     p, p_size);
 763
 764         if (0 > sendto(rdisc_sock, p, p_size, flags,
 765                        (struct sockaddr *)&in, sizeof(in))) {
 766                 if (ifp == NULL || !(ifp->int_state & IS_BROKE))
 767                         msglog("sendto(%s%s%s): %s",
 768                                ifp != NULL ? ifp->int_name : "",
 769                                ifp != NULL ? ", " : "",
 770                                inet_ntoa(in.sin_addr),
 771                                strerror(errno));
 772                 if (ifp != NULL)
 773                         if_sick(ifp);
 774         }
 775 }
 776
 777
 778 /* Send an advertisement
 779  */
 780 static void
 781 send_adv(struct interface *ifp,
 782          naddr  dst,                    /* 0 or unicast destination */
 783          int    type)                   /* 0=unicast, 1=bcast, 2=mcast */
 784 {
 785         union ad_u u;
 786         n_long pref;
 787
 788
 789         memset(&u, 0, sizeof(u.ad));
 790
 791         u.ad.icmp_type = ICMP_ROUTERADVERT;
 792         u.ad.icmp_ad_num = 1;
 793         u.ad.icmp_ad_asize = sizeof(u.ad.icmp_ad_info[0])/4;
 794
 795         u.ad.icmp_ad_life = stopint ? 0 : htons(ifp->int_rdisc_int*3);
 796
 797         /* Convert the configured preference to an unsigned value,
 798          * bias it by the interface metric, and then send it as a
 799          * signed, network byte order value.
 800          */
 801         pref = UNSIGN_PREF(ifp->int_rdisc_pref);
 802         u.ad.icmp_ad_info[0].icmp_ad_pref = htonl(SIGN_PREF(PREF(pref, ifp)));
 803
 804         u.ad.icmp_ad_info[0].icmp_ad_addr = ifp->int_addr;
 805
 806         u.ad.icmp_cksum = in_cksum((u_short*)&u.ad, sizeof(u.ad));
 807
 808         send_rdisc(&u, sizeof(u.ad), ifp, dst, type);
 809 }
 810
 811
 812 /* Advertise for Router Discovery
 813  */
 814 void
 815 rdisc_adv(void)
 816 {
 817         struct interface *ifp;
 818
 819         if (!supplier)
 820                 return;
 821
 822         rdisc_timer.tv_sec = now.tv_sec + NEVER;
 823
 824         for (ifp = ifnet; ifp; ifp = ifp->int_next) {
 825                 if (0 != (ifp->int_state & (IS_NO_ADV_OUT | IS_BROKE)))
 826                         continue;
 827
 828                 if (!timercmp(&ifp->int_rdisc_timer, &now, >)
 829                     || stopint) {
 830                         send_adv(ifp, htonl(INADDR_ALLHOSTS_GROUP),
 831                                  (ifp->int_state&IS_BCAST_RDISC) ? 1 : 2);
 832                         ifp->int_rdisc_cnt++;
 833
 834                         intvl_random(&ifp->int_rdisc_timer,
 835                                      (ifp->int_rdisc_int*3)/4,
 836                                      ifp->int_rdisc_int);
 837                         if (ifp->int_rdisc_cnt < MAX_INITIAL_ADVERTS
 838                             && (ifp->int_rdisc_timer.tv_sec
 839                                 > MAX_INITIAL_ADVERT_INTERVAL)) {
 840                                 ifp->int_rdisc_timer.tv_sec
 841                                 = MAX_INITIAL_ADVERT_INTERVAL;
 842                         }
 843                         timevaladd(&ifp->int_rdisc_timer, &now);
 844                 }
 845
 846                 if (timercmp(&rdisc_timer, &ifp->int_rdisc_timer, >))
 847                         rdisc_timer = ifp->int_rdisc_timer;
 848         }
 849 }
 850
 851
 852 /* Solicit for Router Discovery
 853  */
 854 void
 855 rdisc_sol(void)
 856 {
 857         struct interface *ifp;
 858         union ad_u u;
 859
 860
 861         if (supplier)
 862                 return;
 863
 864         rdisc_timer.tv_sec = now.tv_sec + NEVER;
 865
 866         for (ifp = ifnet; ifp; ifp = ifp->int_next) {
 867                 if (0 != (ifp->int_state & (IS_NO_SOL_OUT | IS_BROKE))
 868                     || ifp->int_rdisc_cnt >= MAX_SOLICITATIONS)
 869                         continue;
 870
 871                 if (!timercmp(&ifp->int_rdisc_timer, &now, >)) {
 872                         memset(&u, 0, sizeof(u.so));
 873                         u.so.icmp_type = ICMP_ROUTERSOLICIT;
 874                         u.so.icmp_cksum = in_cksum((u_short*)&u.so,
 875                                                    sizeof(u.so));
 876                         send_rdisc(&u, sizeof(u.so), ifp,
 877                                    htonl(INADDR_ALLROUTERS_GROUP),
 878                                    ((ifp->int_state&IS_BCAST_RDISC) ? 1 : 2));
 879
 880                         if (++ifp->int_rdisc_cnt >= MAX_SOLICITATIONS)
 881                                 continue;
 882
 883                         ifp->int_rdisc_timer.tv_sec = SOLICITATION_INTERVAL;
 884                         ifp->int_rdisc_timer.tv_usec = 0;
 885                         timevaladd(&ifp->int_rdisc_timer, &now);
 886                 }
 887
 888                 if (timercmp(&rdisc_timer, &ifp->int_rdisc_timer, >))
 889                         rdisc_timer = ifp->int_rdisc_timer;
 890         }
 891 }
 892
 893
 894 /* check the IP header of a possible Router Discovery ICMP packet */
 895 static struct interface *               /* 0 if bad */
 896 ck_icmp(const char *act,
 897         naddr   from,
 898         struct interface *ifp,
 899         naddr   to,
 900         union ad_u *p,
 901         u_int   len)
 902 {
 903         const char *type;
 904
 905
 906         if (p->icmp.icmp_type == ICMP_ROUTERADVERT) {
 907                 type = "advertisement";
 908         } else if (p->icmp.icmp_type == ICMP_ROUTERSOLICIT) {
 909                 type = "solicitation";
 910         } else {
 911                 return 0;
 912         }
 913
 914         if (p->icmp.icmp_code != 0) {
 915                 trace_pkt("unrecognized ICMP Router %s code=%d from %s to %s",
 916                           type, p->icmp.icmp_code,
 917                           naddr_ntoa(from), naddr_ntoa(to));
 918                 return 0;
 919         }
 920
 921         trace_rdisc(act, from, to, ifp, p, len);
 922
 923         if (ifp == NULL)
 924                 trace_pkt("unknown interface for router-discovery %s"
 925                           " from %s to %s",
 926                           type, naddr_ntoa(from), naddr_ntoa(to));
 927
 928         return ifp;
 929 }
 930
 931
 932 /* read packets from the router discovery socket
 933  */
 934 void
 935 read_d(void)
 936 {
 937         static struct msg_limit bad_asize, bad_len;
 938 #ifdef USE_PASSIFNAME
 939         static struct msg_limit  bad_name;
 940 #endif
 941         struct sockaddr_in from;
 942         int n, cc, hlen;
 943         socklen_t fromlen;
 944         struct {
 945 #ifdef USE_PASSIFNAME
 946                 char    ifname[IFNAMSIZ];
 947 #endif
 948                 union {
 949                         struct ip ip;
 950                         u_short s[512/2];
 951                         u_char  b[512];
 952                 } pkt;
 953         } buf;
 954         union ad_u *p;
 955         n_long *wp;
 956         struct interface *ifp;
 957
 958
 959         for (;;) {
 960                 fromlen = sizeof(from);
 961                 cc = recvfrom(rdisc_sock, &buf, sizeof(buf), 0,
 962                               (struct sockaddr*)&from,
 963                               &fromlen);
 964                 if (cc <= 0) {
 965                         if (cc < 0 && errno != EWOULDBLOCK)
 966                                 LOGERR("recvfrom(rdisc_sock)");
 967                         break;
 968                 }
 969                 if (fromlen != sizeof(struct sockaddr_in))
 970                         logbad(1,"impossible recvfrom(rdisc_sock) fromlen=%d",
 971                                fromlen);
 972 #ifdef USE_PASSIFNAME
 973                 if ((cc -= sizeof(buf.ifname)) < 0)
 974                         logbad(0,"missing USE_PASSIFNAME; only %d bytes",
 975                                cc+sizeof(buf.ifname));
 976 #endif
 977
 978                 hlen = buf.pkt.ip.ip_hl << 2;
 979                 if (cc < hlen + ICMP_MINLEN)
 980                         continue;
 981                 p = (union ad_u *)&buf.pkt.b[hlen];
 982                 cc -= hlen;
 983
 984 #ifdef USE_PASSIFNAME
 985                 ifp = ifwithname(buf.ifname, 0);
 986                 if (ifp == NULL)
 987                         msglim(&bad_name, from.sin_addr.s_addr,
 988                                "impossible rdisc if_ name %.*s",
 989                                IFNAMSIZ, buf.ifname);
 990 #else
 991                 /* If we could tell the interface on which a packet from
 992                  * address 0 arrived, we could deal with such solicitations.
 993                  */
 994                 ifp = ((from.sin_addr.s_addr == 0)
 995                        ? 0 : iflookup(from.sin_addr.s_addr));
 996 #endif
 997                 ifp = ck_icmp("Recv", from.sin_addr.s_addr, ifp,
 998                               buf.pkt.ip.ip_dst.s_addr, p, cc);
 999                 if (ifp == NULL)
1000                         continue;
1001                 if (ifwithaddr(from.sin_addr.s_addr, 0, 0)) {
1002                         trace_pkt("    "
1003                                   "discard our own Router Discovery message");
1004                         continue;
1005                 }
1006
1007                 switch (p->icmp.icmp_type) {
1008                 case ICMP_ROUTERADVERT:
1009                         if (p->ad.icmp_ad_asize*4
1010                             < (int)sizeof(p->ad.icmp_ad_info[0])) {
1011                                 msglim(&bad_asize, from.sin_addr.s_addr,
1012                                        "intolerable rdisc address size=%d",
1013                                        p->ad.icmp_ad_asize);
1014                                 continue;
1015                         }
1016                         if (p->ad.icmp_ad_num == 0) {
1017                                 trace_pkt("    empty?");
1018                                 continue;
1019                         }
1020                         if (cc != (int)(sizeof(p->ad)
1021                                         - sizeof(p->ad.icmp_ad_info)
1022                                         + (p->ad.icmp_ad_num
1023                                            * sizeof(p->ad.icmp_ad_info[0])))) {
1024                                 msglim(&bad_len, from.sin_addr.s_addr,
1025                                        "rdisc length %d does not match ad_num"
1026                                        " %d", cc, p->ad.icmp_ad_num);
1027                                 continue;
1028                         }
1029                         if (supplier)
1030                                 continue;
1031                         if (ifp->int_state & IS_NO_ADV_IN)
1032                                 continue;
1033
1034                         wp = &p->ad.icmp_ad_info[0].icmp_ad_addr;
1035                         for (n = 0; n < p->ad.icmp_ad_num; n++) {
1036                                 parse_ad(from.sin_addr.s_addr,
1037                                          wp[0], wp[1],
1038                                          ntohs(p->ad.icmp_ad_life),
1039                                          ifp);
1040                                 wp += p->ad.icmp_ad_asize;
1041                         }
1042                         break;
1043
1044
1045                 case ICMP_ROUTERSOLICIT:
1046                         if (!supplier)
1047                                 continue;
1048                         if (ifp->int_state & IS_NO_ADV_OUT)
1049                                 continue;
1050                         if (stopint)
1051                                 continue;
1052
1053                         /* XXX
1054                          * We should handle messages from address 0.
1055                          */
1056
1057                         /* Respond with a point-to-point advertisement */
1058                         send_adv(ifp, from.sin_addr.s_addr, 0);
1059                         break;
1060                 }
1061         }
1062
1063         rdisc_sort();
1064 }