sys/netinet6/nd6_rtr.c

   1 /*      $FreeBSD$       */
   2 /*      $KAME: nd6_rtr.c,v 1.111 2001/04/27 01:37:15 jinmei Exp $       */
   3
   4 /*
   5  * Copyright (C) 1995, 1996, 1997, and 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 "opt_inet.h"
  34 #include "opt_inet6.h"
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mbuf.h>
  40 #include <sys/socket.h>
  41 #include <sys/sockio.h>
  42 #include <sys/time.h>
  43 #include <sys/kernel.h>
  44 #include <sys/errno.h>
  45 #include <sys/syslog.h>
  46 #include <sys/queue.h>
  47
  48 #include <net/if.h>
  49 #include <net/if_types.h>
  50 #include <net/if_dl.h>
  51 #include <net/route.h>
  52 #include <net/radix.h>
  53
  54 #include <netinet/in.h>
  55 #include <netinet6/in6_var.h>
  56 #include <netinet6/in6_ifattach.h>
  57 #include <netinet/ip6.h>
  58 #include <netinet6/ip6_var.h>
  59 #include <netinet6/nd6.h>
  60 #include <netinet/icmp6.h>
  61 #include <netinet6/scope6_var.h>
  62
  63 #include <net/net_osdep.h>
  64
  65 #define SDL(s)  ((struct sockaddr_dl *)s)
  66
  67 static struct nd_defrouter *defrtrlist_update __P((struct nd_defrouter *));
  68 static struct in6_ifaddr *in6_ifadd __P((struct nd_prefix *,
  69         struct in6_addr *));
  70 static struct nd_pfxrouter *pfxrtr_lookup __P((struct nd_prefix *,
  71         struct nd_defrouter *));
  72 static void pfxrtr_add __P((struct nd_prefix *, struct nd_defrouter *));
  73 static void pfxrtr_del __P((struct nd_pfxrouter *));
  74 static struct nd_pfxrouter *find_pfxlist_reachable_router
  75         __P((struct nd_prefix *));
  76 static void defrouter_addifreq __P((struct ifnet *));
  77 static void nd6_rtmsg __P((int, struct rtentry *));
  78
  79 static void in6_init_address_ltimes __P((struct nd_prefix *ndpr,
  80                                          struct in6_addrlifetime *lt6));
  81
  82 static int rt6_deleteroute __P((struct radix_node *, void *));
  83
  84 extern int nd6_recalc_reachtm_interval;
  85
  86 static struct ifnet *nd6_defifp;
  87 int nd6_defifindex;
  88
  89 int ip6_use_tempaddr = 0;
  90
  91 int ip6_desync_factor;
  92 u_int32_t ip6_temp_preferred_lifetime = DEF_TEMP_PREFERRED_LIFETIME;
  93 u_int32_t ip6_temp_valid_lifetime = DEF_TEMP_VALID_LIFETIME;
  94 /*
  95  * shorter lifetimes for debugging purposes.
  96 int ip6_temp_preferred_lifetime = 800;
  97 static int ip6_temp_valid_lifetime = 1800;
  98 */
  99 int ip6_temp_regen_advance = TEMPADDR_REGEN_ADVANCE;
 100
 101 /*
 102  * Receive Router Solicitation Message - just for routers.
 103  * Router solicitation/advertisement is mostly managed by userland program
 104  * (rtadvd) so here we have no function like nd6_ra_output().
 105  *
 106  * Based on RFC 2461
 107  */
 108 void
 109 nd6_rs_input(m, off, icmp6len)
 110         struct  mbuf *m;
 111         int off, icmp6len;
 112 {
 113         struct ifnet *ifp = m->m_pkthdr.rcvif;
 114         struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
 115         struct nd_router_solicit *nd_rs;
 116         struct in6_addr saddr6 = ip6->ip6_src;
 117 #if 0
 118         struct in6_addr daddr6 = ip6->ip6_dst;
 119 #endif
 120         char *lladdr = NULL;
 121         int lladdrlen = 0;
 122 #if 0
 123         struct sockaddr_dl *sdl = (struct sockaddr_dl *)NULL;
 124         struct llinfo_nd6 *ln = (struct llinfo_nd6 *)NULL;
 125         struct rtentry *rt = NULL;
 126         int is_newentry;
 127 #endif
 128         union nd_opts ndopts;
 129
 130         /* If I'm not a router, ignore it. */
 131         if (ip6_accept_rtadv != 0 || ip6_forwarding != 1)
 132                 goto freeit;
 133
 134         /* Sanity checks */
 135         if (ip6->ip6_hlim != 255) {
 136                 nd6log((LOG_ERR,
 137                     "nd6_rs_input: invalid hlim (%d) from %s to %s on %s\n",
 138                     ip6->ip6_hlim, ip6_sprintf(&ip6->ip6_src),
 139                     ip6_sprintf(&ip6->ip6_dst), if_name(ifp)));
 140                 goto bad;
 141         }
 142
 143         /*
 144          * Don't update the neighbor cache, if src = ::.
 145          * This indicates that the src has no IP address assigned yet.
 146          */
 147         if (IN6_IS_ADDR_UNSPECIFIED(&saddr6))
 148                 goto freeit;
 149
 150 #ifndef PULLDOWN_TEST
 151         IP6_EXTHDR_CHECK(m, off, icmp6len,);
 152         nd_rs = (struct nd_router_solicit *)((caddr_t)ip6 + off);
 153 #else
 154         IP6_EXTHDR_GET(nd_rs, struct nd_router_solicit *, m, off, icmp6len);
 155         if (nd_rs == NULL) {
 156                 icmp6stat.icp6s_tooshort++;
 157                 return;
 158         }
 159 #endif
 160
 161         icmp6len -= sizeof(*nd_rs);
 162         nd6_option_init(nd_rs + 1, icmp6len, &ndopts);
 163         if (nd6_options(&ndopts) < 0) {
 164                 nd6log((LOG_INFO,
 165                     "nd6_rs_input: invalid ND option, ignored\n"));
 166                 /* nd6_options have incremented stats */
 167                 goto freeit;
 168         }
 169
 170         if (ndopts.nd_opts_src_lladdr) {
 171                 lladdr = (char *)(ndopts.nd_opts_src_lladdr + 1);
 172                 lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
 173         }
 174
 175         if (lladdr && ((ifp->if_addrlen + 2 + 7) & ~7) != lladdrlen) {
 176                 nd6log((LOG_INFO,
 177                     "nd6_rs_input: lladdrlen mismatch for %s "
 178                     "(if %d, RS packet %d)\n",
 179                         ip6_sprintf(&saddr6), ifp->if_addrlen, lladdrlen - 2));
 180                 goto bad;
 181         }
 182
 183         nd6_cache_lladdr(ifp, &saddr6, lladdr, lladdrlen, ND_ROUTER_SOLICIT, 0);
 184
 185  freeit:
 186         m_freem(m);
 187         return;
 188
 189  bad:
 190         icmp6stat.icp6s_badrs++;
 191         m_freem(m);
 192 }
 193
 194 /*
 195  * Receive Router Advertisement Message.
 196  *
 197  * Based on RFC 2461
 198  * TODO: on-link bit on prefix information
 199  * TODO: ND_RA_FLAG_{OTHER,MANAGED} processing
 200  */
 201 void
 202 nd6_ra_input(m, off, icmp6len)
 203         struct  mbuf *m;
 204         int off, icmp6len;
 205 {
 206         struct ifnet *ifp = m->m_pkthdr.rcvif;
 207         struct nd_ifinfo *ndi = &nd_ifinfo[ifp->if_index];
 208         struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
 209         struct nd_router_advert *nd_ra;
 210         struct in6_addr saddr6 = ip6->ip6_src;
 211 #if 0
 212         struct in6_addr daddr6 = ip6->ip6_dst;
 213         int flags; /* = nd_ra->nd_ra_flags_reserved; */
 214         int is_managed = ((flags & ND_RA_FLAG_MANAGED) != 0);
 215         int is_other = ((flags & ND_RA_FLAG_OTHER) != 0);
 216 #endif
 217         union nd_opts ndopts;
 218         struct nd_defrouter *dr;
 219
 220         if (ip6_accept_rtadv == 0)
 221                 goto freeit;
 222
 223         if (ip6->ip6_hlim != 255) {
 224                 nd6log((LOG_ERR,
 225                     "nd6_ra_input: invalid hlim (%d) from %s to %s on %s\n",
 226                     ip6->ip6_hlim, ip6_sprintf(&ip6->ip6_src),
 227                     ip6_sprintf(&ip6->ip6_dst), if_name(ifp)));
 228                 goto bad;
 229         }
 230
 231         if (!IN6_IS_ADDR_LINKLOCAL(&saddr6)) {
 232                 nd6log((LOG_ERR,
 233                     "nd6_ra_input: src %s is not link-local\n",
 234                     ip6_sprintf(&saddr6)));
 235                 goto bad;
 236         }
 237
 238 #ifndef PULLDOWN_TEST
 239         IP6_EXTHDR_CHECK(m, off, icmp6len,);
 240         nd_ra = (struct nd_router_advert *)((caddr_t)ip6 + off);
 241 #else
 242         IP6_EXTHDR_GET(nd_ra, struct nd_router_advert *, m, off, icmp6len);
 243         if (nd_ra == NULL) {
 244                 icmp6stat.icp6s_tooshort++;
 245                 return;
 246         }
 247 #endif
 248
 249         icmp6len -= sizeof(*nd_ra);
 250         nd6_option_init(nd_ra + 1, icmp6len, &ndopts);
 251         if (nd6_options(&ndopts) < 0) {
 252                 nd6log((LOG_INFO,
 253                     "nd6_ra_input: invalid ND option, ignored\n"));
 254                 /* nd6_options have incremented stats */
 255                 goto freeit;
 256         }
 257
 258     {
 259         struct nd_defrouter dr0;
 260         u_int32_t advreachable = nd_ra->nd_ra_reachable;
 261
 262         dr0.rtaddr = saddr6;
 263         dr0.flags  = nd_ra->nd_ra_flags_reserved;
 264         dr0.rtlifetime = ntohs(nd_ra->nd_ra_router_lifetime);
 265         dr0.expire = time_second + dr0.rtlifetime;
 266         dr0.ifp = ifp;
 267         dr0.advint = 0;         /* Mobile IPv6 */
 268         dr0.advint_expire = 0;  /* Mobile IPv6 */
 269         dr0.advints_lost = 0;   /* Mobile IPv6 */
 270         /* unspecified or not? (RFC 2461 6.3.4) */
 271         if (advreachable) {
 272                 advreachable = ntohl(advreachable);
 273                 if (advreachable <= MAX_REACHABLE_TIME &&
 274                     ndi->basereachable != advreachable) {
 275                         ndi->basereachable = advreachable;
 276                         ndi->reachable = ND_COMPUTE_RTIME(ndi->basereachable);
 277                         ndi->recalctm = nd6_recalc_reachtm_interval; /* reset */
 278                 }
 279         }
 280         if (nd_ra->nd_ra_retransmit)
 281                 ndi->retrans = ntohl(nd_ra->nd_ra_retransmit);
 282         if (nd_ra->nd_ra_curhoplimit)
 283                 ndi->chlim = nd_ra->nd_ra_curhoplimit;
 284         dr = defrtrlist_update(&dr0);
 285     }
 286
 287         /*
 288          * prefix
 289          */
 290         if (ndopts.nd_opts_pi) {
 291                 struct nd_opt_hdr *pt;
 292                 struct nd_opt_prefix_info *pi = NULL;
 293                 struct nd_prefix pr;
 294
 295                 for (pt = (struct nd_opt_hdr *)ndopts.nd_opts_pi;
 296                      pt <= (struct nd_opt_hdr *)ndopts.nd_opts_pi_end;
 297                      pt = (struct nd_opt_hdr *)((caddr_t)pt +
 298                                                 (pt->nd_opt_len << 3))) {
 299                         if (pt->nd_opt_type != ND_OPT_PREFIX_INFORMATION)
 300                                 continue;
 301                         pi = (struct nd_opt_prefix_info *)pt;
 302
 303                         if (pi->nd_opt_pi_len != 4) {
 304                                 nd6log((LOG_INFO,
 305                                     "nd6_ra_input: invalid option "
 306                                     "len %d for prefix information option, "
 307                                     "ignored\n", pi->nd_opt_pi_len));
 308                                 continue;
 309                         }
 310
 311                         if (128 < pi->nd_opt_pi_prefix_len) {
 312                                 nd6log((LOG_INFO,
 313                                     "nd6_ra_input: invalid prefix "
 314                                     "len %d for prefix information option, "
 315                                     "ignored\n", pi->nd_opt_pi_prefix_len));
 316                                 continue;
 317                         }
 318
 319                         if (IN6_IS_ADDR_MULTICAST(&pi->nd_opt_pi_prefix)
 320                          || IN6_IS_ADDR_LINKLOCAL(&pi->nd_opt_pi_prefix)) {
 321                                 nd6log((LOG_INFO,
 322                                     "nd6_ra_input: invalid prefix "
 323                                     "%s, ignored\n",
 324                                     ip6_sprintf(&pi->nd_opt_pi_prefix)));
 325                                 continue;
 326                         }
 327
 328                         /* aggregatable unicast address, rfc2374 */
 329                         if ((pi->nd_opt_pi_prefix.s6_addr8[0] & 0xe0) == 0x20
 330                          && pi->nd_opt_pi_prefix_len != 64) {
 331                                 nd6log((LOG_INFO,
 332                                     "nd6_ra_input: invalid prefixlen "
 333                                     "%d for rfc2374 prefix %s, ignored\n",
 334                                     pi->nd_opt_pi_prefix_len,
 335                                     ip6_sprintf(&pi->nd_opt_pi_prefix)));
 336                                 continue;
 337                         }
 338
 339                         bzero(&pr, sizeof(pr));
 340                         pr.ndpr_prefix.sin6_family = AF_INET6;
 341                         pr.ndpr_prefix.sin6_len = sizeof(pr.ndpr_prefix);
 342                         pr.ndpr_prefix.sin6_addr = pi->nd_opt_pi_prefix;
 343                         pr.ndpr_ifp = (struct ifnet *)m->m_pkthdr.rcvif;
 344
 345                         pr.ndpr_raf_onlink = (pi->nd_opt_pi_flags_reserved &
 346                                               ND_OPT_PI_FLAG_ONLINK) ? 1 : 0;
 347                         pr.ndpr_raf_auto = (pi->nd_opt_pi_flags_reserved &
 348                                             ND_OPT_PI_FLAG_AUTO) ? 1 : 0;
 349                         pr.ndpr_plen = pi->nd_opt_pi_prefix_len;
 350                         pr.ndpr_vltime = ntohl(pi->nd_opt_pi_valid_time);
 351                         pr.ndpr_pltime =
 352                                 ntohl(pi->nd_opt_pi_preferred_time);
 353
 354                         if (in6_init_prefix_ltimes(&pr))
 355                                 continue; /* prefix lifetime init failed */
 356
 357                         (void)prelist_update(&pr, dr, m);
 358                 }
 359         }
 360
 361         /*
 362          * MTU
 363          */
 364         if (ndopts.nd_opts_mtu && ndopts.nd_opts_mtu->nd_opt_mtu_len == 1) {
 365                 u_int32_t mtu = ntohl(ndopts.nd_opts_mtu->nd_opt_mtu_mtu);
 366
 367                 /* lower bound */
 368                 if (mtu < IPV6_MMTU) {
 369                         nd6log((LOG_INFO, "nd6_ra_input: bogus mtu option "
 370                             "mtu=%d sent from %s, ignoring\n",
 371                             mtu, ip6_sprintf(&ip6->ip6_src)));
 372                         goto skip;
 373                 }
 374
 375                 /* upper bound */
 376                 if (ndi->maxmtu) {
 377                         if (mtu <= ndi->maxmtu) {
 378                                 int change = (ndi->linkmtu != mtu);
 379
 380                                 ndi->linkmtu = mtu;
 381                                 if (change) /* in6_maxmtu may change */
 382                                         in6_setmaxmtu();
 383                         } else {
 384                                 nd6log((LOG_INFO, "nd6_ra_input: bogus mtu "
 385                                     "mtu=%d sent from %s; "
 386                                     "exceeds maxmtu %d, ignoring\n",
 387                                     mtu, ip6_sprintf(&ip6->ip6_src),
 388                                     ndi->maxmtu));
 389                         }
 390                 } else {
 391                         nd6log((LOG_INFO, "nd6_ra_input: mtu option "
 392                             "mtu=%d sent from %s; maxmtu unknown, "
 393                             "ignoring\n",
 394                             mtu, ip6_sprintf(&ip6->ip6_src)));
 395                 }
 396         }
 397
 398  skip:
 399
 400         /*
 401          * Src linkaddress
 402          */
 403     {
 404         char *lladdr = NULL;
 405         int lladdrlen = 0;
 406
 407         if (ndopts.nd_opts_src_lladdr) {
 408                 lladdr = (char *)(ndopts.nd_opts_src_lladdr + 1);
 409                 lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
 410         }
 411
 412         if (lladdr && ((ifp->if_addrlen + 2 + 7) & ~7) != lladdrlen) {
 413                 nd6log((LOG_INFO,
 414                     "nd6_ra_input: lladdrlen mismatch for %s "
 415                     "(if %d, RA packet %d)\n",
 416                         ip6_sprintf(&saddr6), ifp->if_addrlen, lladdrlen - 2));
 417                 goto bad;
 418         }
 419
 420         nd6_cache_lladdr(ifp, &saddr6, lladdr, lladdrlen, ND_ROUTER_ADVERT, 0);
 421
 422         /*
 423          * Installing a link-layer address might change the state of the
 424          * router's neighbor cache, which might also affect our on-link
 425          * detection of adveritsed prefixes.
 426          */
 427         pfxlist_onlink_check();
 428     }
 429
 430  freeit:
 431         m_freem(m);
 432         return;
 433
 434  bad:
 435         icmp6stat.icp6s_badra++;
 436         m_freem(m);
 437 }
 438
 439 /*
 440  * default router list proccessing sub routines
 441  */
 442
 443 /* tell the change to user processes watching the routing socket. */
 444 static void
 445 nd6_rtmsg(cmd, rt)
 446         int cmd;
 447         struct rtentry *rt;
 448 {
 449         struct rt_addrinfo info;
 450
 451         bzero((caddr_t)&info, sizeof(info));
 452         info.rti_info[RTAX_DST] = rt_key(rt);
 453         info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
 454         info.rti_info[RTAX_NETMASK] = rt_mask(rt);
 455         info.rti_info[RTAX_IFP] =
 456                 (struct sockaddr *)TAILQ_FIRST(&rt->rt_ifp->if_addrlist);
 457         info.rti_info[RTAX_IFA] = rt->rt_ifa->ifa_addr;
 458
 459         rt_missmsg(cmd, &info, rt->rt_flags, 0);
 460 }
 461
 462 void
 463 defrouter_addreq(new)
 464         struct nd_defrouter *new;
 465 {
 466         struct sockaddr_in6 def, mask, gate;
 467         struct rtentry *newrt = NULL;
 468         int s;
 469
 470         Bzero(&def, sizeof(def));
 471         Bzero(&mask, sizeof(mask));
 472         Bzero(&gate, sizeof(gate));
 473
 474         def.sin6_len = mask.sin6_len = gate.sin6_len
 475                 = sizeof(struct sockaddr_in6);
 476         def.sin6_family = mask.sin6_family = gate.sin6_family = AF_INET6;
 477         gate.sin6_addr = new->rtaddr;
 478
 479         s = splnet();
 480         (void)rtrequest(RTM_ADD, (struct sockaddr *)&def,
 481                 (struct sockaddr *)&gate, (struct sockaddr *)&mask,
 482                 RTF_GATEWAY, &newrt);
 483         if (newrt) {
 484                 nd6_rtmsg(RTM_ADD, newrt); /* tell user process */
 485                 newrt->rt_refcnt--;
 486         }
 487         splx(s);
 488         return;
 489 }
 490
 491 /* Add a route to a given interface as default */
 492 void
 493 defrouter_addifreq(ifp)
 494         struct ifnet *ifp;
 495 {
 496         struct sockaddr_in6 def, mask;
 497         struct ifaddr *ifa;
 498         struct rtentry *newrt = NULL;
 499         int error, flags;
 500
 501         bzero(&def, sizeof(def));
 502         bzero(&mask, sizeof(mask));
 503
 504         def.sin6_len = mask.sin6_len = sizeof(struct sockaddr_in6);
 505         def.sin6_family = mask.sin6_family = AF_INET6;
 506
 507         /*
 508          * Search for an ifaddr beloging to the specified interface.
 509          * XXX: An IPv6 address are required to be assigned on the interface.
 510          */
 511         if ((ifa = ifaof_ifpforaddr((struct sockaddr *)&def, ifp)) == NULL) {
 512                 nd6log((LOG_ERR,        /* better error? */
 513                     "defrouter_addifreq: failed to find an ifaddr "
 514                     "to install a route to interface %s\n",
 515                     if_name(ifp)));
 516                 return;
 517         }
 518
 519         flags = ifa->ifa_flags;
 520         error = rtrequest(RTM_ADD, (struct sockaddr *)&def, ifa->ifa_addr,
 521                           (struct sockaddr *)&mask, flags, &newrt);
 522         if (error != 0) {
 523                 nd6log((LOG_ERR,
 524                     "defrouter_addifreq: failed to install a route to "
 525                     "interface %s (errno = %d)\n",
 526                     if_name(ifp), error));
 527
 528                 if (newrt)      /* maybe unnecessary, but do it for safety */
 529                         newrt->rt_refcnt--;
 530         } else {
 531                 if (newrt) {
 532                         nd6_rtmsg(RTM_ADD, newrt);
 533                         newrt->rt_refcnt--;
 534                 }
 535         }
 536 }
 537
 538 struct nd_defrouter *
 539 defrouter_lookup(addr, ifp)
 540         struct in6_addr *addr;
 541         struct ifnet *ifp;
 542 {
 543         struct nd_defrouter *dr;
 544
 545         for (dr = TAILQ_FIRST(&nd_defrouter); dr;
 546              dr = TAILQ_NEXT(dr, dr_entry)) {
 547                 if (dr->ifp == ifp && IN6_ARE_ADDR_EQUAL(addr, &dr->rtaddr))
 548                         return(dr);
 549         }
 550
 551         return(NULL);           /* search failed */
 552 }
 553
 554 void
 555 defrouter_delreq(dr, dofree)
 556         struct nd_defrouter *dr;
 557         int dofree;
 558 {
 559         struct sockaddr_in6 def, mask, gate;
 560         struct rtentry *oldrt = NULL;
 561
 562         Bzero(&def, sizeof(def));
 563         Bzero(&mask, sizeof(mask));
 564         Bzero(&gate, sizeof(gate));
 565
 566         def.sin6_len = mask.sin6_len = gate.sin6_len
 567                 = sizeof(struct sockaddr_in6);
 568         def.sin6_family = mask.sin6_family = gate.sin6_family = AF_INET6;
 569         gate.sin6_addr = dr->rtaddr;
 570
 571         rtrequest(RTM_DELETE, (struct sockaddr *)&def,
 572                   (struct sockaddr *)&gate,
 573                   (struct sockaddr *)&mask,
 574                   RTF_GATEWAY, &oldrt);
 575         if (oldrt) {
 576                 nd6_rtmsg(RTM_DELETE, oldrt);
 577                 if (oldrt->rt_refcnt <= 0) {
 578                         /*
 579                          * XXX: borrowed from the RTM_DELETE case of
 580                          * rtrequest().
 581                          */
 582                         oldrt->rt_refcnt++;
 583                         rtfree(oldrt);
 584                 }
 585         }
 586
 587         if (dofree)             /* XXX: necessary? */
 588                 free(dr, M_IP6NDP);
 589 }
 590
 591 void
 592 defrtrlist_del(dr)
 593         struct nd_defrouter *dr;
 594 {
 595         struct nd_defrouter *deldr = NULL;
 596         struct nd_prefix *pr;
 597
 598         /*
 599          * Flush all the routing table entries that use the router
 600          * as a next hop.
 601          */
 602         if (!ip6_forwarding && ip6_accept_rtadv) {
 603                 /* above is a good condition? */
 604                 rt6_flush(&dr->rtaddr, dr->ifp);
 605         }
 606
 607         if (dr == TAILQ_FIRST(&nd_defrouter))
 608                 deldr = dr;     /* The router is primary. */
 609
 610         TAILQ_REMOVE(&nd_defrouter, dr, dr_entry);
 611
 612         /*
 613          * Also delete all the pointers to the router in each prefix lists.
 614          */
 615         for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
 616                 struct nd_pfxrouter *pfxrtr;
 617                 if ((pfxrtr = pfxrtr_lookup(pr, dr)) != NULL)
 618                         pfxrtr_del(pfxrtr);
 619         }
 620         pfxlist_onlink_check();
 621
 622         /*
 623          * If the router is the primary one, choose a new one.
 624          * Note that defrouter_select() will remove the current gateway
 625          * from the routing table.
 626          */
 627         if (deldr)
 628                 defrouter_select();
 629
 630         free(dr, M_IP6NDP);
 631 }
 632
 633 /*
 634  * Default Router Selection according to Section 6.3.6 of RFC 2461:
 635  * 1) Routers that are reachable or probably reachable should be
 636  *    preferred.
 637  * 2) When no routers on the list are known to be reachable or
 638  *    probably reachable, routers SHOULD be selected in a round-robin
 639  *    fashion.
 640  * 3) If the Default Router List is empty, assume that all
 641  *    destinations are on-link.
 642  */
 643 void
 644 defrouter_select()
 645 {
 646         int s = splnet();
 647         struct nd_defrouter *dr, anydr;
 648         struct rtentry *rt = NULL;
 649         struct llinfo_nd6 *ln = NULL;
 650
 651         /*
 652          * Search for a (probably) reachable router from the list.
 653          */
 654         for (dr = TAILQ_FIRST(&nd_defrouter); dr;
 655              dr = TAILQ_NEXT(dr, dr_entry)) {
 656                 if ((rt = nd6_lookup(&dr->rtaddr, 0, dr->ifp)) &&
 657                     (ln = (struct llinfo_nd6 *)rt->rt_llinfo) &&
 658                     ND6_IS_LLINFO_PROBREACH(ln)) {
 659                         /* Got it, and move it to the head */
 660                         TAILQ_REMOVE(&nd_defrouter, dr, dr_entry);
 661                         TAILQ_INSERT_HEAD(&nd_defrouter, dr, dr_entry);
 662                         break;
 663                 }
 664         }
 665
 666         if ((dr = TAILQ_FIRST(&nd_defrouter))) {
 667                 /*
 668                  * De-install the previous default gateway and install
 669                  * a new one.
 670                  * Note that if there is no reachable router in the list,
 671                  * the head entry will be used anyway.
 672                  * XXX: do we have to check the current routing table entry?
 673                  */
 674                 bzero(&anydr, sizeof(anydr));
 675                 defrouter_delreq(&anydr, 0);
 676                 defrouter_addreq(dr);
 677         }
 678         else {
 679                 /*
 680                  * The Default Router List is empty, so install the default
 681                  * route to an inteface.
 682                  * XXX: The specification does not say this mechanism should
 683                  * be restricted to hosts, but this would be not useful
 684                  * (even harmful) for routers.
 685                  */
 686                 if (!ip6_forwarding) {
 687                         /*
 688                          * De-install the current default route
 689                          * in advance.
 690                          */
 691                         bzero(&anydr, sizeof(anydr));
 692                         defrouter_delreq(&anydr, 0);
 693                         if (nd6_defifp) {
 694                                 /*
 695                                  * Install a route to the default interface
 696                                  * as default route.
 697                                  * XXX: we enable this for host only, because
 698                                  * this may override a default route installed
 699                                  * a user process (e.g. routing daemon) in a
 700                                  * router case.
 701                                  */
 702                                 defrouter_addifreq(nd6_defifp);
 703                         } else {
 704                                 nd6log((LOG_INFO, "defrouter_select: "
 705                                     "there's no default router and no default"
 706                                     " interface\n"));
 707                         }
 708                 }
 709         }
 710
 711         splx(s);
 712         return;
 713 }
 714
 715 static struct nd_defrouter *
 716 defrtrlist_update(new)
 717         struct nd_defrouter *new;
 718 {
 719         struct nd_defrouter *dr, *n;
 720         int s = splnet();
 721
 722         if ((dr = defrouter_lookup(&new->rtaddr, new->ifp)) != NULL) {
 723                 /* entry exists */
 724                 if (new->rtlifetime == 0) {
 725                         defrtrlist_del(dr);
 726                         dr = NULL;
 727                 } else {
 728                         /* override */
 729                         dr->flags = new->flags; /* xxx flag check */
 730                         dr->rtlifetime = new->rtlifetime;
 731                         dr->expire = new->expire;
 732                 }
 733                 splx(s);
 734                 return(dr);
 735         }
 736
 737         /* entry does not exist */
 738         if (new->rtlifetime == 0) {
 739                 splx(s);
 740                 return(NULL);
 741         }
 742
 743         n = (struct nd_defrouter *)malloc(sizeof(*n), M_IP6NDP, M_NOWAIT);
 744         if (n == NULL) {
 745                 splx(s);
 746                 return(NULL);
 747         }
 748         bzero(n, sizeof(*n));
 749         *n = *new;
 750
 751         /*
 752          * Insert the new router at the end of the Default Router List.
 753          * If there is no other router, install it anyway. Otherwise,
 754          * just continue to use the current default router.
 755          */
 756         TAILQ_INSERT_TAIL(&nd_defrouter, n, dr_entry);
 757         if (TAILQ_FIRST(&nd_defrouter) == n)
 758                 defrouter_select();
 759         splx(s);
 760
 761         return(n);
 762 }
 763
 764 static struct nd_pfxrouter *
 765 pfxrtr_lookup(pr, dr)
 766         struct nd_prefix *pr;
 767         struct nd_defrouter *dr;
 768 {
 769         struct nd_pfxrouter *search;
 770
 771         for (search = pr->ndpr_advrtrs.lh_first; search; search = search->pfr_next) {
 772                 if (search->router == dr)
 773                         break;
 774         }
 775
 776         return(search);
 777 }
 778
 779 static void
 780 pfxrtr_add(pr, dr)
 781         struct nd_prefix *pr;
 782         struct nd_defrouter *dr;
 783 {
 784         struct nd_pfxrouter *new;
 785
 786         new = (struct nd_pfxrouter *)malloc(sizeof(*new), M_IP6NDP, M_NOWAIT);
 787         if (new == NULL)
 788                 return;
 789         bzero(new, sizeof(*new));
 790         new->router = dr;
 791
 792         LIST_INSERT_HEAD(&pr->ndpr_advrtrs, new, pfr_entry);
 793
 794         pfxlist_onlink_check();
 795 }
 796
 797 static void
 798 pfxrtr_del(pfr)
 799         struct nd_pfxrouter *pfr;
 800 {
 801         LIST_REMOVE(pfr, pfr_entry);
 802         free(pfr, M_IP6NDP);
 803 }
 804
 805 struct nd_prefix *
 806 nd6_prefix_lookup(pr)
 807         struct nd_prefix *pr;
 808 {
 809         struct nd_prefix *search;
 810
 811         for (search = nd_prefix.lh_first; search; search = search->ndpr_next) {
 812                 if (pr->ndpr_ifp == search->ndpr_ifp &&
 813                     pr->ndpr_plen == search->ndpr_plen &&
 814                     in6_are_prefix_equal(&pr->ndpr_prefix.sin6_addr,
 815                                          &search->ndpr_prefix.sin6_addr,
 816                                          pr->ndpr_plen)
 817                     ) {
 818                         break;
 819                 }
 820         }
 821
 822         return(search);
 823 }
 824
 825 int
 826 nd6_prelist_add(pr, dr, newp)
 827         struct nd_prefix *pr, **newp;
 828         struct nd_defrouter *dr;
 829 {
 830         struct nd_prefix *new = NULL;
 831         int i, s;
 832
 833         new = (struct nd_prefix *)malloc(sizeof(*new), M_IP6NDP, M_NOWAIT);
 834         if (new == NULL)
 835                 return ENOMEM;
 836         bzero(new, sizeof(*new));
 837         *new = *pr;
 838         if (newp != NULL)
 839                 *newp = new;
 840
 841         /* initilization */
 842         LIST_INIT(&new->ndpr_advrtrs);
 843         in6_prefixlen2mask(&new->ndpr_mask, new->ndpr_plen);
 844         /* make prefix in the canonical form */
 845         for (i = 0; i < 4; i++)
 846                 new->ndpr_prefix.sin6_addr.s6_addr32[i] &=
 847                         new->ndpr_mask.s6_addr32[i];
 848
 849         s = splnet();
 850         /* link ndpr_entry to nd_prefix list */
 851         LIST_INSERT_HEAD(&nd_prefix, new, ndpr_entry);
 852         splx(s);
 853
 854         /* ND_OPT_PI_FLAG_ONLINK processing */
 855         if (new->ndpr_raf_onlink) {
 856                 int e;
 857
 858                 if ((e = nd6_prefix_onlink(new)) != 0) {
 859                         nd6log((LOG_ERR, "nd6_prelist_add: failed to make "
 860                             "the prefix %s/%d on-link on %s (errno=%d)\n",
 861                             ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
 862                             pr->ndpr_plen, if_name(pr->ndpr_ifp), e));
 863                         /* proceed anyway. XXX: is it correct? */
 864                 }
 865         }
 866
 867         if (dr) {
 868                 pfxrtr_add(new, dr);
 869         }
 870
 871         return 0;
 872 }
 873
 874 void
 875 prelist_remove(pr)
 876         struct nd_prefix *pr;
 877 {
 878         struct nd_pfxrouter *pfr, *next;
 879         int e, s;
 880
 881         /* make sure to invalidate the prefix until it is really freed. */
 882         pr->ndpr_vltime = 0;
 883         pr->ndpr_pltime = 0;
 884 #if 0
 885         /*
 886          * Though these flags are now meaningless, we'd rather keep the value
 887          * not to confuse users when executing "ndp -p".
 888          */
 889         pr->ndpr_raf_onlink = 0;
 890         pr->ndpr_raf_auto = 0;
 891 #endif
 892         if ((pr->ndpr_stateflags & NDPRF_ONLINK) != 0 &&
 893             (e = nd6_prefix_offlink(pr)) != 0) {
 894                 nd6log((LOG_ERR, "prelist_remove: failed to make %s/%d offlink "
 895                     "on %s, errno=%d\n",
 896                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
 897                     pr->ndpr_plen, if_name(pr->ndpr_ifp), e));
 898                 /* what should we do? */
 899         }
 900
 901         if (pr->ndpr_refcnt > 0)
 902                 return;         /* notice here? */
 903
 904         s = splnet();
 905
 906         /* unlink ndpr_entry from nd_prefix list */
 907         LIST_REMOVE(pr, ndpr_entry);
 908
 909         /* free list of routers that adversed the prefix */
 910         for (pfr = pr->ndpr_advrtrs.lh_first; pfr; pfr = next) {
 911                 next = pfr->pfr_next;
 912
 913                 free(pfr, M_IP6NDP);
 914         }
 915         splx(s);
 916
 917         free(pr, M_IP6NDP);
 918
 919         pfxlist_onlink_check();
 920 }
 921
 922 int
 923 prelist_update(new, dr, m)
 924         struct nd_prefix *new;
 925         struct nd_defrouter *dr; /* may be NULL */
 926         struct mbuf *m;
 927 {
 928         struct in6_ifaddr *ia6 = NULL, *ia6_match = NULL;
 929         struct ifaddr *ifa;
 930         struct ifnet *ifp = new->ndpr_ifp;
 931         struct nd_prefix *pr;
 932         int s = splnet();
 933         int error = 0;
 934         int newprefix = 0;
 935         int auth;
 936         struct in6_addrlifetime lt6_tmp;
 937
 938         auth = 0;
 939         if (m) {
 940                 /*
 941                  * Authenticity for NA consists authentication for
 942                  * both IP header and IP datagrams, doesn't it ?
 943                  */
 944 #if defined(M_AUTHIPHDR) && defined(M_AUTHIPDGM)
 945                 auth = (m->m_flags & M_AUTHIPHDR
 946                      && m->m_flags & M_AUTHIPDGM) ? 1 : 0;
 947 #endif
 948         }
 949
 950
 951         if ((pr = nd6_prefix_lookup(new)) != NULL) {
 952                 /*
 953                  * nd6_prefix_lookup() ensures that pr and new have the same
 954                  * prefix on a same interface.
 955                  */
 956
 957                 /*
 958                  * Update prefix information.  Note that the on-link (L) bit
 959                  * and the autonomous (A) bit should NOT be changed from 1
 960                  * to 0.
 961                  */
 962                 if (new->ndpr_raf_onlink == 1)
 963                         pr->ndpr_raf_onlink = 1;
 964                 if (new->ndpr_raf_auto == 1)
 965                         pr->ndpr_raf_auto = 1;
 966                 if (new->ndpr_raf_onlink) {
 967                         pr->ndpr_vltime = new->ndpr_vltime;
 968                         pr->ndpr_pltime = new->ndpr_pltime;
 969                         pr->ndpr_preferred = new->ndpr_preferred;
 970                         pr->ndpr_expire = new->ndpr_expire;
 971                 }
 972
 973                 if (new->ndpr_raf_onlink &&
 974                     (pr->ndpr_stateflags & NDPRF_ONLINK) == 0) {
 975                         int e;
 976
 977                         if ((e = nd6_prefix_onlink(pr)) != 0) {
 978                                 nd6log((LOG_ERR,
 979                                     "prelist_update: failed to make "
 980                                     "the prefix %s/%d on-link on %s "
 981                                     "(errno=%d)\n",
 982                                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
 983                                     pr->ndpr_plen, if_name(pr->ndpr_ifp), e));
 984                                 /* proceed anyway. XXX: is it correct? */
 985                         }
 986                 }
 987
 988                 if (dr && pfxrtr_lookup(pr, dr) == NULL)
 989                         pfxrtr_add(pr, dr);
 990         } else {
 991                 struct nd_prefix *newpr = NULL;
 992
 993                 newprefix = 1;
 994
 995                 if (new->ndpr_vltime == 0)
 996                         goto end;
 997                 if (new->ndpr_raf_onlink == 0 && new->ndpr_raf_auto == 0)
 998                         goto end;
 999
1000                 bzero(&new->ndpr_addr, sizeof(struct in6_addr));
1001
1002                 error = nd6_prelist_add(new, dr, &newpr);
1003                 if (error != 0 || newpr == NULL) {
1004                         nd6log((LOG_NOTICE, "prelist_update: "
1005                             "nd6_prelist_add failed for %s/%d on %s "
1006                             "errno=%d, returnpr=%p\n",
1007                             ip6_sprintf(&new->ndpr_prefix.sin6_addr),
1008                                         new->ndpr_plen, if_name(new->ndpr_ifp),
1009                                         error, newpr));
1010                         goto end; /* we should just give up in this case. */
1011                 }
1012
1013                 /*
1014                  * XXX: from the ND point of view, we can ignore a prefix
1015                  * with the on-link bit being zero.  However, we need a
1016                  * prefix structure for references from autoconfigured
1017                  * addresses.  Thus, we explicitly make suret that the prefix
1018                  * itself expires now.
1019                  */
1020                 if (newpr->ndpr_raf_onlink == 0) {
1021                         newpr->ndpr_vltime = 0;
1022                         newpr->ndpr_pltime = 0;
1023                         in6_init_prefix_ltimes(newpr);
1024                 }
1025
1026                 pr = newpr;
1027         }
1028
1029         /*
1030          * Address autoconfiguration based on Section 5.5.3 of RFC 2462.
1031          * Note that pr must be non NULL at this point.
1032          */
1033
1034         /* 5.5.3 (a). Ignore the prefix without the A bit set. */
1035         if (!new->ndpr_raf_auto)
1036                 goto afteraddrconf;
1037
1038         /*
1039          * 5.5.3 (b). the link-local prefix should have been ignored in
1040          * nd6_ra_input.
1041          */
1042
1043         /*
1044          * 5.5.3 (c). Consistency check on lifetimes: pltime <= vltime.
1045          * This should have been done in nd6_ra_input.
1046          */
1047
1048         /*
1049          * 5.5.3 (d). If the prefix advertised does not match the prefix of an
1050          * address already in the list, and the Valid Lifetime is not 0,
1051          * form an address.  Note that even a manually configured address
1052          * should reject autoconfiguration of a new address.
1053          */
1054         TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1055         {
1056                 struct in6_ifaddr *ifa6;
1057                 int ifa_plen;
1058                 u_int32_t storedlifetime;
1059
1060                 if (ifa->ifa_addr->sa_family != AF_INET6)
1061                         continue;
1062
1063                 ifa6 = (struct in6_ifaddr *)ifa;
1064
1065                 /*
1066                  * Spec is not clear here, but I believe we should concentrate
1067                  * on unicast (i.e. not anycast) addresses.
1068                  * XXX: other ia6_flags? detached or duplicated?
1069                  */
1070                 if ((ifa6->ia6_flags & IN6_IFF_ANYCAST) != 0)
1071                         continue;
1072
1073                 ifa_plen = in6_mask2len(&ifa6->ia_prefixmask.sin6_addr, NULL);
1074                 if (ifa_plen != new->ndpr_plen ||
1075                     !in6_are_prefix_equal(&ifa6->ia_addr.sin6_addr,
1076                                           &new->ndpr_prefix.sin6_addr,
1077                                           ifa_plen))
1078                         continue;
1079
1080                 if (ia6_match == NULL) /* remember the first one */
1081                         ia6_match = ifa6;
1082
1083                 if ((ifa6->ia6_flags & IN6_IFF_AUTOCONF) == 0)
1084                         continue;
1085
1086                 /*
1087                  * An already autoconfigured address matched.  Now that we
1088                  * are sure there is at least one matched address, we can
1089                  * proceed to 5.5.3. (e): update the lifetimes according to the
1090                  * "two hours" rule and the privacy extension.
1091                  */
1092 #define TWOHOUR         (120*60)
1093                 lt6_tmp = ifa6->ia6_lifetime;
1094
1095                 storedlifetime = IFA6_IS_INVALID(ifa6) ? 0 :
1096                         (lt6_tmp.ia6t_expire - time_second);
1097
1098                 if (TWOHOUR < new->ndpr_vltime ||
1099                     storedlifetime < new->ndpr_vltime) {
1100                         lt6_tmp.ia6t_vltime = new->ndpr_vltime;
1101                 } else if (storedlifetime <= TWOHOUR
1102 #if 0
1103                            /*
1104                             * This condition is logically redundant, so we just
1105                             * omit it.
1106                             * See IPng 6712, 6717, and 6721.
1107                             */
1108                            && new->ndpr_vltime <= storedlifetime
1109 #endif
1110                         ) {
1111                         if (auth) {
1112                                 lt6_tmp.ia6t_vltime = new->ndpr_vltime;
1113                         }
1114                 } else {
1115                         /*
1116                          * new->ndpr_vltime <= TWOHOUR &&
1117                          * TWOHOUR < storedlifetime
1118                          */
1119                         lt6_tmp.ia6t_vltime = TWOHOUR;
1120                 }
1121
1122                 /* The 2 hour rule is not imposed for preferred lifetime. */
1123                 lt6_tmp.ia6t_pltime = new->ndpr_pltime;
1124
1125                 in6_init_address_ltimes(pr, &lt6_tmp);
1126
1127                 /*
1128                  * When adjusting the lifetimes of an existing temporary
1129                  * address, only lower the lifetimes.
1130                  * RFC 3041 3.3. (1).
1131                  * XXX: how should we modify ia6t_[pv]ltime?
1132                  */
1133                 if ((ifa6->ia6_flags & IN6_IFF_TEMPORARY) != 0) {
1134                         if (lt6_tmp.ia6t_expire == 0 || /* no expire */
1135                             lt6_tmp.ia6t_expire >
1136                             ifa6->ia6_lifetime.ia6t_expire) {
1137                                 lt6_tmp.ia6t_expire =
1138                                         ifa6->ia6_lifetime.ia6t_expire;
1139                         }
1140                         if (lt6_tmp.ia6t_preferred == 0 || /* no expire */
1141                             lt6_tmp.ia6t_preferred >
1142                             ifa6->ia6_lifetime.ia6t_preferred) {
1143                                 lt6_tmp.ia6t_preferred =
1144                                         ifa6->ia6_lifetime.ia6t_preferred;
1145                         }
1146                 }
1147
1148                 ifa6->ia6_lifetime = lt6_tmp;
1149         }
1150         if (ia6_match == NULL && new->ndpr_vltime) {
1151                 /*
1152                  * No address matched and the valid lifetime is non-zero.
1153                  * Create a new address.
1154                  */
1155                 if ((ia6 = in6_ifadd(new, NULL)) != NULL) {
1156                         /*
1157                          * note that we should use pr (not new) for reference.
1158                          */
1159                         pr->ndpr_refcnt++;
1160                         ia6->ia6_ndpr = pr;
1161
1162 #if 0
1163                         /* XXXYYY Don't do this, according to Jinmei. */
1164                         pr->ndpr_addr = new->ndpr_addr;
1165 #endif
1166
1167                         /*
1168                          * RFC 3041 3.3 (2).
1169                          * When a new public address is created as described
1170                          * in RFC2462, also create a new temporary address.
1171                          *
1172                          * RFC 3041 3.5.
1173                          * When an interface connects to a new link, a new
1174                          * randomized interface identifier should be generated
1175                          * immediately together with a new set of temporary
1176                          * addresses.  Thus, we specifiy 1 as the 2nd arg of
1177                          * in6_tmpifadd().
1178                          */
1179                         if (ip6_use_tempaddr) {
1180                                 int e;
1181                                 if ((e = in6_tmpifadd(ia6, 1)) != 0) {
1182                                         nd6log((LOG_NOTICE, "prelist_update: "
1183                                             "failed to create a temporary "
1184                                             "address, errno=%d\n",
1185                                             e));
1186                                 }
1187                         }
1188
1189                         /*
1190                          * A newly added address might affect the status
1191                          * of other addresses, so we check and update it.
1192                          * XXX: what if address duplication happens?
1193                          */
1194                         pfxlist_onlink_check();
1195                 } else {
1196                         /* just set an error. do not bark here. */
1197                         error = EADDRNOTAVAIL; /* XXX: might be unused. */
1198                 }
1199         }
1200
1201   afteraddrconf:
1202
1203  end:
1204         splx(s);
1205         return error;
1206 }
1207
1208 /*
1209  * A supplement function used in the on-link detection below;
1210  * detect if a given prefix has a (probably) reachable advertising router.
1211  * XXX: lengthy function name...
1212  */
1213 static struct nd_pfxrouter *
1214 find_pfxlist_reachable_router(pr)
1215         struct nd_prefix *pr;
1216 {
1217         struct nd_pfxrouter *pfxrtr;
1218         struct rtentry *rt;
1219         struct llinfo_nd6 *ln;
1220
1221         for (pfxrtr = LIST_FIRST(&pr->ndpr_advrtrs); pfxrtr;
1222              pfxrtr = LIST_NEXT(pfxrtr, pfr_entry)) {
1223                 if ((rt = nd6_lookup(&pfxrtr->router->rtaddr, 0,
1224                                      pfxrtr->router->ifp)) &&
1225                     (ln = (struct llinfo_nd6 *)rt->rt_llinfo) &&
1226                     ND6_IS_LLINFO_PROBREACH(ln))
1227                         break;  /* found */
1228         }
1229
1230         return(pfxrtr);
1231
1232 }
1233
1234 /*
1235  * Check if each prefix in the prefix list has at least one available router
1236  * that advertised the prefix (a router is "available" if its neighbor cache
1237  * entry is reachable or probably reachable).
1238  * If the check fails, the prefix may be off-link, because, for example,
1239  * we have moved from the network but the lifetime of the prefix has not
1240  * expired yet.  So we should not use the prefix if there is another prefix
1241  * that has an available router.
1242  * But, if there is no prefix that has an available router, we still regards
1243  * all the prefixes as on-link.  This is because we can't tell if all the
1244  * routers are simply dead or if we really moved from the network and there
1245  * is no router around us.
1246  */
1247 void
1248 pfxlist_onlink_check()
1249 {
1250         struct nd_prefix *pr;
1251         struct in6_ifaddr *ifa;
1252
1253         /*
1254          * Check if there is a prefix that has a reachable advertising
1255          * router.
1256          */
1257         for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
1258                 if (pr->ndpr_raf_onlink && find_pfxlist_reachable_router(pr))
1259                         break;
1260         }
1261
1262         if (pr) {
1263                 /*
1264                  * There is at least one prefix that has a reachable router.
1265                  * Detach prefixes which have no reachable advertising
1266                  * router, and attach other prefixes.
1267                  */
1268                 for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
1269                         /* XXX: a link-local prefix should never be detached */
1270                         if (IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr))
1271                                 continue;
1272
1273                         /*
1274                          * we aren't interested in prefixes without the L bit
1275                          * set.
1276                          */
1277                         if (pr->ndpr_raf_onlink == 0)
1278                                 continue;
1279
1280                         if ((pr->ndpr_stateflags & NDPRF_DETACHED) == 0 &&
1281                             find_pfxlist_reachable_router(pr) == NULL)
1282                                 pr->ndpr_stateflags |= NDPRF_DETACHED;
1283                         if ((pr->ndpr_stateflags & NDPRF_DETACHED) != 0 &&
1284                             find_pfxlist_reachable_router(pr) != 0)
1285                                 pr->ndpr_stateflags &= ~NDPRF_DETACHED;
1286                 }
1287         } else {
1288                 /* there is no prefix that has a reachable router */
1289                 for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
1290                         if (IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr))
1291                                 continue;
1292
1293                         if (pr->ndpr_raf_onlink == 0)
1294                                 continue;
1295
1296                         if ((pr->ndpr_stateflags & NDPRF_DETACHED) != 0)
1297                                 pr->ndpr_stateflags &= ~NDPRF_DETACHED;
1298                 }
1299         }
1300
1301         /*
1302          * Remove each interface route associated with a (just) detached
1303          * prefix, and reinstall the interface route for a (just) attached
1304          * prefix.  Note that all attempt of reinstallation does not
1305          * necessarily success, when a same prefix is shared among multiple
1306          * interfaces.  Such cases will be handled in nd6_prefix_onlink,
1307          * so we don't have to care about them.
1308          */
1309         for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
1310                 int e;
1311
1312                 if (IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr))
1313                         continue;
1314
1315                 if (pr->ndpr_raf_onlink == 0)
1316                         continue;
1317
1318                 if ((pr->ndpr_stateflags & NDPRF_DETACHED) != 0 &&
1319                     (pr->ndpr_stateflags & NDPRF_ONLINK) != 0) {
1320                         if ((e = nd6_prefix_offlink(pr)) != 0) {
1321                                 nd6log((LOG_ERR,
1322                                     "pfxlist_onlink_check: failed to "
1323                                     "make %s/%d offlink, errno=%d\n",
1324                                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
1325                                     pr->ndpr_plen, e));
1326                         }
1327                 }
1328                 if ((pr->ndpr_stateflags & NDPRF_DETACHED) == 0 &&
1329                     (pr->ndpr_stateflags & NDPRF_ONLINK) == 0 &&
1330                     pr->ndpr_raf_onlink) {
1331                         if ((e = nd6_prefix_onlink(pr)) != 0) {
1332                                 nd6log((LOG_ERR,
1333                                     "pfxlist_onlink_check: failed to "
1334                                     "make %s/%d offlink, errno=%d\n",
1335                                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
1336                                     pr->ndpr_plen, e));
1337                         }
1338                 }
1339         }
1340
1341         /*
1342          * Changes on the prefix status might affect address status as well.
1343          * Make sure that all addresses derived from an attached prefix are
1344          * attached, and that all addresses derived from a detached prefix are
1345          * detached.  Note, however, that a manually configured address should
1346          * always be attached.
1347          * The precise detection logic is same as the one for prefixes.
1348          */
1349         for (ifa = in6_ifaddr; ifa; ifa = ifa->ia_next) {
1350                 if ((ifa->ia6_flags & IN6_IFF_AUTOCONF) == 0)
1351                         continue;
1352
1353                 if (ifa->ia6_ndpr == NULL) {
1354                         /*
1355                          * This can happen when we first configure the address
1356                          * (i.e. the address exists, but the prefix does not).
1357                          * XXX: complicated relationships...
1358                          */
1359                         continue;
1360                 }
1361
1362                 if (find_pfxlist_reachable_router(ifa->ia6_ndpr))
1363                         break;
1364         }
1365         if (ifa) {
1366                 for (ifa = in6_ifaddr; ifa; ifa = ifa->ia_next) {
1367                         if ((ifa->ia6_flags & IN6_IFF_AUTOCONF) == 0)
1368                                 continue;
1369
1370                         if (ifa->ia6_ndpr == NULL) /* XXX: see above. */
1371                                 continue;
1372
1373                         if (find_pfxlist_reachable_router(ifa->ia6_ndpr))
1374                                 ifa->ia6_flags &= ~IN6_IFF_DETACHED;
1375                         else
1376                                 ifa->ia6_flags |= IN6_IFF_DETACHED;
1377                 }
1378         }
1379         else {
1380                 for (ifa = in6_ifaddr; ifa; ifa = ifa->ia_next) {
1381                         if ((ifa->ia6_flags & IN6_IFF_AUTOCONF) == 0)
1382                                 continue;
1383
1384                         ifa->ia6_flags &= ~IN6_IFF_DETACHED;
1385                 }
1386         }
1387 }
1388
1389 int
1390 nd6_prefix_onlink(pr)
1391         struct nd_prefix *pr;
1392 {
1393         struct ifaddr *ifa;
1394         struct ifnet *ifp = pr->ndpr_ifp;
1395         struct sockaddr_in6 mask6;
1396         struct nd_prefix *opr;
1397         u_long rtflags;
1398         int error = 0;
1399         struct rtentry *rt = NULL;
1400
1401         /* sanity check */
1402         if ((pr->ndpr_stateflags & NDPRF_ONLINK) != 0) {
1403                 nd6log((LOG_ERR,
1404                     "nd6_prefix_onlink: %s/%d is already on-link\n",
1405                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr), pr->ndpr_plen);
1406                 return(EEXIST));
1407         }
1408
1409         /*
1410          * Add the interface route associated with the prefix.  Before
1411          * installing the route, check if there's the same prefix on another
1412          * interface, and the prefix has already installed the interface route.
1413          * Although such a configuration is expected to be rare, we explicitly
1414          * allow it.
1415          */
1416         for (opr = nd_prefix.lh_first; opr; opr = opr->ndpr_next) {
1417                 if (opr == pr)
1418                         continue;
1419
1420                 if ((opr->ndpr_stateflags & NDPRF_ONLINK) == 0)
1421                         continue;
1422
1423                 if (opr->ndpr_plen == pr->ndpr_plen &&
1424                     in6_are_prefix_equal(&pr->ndpr_prefix.sin6_addr,
1425                                          &opr->ndpr_prefix.sin6_addr,
1426                                          pr->ndpr_plen))
1427                         return(0);
1428         }
1429
1430         /*
1431          * We prefer link-local addresses as the associated interface address.
1432          */
1433         /* search for a link-local addr */
1434         ifa = (struct ifaddr *)in6ifa_ifpforlinklocal(ifp,
1435                                                       IN6_IFF_NOTREADY|
1436                                                       IN6_IFF_ANYCAST);
1437         if (ifa == NULL) {
1438                 /* XXX: freebsd does not have ifa_ifwithaf */
1439                 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
1440                 {
1441                         if (ifa->ifa_addr->sa_family == AF_INET6)
1442                                 break;
1443                 }
1444                 /* should we care about ia6_flags? */
1445         }
1446         if (ifa == NULL) {
1447                 /*
1448                  * This can still happen, when, for example, we receive an RA
1449                  * containing a prefix with the L bit set and the A bit clear,
1450                  * after removing all IPv6 addresses on the receiving
1451                  * interface.  This should, of course, be rare though.
1452                  */
1453                 nd6log((LOG_NOTICE,
1454                     "nd6_prefix_onlink: failed to find any ifaddr"
1455                     " to add route for a prefix(%s/%d) on %s\n",
1456                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
1457                     pr->ndpr_plen, if_name(ifp)));
1458                 return(0);
1459         }
1460
1461         /*
1462          * in6_ifinit() sets nd6_rtrequest to ifa_rtrequest for all ifaddrs.
1463          * ifa->ifa_rtrequest = nd6_rtrequest;
1464          */
1465         bzero(&mask6, sizeof(mask6));
1466         mask6.sin6_len = sizeof(mask6);
1467         mask6.sin6_addr = pr->ndpr_mask;
1468         rtflags = ifa->ifa_flags | RTF_CLONING | RTF_UP;
1469         if (nd6_need_cache(ifp)) {
1470                 /* explicitly set in case ifa_flags does not set the flag. */
1471                 rtflags |= RTF_CLONING;
1472         } else {
1473                 /*
1474                  * explicitly clear the cloning bit in case ifa_flags sets it.
1475                  */
1476                 rtflags &= ~RTF_CLONING;
1477         }
1478         error = rtrequest(RTM_ADD, (struct sockaddr *)&pr->ndpr_prefix,
1479                           ifa->ifa_addr, (struct sockaddr *)&mask6,
1480                           rtflags, &rt);
1481         if (error == 0) {
1482                 if (rt != NULL) /* this should be non NULL, though */
1483                         nd6_rtmsg(RTM_ADD, rt);
1484                 pr->ndpr_stateflags |= NDPRF_ONLINK;
1485         }
1486         else {
1487                 nd6log((LOG_ERR, "nd6_prefix_onlink: failed to add route for a"
1488                     " prefix (%s/%d) on %s, gw=%s, mask=%s, flags=%lx "
1489                     "errno = %d\n",
1490                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
1491                     pr->ndpr_plen, if_name(ifp),
1492                     ip6_sprintf(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr),
1493                     ip6_sprintf(&mask6.sin6_addr), rtflags, error));
1494         }
1495
1496         if (rt != NULL)
1497                 rt->rt_refcnt--;
1498
1499         return(error);
1500 }
1501
1502 int
1503 nd6_prefix_offlink(pr)
1504         struct nd_prefix *pr;
1505 {
1506         int error = 0;
1507         struct ifnet *ifp = pr->ndpr_ifp;
1508         struct nd_prefix *opr;
1509         struct sockaddr_in6 sa6, mask6;
1510         struct rtentry *rt = NULL;
1511
1512         /* sanity check */
1513         if ((pr->ndpr_stateflags & NDPRF_ONLINK) == 0) {
1514                 nd6log((LOG_ERR,
1515                     "nd6_prefix_offlink: %s/%d is already off-link\n",
1516                     ip6_sprintf(&pr->ndpr_prefix.sin6_addr), pr->ndpr_plen));
1517                 return(EEXIST);
1518         }
1519
1520         bzero(&sa6, sizeof(sa6));
1521         sa6.sin6_family = AF_INET6;
1522         sa6.sin6_len = sizeof(sa6);
1523         bcopy(&pr->ndpr_prefix.sin6_addr, &sa6.sin6_addr,
1524               sizeof(struct in6_addr));
1525         bzero(&mask6, sizeof(mask6));
1526         mask6.sin6_family = AF_INET6;
1527         mask6.sin6_len = sizeof(sa6);
1528         bcopy(&pr->ndpr_mask, &mask6.sin6_addr, sizeof(struct in6_addr));
1529         error = rtrequest(RTM_DELETE, (struct sockaddr *)&sa6, NULL,
1530                           (struct sockaddr *)&mask6, 0, &rt);
1531         if (error == 0) {
1532                 pr->ndpr_stateflags &= ~NDPRF_ONLINK;
1533
1534                 /* report the route deletion to the routing socket. */
1535                 if (rt != NULL)
1536                         nd6_rtmsg(RTM_DELETE, rt);
1537
1538                 /*
1539                  * There might be the same prefix on another interface,
1540                  * the prefix which could not be on-link just because we have
1541                  * the interface route (see comments in nd6_prefix_onlink).
1542                  * If there's one, try to make the prefix on-link on the
1543                  * interface.
1544                  */
1545                 for (opr = nd_prefix.lh_first; opr; opr = opr->ndpr_next) {
1546                         if (opr == pr)
1547                                 continue;
1548
1549                         if ((opr->ndpr_stateflags & NDPRF_ONLINK) != 0)
1550                                 continue;
1551
1552                         /*
1553                          * KAME specific: detached prefixes should not be
1554                          * on-link.
1555                          */
1556                         if ((opr->ndpr_stateflags & NDPRF_DETACHED) != 0)
1557                                 continue;
1558
1559                         if (opr->ndpr_plen == pr->ndpr_plen &&
1560                             in6_are_prefix_equal(&pr->ndpr_prefix.sin6_addr,
1561                                                  &opr->ndpr_prefix.sin6_addr,
1562                                                  pr->ndpr_plen)) {
1563                                 int e;
1564
1565                                 if ((e = nd6_prefix_onlink(opr)) != 0) {
1566                                         nd6log((LOG_ERR,
1567                                             "nd6_prefix_offlink: failed to "
1568                                             "recover a prefix %s/%d from %s "
1569                                             "to %s (errno = %d)\n",
1570                                             ip6_sprintf(&opr->ndpr_prefix.sin6_addr),
1571                                             opr->ndpr_plen, if_name(ifp),
1572                                             if_name(opr->ndpr_ifp), e));
1573                                 }
1574                         }
1575                 }
1576         }
1577         else {
1578                 /* XXX: can we still set the NDPRF_ONLINK flag? */
1579                 nd6log((LOG_ERR,
1580                     "nd6_prefix_offlink: failed to delete route: "
1581                     "%s/%d on %s (errno = %d)\n",
1582                     ip6_sprintf(&sa6.sin6_addr), pr->ndpr_plen, if_name(ifp),
1583                     error));
1584         }
1585
1586         if (rt != NULL) {
1587                 if (rt->rt_refcnt <= 0) {
1588                         /* XXX: we should free the entry ourselves. */
1589                         rt->rt_refcnt++;
1590                         rtfree(rt);
1591                 }
1592         }
1593
1594         return(error);
1595 }
1596
1597 static struct in6_ifaddr *
1598 in6_ifadd(pr, ifid)
1599         struct nd_prefix *pr;
1600         struct in6_addr  *ifid;   /* Mobile IPv6 addition */
1601 {
1602         struct ifnet *ifp = pr->ndpr_ifp;
1603         struct ifaddr *ifa;
1604         struct in6_aliasreq ifra;
1605         struct in6_ifaddr *ia, *ib;
1606         int error, plen0;
1607         struct in6_addr mask;
1608         int prefixlen = pr->ndpr_plen;
1609
1610         in6_len2mask(&mask, prefixlen);
1611
1612         /*
1613          * find a link-local address (will be interface ID).
1614          * Is it really mandatory? Theoretically, a global or a site-local
1615          * address can be configured without a link-local address, if we
1616          * have a unique interface identifier...
1617          *
1618          * it is not mandatory to have a link-local address, we can generate
1619          * interface identifier on the fly.  we do this because:
1620          * (1) it should be the easiest way to find interface identifier.
1621          * (2) RFC2462 5.4 suggesting the use of the same interface identifier
1622          * for multiple addresses on a single interface, and possible shortcut
1623          * of DAD.  we omitted DAD for this reason in the past.
1624          * (3) a user can prevent autoconfiguration of global address
1625          * by removing link-local address by hand (this is partly because we
1626          * don't have other way to control the use of IPv6 on a interface.
1627          * this has been our design choice - cf. NRL's "ifconfig auto").
1628          * (4) it is easier to manage when an interface has addresses
1629          * with the same interface identifier, than to have multiple addresses
1630          * with different interface identifiers.
1631          *
1632          * Mobile IPv6 addition: allow for caller to specify a wished interface
1633          * ID. This is to not break connections when moving addresses between
1634          * interfaces.
1635          */
1636         ifa = (struct ifaddr *)in6ifa_ifpforlinklocal(ifp, 0);/* 0 is OK? */
1637         if (ifa)
1638                 ib = (struct in6_ifaddr *)ifa;
1639         else
1640                 return NULL;
1641
1642 #if 0 /* don't care link local addr state, and always do DAD */
1643         /* if link-local address is not eligible, do not autoconfigure. */
1644         if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY) {
1645                 printf("in6_ifadd: link-local address not ready\n");
1646                 return NULL;
1647         }
1648 #endif
1649
1650         /* prefixlen + ifidlen must be equal to 128 */
1651         plen0 = in6_mask2len(&ib->ia_prefixmask.sin6_addr, NULL);
1652         if (prefixlen != plen0) {
1653                 nd6log((LOG_INFO, "in6_ifadd: wrong prefixlen for %s "
1654                     "(prefix=%d ifid=%d)\n",
1655                     if_name(ifp), prefixlen, 128 - plen0));
1656                 return NULL;
1657         }
1658
1659         /* make ifaddr */
1660
1661         bzero(&ifra, sizeof(ifra));
1662         /*
1663          * in6_update_ifa() does not use ifra_name, but we accurately set it
1664          * for safety.
1665          */
1666         strncpy(ifra.ifra_name, if_name(ifp), sizeof(ifra.ifra_name));
1667         ifra.ifra_addr.sin6_family = AF_INET6;
1668         ifra.ifra_addr.sin6_len = sizeof(struct sockaddr_in6);
1669         /* prefix */
1670         bcopy(&pr->ndpr_prefix.sin6_addr, &ifra.ifra_addr.sin6_addr,
1671               sizeof(ifra.ifra_addr.sin6_addr));
1672         ifra.ifra_addr.sin6_addr.s6_addr32[0] &= mask.s6_addr32[0];
1673         ifra.ifra_addr.sin6_addr.s6_addr32[1] &= mask.s6_addr32[1];
1674         ifra.ifra_addr.sin6_addr.s6_addr32[2] &= mask.s6_addr32[2];
1675         ifra.ifra_addr.sin6_addr.s6_addr32[3] &= mask.s6_addr32[3];
1676
1677         /* interface ID */
1678         if (ifid == NULL || IN6_IS_ADDR_UNSPECIFIED(ifid))
1679                 ifid = &ib->ia_addr.sin6_addr;
1680         ifra.ifra_addr.sin6_addr.s6_addr32[0]
1681                 |= (ifid->s6_addr32[0] & ~mask.s6_addr32[0]);
1682         ifra.ifra_addr.sin6_addr.s6_addr32[1]
1683                 |= (ifid->s6_addr32[1] & ~mask.s6_addr32[1]);
1684         ifra.ifra_addr.sin6_addr.s6_addr32[2]
1685                 |= (ifid->s6_addr32[2] & ~mask.s6_addr32[2]);
1686         ifra.ifra_addr.sin6_addr.s6_addr32[3]
1687                 |= (ifid->s6_addr32[3] & ~mask.s6_addr32[3]);
1688
1689         /* new prefix mask. */
1690         ifra.ifra_prefixmask.sin6_len = sizeof(struct sockaddr_in6);
1691         ifra.ifra_prefixmask.sin6_family = AF_INET6;
1692         bcopy(&mask, &ifra.ifra_prefixmask.sin6_addr,
1693               sizeof(ifra.ifra_prefixmask.sin6_addr));
1694
1695         /*
1696          * lifetime.
1697          * XXX: in6_init_address_ltimes would override these values later.
1698          * We should reconsider this logic.
1699          */
1700         ifra.ifra_lifetime.ia6t_vltime = pr->ndpr_vltime;
1701         ifra.ifra_lifetime.ia6t_pltime = pr->ndpr_pltime;
1702
1703         /* XXX: scope zone ID? */
1704
1705         ifra.ifra_flags |= IN6_IFF_AUTOCONF; /* obey autoconf */
1706         /*
1707          * temporarily set the nopfx flag to avoid conflict.
1708          * XXX: we should reconsider the entire mechanism about prefix
1709          * manipulation.
1710          */
1711         ifra.ifra_flags |= IN6_IFF_NOPFX;
1712
1713         /*
1714          * keep the new address, regardless of the result of in6_update_ifa.
1715          * XXX: this address is now meaningless.
1716          * We should reconsider its role.
1717          */
1718         pr->ndpr_addr = ifra.ifra_addr.sin6_addr;
1719
1720         /* allocate ifaddr structure, link into chain, etc. */
1721         if ((error = in6_update_ifa(ifp, &ifra, NULL)) != 0) {
1722                 nd6log((LOG_ERR,
1723                     "in6_ifadd: failed to make ifaddr %s on %s (errno=%d)\n",
1724                     ip6_sprintf(&ifra.ifra_addr.sin6_addr), if_name(ifp),
1725                     error));
1726                 return(NULL);   /* ifaddr must not have been allocated. */
1727         }
1728
1729         ia = in6ifa_ifpwithaddr(ifp, &ifra.ifra_addr.sin6_addr);
1730
1731         return(ia);             /* this must NOT be NULL. */
1732 }
1733
1734 int
1735 in6_tmpifadd(ia0, forcegen)
1736         const struct in6_ifaddr *ia0; /* corresponding public address */
1737         int forcegen;
1738 {
1739         struct ifnet *ifp = ia0->ia_ifa.ifa_ifp;
1740         struct in6_ifaddr *newia;
1741         struct in6_aliasreq ifra;
1742         int i, error;
1743         int trylimit = 3;       /* XXX: adhoc value */
1744         u_int32_t randid[2];
1745         time_t vltime0, pltime0;
1746
1747         bzero(&ifra, sizeof(ifra));
1748         strncpy(ifra.ifra_name, if_name(ifp), sizeof(ifra.ifra_name));
1749         ifra.ifra_addr = ia0->ia_addr;
1750         /* copy prefix mask */
1751         ifra.ifra_prefixmask = ia0->ia_prefixmask;
1752         /* clear the old IFID */
1753         for (i = 0; i < 4; i++) {
1754                 ifra.ifra_addr.sin6_addr.s6_addr32[i]
1755                         &= ifra.ifra_prefixmask.sin6_addr.s6_addr32[i];
1756         }
1757
1758   again:
1759         in6_get_tmpifid(ifp, (u_int8_t *)randid,
1760                         (const u_int8_t *)&ia0->ia_addr.sin6_addr.s6_addr[8],
1761                         forcegen);
1762         ifra.ifra_addr.sin6_addr.s6_addr32[2]
1763                 |= (randid[0] & ~(ifra.ifra_prefixmask.sin6_addr.s6_addr32[2]));
1764         ifra.ifra_addr.sin6_addr.s6_addr32[3]
1765                 |= (randid[1] & ~(ifra.ifra_prefixmask.sin6_addr.s6_addr32[3]));
1766
1767         /*
1768          * If by chance the new temporary address is the same as an address
1769          * already assigned to the interface, generate a new randomized
1770          * interface identifier and repeat this step.
1771          * RFC 3041 3.3 (4).
1772          */
1773         if (in6ifa_ifpwithaddr(ifp, &ifra.ifra_addr.sin6_addr) != NULL) {
1774                 if (trylimit-- == 0) {
1775                         nd6log((LOG_NOTICE, "in6_tmpifadd: failed to find "
1776                             "a unique random IFID\n"));
1777                         return(EEXIST);
1778                 }
1779                 forcegen = 1;
1780                 goto again;
1781         }
1782
1783         /*
1784          * The Valid Lifetime is the lower of the Valid Lifetime of the
1785          * public address or TEMP_VALID_LIFETIME.
1786          * The Preferred Lifetime is the lower of the Preferred Lifetime
1787          * of the public address or TEMP_PREFERRED_LIFETIME -
1788          * DESYNC_FACTOR.
1789          */
1790         if (ia0->ia6_lifetime.ia6t_expire != 0) {
1791                 vltime0 = IFA6_IS_INVALID(ia0) ? 0 :
1792                         (ia0->ia6_lifetime.ia6t_expire - time_second);
1793                 if (vltime0 > ip6_temp_valid_lifetime)
1794                         vltime0 = ip6_temp_valid_lifetime;
1795         } else
1796                 vltime0 = ip6_temp_valid_lifetime;
1797         if (ia0->ia6_lifetime.ia6t_preferred != 0) {
1798                 pltime0 = IFA6_IS_DEPRECATED(ia0) ? 0 :
1799                         (ia0->ia6_lifetime.ia6t_preferred - time_second);
1800                 if (pltime0 > ip6_temp_preferred_lifetime - ip6_desync_factor){
1801                         pltime0 = ip6_temp_preferred_lifetime -
1802                                 ip6_desync_factor;
1803                 }
1804         } else
1805                 pltime0 = ip6_temp_preferred_lifetime - ip6_desync_factor;
1806         ifra.ifra_lifetime.ia6t_vltime = vltime0;
1807         ifra.ifra_lifetime.ia6t_pltime = pltime0;
1808
1809         /*
1810          * A temporary address is created only if this calculated Preferred
1811          * Lifetime is greater than REGEN_ADVANCE time units.
1812          */
1813         if (ifra.ifra_lifetime.ia6t_pltime <= ip6_temp_regen_advance)
1814                 return(0);
1815
1816         /* XXX: scope zone ID? */
1817
1818         ifra.ifra_flags |= (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY);
1819
1820         /* allocate ifaddr structure, link into chain, etc. */
1821         if ((error = in6_update_ifa(ifp, &ifra, NULL)) != 0)
1822                 return(error);
1823
1824         newia = in6ifa_ifpwithaddr(ifp, &ifra.ifra_addr.sin6_addr);
1825         if (newia == NULL) {    /* XXX: can it happen? */
1826                 nd6log((LOG_ERR,
1827                     "in6_tmpifadd: ifa update succeeded, but we got "
1828                     "no ifaddr\n"));
1829                 return(EINVAL); /* XXX */
1830         }
1831         newia->ia6_ndpr = ia0->ia6_ndpr;
1832         newia->ia6_ndpr->ndpr_refcnt++;
1833
1834         /*
1835          * A newly added address might affect the status of other addresses.
1836          * XXX: when the temporary address is generated with a new public
1837          * address, the onlink check is redundant.  However, it would be safe
1838          * to do the check explicitly everywhere a new address is generated,
1839          * and, in fact, we surely need the check when we create a new
1840          * temporary address due to deprecation of an old temporary address.
1841          */
1842         pfxlist_onlink_check();
1843
1844         return(0);
1845 }
1846
1847 int
1848 in6_init_prefix_ltimes(struct nd_prefix *ndpr)
1849 {
1850         /* check if preferred lifetime > valid lifetime.  RFC2462 5.5.3 (c) */
1851         if (ndpr->ndpr_pltime > ndpr->ndpr_vltime) {
1852                 nd6log((LOG_INFO, "in6_init_prefix_ltimes: preferred lifetime"
1853                     "(%d) is greater than valid lifetime(%d)\n",
1854                     (u_int)ndpr->ndpr_pltime, (u_int)ndpr->ndpr_vltime));
1855                 return (EINVAL);
1856         }
1857         if (ndpr->ndpr_pltime == ND6_INFINITE_LIFETIME)
1858                 ndpr->ndpr_preferred = 0;
1859         else
1860                 ndpr->ndpr_preferred = time_second + ndpr->ndpr_pltime;
1861         if (ndpr->ndpr_vltime == ND6_INFINITE_LIFETIME)
1862                 ndpr->ndpr_expire = 0;
1863         else
1864                 ndpr->ndpr_expire = time_second + ndpr->ndpr_vltime;
1865
1866         return 0;
1867 }
1868
1869 static void
1870 in6_init_address_ltimes(struct nd_prefix *new, struct in6_addrlifetime *lt6)
1871 {
1872         /* Valid lifetime must not be updated unless explicitly specified. */
1873         /* init ia6t_expire */
1874         if (lt6->ia6t_vltime == ND6_INFINITE_LIFETIME)
1875                 lt6->ia6t_expire = 0;
1876         else {
1877                 lt6->ia6t_expire = time_second;
1878                 lt6->ia6t_expire += lt6->ia6t_vltime;
1879         }
1880
1881         /* init ia6t_preferred */
1882         if (lt6->ia6t_pltime == ND6_INFINITE_LIFETIME)
1883                 lt6->ia6t_preferred = 0;
1884         else {
1885                 lt6->ia6t_preferred = time_second;
1886                 lt6->ia6t_preferred += lt6->ia6t_pltime;
1887         }
1888 }
1889
1890 /*
1891  * Delete all the routing table entries that use the specified gateway.
1892  * XXX: this function causes search through all entries of routing table, so
1893  * it shouldn't be called when acting as a router.
1894  */
1895 void
1896 rt6_flush(gateway, ifp)
1897         struct in6_addr *gateway;
1898         struct ifnet *ifp;
1899 {
1900         struct radix_node_head *rnh = rt_tables[AF_INET6];
1901         int s = splnet();
1902
1903         /* We'll care only link-local addresses */
1904         if (!IN6_IS_ADDR_LINKLOCAL(gateway)) {
1905                 splx(s);
1906                 return;
1907         }
1908         /* XXX: hack for KAME's link-local address kludge */
1909         gateway->s6_addr16[1] = htons(ifp->if_index);
1910
1911         rnh->rnh_walktree(rnh, rt6_deleteroute, (void *)gateway);
1912         splx(s);
1913 }
1914
1915 static int
1916 rt6_deleteroute(rn, arg)
1917         struct radix_node *rn;
1918         void *arg;
1919 {
1920 #define SIN6(s) ((struct sockaddr_in6 *)s)
1921         struct rtentry *rt = (struct rtentry *)rn;
1922         struct in6_addr *gate = (struct in6_addr *)arg;
1923
1924         if (rt->rt_gateway == NULL || rt->rt_gateway->sa_family != AF_INET6)
1925                 return(0);
1926
1927         if (!IN6_ARE_ADDR_EQUAL(gate, &SIN6(rt->rt_gateway)->sin6_addr))
1928                 return(0);
1929
1930         /*
1931          * Do not delete a static route.
1932          * XXX: this seems to be a bit ad-hoc. Should we consider the
1933          * 'cloned' bit instead?
1934          */
1935         if ((rt->rt_flags & RTF_STATIC) != 0)
1936                 return(0);
1937
1938         /*
1939          * We delete only host route. This means, in particular, we don't
1940          * delete default route.
1941          */
1942         if ((rt->rt_flags & RTF_HOST) == 0)
1943                 return(0);
1944
1945         return(rtrequest(RTM_DELETE, rt_key(rt),
1946                          rt->rt_gateway, rt_mask(rt), rt->rt_flags, 0));
1947 #undef SIN6
1948 }
1949
1950 int
1951 nd6_setdefaultiface(ifindex)
1952         int ifindex;
1953 {
1954         int error = 0;
1955
1956         if (ifindex < 0 || if_index < ifindex)
1957                 return(EINVAL);
1958
1959         if (nd6_defifindex != ifindex) {
1960                 nd6_defifindex = ifindex;
1961                 if (nd6_defifindex > 0)
1962                         nd6_defifp = ifnet_byindex(nd6_defifindex);
1963                 else
1964                         nd6_defifp = NULL;
1965
1966                 /*
1967                  * If the Default Router List is empty, install a route
1968                  * to the specified interface as default or remove the default
1969                  * route when the default interface becomes canceled.
1970                  * The check for the queue is actually redundant, but
1971                  * we do this here to avoid re-install the default route
1972                  * if the list is NOT empty.
1973                  */
1974                 if (TAILQ_FIRST(&nd_defrouter) == NULL)
1975                         defrouter_select();
1976
1977                 /*
1978                  * Our current implementation assumes one-to-one maping between
1979                  * interfaces and links, so it would be natural to use the
1980                  * default interface as the default link.
1981                  */
1982                 scope6_setdefault(nd6_defifp);
1983         }
1984
1985         return(error);
1986 }