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