usr.sbin/ppp/ipv6cp.c

   1 /*-
   2  * Copyright (c) 2001 Brian Somers <brian@Awfulhak.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/usr.sbin/ppp/ipv6cp.c,v 1.8.2.4 2003/04/29 16:04:41 ume Exp $
  27  * $DragonFly: src/usr.sbin/ppp/ipv6cp.c,v 1.2 2003/06/17 04:30:00 dillon Exp $
  28  */
  29
  30 #include <sys/param.h>
  31 #include <netinet/in_systm.h>
  32 #include <netinet/in.h>
  33 #include <netinet/ip.h>
  34 #include <sys/socket.h>
  35 #include <net/route.h>
  36 #include <net/if.h>
  37 #include <net/if_types.h>
  38 #include <net/if_dl.h>
  39 #include <sys/un.h>
  40
  41 #include <stdarg.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <termios.h>
  46 #include <ifaddrs.h>
  47
  48 #include "layer.h"
  49 #include "defs.h"
  50 #include "mbuf.h"
  51 #include "timer.h"
  52 #include "fsm.h"
  53 #include "iplist.h"
  54 #include "throughput.h"
  55 #include "slcompress.h"
  56 #include "lqr.h"
  57 #include "hdlc.h"
  58 #include "lcp.h"
  59 #include "ncpaddr.h"
  60 #include "ip.h"
  61 #include "ipcp.h"
  62 #include "ipv6cp.h"
  63 #include "filter.h"
  64 #include "descriptor.h"
  65 #include "ccp.h"
  66 #include "link.h"
  67 #include "mp.h"
  68 #ifndef NORADIUS
  69 #include "radius.h"
  70 #endif
  71 #include "ncp.h"
  72 #include "bundle.h"
  73 #include "route.h"
  74 #include "iface.h"
  75 #include "log.h"
  76 #include "proto.h"
  77 #include "command.h"
  78 #include "prompt.h"
  79 #include "async.h"
  80 #include "physical.h"
  81 #include "probe.h"
  82
  83
  84 #ifndef NOINET6
  85 #define IN6ADDR_LINKLOCAL_MCAST_INIT \
  86         {{{ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
  87             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}}
  88 static const struct in6_addr in6addr_linklocal_mcast =
  89         IN6ADDR_LINKLOCAL_MCAST_INIT;
  90
  91 static int ipv6cp_LayerUp(struct fsm *);
  92 static void ipv6cp_LayerDown(struct fsm *);
  93 static void ipv6cp_LayerStart(struct fsm *);
  94 static void ipv6cp_LayerFinish(struct fsm *);
  95 static void ipv6cp_InitRestartCounter(struct fsm *, int);
  96 static void ipv6cp_SendConfigReq(struct fsm *);
  97 static void ipv6cp_SentTerminateReq(struct fsm *);
  98 static void ipv6cp_SendTerminateAck(struct fsm *, u_char);
  99 static void ipv6cp_DecodeConfig(struct fsm *, u_char *, u_char *, int,
 100                                 struct fsm_decode *);
 101
 102 static struct fsm_callbacks ipv6cp_Callbacks = {
 103   ipv6cp_LayerUp,
 104   ipv6cp_LayerDown,
 105   ipv6cp_LayerStart,
 106   ipv6cp_LayerFinish,
 107   ipv6cp_InitRestartCounter,
 108   ipv6cp_SendConfigReq,
 109   ipv6cp_SentTerminateReq,
 110   ipv6cp_SendTerminateAck,
 111   ipv6cp_DecodeConfig,
 112   fsm_NullRecvResetReq,
 113   fsm_NullRecvResetAck
 114 };
 115
 116 static void
 117 SetInterfaceID(u_char *ifid, int userandom)
 118 {
 119   struct ifaddrs *ifa, *ifap = NULL;
 120   struct sockaddr_dl *sdl;
 121   const u_long i32_max = 0xffffffff;
 122   u_long r1, r2;
 123
 124   /* configure an interface ID based on Section 4.1 of RFC 2472 */
 125   memset(ifid, 0, IPV6CP_IFIDLEN);
 126
 127   /*
 128    * 1) If an IEEE global identifier (EUI-48 or EUI-64) is
 129    * available anywhere on the node, it should be used to construct
 130    * the tentative Interface-Identifier due to its uniqueness
 131    * properties.
 132    */
 133   if (userandom)
 134     goto randomid;
 135   if (getifaddrs(&ifap) < 0)
 136     goto randomid;
 137
 138   for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
 139     char *cp;
 140
 141     if (ifa->ifa_addr->sa_family != AF_LINK)
 142       continue;
 143
 144     sdl = (struct sockaddr_dl *)ifa->ifa_addr;
 145     if (sdl->sdl_alen < 6)
 146       continue;
 147     /* we're only interested in IEEE hardware addresses */
 148     switch(sdl->sdl_type) {
 149     case IFT_ETHER:
 150     case IFT_FDDI:
 151       /* XXX need more cases? */
 152       break;
 153     default:
 154       continue;
 155     }
 156
 157     cp = (char *)(sdl->sdl_data + sdl->sdl_nlen);
 158     ifid[0] = cp[0];
 159     ifid[0] ^= 0x02; /* reverse the u/l bit*/
 160     ifid[1] = cp[1];
 161     ifid[2] = cp[2];
 162     ifid[3] = 0xff;
 163     ifid[4] = 0xfe;
 164     ifid[5] = cp[3];
 165     ifid[6] = cp[4];
 166     ifid[7] = cp[5];
 167
 168     freeifaddrs(ifap);
 169     return;
 170   }
 171
 172   freeifaddrs(ifap);
 173
 174   /*
 175    * 2) If an IEEE global identifier is not available a different source
 176    * of uniqueness should be used.
 177    * XXX: we skip this case.
 178    */
 179
 180   /*
 181    * 3) If a good source of uniqueness cannot be found, it is
 182    * recommended that a random number be generated.  In this case the
 183    * "u" bit of the interface identifier MUST be set to zero (0).
 184    */
 185  randomid:
 186   randinit();
 187   r1 = (((u_long)random()) % i32_max) + 1;
 188   r2 = (((u_long)random()) % i32_max) + 1;
 189   memcpy(ifid, &r1, sizeof(r1));
 190   memcpy(ifid + 4, &r2, sizeof(r2));
 191   ifid[0] &= 0xfd;
 192   return;
 193 }
 194
 195 static int
 196 ipcp_SetIPv6address(struct ipv6cp *ipv6cp, u_char *myifid, u_char *hisifid)
 197 {
 198   struct bundle *bundle = ipv6cp->fsm.bundle;
 199   struct in6_addr myaddr, hisaddr;
 200   struct ncprange myrange, range;
 201   struct ncpaddr addr;
 202   struct sockaddr_storage ssdst, ssgw, ssmask;
 203   struct sockaddr *sadst, *sagw, *samask;
 204
 205   sadst = (struct sockaddr *)&ssdst;
 206   sagw = (struct sockaddr *)&ssgw;
 207   samask = (struct sockaddr *)&ssmask;
 208
 209   memset(&myaddr, '\0', sizeof myaddr);
 210   memset(&hisaddr, '\0', sizeof hisaddr);
 211
 212   myaddr.s6_addr[0] = 0xfe;
 213   myaddr.s6_addr[1] = 0x80;
 214   memcpy(&myaddr.s6_addr[8], myifid, IPV6CP_IFIDLEN);
 215 #if 0
 216   myaddr.s6_addr[8] |= 0x02;    /* set 'universal' bit */
 217 #endif
 218
 219   hisaddr.s6_addr[0] = 0xfe;
 220   hisaddr.s6_addr[1] = 0x80;
 221   memcpy(&hisaddr.s6_addr[8], hisifid, IPV6CP_IFIDLEN);
 222 #if 0
 223   hisaddr.s6_addr[8] |= 0x02;   /* set 'universal' bit */
 224 #endif
 225
 226   ncpaddr_setip6(&ipv6cp->myaddr, &myaddr);
 227   ncpaddr_setip6(&ipv6cp->hisaddr, &hisaddr);
 228   ncprange_set(&myrange, &ipv6cp->myaddr, 64);
 229
 230   if (!iface_Add(bundle->iface, &bundle->ncp, &myrange, &ipv6cp->hisaddr,
 231                  IFACE_ADD_FIRST|IFACE_FORCE_ADD|IFACE_SYSTEM))
 232     return 0;
 233
 234   if (!Enabled(bundle, OPT_IFACEALIAS))
 235     iface_Clear(bundle->iface, &bundle->ncp, AF_INET6,
 236                 IFACE_CLEAR_ALIASES|IFACE_SYSTEM);
 237
 238   ncpaddr_setip6(&addr, &in6addr_linklocal_mcast);
 239   ncprange_set(&range, &addr, 32);
 240   rt_Set(bundle, RTM_ADD, &range, &ipv6cp->myaddr, 1, 0);
 241
 242   if (bundle->ncp.cfg.sendpipe > 0 || bundle->ncp.cfg.recvpipe > 0) {
 243     ncprange_getsa(&myrange, &ssgw, &ssmask);
 244     if (ncpaddr_isset(&ipv6cp->hisaddr))
 245       ncpaddr_getsa(&ipv6cp->hisaddr, &ssdst);
 246     else
 247       sadst = NULL;
 248     rt_Update(bundle, sadst, sagw, samask);
 249   }
 250
 251   if (Enabled(bundle, OPT_SROUTES))
 252     route_Change(bundle, bundle->ncp.route, &ipv6cp->myaddr, &ipv6cp->hisaddr);
 253
 254 #ifndef NORADIUS
 255   if (bundle->radius.valid)
 256     route_Change(bundle, bundle->radius.routes, &ipv6cp->myaddr,
 257                  &ipv6cp->hisaddr);
 258 #endif
 259
 260   return 1;     /* Ok */
 261 }
 262
 263 void
 264 ipv6cp_Init(struct ipv6cp *ipv6cp, struct bundle *bundle, struct link *l,
 265                  const struct fsm_parent *parent)
 266 {
 267   static const char * const timer_names[] =
 268     {"IPV6CP restart", "IPV6CP openmode", "IPV6CP stopped"};
 269   int n;
 270
 271   fsm_Init(&ipv6cp->fsm, "IPV6CP", PROTO_IPV6CP, 1, IPV6CP_MAXCODE, LogIPV6CP,
 272            bundle, l, parent, &ipv6cp_Callbacks, timer_names);
 273
 274   ipv6cp->cfg.fsm.timeout = DEF_FSMRETRY;
 275   ipv6cp->cfg.fsm.maxreq = DEF_FSMTRIES;
 276   ipv6cp->cfg.fsm.maxtrm = DEF_FSMTRIES;
 277
 278   SetInterfaceID(ipv6cp->my_ifid, 0);
 279   do {
 280     SetInterfaceID(ipv6cp->his_ifid, 1);
 281   } while (memcmp(ipv6cp->his_ifid, ipv6cp->my_ifid, IPV6CP_IFIDLEN) == 0);
 282
 283   if (probe.ipv6_available) {
 284     n = 100;
 285     while (n &&
 286            !ipcp_SetIPv6address(ipv6cp, ipv6cp->my_ifid, ipv6cp->his_ifid)) {
 287       do {
 288         n--;
 289         SetInterfaceID(ipv6cp->my_ifid, 1);
 290       } while (n
 291         && memcmp(ipv6cp->his_ifid, ipv6cp->my_ifid, IPV6CP_IFIDLEN) == 0);
 292     }
 293   }
 294
 295   throughput_init(&ipv6cp->throughput, SAMPLE_PERIOD);
 296   memset(ipv6cp->Queue, '\0', sizeof ipv6cp->Queue);
 297   ipv6cp_Setup(ipv6cp);
 298 }
 299
 300 void
 301 ipv6cp_Destroy(struct ipv6cp *ipv6cp)
 302 {
 303   throughput_destroy(&ipv6cp->throughput);
 304 }
 305
 306 void
 307 ipv6cp_Setup(struct ipv6cp *ipv6cp)
 308 {
 309   ncpaddr_init(&ipv6cp->myaddr);
 310   ncpaddr_init(&ipv6cp->hisaddr);
 311
 312   ipv6cp->his_reject = 0;
 313   ipv6cp->my_reject = 0;
 314 }
 315
 316 void
 317 ipv6cp_SetLink(struct ipv6cp *ipv6cp, struct link *l)
 318 {
 319   ipv6cp->fsm.link = l;
 320 }
 321
 322 int
 323 ipv6cp_Show(struct cmdargs const *arg)
 324 {
 325   struct ipv6cp *ipv6cp = &arg->bundle->ncp.ipv6cp;
 326
 327   prompt_Printf(arg->prompt, "%s [%s]\n", ipv6cp->fsm.name,
 328                 State2Nam(ipv6cp->fsm.state));
 329   if (ipv6cp->fsm.state == ST_OPENED) {
 330     prompt_Printf(arg->prompt, " His side:        %s\n",
 331                   ncpaddr_ntoa(&ipv6cp->hisaddr));
 332     prompt_Printf(arg->prompt, " My side:         %s\n",
 333                   ncpaddr_ntoa(&ipv6cp->myaddr));
 334     prompt_Printf(arg->prompt, " Queued packets:  %lu\n",
 335                   (unsigned long)ipv6cp_QueueLen(ipv6cp));
 336   }
 337
 338   prompt_Printf(arg->prompt, "\nDefaults:\n");
 339   prompt_Printf(arg->prompt, "  FSM retry = %us, max %u Config"
 340                 " REQ%s, %u Term REQ%s\n\n", ipv6cp->cfg.fsm.timeout,
 341                 ipv6cp->cfg.fsm.maxreq, ipv6cp->cfg.fsm.maxreq == 1 ? "" : "s",
 342                 ipv6cp->cfg.fsm.maxtrm, ipv6cp->cfg.fsm.maxtrm == 1 ? "" : "s");
 343
 344   throughput_disp(&ipv6cp->throughput, arg->prompt);
 345
 346   return 0;
 347 }
 348
 349 struct mbuf *
 350 ipv6cp_Input(struct bundle *bundle, struct link *l, struct mbuf *bp)
 351 {
 352   /* Got PROTO_IPV6CP from link */
 353   m_settype(bp, MB_IPV6CPIN);
 354   if (bundle_Phase(bundle) == PHASE_NETWORK)
 355     fsm_Input(&bundle->ncp.ipv6cp.fsm, bp);
 356   else {
 357     if (bundle_Phase(bundle) < PHASE_NETWORK)
 358       log_Printf(LogIPV6CP, "%s: Error: Unexpected IPV6CP in phase %s"
 359                  " (ignored)\n", l->name, bundle_PhaseName(bundle));
 360     m_freem(bp);
 361   }
 362   return NULL;
 363 }
 364
 365 void
 366 ipv6cp_AddInOctets(struct ipv6cp *ipv6cp, int n)
 367 {
 368   throughput_addin(&ipv6cp->throughput, n);
 369 }
 370
 371 void
 372 ipv6cp_AddOutOctets(struct ipv6cp *ipv6cp, int n)
 373 {
 374   throughput_addout(&ipv6cp->throughput, n);
 375 }
 376
 377 void
 378 ipv6cp_IfaceAddrAdded(struct ipv6cp *ipv6cp, const struct iface_addr *addr)
 379 {
 380 }
 381
 382 void
 383 ipv6cp_IfaceAddrDeleted(struct ipv6cp *ipv6cp, const struct iface_addr *addr)
 384 {
 385 }
 386
 387 int
 388 ipv6cp_InterfaceUp(struct ipv6cp *ipv6cp)
 389 {
 390   if (!ipcp_SetIPv6address(ipv6cp, ipv6cp->my_ifid, ipv6cp->his_ifid)) {
 391     log_Printf(LogERROR, "ipv6cp_InterfaceUp: unable to set ipv6 address\n");
 392     return 0;
 393   }
 394
 395   if (!iface_SetFlags(ipv6cp->fsm.bundle->iface->name, IFF_UP)) {
 396     log_Printf(LogERROR, "ipv6cp_InterfaceUp: Can't set the IFF_UP"
 397                " flag on %s\n", ipv6cp->fsm.bundle->iface->name);
 398     return 0;
 399   }
 400
 401   return 1;
 402 }
 403
 404 size_t
 405 ipv6cp_QueueLen(struct ipv6cp *ipv6cp)
 406 {
 407   struct mqueue *q;
 408   size_t result;
 409
 410   result = 0;
 411   for (q = ipv6cp->Queue; q < ipv6cp->Queue + IPV6CP_QUEUES(ipv6cp); q++)
 412     result += q->len;
 413
 414   return result;
 415 }
 416
 417 int
 418 ipv6cp_PushPacket(struct ipv6cp *ipv6cp, struct link *l)
 419 {
 420   struct bundle *bundle = ipv6cp->fsm.bundle;
 421   struct mqueue *queue;
 422   struct mbuf *bp;
 423   int m_len;
 424   u_int32_t secs = 0;
 425   unsigned alivesecs = 0;
 426
 427   if (ipv6cp->fsm.state != ST_OPENED)
 428     return 0;
 429
 430   /*
 431    * If ccp is not open but is required, do nothing.
 432    */
 433   if (l->ccp.fsm.state != ST_OPENED && ccp_Required(&l->ccp)) {
 434     log_Printf(LogPHASE, "%s: Not transmitting... waiting for CCP\n", l->name);
 435     return 0;
 436   }
 437
 438   queue = ipv6cp->Queue + IPV6CP_QUEUES(ipv6cp) - 1;
 439   do {
 440     if (queue->top) {
 441       bp = m_dequeue(queue);
 442       bp = mbuf_Read(bp, &secs, sizeof secs);
 443       bp = m_pullup(bp);
 444       m_len = m_length(bp);
 445       if (!FilterCheck(MBUF_CTOP(bp), AF_INET6, &bundle->filter.alive,
 446                        &alivesecs)) {
 447         if (secs == 0)
 448           secs = alivesecs;
 449         bundle_StartIdleTimer(bundle, secs);
 450       }
 451       link_PushPacket(l, bp, bundle, 0, PROTO_IPV6);
 452       ipv6cp_AddOutOctets(ipv6cp, m_len);
 453       return 1;
 454     }
 455   } while (queue-- != ipv6cp->Queue);
 456
 457   return 0;
 458 }
 459
 460 static int
 461 ipv6cp_LayerUp(struct fsm *fp)
 462 {
 463   /* We're now up */
 464   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 465   char tbuff[40];
 466
 467   log_Printf(LogIPV6CP, "%s: LayerUp.\n", fp->link->name);
 468   if (!ipv6cp_InterfaceUp(ipv6cp))
 469     return 0;
 470
 471   snprintf(tbuff, sizeof tbuff, "%s", ncpaddr_ntoa(&ipv6cp->myaddr));
 472   log_Printf(LogIPV6CP, "myaddr %s hisaddr = %s\n",
 473              tbuff, ncpaddr_ntoa(&ipv6cp->hisaddr));
 474
 475   /* XXX: Call radius_Account() */
 476
 477   if (!Enabled(fp->bundle, OPT_IPCP)) {
 478     /*
 479      * XXX this stuff should really live in the FSM.  Our config should
 480      * associate executable sections in files with events.
 481      */
 482     if (system_Select(fp->bundle, tbuff, LINKUPFILE, NULL, NULL) < 0) {
 483       if (bundle_GetLabel(fp->bundle)) {
 484         if (system_Select(fp->bundle, bundle_GetLabel(fp->bundle),
 485                           LINKUPFILE, NULL, NULL) < 0)
 486           system_Select(fp->bundle, "MYADDR6", LINKUPFILE, NULL, NULL);
 487       } else
 488         system_Select(fp->bundle, "MYADDR6", LINKUPFILE, NULL, NULL);
 489     }
 490   }
 491
 492   fp->more.reqs = fp->more.naks = fp->more.rejs = ipv6cp->cfg.fsm.maxreq * 3;
 493   log_DisplayPrompts();
 494
 495   return 1;
 496 }
 497
 498 static void
 499 ipv6cp_LayerDown(struct fsm *fp)
 500 {
 501   /* About to come down */
 502   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 503   static int recursing;
 504   char addr[40];
 505
 506   if (!recursing++) {
 507     snprintf(addr, sizeof addr, "%s", ncpaddr_ntoa(&ipv6cp->myaddr));
 508     log_Printf(LogIPV6CP, "%s: LayerDown: %s\n", fp->link->name, addr);
 509
 510     /* XXX: Call radius_Account() */
 511
 512     if (!Enabled(fp->bundle, OPT_IPCP)) {
 513       /*
 514        * XXX this stuff should really live in the FSM.  Our config should
 515        * associate executable sections in files with events.
 516        */
 517       if (system_Select(fp->bundle, addr, LINKDOWNFILE, NULL, NULL) < 0) {
 518         if (bundle_GetLabel(fp->bundle)) {
 519           if (system_Select(fp->bundle, bundle_GetLabel(fp->bundle),
 520                             LINKDOWNFILE, NULL, NULL) < 0)
 521             system_Select(fp->bundle, "MYADDR6", LINKDOWNFILE, NULL, NULL);
 522         } else
 523           system_Select(fp->bundle, "MYADDR6", LINKDOWNFILE, NULL, NULL);
 524       }
 525     }
 526
 527     ipv6cp_Setup(ipv6cp);
 528   }
 529   recursing--;
 530 }
 531
 532 static void
 533 ipv6cp_LayerStart(struct fsm *fp)
 534 {
 535   /* We're about to start up ! */
 536   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 537
 538   log_Printf(LogIPV6CP, "%s: LayerStart.\n", fp->link->name);
 539   throughput_start(&ipv6cp->throughput, "IPV6CP throughput",
 540                    Enabled(fp->bundle, OPT_THROUGHPUT));
 541   fp->more.reqs = fp->more.naks = fp->more.rejs = ipv6cp->cfg.fsm.maxreq * 3;
 542   ipv6cp->peer_tokenreq = 0;
 543 }
 544
 545 static void
 546 ipv6cp_LayerFinish(struct fsm *fp)
 547 {
 548   /* We're now down */
 549   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 550
 551   log_Printf(LogIPV6CP, "%s: LayerFinish.\n", fp->link->name);
 552   throughput_stop(&ipv6cp->throughput);
 553   throughput_log(&ipv6cp->throughput, LogIPV6CP, NULL);
 554 }
 555
 556 static void
 557 ipv6cp_InitRestartCounter(struct fsm *fp, int what)
 558 {
 559   /* Set fsm timer load */
 560   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 561
 562   fp->FsmTimer.load = ipv6cp->cfg.fsm.timeout * SECTICKS;
 563   switch (what) {
 564     case FSM_REQ_TIMER:
 565       fp->restart = ipv6cp->cfg.fsm.maxreq;
 566       break;
 567     case FSM_TRM_TIMER:
 568       fp->restart = ipv6cp->cfg.fsm.maxtrm;
 569       break;
 570     default:
 571       fp->restart = 1;
 572       break;
 573   }
 574 }
 575
 576 static void
 577 ipv6cp_SendConfigReq(struct fsm *fp)
 578 {
 579   /* Send config REQ please */
 580   struct physical *p = link2physical(fp->link);
 581   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 582   u_char buff[IPV6CP_IFIDLEN+2];
 583   struct fsm_opt *o;
 584
 585   o = (struct fsm_opt *)buff;
 586
 587   if ((p && !physical_IsSync(p)) || !REJECTED(ipv6cp, TY_TOKEN)) {
 588     memcpy(o->data, ipv6cp->my_ifid, IPV6CP_IFIDLEN);
 589     INC_FSM_OPT(TY_TOKEN, IPV6CP_IFIDLEN + 2, o);
 590   }
 591
 592   fsm_Output(fp, CODE_CONFIGREQ, fp->reqid, buff, (u_char *)o - buff,
 593              MB_IPV6CPOUT);
 594 }
 595
 596 static void
 597 ipv6cp_SentTerminateReq(struct fsm *fp)
 598 {
 599   /* Term REQ just sent by FSM */
 600 }
 601
 602 static void
 603 ipv6cp_SendTerminateAck(struct fsm *fp, u_char id)
 604 {
 605   /* Send Term ACK please */
 606   fsm_Output(fp, CODE_TERMACK, id, NULL, 0, MB_IPV6CPOUT);
 607 }
 608
 609 static const char *
 610 protoname(int proto)
 611 {
 612   static const char *cftypes[] = { "IFACEID", "COMPPROTO" };
 613
 614   if (proto > 0 && proto <= sizeof cftypes / sizeof *cftypes)
 615     return cftypes[proto - 1];
 616
 617   return NumStr(proto, NULL, 0);
 618 }
 619
 620 static void
 621 ipv6cp_ValidateInterfaceID(struct ipv6cp *ipv6cp, u_char *ifid,
 622                            struct fsm_decode *dec)
 623 {
 624   struct fsm_opt opt;
 625   u_char zero[IPV6CP_IFIDLEN];
 626
 627   memset(zero, 0, IPV6CP_IFIDLEN);
 628
 629   if (memcmp(ifid, zero, IPV6CP_IFIDLEN) != 0
 630       && memcmp(ifid, ipv6cp->my_ifid, IPV6CP_IFIDLEN) != 0)
 631     memcpy(ipv6cp->his_ifid, ifid, IPV6CP_IFIDLEN);
 632
 633   opt.hdr.id = TY_TOKEN;
 634   opt.hdr.len = IPV6CP_IFIDLEN + 2;
 635   memcpy(opt.data, &ipv6cp->his_ifid, IPV6CP_IFIDLEN);
 636   if (memcmp(ifid, ipv6cp->his_ifid, IPV6CP_IFIDLEN) == 0)
 637     fsm_ack(dec, &opt);
 638   else
 639     fsm_nak(dec, &opt);
 640 }
 641
 642 static void
 643 ipv6cp_DecodeConfig(struct fsm *fp, u_char *cp, u_char *end, int mode_type,
 644                     struct fsm_decode *dec)
 645 {
 646   /* Deal with incoming PROTO_IPV6CP */
 647   struct ipv6cp *ipv6cp = fsm2ipv6cp(fp);
 648   int n;
 649   char tbuff[100];
 650   u_char ifid[IPV6CP_IFIDLEN], zero[IPV6CP_IFIDLEN];
 651   struct fsm_opt *opt;
 652
 653   memset(zero, 0, IPV6CP_IFIDLEN);
 654
 655   while (end - cp >= sizeof(opt->hdr)) {
 656     if ((opt = fsm_readopt(&cp)) == NULL)
 657       break;
 658
 659     snprintf(tbuff, sizeof tbuff, " %s[%d]", protoname(opt->hdr.id),
 660              opt->hdr.len);
 661
 662     switch (opt->hdr.id) {
 663     case TY_TOKEN:
 664       memcpy(ifid, opt->data, IPV6CP_IFIDLEN);
 665       log_Printf(LogIPV6CP, "%s 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", tbuff,
 666                  ifid[0], ifid[1], ifid[2], ifid[3], ifid[4], ifid[5], ifid[6], ifid[7]);
 667
 668       switch (mode_type) {
 669       case MODE_REQ:
 670         ipv6cp->peer_tokenreq = 1;
 671         ipv6cp_ValidateInterfaceID(ipv6cp, ifid, dec);
 672         break;
 673
 674       case MODE_NAK:
 675         if (memcmp(ifid, zero, IPV6CP_IFIDLEN) == 0) {
 676           log_Printf(log_IsKept(LogIPV6CP) ? LogIPV6CP : LogPHASE,
 677                      "0x0000000000000000: Unacceptable IntefaceID!\n");
 678           fsm_Close(&ipv6cp->fsm);
 679         } else if (memcmp(ifid, ipv6cp->his_ifid, IPV6CP_IFIDLEN) == 0) {
 680           log_Printf(log_IsKept(LogIPV6CP) ? LogIPV6CP : LogPHASE,
 681                      "0x%02x%02x%02x%02x%02x%02x%02x%02x: "
 682                      "Unacceptable IntefaceID!\n",
 683                      ifid[0], ifid[1], ifid[2], ifid[3],
 684                      ifid[4], ifid[5], ifid[6], ifid[7]);
 685         } else if (memcmp(ifid, ipv6cp->my_ifid, IPV6CP_IFIDLEN) != 0) {
 686           n = 100;
 687           while (n && !ipcp_SetIPv6address(ipv6cp, ifid, ipv6cp->his_ifid)) {
 688             do {
 689               n--;
 690               SetInterfaceID(ifid, 1);
 691             } while (n && memcmp(ifid, ipv6cp->his_ifid, IPV6CP_IFIDLEN) == 0);
 692           }
 693
 694           if (n == 0) {
 695             log_Printf(log_IsKept(LogIPV6CP) ? LogIPV6CP : LogPHASE,
 696                        "0x0000000000000000: Unacceptable IntefaceID!\n");
 697             fsm_Close(&ipv6cp->fsm);
 698           } else {
 699             log_Printf(LogIPV6CP, "%s changing IntefaceID: "
 700                        "0x%02x%02x%02x%02x%02x%02x%02x%02x "
 701                        "--> 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", tbuff,
 702                        ipv6cp->my_ifid[0], ipv6cp->my_ifid[1],
 703                        ipv6cp->my_ifid[2], ipv6cp->my_ifid[3],
 704                        ipv6cp->my_ifid[4], ipv6cp->my_ifid[5],
 705                        ipv6cp->my_ifid[6], ipv6cp->my_ifid[7],
 706                        ifid[0], ifid[1], ifid[2], ifid[3],
 707                        ifid[4], ifid[5], ifid[6], ifid[7]);
 708             memcpy(ipv6cp->my_ifid, ifid, IPV6CP_IFIDLEN);
 709             bundle_AdjustFilters(fp->bundle, &ipv6cp->myaddr, NULL);
 710           }
 711         }
 712         break;
 713
 714       case MODE_REJ:
 715         ipv6cp->his_reject |= (1 << opt->hdr.id);
 716         break;
 717       }
 718       break;
 719
 720     default:
 721       if (mode_type != MODE_NOP) {
 722         ipv6cp->my_reject |= (1 << opt->hdr.id);
 723         fsm_rej(dec, opt);
 724       }
 725       break;
 726     }
 727   }
 728
 729   if (mode_type != MODE_NOP) {
 730     if (mode_type == MODE_REQ && !ipv6cp->peer_tokenreq) {
 731       if (dec->rejend == dec->rej && dec->nakend == dec->nak) {
 732         /*
 733          * Pretend the peer has requested a TOKEN.
 734          * We do this to ensure that we only send one NAK if the only
 735          * reason for the NAK is because the peer isn't sending a
 736          * TY_TOKEN REQ.  This stops us from repeatedly trying to tell
 737          * the peer that we have to have an IP address on their end.
 738          */
 739         ipv6cp->peer_tokenreq = 1;
 740       }
 741       memset(ifid, 0, IPV6CP_IFIDLEN);
 742       ipv6cp_ValidateInterfaceID(ipv6cp, ifid, dec);
 743     }
 744     fsm_opt_normalise(dec);
 745   }
 746 }
 747 #endif