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