usr.sbin/rtadvd/config.c

   1 /*      $FreeBSD$       */
   2 /*      $KAME: config.c,v 1.84 2003/08/05 12:34:23 itojun Exp $ */
   3
   4 /*
   5  * Copyright (C) 1998 WIDE Project.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the project nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/ioctl.h>
  35 #include <sys/socket.h>
  36 #include <sys/time.h>
  37 #include <sys/sysctl.h>
  38
  39 #include <net/if.h>
  40 #include <net/if_var.h>
  41 #include <net/route.h>
  42 #include <net/if_dl.h>
  43
  44 #include <netinet/in.h>
  45 #include <netinet/in_var.h>
  46 #include <netinet/ip6.h>
  47 #include <netinet6/ip6_var.h>
  48 #include <netinet/icmp6.h>
  49 #include <netinet6/nd6.h>
  50
  51 #include <arpa/inet.h>
  52
  53 #include <stdio.h>
  54 #include <syslog.h>
  55 #include <errno.h>
  56 #include <string.h>
  57 #include <search.h>
  58 #include <stdlib.h>
  59 #include <unistd.h>
  60 #include <ifaddrs.h>
  61
  62 #include "rtadvd.h"
  63 #include "advcap.h"
  64 #include "timer.h"
  65 #include "if.h"
  66 #include "config.h"
  67
  68 static time_t prefix_timo = (60 * 120); /* 2 hours.
  69                                          * XXX: should be configurable. */
  70 extern struct rainfo *ralist;
  71
  72 static struct rtadvd_timer *prefix_timeout(void *);
  73 static void makeentry(char *, size_t, int, char *);
  74 static int getinet6sysctl(int);
  75
  76 void
  77 getconfig(intface)
  78         char *intface;
  79 {
  80         int stat, i;
  81         char tbuf[BUFSIZ];
  82         struct rainfo *tmp;
  83         long val;
  84         int64_t val64;
  85         char buf[BUFSIZ];
  86         char *bp = buf;
  87         char *addr, *flagstr;
  88         static int forwarding = -1;
  89
  90 #define MUSTHAVE(var, cap)      \
  91     do {                                                                \
  92         int64_t t;                                                      \
  93         if ((t = agetnum(cap)) < 0) {                                   \
  94                 fprintf(stderr, "rtadvd: need %s for interface %s\n",   \
  95                         cap, intface);                                  \
  96                 exit(1);                                                \
  97         }                                                               \
  98         var = t;                                                        \
  99      } while (0)
 100 #define MAYHAVE(var, cap, def)  \
 101      do {                                                               \
 102         if ((var = agetnum(cap)) < 0)                                   \
 103                 var = def;                                              \
 104      } while (0)
 105
 106         if ((stat = agetent(tbuf, intface)) <= 0) {
 107                 memset(tbuf, 0, sizeof(tbuf));
 108                 syslog(LOG_INFO,
 109                        "<%s> %s isn't defined in the configuration file"
 110                        " or the configuration file doesn't exist."
 111                        " Treat it as default",
 112                         __func__, intface);
 113         }
 114
 115         tmp = (struct rainfo *)malloc(sizeof(*ralist));
 116         if (tmp == NULL) {
 117                 syslog(LOG_INFO, "<%s> %s: can't allocate enough memory",
 118                     __func__, intface);
 119                 exit(1);
 120         }
 121         memset(tmp, 0, sizeof(*tmp));
 122         tmp->prefix.next = tmp->prefix.prev = &tmp->prefix;
 123 #ifdef ROUTEINFO
 124         tmp->route.next = tmp->route.prev = &tmp->route;
 125 #endif
 126
 127         /* check if we are allowed to forward packets (if not determined) */
 128         if (forwarding < 0) {
 129                 if ((forwarding = getinet6sysctl(IPV6CTL_FORWARDING)) < 0)
 130                         exit(1);
 131         }
 132
 133         /* get interface information */
 134         if (agetflag("nolladdr"))
 135                 tmp->advlinkopt = 0;
 136         else
 137                 tmp->advlinkopt = 1;
 138         if (tmp->advlinkopt) {
 139                 if ((tmp->sdl = if_nametosdl(intface)) == NULL) {
 140                         syslog(LOG_ERR,
 141                                "<%s> can't get information of %s",
 142                                __func__, intface);
 143                         exit(1);
 144                 }
 145                 tmp->ifindex = tmp->sdl->sdl_index;
 146         } else
 147                 tmp->ifindex = if_nametoindex(intface);
 148         strncpy(tmp->ifname, intface, sizeof(tmp->ifname));
 149         if ((tmp->phymtu = if_getmtu(intface)) == 0) {
 150                 tmp->phymtu = IPV6_MMTU;
 151                 syslog(LOG_WARNING,
 152                        "<%s> can't get interface mtu of %s. Treat as %d",
 153                        __func__, intface, IPV6_MMTU);
 154         }
 155
 156         /*
 157          * set router configuration variables.
 158          */
 159         MAYHAVE(val, "maxinterval", DEF_MAXRTRADVINTERVAL);
 160         if (val < MIN_MAXINTERVAL || val > MAX_MAXINTERVAL) {
 161                 syslog(LOG_ERR,
 162                        "<%s> maxinterval (%ld) on %s is invalid "
 163                        "(must be between %u and %u)", __func__, val,
 164                        intface, MIN_MAXINTERVAL, MAX_MAXINTERVAL);
 165                 exit(1);
 166         }
 167         tmp->maxinterval = (u_int)val;
 168         MAYHAVE(val, "mininterval", tmp->maxinterval/3);
 169         if (val < MIN_MININTERVAL || val > (tmp->maxinterval * 3) / 4) {
 170                 syslog(LOG_ERR,
 171                        "<%s> mininterval (%ld) on %s is invalid "
 172                        "(must be between %d and %d)",
 173                        __func__, val, intface, MIN_MININTERVAL,
 174                        (tmp->maxinterval * 3) / 4);
 175                 exit(1);
 176         }
 177         tmp->mininterval = (u_int)val;
 178
 179         MAYHAVE(val, "chlim", DEF_ADVCURHOPLIMIT);
 180         tmp->hoplimit = val & 0xff;
 181
 182         if ((flagstr = (char *)agetstr("raflags", &bp))) {
 183                 val = 0;
 184                 if (strchr(flagstr, 'm'))
 185                         val |= ND_RA_FLAG_MANAGED;
 186                 if (strchr(flagstr, 'o'))
 187                         val |= ND_RA_FLAG_OTHER;
 188                 if (strchr(flagstr, 'h'))
 189                         val |= ND_RA_FLAG_RTPREF_HIGH;
 190                 if (strchr(flagstr, 'l')) {
 191                         if ((val & ND_RA_FLAG_RTPREF_HIGH)) {
 192                                 syslog(LOG_ERR, "<%s> the \'h\' and \'l\'"
 193                                     " router flags are exclusive", __func__);
 194                                 exit(1);
 195                         }
 196                         val |= ND_RA_FLAG_RTPREF_LOW;
 197                 }
 198         } else {
 199                 MAYHAVE(val, "raflags", 0);
 200         }
 201         tmp->managedflg = val & ND_RA_FLAG_MANAGED;
 202         tmp->otherflg = val & ND_RA_FLAG_OTHER;
 203 #ifndef ND_RA_FLAG_RTPREF_MASK
 204 #define ND_RA_FLAG_RTPREF_MASK  0x18 /* 00011000 */
 205 #define ND_RA_FLAG_RTPREF_RSV   0x10 /* 00010000 */
 206 #endif
 207         tmp->rtpref = val & ND_RA_FLAG_RTPREF_MASK;
 208         if (tmp->rtpref == ND_RA_FLAG_RTPREF_RSV) {
 209                 syslog(LOG_ERR, "<%s> invalid router preference (%02x) on %s",
 210                        __func__, tmp->rtpref, intface);
 211                 exit(1);
 212         }
 213
 214         MAYHAVE(val, "rltime", tmp->maxinterval * 3);
 215         if (val && (val < tmp->maxinterval || val > MAXROUTERLIFETIME)) {
 216                 syslog(LOG_ERR,
 217                        "<%s> router lifetime (%ld) on %s is invalid "
 218                        "(must be 0 or between %d and %d)",
 219                        __func__, val, intface,
 220                        tmp->maxinterval,
 221                        MAXROUTERLIFETIME);
 222                 exit(1);
 223         }
 224         /*
 225          * Basically, hosts MUST NOT send Router Advertisement messages at any
 226          * time (RFC 2461, Section 6.2.3). However, it would sometimes be
 227          * useful to allow hosts to advertise some parameters such as prefix
 228          * information and link MTU. Thus, we allow hosts to invoke rtadvd
 229          * only when router lifetime (on every advertising interface) is
 230          * explicitly set zero. (see also the above section)
 231          */
 232         if (val && forwarding == 0) {
 233                 syslog(LOG_ERR,
 234                        "<%s> non zero router lifetime is specified for %s, "
 235                        "which must not be allowed for hosts.  you must "
 236                        "change router lifetime or enable IPv6 forwarding.",
 237                        __func__, intface);
 238                 exit(1);
 239         }
 240         tmp->lifetime = val & 0xffff;
 241
 242         MAYHAVE(val, "rtime", DEF_ADVREACHABLETIME);
 243         if (val < 0 || val > MAXREACHABLETIME) {
 244                 syslog(LOG_ERR,
 245                        "<%s> reachable time (%ld) on %s is invalid "
 246                        "(must be no greater than %d)",
 247                        __func__, val, intface, MAXREACHABLETIME);
 248                 exit(1);
 249         }
 250         tmp->reachabletime = (u_int32_t)val;
 251
 252         MAYHAVE(val64, "retrans", DEF_ADVRETRANSTIMER);
 253         if (val64 < 0 || val64 > 0xffffffff) {
 254                 syslog(LOG_ERR, "<%s> retrans time (%lld) on %s out of range",
 255                        __func__, (long long)val64, intface);
 256                 exit(1);
 257         }
 258         tmp->retranstimer = (u_int32_t)val64;
 259
 260         if (agetnum("hapref") != -1 || agetnum("hatime") != -1) {
 261                 syslog(LOG_ERR,
 262                        "<%s> mobile-ip6 configuration not supported",
 263                        __func__);
 264                 exit(1);
 265         }
 266         /* prefix information */
 267
 268         /*
 269          * This is an implementation specific parameter to consider
 270          * link propagation delays and poorly synchronized clocks when
 271          * checking consistency of advertised lifetimes.
 272          */
 273         MAYHAVE(val, "clockskew", 0);
 274         tmp->clockskew = val;
 275
 276         tmp->pfxs = 0;
 277         for (i = -1; i < MAXPREFIX; i++) {
 278                 struct prefix *pfx;
 279                 char entbuf[256];
 280
 281                 makeentry(entbuf, sizeof(entbuf), i, "addr");
 282                 addr = (char *)agetstr(entbuf, &bp);
 283                 if (addr == NULL)
 284                         continue;
 285
 286                 /* allocate memory to store prefix information */
 287                 if ((pfx = malloc(sizeof(struct prefix))) == NULL) {
 288                         syslog(LOG_ERR,
 289                                "<%s> can't allocate enough memory",
 290                                __func__);
 291                         exit(1);
 292                 }
 293                 memset(pfx, 0, sizeof(*pfx));
 294
 295                 /* link into chain */
 296                 insque(pfx, &tmp->prefix);
 297                 tmp->pfxs++;
 298                 pfx->rainfo = tmp;
 299
 300                 pfx->origin = PREFIX_FROM_CONFIG;
 301
 302                 if (inet_pton(AF_INET6, addr, &pfx->prefix) != 1) {
 303                         syslog(LOG_ERR,
 304                                "<%s> inet_pton failed for %s",
 305                                __func__, addr);
 306                         exit(1);
 307                 }
 308                 if (IN6_IS_ADDR_MULTICAST(&pfx->prefix)) {
 309                         syslog(LOG_ERR,
 310                                "<%s> multicast prefix (%s) must "
 311                                "not be advertised on %s",
 312                                __func__, addr, intface);
 313                         exit(1);
 314                 }
 315                 if (IN6_IS_ADDR_LINKLOCAL(&pfx->prefix))
 316                         syslog(LOG_NOTICE,
 317                                "<%s> link-local prefix (%s) will be"
 318                                " advertised on %s",
 319                                __func__, addr, intface);
 320
 321                 makeentry(entbuf, sizeof(entbuf), i, "prefixlen");
 322                 MAYHAVE(val, entbuf, 64);
 323                 if (val < 0 || val > 128) {
 324                         syslog(LOG_ERR, "<%s> prefixlen (%ld) for %s "
 325                                "on %s out of range",
 326                                __func__, val, addr, intface);
 327                         exit(1);
 328                 }
 329                 pfx->prefixlen = (int)val;
 330
 331                 makeentry(entbuf, sizeof(entbuf), i, "pinfoflags");
 332                 if ((flagstr = (char *)agetstr(entbuf, &bp))) {
 333                         val = 0;
 334                         if (strchr(flagstr, 'l'))
 335                                 val |= ND_OPT_PI_FLAG_ONLINK;
 336                         if (strchr(flagstr, 'a'))
 337                                 val |= ND_OPT_PI_FLAG_AUTO;
 338                 } else {
 339                         MAYHAVE(val, entbuf,
 340                             (ND_OPT_PI_FLAG_ONLINK|ND_OPT_PI_FLAG_AUTO));
 341                 }
 342                 pfx->onlinkflg = val & ND_OPT_PI_FLAG_ONLINK;
 343                 pfx->autoconfflg = val & ND_OPT_PI_FLAG_AUTO;
 344
 345                 makeentry(entbuf, sizeof(entbuf), i, "vltime");
 346                 MAYHAVE(val64, entbuf, DEF_ADVVALIDLIFETIME);
 347                 if (val64 < 0 || val64 > 0xffffffff) {
 348                         syslog(LOG_ERR, "<%s> vltime (%lld) for "
 349                             "%s/%d on %s is out of range",
 350                             __func__, (long long)val64,
 351                             addr, pfx->prefixlen, intface);
 352                         exit(1);
 353                 }
 354                 pfx->validlifetime = (u_int32_t)val64;
 355
 356                 makeentry(entbuf, sizeof(entbuf), i, "vltimedecr");
 357                 if (agetflag(entbuf)) {
 358                         struct timeval now;
 359                         gettimeofday(&now, 0);
 360                         pfx->vltimeexpire =
 361                                 now.tv_sec + pfx->validlifetime;
 362                 }
 363
 364                 makeentry(entbuf, sizeof(entbuf), i, "pltime");
 365                 MAYHAVE(val64, entbuf, DEF_ADVPREFERREDLIFETIME);
 366                 if (val64 < 0 || val64 > 0xffffffff) {
 367                         syslog(LOG_ERR,
 368                             "<%s> pltime (%lld) for %s/%d on %s "
 369                             "is out of range",
 370                             __func__, (long long)val64,
 371                             addr, pfx->prefixlen, intface);
 372                         exit(1);
 373                 }
 374                 pfx->preflifetime = (u_int32_t)val64;
 375
 376                 makeentry(entbuf, sizeof(entbuf), i, "pltimedecr");
 377                 if (agetflag(entbuf)) {
 378                         struct timeval now;
 379                         gettimeofday(&now, 0);
 380                         pfx->pltimeexpire =
 381                                 now.tv_sec + pfx->preflifetime;
 382                 }
 383         }
 384         if (tmp->pfxs == 0)
 385                 get_prefix(tmp);
 386
 387         MAYHAVE(val, "mtu", 0);
 388         if (val < 0 || val > 0xffffffff) {
 389                 syslog(LOG_ERR,
 390                        "<%s> mtu (%ld) on %s out of range",
 391                        __func__, val, intface);
 392                 exit(1);
 393         }
 394         tmp->linkmtu = (u_int32_t)val;
 395         if (tmp->linkmtu == 0) {
 396                 char *mtustr;
 397
 398                 if ((mtustr = (char *)agetstr("mtu", &bp)) &&
 399                     strcmp(mtustr, "auto") == 0)
 400                         tmp->linkmtu = tmp->phymtu;
 401         }
 402         else if (tmp->linkmtu < IPV6_MMTU || tmp->linkmtu > tmp->phymtu) {
 403                 syslog(LOG_ERR,
 404                        "<%s> advertised link mtu (%lu) on %s is invalid (must "
 405                        "be between least MTU (%d) and physical link MTU (%d)",
 406                        __func__, (unsigned long)tmp->linkmtu, intface,
 407                        IPV6_MMTU, tmp->phymtu);
 408                 exit(1);
 409         }
 410
 411 #ifdef SIOCSIFINFO_IN6
 412         {
 413                 struct in6_ndireq ndi;
 414                 int s;
 415
 416                 if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 417                         syslog(LOG_ERR, "<%s> socket: %s", __func__,
 418                                strerror(errno));
 419                         exit(1);
 420                 }
 421                 memset(&ndi, 0, sizeof(ndi));
 422                 strncpy(ndi.ifname, intface, IFNAMSIZ);
 423                 if (ioctl(s, SIOCGIFINFO_IN6, (caddr_t)&ndi) < 0) {
 424                         syslog(LOG_INFO, "<%s> ioctl:SIOCGIFINFO_IN6 at %s: %s",
 425                              __func__, intface, strerror(errno));
 426                 }
 427
 428                 /* reflect the RA info to the host variables in kernel */
 429                 ndi.ndi.chlim = tmp->hoplimit;
 430                 ndi.ndi.retrans = tmp->retranstimer;
 431                 ndi.ndi.basereachable = tmp->reachabletime;
 432                 if (ioctl(s, SIOCSIFINFO_IN6, (caddr_t)&ndi) < 0) {
 433                         syslog(LOG_INFO, "<%s> ioctl:SIOCSIFINFO_IN6 at %s: %s",
 434                              __func__, intface, strerror(errno));
 435                 }
 436                 close(s);
 437         }
 438 #endif
 439
 440         /* route information */
 441 #ifdef ROUTEINFO
 442         tmp->routes = 0;
 443         for (i = -1; i < MAXROUTE; i++) {
 444                 struct rtinfo *rti;
 445                 char entbuf[256], oentbuf[256];
 446
 447                 makeentry(entbuf, sizeof(entbuf), i, "rtprefix");
 448                 addr = (char *)agetstr(entbuf, &bp);
 449                 if (addr == NULL) {
 450                         makeentry(oentbuf, sizeof(oentbuf), i, "rtrprefix");
 451                         addr = (char *)agetstr(oentbuf, &bp);
 452                         if (addr) {
 453                                 fprintf(stderr, "%s was obsoleted.  Use %s.\n",
 454                                         oentbuf, entbuf);
 455                         }
 456                 }
 457                 if (addr == NULL)
 458                         continue;
 459
 460                 /* allocate memory to store prefix information */
 461                 if ((rti = malloc(sizeof(struct rtinfo))) == NULL) {
 462                         syslog(LOG_ERR,
 463                                "<%s> can't allocate enough memory",
 464                                __func__);
 465                         exit(1);
 466                 }
 467                 memset(rti, 0, sizeof(*rti));
 468
 469                 /* link into chain */
 470                 insque(rti, &tmp->route);
 471                 tmp->routes++;
 472
 473                 if (inet_pton(AF_INET6, addr, &rti->prefix) != 1) {
 474                         syslog(LOG_ERR, "<%s> inet_pton failed for %s",
 475                                __func__, addr);
 476                         exit(1);
 477                 }
 478 #if 0
 479                 /*
 480                  * XXX: currently there's no restriction in route information
 481                  * prefix according to
 482                  * draft-ietf-ipngwg-router-selection-00.txt.
 483                  * However, I think the similar restriction be necessary.
 484                  */
 485                 MAYHAVE(val64, entbuf, DEF_ADVVALIDLIFETIME);
 486                 if (IN6_IS_ADDR_MULTICAST(&rti->prefix)) {
 487                         syslog(LOG_ERR,
 488                                "<%s> multicast route (%s) must "
 489                                "not be advertised on %s",
 490                                __func__, addr, intface);
 491                         exit(1);
 492                 }
 493                 if (IN6_IS_ADDR_LINKLOCAL(&rti->prefix)) {
 494                         syslog(LOG_NOTICE,
 495                                "<%s> link-local route (%s) will "
 496                                "be advertised on %s",
 497                                __func__, addr, intface);
 498                         exit(1);
 499                 }
 500 #endif
 501
 502                 makeentry(entbuf, sizeof(entbuf), i, "rtplen");
 503                 /* XXX: 256 is a magic number for compatibility check. */
 504                 MAYHAVE(val, entbuf, 256);
 505                 if (val == 256) {
 506                         makeentry(oentbuf, sizeof(oentbuf), i, "rtrplen");
 507                         MAYHAVE(val, oentbuf, 256);
 508                         if (val != 256) {
 509                                 fprintf(stderr, "%s was obsoleted.  Use %s.\n",
 510                                         oentbuf, entbuf);
 511                         } else
 512                                 val = 64;
 513                 }
 514                 if (val < 0 || val > 128) {
 515                         syslog(LOG_ERR, "<%s> prefixlen (%ld) for %s on %s "
 516                                "out of range",
 517                                __func__, val, addr, intface);
 518                         exit(1);
 519                 }
 520                 rti->prefixlen = (int)val;
 521
 522                 makeentry(entbuf, sizeof(entbuf), i, "rtflags");
 523                 if ((flagstr = (char *)agetstr(entbuf, &bp))) {
 524                         val = 0;
 525                         if (strchr(flagstr, 'h'))
 526                                 val |= ND_RA_FLAG_RTPREF_HIGH;
 527                         if (strchr(flagstr, 'l')) {
 528                                 if ((val & ND_RA_FLAG_RTPREF_HIGH)) {
 529                                         syslog(LOG_ERR,
 530                                             "<%s> the \'h\' and \'l\' route"
 531                                             " preferences are exclusive",
 532                                             __func__);
 533                                         exit(1);
 534                                 }
 535                                 val |= ND_RA_FLAG_RTPREF_LOW;
 536                         }
 537                 } else
 538                         MAYHAVE(val, entbuf, 256); /* XXX */
 539                 if (val == 256) {
 540                         makeentry(oentbuf, sizeof(oentbuf), i, "rtrflags");
 541                         MAYHAVE(val, oentbuf, 256);
 542                         if (val != 256) {
 543                                 fprintf(stderr, "%s was obsoleted.  Use %s.\n",
 544                                         oentbuf, entbuf);
 545                         } else
 546                                 val = 0;
 547                 }
 548                 rti->rtpref = val & ND_RA_FLAG_RTPREF_MASK;
 549                 if (rti->rtpref == ND_RA_FLAG_RTPREF_RSV) {
 550                         syslog(LOG_ERR, "<%s> invalid route preference (%02x) "
 551                                "for %s/%d on %s",
 552                                __func__, rti->rtpref, addr,
 553                                rti->prefixlen, intface);
 554                         exit(1);
 555                 }
 556
 557                 /*
 558                  * Since the spec does not a default value, we should make
 559                  * this entry mandatory.  However, FreeBSD 4.4 has shipped
 560                  * with this field being optional, we use the router lifetime
 561                  * as an ad-hoc default value with a warning message.
 562                  */
 563                 makeentry(entbuf, sizeof(entbuf), i, "rtltime");
 564                 MAYHAVE(val64, entbuf, -1);
 565                 if (val64 == -1) {
 566                         makeentry(oentbuf, sizeof(oentbuf), i, "rtrltime");
 567                         MAYHAVE(val64, oentbuf, -1);
 568                         if (val64 != -1) {
 569                                 fprintf(stderr, "%s was obsoleted.  Use %s.\n",
 570                                         oentbuf, entbuf);
 571                         } else {
 572                                 fprintf(stderr, "%s should be specified "
 573                                         "for interface %s.\n",
 574                                         entbuf, intface);
 575                                 val64 = tmp->lifetime;
 576                         }
 577                 }
 578                 if (val64 < 0 || val64 > 0xffffffff) {
 579                         syslog(LOG_ERR, "<%s> route lifetime (%lld) for "
 580                             "%s/%d on %s out of range", __func__,
 581                             (long long)val64, addr, rti->prefixlen, intface);
 582                         exit(1);
 583                 }
 584                 rti->ltime = (u_int32_t)val64;
 585         }
 586 #endif
 587
 588         /* okey */
 589         tmp->next = ralist;
 590         ralist = tmp;
 591
 592         /* construct the sending packet */
 593         make_packet(tmp);
 594
 595         /* set timer */
 596         tmp->timer = rtadvd_add_timer(ra_timeout, ra_timer_update,
 597                                       tmp, tmp);
 598         ra_timer_update((void *)tmp, &tmp->timer->tm);
 599         rtadvd_set_timer(&tmp->timer->tm, tmp->timer);
 600 }
 601
 602 void
 603 get_prefix(struct rainfo *rai)
 604 {
 605         struct ifaddrs *ifap, *ifa;
 606         struct prefix *pp;
 607         struct in6_addr *a;
 608         u_char *p, *ep, *m, *lim;
 609         u_char ntopbuf[INET6_ADDRSTRLEN];
 610
 611         if (getifaddrs(&ifap) < 0) {
 612                 syslog(LOG_ERR,
 613                        "<%s> can't get interface addresses",
 614                        __func__);
 615                 exit(1);
 616         }
 617
 618         for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
 619                 int plen;
 620
 621                 if (strcmp(ifa->ifa_name, rai->ifname) != 0)
 622                         continue;
 623                 if (ifa->ifa_addr->sa_family != AF_INET6)
 624                         continue;
 625                 a = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
 626                 if (IN6_IS_ADDR_LINKLOCAL(a))
 627                         continue;
 628                 /* get prefix length */
 629                 m = (u_char *)&((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
 630                 lim = (u_char *)(ifa->ifa_netmask) + ifa->ifa_netmask->sa_len;
 631                 plen = prefixlen(m, lim);
 632                 if (plen <= 0 || plen > 128) {
 633                         syslog(LOG_ERR, "<%s> failed to get prefixlen "
 634                                "or prefix is invalid",
 635                                __func__);
 636                         exit(1);
 637                 }
 638                 if (plen == 128)        /* XXX */
 639                         continue;
 640                 if (find_prefix(rai, a, plen)) {
 641                         /* ignore a duplicated prefix. */
 642                         continue;
 643                 }
 644
 645                 /* allocate memory to store prefix info. */
 646                 if ((pp = malloc(sizeof(*pp))) == NULL) {
 647                         syslog(LOG_ERR,
 648                                "<%s> can't get allocate buffer for prefix",
 649                                __func__);
 650                         exit(1);
 651                 }
 652                 memset(pp, 0, sizeof(*pp));
 653
 654                 /* set prefix, sweep bits outside of prefixlen */
 655                 pp->prefixlen = plen;
 656                 memcpy(&pp->prefix, a, sizeof(*a));
 657                 p = (u_char *)&pp->prefix;
 658                 ep = (u_char *)(&pp->prefix + 1);
 659                 while (m < lim && p < ep)
 660                         *p++ &= *m++;
 661                 while (p < ep)
 662                         *p++ = 0x00;
 663                 if (!inet_ntop(AF_INET6, &pp->prefix, ntopbuf,
 664                     sizeof(ntopbuf))) {
 665                         syslog(LOG_ERR, "<%s> inet_ntop failed", __func__);
 666                         exit(1);
 667                 }
 668                 syslog(LOG_DEBUG,
 669                        "<%s> add %s/%d to prefix list on %s",
 670                        __func__, ntopbuf, pp->prefixlen, rai->ifname);
 671
 672                 /* set other fields with protocol defaults */
 673                 pp->validlifetime = DEF_ADVVALIDLIFETIME;
 674                 pp->preflifetime = DEF_ADVPREFERREDLIFETIME;
 675                 pp->onlinkflg = 1;
 676                 pp->autoconfflg = 1;
 677                 pp->origin = PREFIX_FROM_KERNEL;
 678                 pp->rainfo = rai;
 679
 680                 /* link into chain */
 681                 insque(pp, &rai->prefix);
 682
 683                 /* counter increment */
 684                 rai->pfxs++;
 685         }
 686
 687         freeifaddrs(ifap);
 688 }
 689
 690 static void
 691 makeentry(buf, len, id, string)
 692         char *buf;
 693         size_t len;
 694         int id;
 695         char *string;
 696 {
 697
 698         if (id < 0)
 699                 strlcpy(buf, string, len);
 700         else
 701                 snprintf(buf, len, "%s%d", string, id);
 702 }
 703
 704 /*
 705  * Add a prefix to the list of specified interface and reconstruct
 706  * the outgoing packet.
 707  * The prefix must not be in the list.
 708  * XXX: other parameters of the prefix (e.g. lifetime) should be
 709  * able to be specified.
 710  */
 711 static void
 712 add_prefix(struct rainfo *rai, struct in6_prefixreq *ipr)
 713 {
 714         struct prefix *prefix;
 715         u_char ntopbuf[INET6_ADDRSTRLEN];
 716
 717         if ((prefix = malloc(sizeof(*prefix))) == NULL) {
 718                 syslog(LOG_ERR, "<%s> memory allocation failed",
 719                        __func__);
 720                 return;         /* XXX: error or exit? */
 721         }
 722         memset(prefix, 0, sizeof(*prefix));
 723         prefix->prefix = ipr->ipr_prefix.sin6_addr;
 724         prefix->prefixlen = ipr->ipr_plen;
 725         prefix->validlifetime = ipr->ipr_vltime;
 726         prefix->preflifetime = ipr->ipr_pltime;
 727         prefix->onlinkflg = ipr->ipr_raf_onlink;
 728         prefix->autoconfflg = ipr->ipr_raf_auto;
 729         prefix->origin = PREFIX_FROM_DYNAMIC;
 730
 731         insque(prefix, &rai->prefix);
 732         prefix->rainfo = rai;
 733
 734         syslog(LOG_DEBUG, "<%s> new prefix %s/%d was added on %s",
 735                __func__, inet_ntop(AF_INET6, &ipr->ipr_prefix.sin6_addr,
 736                                        ntopbuf, INET6_ADDRSTRLEN),
 737                ipr->ipr_plen, rai->ifname);
 738
 739         /* free the previous packet */
 740         free(rai->ra_data);
 741         rai->ra_data = NULL;
 742
 743         /* reconstruct the packet */
 744         rai->pfxs++;
 745         make_packet(rai);
 746 }
 747
 748 /*
 749  * Delete a prefix to the list of specified interface and reconstruct
 750  * the outgoing packet.
 751  * The prefix must be in the list.
 752  */
 753 void
 754 delete_prefix(struct prefix *prefix)
 755 {
 756         u_char ntopbuf[INET6_ADDRSTRLEN];
 757         struct rainfo *rai = prefix->rainfo;
 758
 759         remque(prefix);
 760         syslog(LOG_DEBUG, "<%s> prefix %s/%d was deleted on %s",
 761                __func__, inet_ntop(AF_INET6, &prefix->prefix,
 762                                        ntopbuf, INET6_ADDRSTRLEN),
 763                prefix->prefixlen, rai->ifname);
 764         if (prefix->timer)
 765                 rtadvd_remove_timer(&prefix->timer);
 766         free(prefix);
 767         rai->pfxs--;
 768 }
 769
 770 void
 771 invalidate_prefix(struct prefix *prefix)
 772 {
 773         u_char ntopbuf[INET6_ADDRSTRLEN];
 774         struct timeval timo;
 775         struct rainfo *rai = prefix->rainfo;
 776
 777         if (prefix->timer) {    /* sanity check */
 778                 syslog(LOG_ERR,
 779                     "<%s> assumption failure: timer already exists",
 780                     __func__);
 781                 exit(1);
 782         }
 783
 784         syslog(LOG_DEBUG, "<%s> prefix %s/%d was invalidated on %s, "
 785             "will expire in %ld seconds", __func__,
 786             inet_ntop(AF_INET6, &prefix->prefix, ntopbuf, INET6_ADDRSTRLEN),
 787             prefix->prefixlen, rai->ifname, (long)prefix_timo);
 788
 789         /* set the expiration timer */
 790         prefix->timer = rtadvd_add_timer(prefix_timeout, NULL, prefix, NULL);
 791         if (prefix->timer == NULL) {
 792                 syslog(LOG_ERR, "<%s> failed to add a timer for a prefix. "
 793                     "remove the prefix", __func__);
 794                 delete_prefix(prefix);
 795         }
 796         timo.tv_sec = prefix_timo;
 797         timo.tv_usec = 0;
 798         rtadvd_set_timer(&timo, prefix->timer);
 799 }
 800
 801 static struct rtadvd_timer *
 802 prefix_timeout(void *arg)
 803 {
 804         struct prefix *prefix = (struct prefix *)arg;
 805
 806         delete_prefix(prefix);
 807
 808         return(NULL);
 809 }
 810
 811 void
 812 update_prefix(struct prefix * prefix)
 813 {
 814         u_char ntopbuf[INET6_ADDRSTRLEN];
 815         struct rainfo *rai = prefix->rainfo;
 816
 817         if (prefix->timer == NULL) { /* sanity check */
 818                 syslog(LOG_ERR,
 819                     "<%s> assumption failure: timer does not exist",
 820                     __func__);
 821                 exit(1);
 822         }
 823
 824         syslog(LOG_DEBUG, "<%s> prefix %s/%d was re-enabled on %s",
 825             __func__, inet_ntop(AF_INET6, &prefix->prefix, ntopbuf,
 826             INET6_ADDRSTRLEN), prefix->prefixlen, rai->ifname);
 827
 828         /* stop the expiration timer */
 829         rtadvd_remove_timer(&prefix->timer);
 830 }
 831
 832 /*
 833  * Try to get an in6_prefixreq contents for a prefix which matches
 834  * ipr->ipr_prefix and ipr->ipr_plen and belongs to
 835  * the interface whose name is ipr->ipr_name[].
 836  */
 837 static int
 838 init_prefix(struct in6_prefixreq *ipr)
 839 {
 840 #if 0
 841         int s;
 842
 843         if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 844                 syslog(LOG_ERR, "<%s> socket: %s", __func__,
 845                        strerror(errno));
 846                 exit(1);
 847         }
 848
 849         if (ioctl(s, SIOCGIFPREFIX_IN6, (caddr_t)ipr) < 0) {
 850                 syslog(LOG_INFO, "<%s> ioctl:SIOCGIFPREFIX %s", __func__,
 851                        strerror(errno));
 852
 853                 ipr->ipr_vltime = DEF_ADVVALIDLIFETIME;
 854                 ipr->ipr_pltime = DEF_ADVPREFERREDLIFETIME;
 855                 ipr->ipr_raf_onlink = 1;
 856                 ipr->ipr_raf_auto = 1;
 857                 /* omit other field initialization */
 858         }
 859         else if (ipr->ipr_origin < PR_ORIG_RR) {
 860                 u_char ntopbuf[INET6_ADDRSTRLEN];
 861
 862                 syslog(LOG_WARNING, "<%s> Added prefix(%s)'s origin %d is"
 863                        "lower than PR_ORIG_RR(router renumbering)."
 864                        "This should not happen if I am router", __func__,
 865                        inet_ntop(AF_INET6, &ipr->ipr_prefix.sin6_addr, ntopbuf,
 866                                  sizeof(ntopbuf)), ipr->ipr_origin);
 867                 close(s);
 868                 return 1;
 869         }
 870
 871         close(s);
 872         return 0;
 873 #else
 874         ipr->ipr_vltime = DEF_ADVVALIDLIFETIME;
 875         ipr->ipr_pltime = DEF_ADVPREFERREDLIFETIME;
 876         ipr->ipr_raf_onlink = 1;
 877         ipr->ipr_raf_auto = 1;
 878         return 0;
 879 #endif
 880 }
 881
 882 void
 883 make_prefix(struct rainfo *rai, int ifindex, struct in6_addr *addr, int plen)
 884 {
 885         struct in6_prefixreq ipr;
 886
 887         memset(&ipr, 0, sizeof(ipr));
 888         if (if_indextoname(ifindex, ipr.ipr_name) == NULL) {
 889                 syslog(LOG_ERR, "<%s> Prefix added interface No.%d doesn't"
 890                        "exist. This should not happen! %s", __func__,
 891                        ifindex, strerror(errno));
 892                 exit(1);
 893         }
 894         ipr.ipr_prefix.sin6_len = sizeof(ipr.ipr_prefix);
 895         ipr.ipr_prefix.sin6_family = AF_INET6;
 896         ipr.ipr_prefix.sin6_addr = *addr;
 897         ipr.ipr_plen = plen;
 898
 899         if (init_prefix(&ipr))
 900                 return; /* init failed by some error */
 901         add_prefix(rai, &ipr);
 902 }
 903
 904 void
 905 make_packet(struct rainfo *rainfo)
 906 {
 907         size_t packlen, lladdroptlen = 0;
 908         char *buf;
 909         struct nd_router_advert *ra;
 910         struct nd_opt_prefix_info *ndopt_pi;
 911         struct nd_opt_mtu *ndopt_mtu;
 912 #ifdef ROUTEINFO
 913         struct nd_opt_route_info *ndopt_rti;
 914         struct rtinfo *rti;
 915 #endif
 916         struct prefix *pfx;
 917
 918         /* calculate total length */
 919         packlen = sizeof(struct nd_router_advert);
 920         if (rainfo->advlinkopt) {
 921                 if ((lladdroptlen = lladdropt_length(rainfo->sdl)) == 0) {
 922                         syslog(LOG_INFO,
 923                                "<%s> link-layer address option has"
 924                                " null length on %s.  Treat as not included.",
 925                                __func__, rainfo->ifname);
 926                         rainfo->advlinkopt = 0;
 927                 }
 928                 packlen += lladdroptlen;
 929         }
 930         if (rainfo->pfxs)
 931                 packlen += sizeof(struct nd_opt_prefix_info) * rainfo->pfxs;
 932         if (rainfo->linkmtu)
 933                 packlen += sizeof(struct nd_opt_mtu);
 934 #ifdef ROUTEINFO
 935         for (rti = rainfo->route.next; rti != &rainfo->route; rti = rti->next)
 936                 packlen += sizeof(struct nd_opt_route_info) +
 937                            ((rti->prefixlen + 0x3f) >> 6) * 8;
 938 #endif
 939
 940         /* allocate memory for the packet */
 941         if ((buf = malloc(packlen)) == NULL) {
 942                 syslog(LOG_ERR,
 943                        "<%s> can't get enough memory for an RA packet",
 944                        __func__);
 945                 exit(1);
 946         }
 947         if (rainfo->ra_data) {
 948                 /* free the previous packet */
 949                 free(rainfo->ra_data);
 950                 rainfo->ra_data = NULL;
 951         }
 952         rainfo->ra_data = buf;
 953         /* XXX: what if packlen > 576? */
 954         rainfo->ra_datalen = packlen;
 955
 956         /*
 957          * construct the packet
 958          */
 959         ra = (struct nd_router_advert *)buf;
 960         ra->nd_ra_type = ND_ROUTER_ADVERT;
 961         ra->nd_ra_code = 0;
 962         ra->nd_ra_cksum = 0;
 963         ra->nd_ra_curhoplimit = (u_int8_t)(0xff & rainfo->hoplimit);
 964         ra->nd_ra_flags_reserved = 0; /* just in case */
 965         /*
 966          * XXX: the router preference field, which is a 2-bit field, should be
 967          * initialized before other fields.
 968          */
 969         ra->nd_ra_flags_reserved = 0xff & rainfo->rtpref;
 970         ra->nd_ra_flags_reserved |=
 971                 rainfo->managedflg ? ND_RA_FLAG_MANAGED : 0;
 972         ra->nd_ra_flags_reserved |=
 973                 rainfo->otherflg ? ND_RA_FLAG_OTHER : 0;
 974         ra->nd_ra_router_lifetime = htons(rainfo->lifetime);
 975         ra->nd_ra_reachable = htonl(rainfo->reachabletime);
 976         ra->nd_ra_retransmit = htonl(rainfo->retranstimer);
 977         buf += sizeof(*ra);
 978
 979         if (rainfo->advlinkopt) {
 980                 lladdropt_fill(rainfo->sdl, (struct nd_opt_hdr *)buf);
 981                 buf += lladdroptlen;
 982         }
 983
 984         if (rainfo->linkmtu) {
 985                 ndopt_mtu = (struct nd_opt_mtu *)buf;
 986                 ndopt_mtu->nd_opt_mtu_type = ND_OPT_MTU;
 987                 ndopt_mtu->nd_opt_mtu_len = 1;
 988                 ndopt_mtu->nd_opt_mtu_reserved = 0;
 989                 ndopt_mtu->nd_opt_mtu_mtu = htonl(rainfo->linkmtu);
 990                 buf += sizeof(struct nd_opt_mtu);
 991         }
 992
 993         for (pfx = rainfo->prefix.next;
 994              pfx != &rainfo->prefix; pfx = pfx->next) {
 995                 u_int32_t vltime, pltime;
 996                 struct timeval now;
 997
 998                 ndopt_pi = (struct nd_opt_prefix_info *)buf;
 999                 ndopt_pi->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
1000                 ndopt_pi->nd_opt_pi_len = 4;
1001                 ndopt_pi->nd_opt_pi_prefix_len = pfx->prefixlen;
1002                 ndopt_pi->nd_opt_pi_flags_reserved = 0;
1003                 if (pfx->onlinkflg)
1004                         ndopt_pi->nd_opt_pi_flags_reserved |=
1005                                 ND_OPT_PI_FLAG_ONLINK;
1006                 if (pfx->autoconfflg)
1007                         ndopt_pi->nd_opt_pi_flags_reserved |=
1008                                 ND_OPT_PI_FLAG_AUTO;
1009                 if (pfx->timer)
1010                         vltime = 0;
1011                 else {
1012                         if (pfx->vltimeexpire || pfx->pltimeexpire)
1013                                 gettimeofday(&now, NULL);
1014                         if (pfx->vltimeexpire == 0)
1015                                 vltime = pfx->validlifetime;
1016                         else
1017                                 vltime = (pfx->vltimeexpire > now.tv_sec) ?
1018                                     pfx->vltimeexpire - now.tv_sec : 0;
1019                 }
1020                 if (pfx->timer)
1021                         pltime = 0;
1022                 else {
1023                         if (pfx->pltimeexpire == 0)
1024                                 pltime = pfx->preflifetime;
1025                         else
1026                                 pltime = (pfx->pltimeexpire > now.tv_sec) ?
1027                                     pfx->pltimeexpire - now.tv_sec : 0;
1028                 }
1029                 if (vltime < pltime) {
1030                         /*
1031                          * this can happen if vltime is decrement but pltime
1032                          * is not.
1033                          */
1034                         pltime = vltime;
1035                 }
1036                 ndopt_pi->nd_opt_pi_valid_time = htonl(vltime);
1037                 ndopt_pi->nd_opt_pi_preferred_time = htonl(pltime);
1038                 ndopt_pi->nd_opt_pi_reserved2 = 0;
1039                 ndopt_pi->nd_opt_pi_prefix = pfx->prefix;
1040
1041                 buf += sizeof(struct nd_opt_prefix_info);
1042         }
1043
1044 #ifdef ROUTEINFO
1045         for (rti = rainfo->route.next; rti != &rainfo->route; rti = rti->next) {
1046                 u_int8_t psize = (rti->prefixlen + 0x3f) >> 6;
1047
1048                 ndopt_rti = (struct nd_opt_route_info *)buf;
1049                 ndopt_rti->nd_opt_rti_type = ND_OPT_ROUTE_INFO;
1050                 ndopt_rti->nd_opt_rti_len = 1 + psize;
1051                 ndopt_rti->nd_opt_rti_prefixlen = rti->prefixlen;
1052                 ndopt_rti->nd_opt_rti_flags = 0xff & rti->rtpref;
1053                 ndopt_rti->nd_opt_rti_lifetime = htonl(rti->ltime);
1054                 memcpy(ndopt_rti + 1, &rti->prefix, psize * 8);
1055                 buf += sizeof(struct nd_opt_route_info) + psize * 8;
1056         }
1057 #endif
1058
1059         return;
1060 }
1061
1062 static int
1063 getinet6sysctl(int code)
1064 {
1065         int mib[] = { CTL_NET, PF_INET6, IPPROTO_IPV6, 0 };
1066         int value;
1067         size_t size;
1068
1069         mib[3] = code;
1070         size = sizeof(value);
1071         if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), &value, &size, NULL, 0)
1072             < 0) {
1073                 syslog(LOG_ERR, "<%s>: failed to get ip6 sysctl(%d): %s",
1074                        __func__, code,
1075                        strerror(errno));
1076                 return(-1);
1077         }
1078         else
1079                 return(value);
1080 }