pppd/ipv6cp.c

   1 /*
   2  * ipv6cp.c - PPP IPV6 Control Protocol.
   3  *
   4  * Copyright (c) 1999 Tommi Komulainen.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * 3. The name(s) of the authors of this software must not be used to
  19  *    endorse or promote products derived from this software without
  20  *    prior written permission.
  21  *
  22  * 4. Redistributions of any form whatsoever must retain the following
  23  *    acknowledgment:
  24  *    "This product includes software developed by Tommi Komulainen
  25  *     <Tommi.Komulainen@iki.fi>".
  26  *
  27  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  28  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  29  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  30  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  31  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  32  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  33  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  34  *
  35  */
  36
  37 /*  Original version, based on RFC2023 :
  38
  39     Copyright (c) 1995, 1996, 1997 Francis.Dupont@inria.fr, INRIA Rocquencourt,
  40     Alain.Durand@imag.fr, IMAG,
  41     Jean-Luc.Richier@imag.fr, IMAG-LSR.
  42
  43     Copyright (c) 1998, 1999 Francis.Dupont@inria.fr, GIE DYADE,
  44     Alain.Durand@imag.fr, IMAG,
  45     Jean-Luc.Richier@imag.fr, IMAG-LSR.
  46
  47     Ce travail a été fait au sein du GIE DYADE (Groupement d'Intérêt
  48     Économique ayant pour membres BULL S.A. et l'INRIA).
  49
  50     Ce logiciel informatique est disponible aux conditions
  51     usuelles dans la recherche, c'est-à-dire qu'il peut
  52     être utilisé, copié, modifié, distribué à l'unique
  53     condition que ce texte soit conservé afin que
  54     l'origine de ce logiciel soit reconnue.
  55
  56     Le nom de l'Institut National de Recherche en Informatique
  57     et en Automatique (INRIA), de l'IMAG, ou d'une personne morale
  58     ou physique ayant participé à l'élaboration de ce logiciel ne peut
  59     être utilisé sans son accord préalable explicite.
  60
  61     Ce logiciel est fourni tel quel sans aucune garantie,
  62     support ou responsabilité d'aucune sorte.
  63     Ce logiciel est dérivé de sources d'origine
  64     "University of California at Berkeley" et
  65     "Digital Equipment Corporation" couvertes par des copyrights.
  66
  67     L'Institut d'Informatique et de Mathématiques Appliquées de Grenoble (IMAG)
  68     est une fédération d'unités mixtes de recherche du CNRS, de l'Institut National
  69     Polytechnique de Grenoble et de l'Université Joseph Fourier regroupant
  70     sept laboratoires dont le laboratoire Logiciels, Systèmes, Réseaux (LSR).
  71
  72     This work has been done in the context of GIE DYADE (joint R & D venture
  73     between BULL S.A. and INRIA).
  74
  75     This software is available with usual "research" terms
  76     with the aim of retain credits of the software.
  77     Permission to use, copy, modify and distribute this software for any
  78     purpose and without fee is hereby granted, provided that the above
  79     copyright notice and this permission notice appear in all copies,
  80     and the name of INRIA, IMAG, or any contributor not be used in advertising
  81     or publicity pertaining to this material without the prior explicit
  82     permission. The software is provided "as is" without any
  83     warranties, support or liabilities of any kind.
  84     This software is derived from source code from
  85     "University of California at Berkeley" and
  86     "Digital Equipment Corporation" protected by copyrights.
  87
  88     Grenoble's Institute of Computer Science and Applied Mathematics (IMAG)
  89     is a federation of seven research units funded by the CNRS, National
  90     Polytechnic Institute of Grenoble and University Joseph Fourier.
  91     The research unit in Software, Systems, Networks (LSR) is member of IMAG.
  92 */
  93
  94 /*
  95  * Derived from :
  96  *
  97  *
  98  * ipcp.c - PPP IP Control Protocol.
  99  *
 100  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
 101  *
 102  * Redistribution and use in source and binary forms, with or without
 103  * modification, are permitted provided that the following conditions
 104  * are met:
 105  *
 106  * 1. Redistributions of source code must retain the above copyright
 107  *    notice, this list of conditions and the following disclaimer.
 108  *
 109  * 2. Redistributions in binary form must reproduce the above copyright
 110  *    notice, this list of conditions and the following disclaimer in
 111  *    the documentation and/or other materials provided with the
 112  *    distribution.
 113  *
 114  * 3. The name "Carnegie Mellon University" must not be used to
 115  *    endorse or promote products derived from this software without
 116  *    prior written permission. For permission or any legal
 117  *    details, please contact
 118  *      Office of Technology Transfer
 119  *      Carnegie Mellon University
 120  *      5000 Forbes Avenue
 121  *      Pittsburgh, PA  15213-3890
 122  *      (412) 268-4387, fax: (412) 268-7395
 123  *      tech-transfer@andrew.cmu.edu
 124  *
 125  * 4. Redistributions of any form whatsoever must retain the following
 126  *    acknowledgment:
 127  *    "This product includes software developed by Computing Services
 128  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
 129  *
 130  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
 131  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 132  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
 133  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 134  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 135  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 136  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 137  *
 138  * $Id: ipv6cp.c,v 1.21 2005/08/25 23:59:34 paulus Exp $
 139  */
 140
 141 #define RCSID   "$Id: ipv6cp.c,v 1.21 2005/08/25 23:59:34 paulus Exp $"
 142
 143 /*
 144  * TODO:
 145  *
 146  * Proxy Neighbour Discovery.
 147  *
 148  * Better defines for selecting the ordering of
 149  *   interface up / set address. (currently checks for __linux__,
 150  *   since SVR4 && (SNI || __USLC__) didn't work properly)
 151  */
 152
 153 #include <stdio.h>
 154 #include <stdlib.h>
 155 #include <string.h>
 156 #include <unistd.h>
 157 #include <netdb.h>
 158 #include <sys/param.h>
 159 #include <sys/types.h>
 160 #include <sys/socket.h>
 161 #include <netinet/in.h>
 162 #include <arpa/inet.h>
 163
 164 #include "pppd.h"
 165 #include "fsm.h"
 166 #include "ipcp.h"
 167 #include "ipv6cp.h"
 168 #include "magic.h"
 169 #include "pathnames.h"
 170
 171
 172 /* global vars */
 173 ipv6cp_options ipv6cp_wantoptions[NUM_PPP];     /* Options that we want to request */
 174 ipv6cp_options ipv6cp_gotoptions[NUM_PPP];      /* Options that peer ack'd */
 175 ipv6cp_options ipv6cp_allowoptions[NUM_PPP];    /* Options we allow peer to request */
 176 ipv6cp_options ipv6cp_hisoptions[NUM_PPP];      /* Options that we ack'd */
 177 int no_ifaceid_neg = 0;
 178
 179 /* local vars */
 180 static int default_route_set[NUM_PPP];          /* Have set up a default route */
 181 static int ipv6cp_is_up;
 182
 183 /* Hook for a plugin to know when IPv6 protocol has come up */
 184 void (*ipv6_up_hook) __P((void)) = NULL;
 185
 186 /* Hook for a plugin to know when IPv6 protocol has come down */
 187 void (*ipv6_down_hook) __P((void)) = NULL;
 188
 189 /* Notifiers for when IPCPv6 goes up and down */
 190 struct notifier *ipv6_up_notifier = NULL;
 191 struct notifier *ipv6_down_notifier = NULL;
 192
 193 /*
 194  * Callbacks for fsm code.  (CI = Configuration Information)
 195  */
 196 static void ipv6cp_resetci __P((fsm *));        /* Reset our CI */
 197 static int  ipv6cp_cilen __P((fsm *));          /* Return length of our CI */
 198 static void ipv6cp_addci __P((fsm *, u_char *, int *)); /* Add our CI */
 199 static int  ipv6cp_ackci __P((fsm *, u_char *, int));   /* Peer ack'd our CI */
 200 static int  ipv6cp_nakci __P((fsm *, u_char *, int, int));/* Peer nak'd our CI */
 201 static int  ipv6cp_rejci __P((fsm *, u_char *, int));   /* Peer rej'd our CI */
 202 static int  ipv6cp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */
 203 static void ipv6cp_up __P((fsm *));             /* We're UP */
 204 static void ipv6cp_down __P((fsm *));           /* We're DOWN */
 205 static void ipv6cp_finished __P((fsm *));       /* Don't need lower layer */
 206
 207 fsm ipv6cp_fsm[NUM_PPP];                /* IPV6CP fsm structure */
 208
 209 static fsm_callbacks ipv6cp_callbacks = { /* IPV6CP callback routines */
 210     ipv6cp_resetci,             /* Reset our Configuration Information */
 211     ipv6cp_cilen,               /* Length of our Configuration Information */
 212     ipv6cp_addci,               /* Add our Configuration Information */
 213     ipv6cp_ackci,               /* ACK our Configuration Information */
 214     ipv6cp_nakci,               /* NAK our Configuration Information */
 215     ipv6cp_rejci,               /* Reject our Configuration Information */
 216     ipv6cp_reqci,               /* Request peer's Configuration Information */
 217     ipv6cp_up,                  /* Called when fsm reaches OPENED state */
 218     ipv6cp_down,                /* Called when fsm leaves OPENED state */
 219     NULL,                       /* Called when we want the lower layer up */
 220     ipv6cp_finished,            /* Called when we want the lower layer down */
 221     NULL,                       /* Called when Protocol-Reject received */
 222     NULL,                       /* Retransmission is necessary */
 223     NULL,                       /* Called to handle protocol-specific codes */
 224     "IPV6CP"                    /* String name of protocol */
 225 };
 226
 227 /*
 228  * Command-line options.
 229  */
 230 static int setifaceid __P((char **arg));
 231 static void printifaceid __P((option_t *,
 232                               void (*)(void *, char *, ...), void *));
 233
 234 static option_t ipv6cp_option_list[] = {
 235     { "ipv6", o_special, (void *)setifaceid,
 236       "Set interface identifiers for IPV6",
 237       OPT_A2PRINTER, (void *)printifaceid },
 238
 239     { "+ipv6", o_bool, &ipv6cp_protent.enabled_flag,
 240       "Enable IPv6 and IPv6CP", OPT_PRIO | 1 },
 241     { "noipv6", o_bool, &ipv6cp_protent.enabled_flag,
 242       "Disable IPv6 and IPv6CP", OPT_PRIOSUB },
 243     { "-ipv6", o_bool, &ipv6cp_protent.enabled_flag,
 244       "Disable IPv6 and IPv6CP", OPT_PRIOSUB | OPT_ALIAS },
 245
 246     { "ipv6cp-accept-local", o_bool, &ipv6cp_allowoptions[0].accept_local,
 247       "Accept peer's interface identifier for us", 1 },
 248
 249     { "defaultroute6", o_bool, &ipv6cp_wantoptions[0].default_route,
 250       "Add default IPv6 route", OPT_ENABLE|1, &ipv6cp_allowoptions[0].default_route },
 251     { "nodefaultroute6", o_bool, &ipv6cp_allowoptions[0].default_route,
 252       "disable defaultroute6 option", OPT_A2CLR,
 253       &ipv6cp_wantoptions[0].default_route },
 254     { "-defaultroute6", o_bool, &ipv6cp_allowoptions[0].default_route,
 255       "disable defaultroute6 option", OPT_ALIAS | OPT_A2CLR,
 256       &ipv6cp_wantoptions[0].default_route },
 257
 258     { "ipv6cp-use-ipaddr", o_bool, &ipv6cp_allowoptions[0].use_ip,
 259       "Use (default) IPv4 address as interface identifier", 1 },
 260
 261     { "ipv6cp-use-persistent", o_bool, &ipv6cp_wantoptions[0].use_persistent,
 262       "Use uniquely-available persistent value for link local address", 1 },
 263
 264     { "ipv6cp-restart", o_int, &ipv6cp_fsm[0].timeouttime,
 265       "Set timeout for IPv6CP", OPT_PRIO },
 266     { "ipv6cp-max-terminate", o_int, &ipv6cp_fsm[0].maxtermtransmits,
 267       "Set max #xmits for term-reqs", OPT_PRIO },
 268     { "ipv6cp-max-configure", o_int, &ipv6cp_fsm[0].maxconfreqtransmits,
 269       "Set max #xmits for conf-reqs", OPT_PRIO },
 270     { "ipv6cp-max-failure", o_int, &ipv6cp_fsm[0].maxnakloops,
 271       "Set max #conf-naks for IPv6CP", OPT_PRIO },
 272
 273    { NULL }
 274 };
 275
 276
 277 /*
 278  * Protocol entry points from main code.
 279  */
 280 static void ipv6cp_init __P((int));
 281 static void ipv6cp_open __P((int));
 282 static void ipv6cp_close __P((int, char *));
 283 static void ipv6cp_lowerup __P((int));
 284 static void ipv6cp_lowerdown __P((int));
 285 static void ipv6cp_input __P((int, u_char *, int));
 286 static void ipv6cp_protrej __P((int));
 287 static int  ipv6cp_printpkt __P((u_char *, int,
 288                                void (*) __P((void *, char *, ...)), void *));
 289 static void ipv6_check_options __P((void));
 290 static int  ipv6_demand_conf __P((int));
 291 static int  ipv6_active_pkt __P((u_char *, int));
 292
 293 struct protent ipv6cp_protent = {
 294     PPP_IPV6CP,
 295     ipv6cp_init,
 296     ipv6cp_input,
 297     ipv6cp_protrej,
 298     ipv6cp_lowerup,
 299     ipv6cp_lowerdown,
 300     ipv6cp_open,
 301     ipv6cp_close,
 302     ipv6cp_printpkt,
 303     NULL,
 304     0,
 305     "IPV6CP",
 306     "IPV6",
 307     ipv6cp_option_list,
 308     ipv6_check_options,
 309     ipv6_demand_conf,
 310     ipv6_active_pkt
 311 };
 312
 313 static void ipv6cp_clear_addrs __P((int, eui64_t, eui64_t));
 314 static void ipv6cp_script __P((char *));
 315 static void ipv6cp_script_done __P((void *));
 316
 317 /*
 318  * Lengths of configuration options.
 319  */
 320 #define CILEN_VOID      2
 321 #define CILEN_COMPRESS  4       /* length for RFC2023 compress opt. */
 322 #define CILEN_IFACEID   10      /* RFC2472, interface identifier    */
 323
 324 #define CODENAME(x)     ((x) == CONFACK ? "ACK" : \
 325                          (x) == CONFNAK ? "NAK" : "REJ")
 326
 327 /*
 328  * This state variable is used to ensure that we don't
 329  * run an ipcp-up/down script while one is already running.
 330  */
 331 static enum script_state {
 332     s_down,
 333     s_up,
 334 } ipv6cp_script_state;
 335 static pid_t ipv6cp_script_pid;
 336
 337 /*
 338  * setifaceid - set the interface identifiers manually
 339  */
 340 static int
 341 setifaceid(argv)
 342     char **argv;
 343 {
 344     char *comma, *arg, c;
 345     ipv6cp_options *wo = &ipv6cp_wantoptions[0];
 346     struct in6_addr addr;
 347     static int prio_local, prio_remote;
 348
 349 #define VALIDID(a) ( (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0)) && \
 350                         (((a).s6_addr32[2] != 0) || ((a).s6_addr32[3] != 0)) )
 351
 352     arg = *argv;
 353     if ((comma = strchr(arg, ',')) == NULL)
 354         comma = arg + strlen(arg);
 355
 356     /*
 357      * If comma first character, then no local identifier
 358      */
 359     if (comma != arg) {
 360         c = *comma;
 361         *comma = '\0';
 362
 363         if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) {
 364             option_error("Illegal interface identifier (local): %s", arg);
 365             return 0;
 366         }
 367
 368         if (option_priority >= prio_local) {
 369             eui64_copy(addr.s6_addr32[2], wo->ourid);
 370             wo->opt_local = 1;
 371             prio_local = option_priority;
 372         }
 373         *comma = c;
 374     }
 375
 376     /*
 377      * If comma last character, the no remote identifier
 378      */
 379     if (*comma != 0 && *++comma != '\0') {
 380         if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) {
 381             option_error("Illegal interface identifier (remote): %s", comma);
 382             return 0;
 383         }
 384         if (option_priority >= prio_remote) {
 385             eui64_copy(addr.s6_addr32[2], wo->hisid);
 386             wo->opt_remote = 1;
 387             prio_remote = option_priority;
 388         }
 389     }
 390
 391     if (override_value("+ipv6", option_priority, option_source))
 392         ipv6cp_protent.enabled_flag = 1;
 393     return 1;
 394 }
 395
 396 char *llv6_ntoa(eui64_t ifaceid);
 397
 398 static void
 399 printifaceid(opt, printer, arg)
 400     option_t *opt;
 401     void (*printer) __P((void *, char *, ...));
 402     void *arg;
 403 {
 404         ipv6cp_options *wo = &ipv6cp_wantoptions[0];
 405
 406         if (wo->opt_local)
 407                 printer(arg, "%s", llv6_ntoa(wo->ourid));
 408         printer(arg, ",");
 409         if (wo->opt_remote)
 410                 printer(arg, "%s", llv6_ntoa(wo->hisid));
 411 }
 412
 413 /*
 414  * Make a string representation of a network address.
 415  */
 416 char *
 417 llv6_ntoa(ifaceid)
 418     eui64_t ifaceid;
 419 {
 420     static char b[64];
 421
 422     sprintf(b, "fe80::%s", eui64_ntoa(ifaceid));
 423     return b;
 424 }
 425
 426
 427 /*
 428  * ipv6cp_init - Initialize IPV6CP.
 429  */
 430 static void
 431 ipv6cp_init(unit)
 432     int unit;
 433 {
 434     fsm *f = &ipv6cp_fsm[unit];
 435     ipv6cp_options *wo = &ipv6cp_wantoptions[unit];
 436     ipv6cp_options *ao = &ipv6cp_allowoptions[unit];
 437
 438     f->unit = unit;
 439     f->protocol = PPP_IPV6CP;
 440     f->callbacks = &ipv6cp_callbacks;
 441     fsm_init(&ipv6cp_fsm[unit]);
 442
 443     memset(wo, 0, sizeof(*wo));
 444     memset(ao, 0, sizeof(*ao));
 445
 446     wo->accept_local = 1;
 447     wo->neg_ifaceid = 1;
 448     ao->neg_ifaceid = 1;
 449
 450 #ifdef IPV6CP_COMP
 451     wo->neg_vj = 1;
 452     ao->neg_vj = 1;
 453     wo->vj_protocol = IPV6CP_COMP;
 454 #endif
 455
 456     /*
 457      * XXX This controls whether the user may use the defaultroute option.
 458      */
 459     ao->default_route = 1;
 460 }
 461
 462
 463 /*
 464  * ipv6cp_open - IPV6CP is allowed to come up.
 465  */
 466 static void
 467 ipv6cp_open(unit)
 468     int unit;
 469 {
 470     fsm_open(&ipv6cp_fsm[unit]);
 471 }
 472
 473
 474 /*
 475  * ipv6cp_close - Take IPV6CP down.
 476  */
 477 static void
 478 ipv6cp_close(unit, reason)
 479     int unit;
 480     char *reason;
 481 {
 482     fsm_close(&ipv6cp_fsm[unit], reason);
 483 }
 484
 485
 486 /*
 487  * ipv6cp_lowerup - The lower layer is up.
 488  */
 489 static void
 490 ipv6cp_lowerup(unit)
 491     int unit;
 492 {
 493     fsm_lowerup(&ipv6cp_fsm[unit]);
 494 }
 495
 496
 497 /*
 498  * ipv6cp_lowerdown - The lower layer is down.
 499  */
 500 static void
 501 ipv6cp_lowerdown(unit)
 502     int unit;
 503 {
 504     fsm_lowerdown(&ipv6cp_fsm[unit]);
 505 }
 506
 507
 508 /*
 509  * ipv6cp_input - Input IPV6CP packet.
 510  */
 511 static void
 512 ipv6cp_input(unit, p, len)
 513     int unit;
 514     u_char *p;
 515     int len;
 516 {
 517     fsm_input(&ipv6cp_fsm[unit], p, len);
 518 }
 519
 520
 521 /*
 522  * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP.
 523  *
 524  * Pretend the lower layer went down, so we shut up.
 525  */
 526 static void
 527 ipv6cp_protrej(unit)
 528     int unit;
 529 {
 530     fsm_lowerdown(&ipv6cp_fsm[unit]);
 531 }
 532
 533
 534 /*
 535  * ipv6cp_resetci - Reset our CI.
 536  */
 537 static void
 538 ipv6cp_resetci(f)
 539     fsm *f;
 540 {
 541     ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
 542     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 543
 544     wo->req_ifaceid = wo->neg_ifaceid && ipv6cp_allowoptions[f->unit].neg_ifaceid;
 545
 546     if (!wo->opt_local) {
 547         eui64_magic_nz(wo->ourid);
 548     }
 549
 550     *go = *wo;
 551     eui64_zero(go->hisid);      /* last proposed interface identifier */
 552 }
 553
 554
 555 /*
 556  * ipv6cp_cilen - Return length of our CI.
 557  */
 558 static int
 559 ipv6cp_cilen(f)
 560     fsm *f;
 561 {
 562     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 563
 564 #define LENCIVJ(neg)            (neg ? CILEN_COMPRESS : 0)
 565 #define LENCIIFACEID(neg)       (neg ? CILEN_IFACEID : 0)
 566
 567     return (LENCIIFACEID(go->neg_ifaceid) +
 568             LENCIVJ(go->neg_vj));
 569 }
 570
 571
 572 /*
 573  * ipv6cp_addci - Add our desired CIs to a packet.
 574  */
 575 static void
 576 ipv6cp_addci(f, ucp, lenp)
 577     fsm *f;
 578     u_char *ucp;
 579     int *lenp;
 580 {
 581     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 582     int len = *lenp;
 583
 584 #define ADDCIVJ(opt, neg, val) \
 585     if (neg) { \
 586         int vjlen = CILEN_COMPRESS; \
 587         if (len >= vjlen) { \
 588             PUTCHAR(opt, ucp); \
 589             PUTCHAR(vjlen, ucp); \
 590             PUTSHORT(val, ucp); \
 591             len -= vjlen; \
 592         } else \
 593             neg = 0; \
 594     }
 595
 596 #define ADDCIIFACEID(opt, neg, val1) \
 597     if (neg) { \
 598         int idlen = CILEN_IFACEID; \
 599         if (len >= idlen) { \
 600             PUTCHAR(opt, ucp); \
 601             PUTCHAR(idlen, ucp); \
 602             eui64_put(val1, ucp); \
 603             len -= idlen; \
 604         } else \
 605             neg = 0; \
 606     }
 607
 608     ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
 609
 610     ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
 611
 612     *lenp -= len;
 613 }
 614
 615
 616 /*
 617  * ipv6cp_ackci - Ack our CIs.
 618  *
 619  * Returns:
 620  *      0 - Ack was bad.
 621  *      1 - Ack was good.
 622  */
 623 static int
 624 ipv6cp_ackci(f, p, len)
 625     fsm *f;
 626     u_char *p;
 627     int len;
 628 {
 629     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 630     u_short cilen, citype, cishort;
 631     eui64_t ifaceid;
 632
 633     /*
 634      * CIs must be in exactly the same order that we sent...
 635      * Check packet length and CI length at each step.
 636      * If we find any deviations, then this packet is bad.
 637      */
 638
 639 #define ACKCIVJ(opt, neg, val) \
 640     if (neg) { \
 641         int vjlen = CILEN_COMPRESS; \
 642         if ((len -= vjlen) < 0) \
 643             goto bad; \
 644         GETCHAR(citype, p); \
 645         GETCHAR(cilen, p); \
 646         if (cilen != vjlen || \
 647             citype != opt)  \
 648             goto bad; \
 649         GETSHORT(cishort, p); \
 650         if (cishort != val) \
 651             goto bad; \
 652     }
 653
 654 #define ACKCIIFACEID(opt, neg, val1) \
 655     if (neg) { \
 656         int idlen = CILEN_IFACEID; \
 657         if ((len -= idlen) < 0) \
 658             goto bad; \
 659         GETCHAR(citype, p); \
 660         GETCHAR(cilen, p); \
 661         if (cilen != idlen || \
 662             citype != opt) \
 663             goto bad; \
 664         eui64_get(ifaceid, p); \
 665         if (! eui64_equals(val1, ifaceid)) \
 666             goto bad; \
 667     }
 668
 669     ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
 670
 671     ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
 672
 673     /*
 674      * If there are any remaining CIs, then this packet is bad.
 675      */
 676     if (len != 0)
 677         goto bad;
 678     return (1);
 679
 680 bad:
 681     IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!"));
 682     return (0);
 683 }
 684
 685 /*
 686  * ipv6cp_nakci - Peer has sent a NAK for some of our CIs.
 687  * This should not modify any state if the Nak is bad
 688  * or if IPV6CP is in the OPENED state.
 689  *
 690  * Returns:
 691  *      0 - Nak was bad.
 692  *      1 - Nak was good.
 693  */
 694 static int
 695 ipv6cp_nakci(f, p, len, treat_as_reject)
 696     fsm *f;
 697     u_char *p;
 698     int len;
 699     int treat_as_reject;
 700 {
 701     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 702     u_char citype, cilen, *next;
 703     u_short cishort;
 704     eui64_t ifaceid;
 705     ipv6cp_options no;          /* options we've seen Naks for */
 706     ipv6cp_options try;         /* options to request next time */
 707
 708     BZERO(&no, sizeof(no));
 709     try = *go;
 710
 711     /*
 712      * Any Nak'd CIs must be in exactly the same order that we sent.
 713      * Check packet length and CI length at each step.
 714      * If we find any deviations, then this packet is bad.
 715      */
 716 #define NAKCIIFACEID(opt, neg, code) \
 717     if (go->neg && \
 718         len >= (cilen = CILEN_IFACEID) && \
 719         p[1] == cilen && \
 720         p[0] == opt) { \
 721         len -= cilen; \
 722         INCPTR(2, p); \
 723         eui64_get(ifaceid, p); \
 724         no.neg = 1; \
 725         code \
 726     }
 727
 728 #define NAKCIVJ(opt, neg, code) \
 729     if (go->neg && \
 730         ((cilen = p[1]) == CILEN_COMPRESS) && \
 731         len >= cilen && \
 732         p[0] == opt) { \
 733         len -= cilen; \
 734         INCPTR(2, p); \
 735         GETSHORT(cishort, p); \
 736         no.neg = 1; \
 737         code \
 738     }
 739
 740     /*
 741      * Accept the peer's idea of {our,his} interface identifier, if different
 742      * from our idea, only if the accept_{local,remote} flag is set.
 743      */
 744     NAKCIIFACEID(CI_IFACEID, neg_ifaceid,
 745                  if (treat_as_reject) {
 746                      try.neg_ifaceid = 0;
 747                  } else if (go->accept_local) {
 748                      while (eui64_iszero(ifaceid) ||
 749                             eui64_equals(ifaceid, go->hisid)) /* bad luck */
 750                          eui64_magic(ifaceid);
 751                      try.ourid = ifaceid;
 752                      IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid)));
 753                  }
 754                  );
 755
 756 #ifdef IPV6CP_COMP
 757     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
 758             {
 759                 if (cishort == IPV6CP_COMP && !treat_as_reject) {
 760                     try.vj_protocol = cishort;
 761                 } else {
 762                     try.neg_vj = 0;
 763                 }
 764             }
 765             );
 766 #else
 767     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
 768             {
 769                 try.neg_vj = 0;
 770             }
 771             );
 772 #endif
 773
 774     /*
 775      * There may be remaining CIs, if the peer is requesting negotiation
 776      * on an option that we didn't include in our request packet.
 777      * If they want to negotiate about interface identifier, we comply.
 778      * If they want us to ask for compression, we refuse.
 779      */
 780     while (len >= CILEN_VOID) {
 781         GETCHAR(citype, p);
 782         GETCHAR(cilen, p);
 783         if ( cilen < CILEN_VOID || (len -= cilen) < 0 )
 784             goto bad;
 785         next = p + cilen - 2;
 786
 787         switch (citype) {
 788         case CI_COMPRESSTYPE:
 789             if (go->neg_vj || no.neg_vj ||
 790                 (cilen != CILEN_COMPRESS))
 791                 goto bad;
 792             no.neg_vj = 1;
 793             break;
 794         case CI_IFACEID:
 795             if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID)
 796                 goto bad;
 797             try.neg_ifaceid = 1;
 798             eui64_get(ifaceid, p);
 799             if (go->accept_local) {
 800                 while (eui64_iszero(ifaceid) ||
 801                        eui64_equals(ifaceid, go->hisid)) /* bad luck */
 802                     eui64_magic(ifaceid);
 803                 try.ourid = ifaceid;
 804             }
 805             no.neg_ifaceid = 1;
 806             break;
 807         }
 808         p = next;
 809     }
 810
 811     /* If there is still anything left, this packet is bad. */
 812     if (len != 0)
 813         goto bad;
 814
 815     /*
 816      * OK, the Nak is good.  Now we can update state.
 817      */
 818     if (f->state != OPENED)
 819         *go = try;
 820
 821     return 1;
 822
 823 bad:
 824     IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!"));
 825     return 0;
 826 }
 827
 828
 829 /*
 830  * ipv6cp_rejci - Reject some of our CIs.
 831  */
 832 static int
 833 ipv6cp_rejci(f, p, len)
 834     fsm *f;
 835     u_char *p;
 836     int len;
 837 {
 838     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 839     u_char cilen;
 840     u_short cishort;
 841     eui64_t ifaceid;
 842     ipv6cp_options try;         /* options to request next time */
 843
 844     try = *go;
 845     /*
 846      * Any Rejected CIs must be in exactly the same order that we sent.
 847      * Check packet length and CI length at each step.
 848      * If we find any deviations, then this packet is bad.
 849      */
 850 #define REJCIIFACEID(opt, neg, val1) \
 851     if (go->neg && \
 852         len >= (cilen = CILEN_IFACEID) && \
 853         p[1] == cilen && \
 854         p[0] == opt) { \
 855         len -= cilen; \
 856         INCPTR(2, p); \
 857         eui64_get(ifaceid, p); \
 858         /* Check rejected value. */ \
 859         if (! eui64_equals(ifaceid, val1)) \
 860             goto bad; \
 861         try.neg = 0; \
 862     }
 863
 864 #define REJCIVJ(opt, neg, val) \
 865     if (go->neg && \
 866         p[1] == CILEN_COMPRESS && \
 867         len >= p[1] && \
 868         p[0] == opt) { \
 869         len -= p[1]; \
 870         INCPTR(2, p); \
 871         GETSHORT(cishort, p); \
 872         /* Check rejected value. */  \
 873         if (cishort != val) \
 874             goto bad; \
 875         try.neg = 0; \
 876      }
 877
 878     REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid);
 879
 880     REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol);
 881
 882     /*
 883      * If there are any remaining CIs, then this packet is bad.
 884      */
 885     if (len != 0)
 886         goto bad;
 887     /*
 888      * Now we can update state.
 889      */
 890     if (f->state != OPENED)
 891         *go = try;
 892     return 1;
 893
 894 bad:
 895     IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!"));
 896     return 0;
 897 }
 898
 899
 900 /*
 901  * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response.
 902  *
 903  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
 904  * appropriately.  If reject_if_disagree is non-zero, doesn't return
 905  * CONFNAK; returns CONFREJ if it can't return CONFACK.
 906  */
 907 static int
 908 ipv6cp_reqci(f, inp, len, reject_if_disagree)
 909     fsm *f;
 910     u_char *inp;                /* Requested CIs */
 911     int *len;                   /* Length of requested CIs */
 912     int reject_if_disagree;
 913 {
 914     ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
 915     ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
 916     ipv6cp_options *ao = &ipv6cp_allowoptions[f->unit];
 917     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 918     u_char *cip, *next;         /* Pointer to current and next CIs */
 919     u_short cilen, citype;      /* Parsed len, type */
 920     u_short cishort;            /* Parsed short value */
 921     eui64_t ifaceid;            /* Parsed interface identifier */
 922     int rc = CONFACK;           /* Final packet return code */
 923     int orc;                    /* Individual option return code */
 924     u_char *p;                  /* Pointer to next char to parse */
 925     u_char *ucp = inp;          /* Pointer to current output char */
 926     int l = *len;               /* Length left */
 927
 928     /*
 929      * Reset all his options.
 930      */
 931     BZERO(ho, sizeof(*ho));
 932
 933     /*
 934      * Process all his options.
 935      */
 936     next = inp;
 937     while (l) {
 938         orc = CONFACK;                  /* Assume success */
 939         cip = p = next;                 /* Remember begining of CI */
 940         if (l < 2 ||                    /* Not enough data for CI header or */
 941             p[1] < 2 ||                 /*  CI length too small or */
 942             p[1] > l) {                 /*  CI length too big? */
 943             IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!"));
 944             orc = CONFREJ;              /* Reject bad CI */
 945             cilen = l;                  /* Reject till end of packet */
 946             l = 0;                      /* Don't loop again */
 947             goto endswitch;
 948         }
 949         GETCHAR(citype, p);             /* Parse CI type */
 950         GETCHAR(cilen, p);              /* Parse CI length */
 951         l -= cilen;                     /* Adjust remaining length */
 952         next += cilen;                  /* Step to next CI */
 953
 954         switch (citype) {               /* Check CI type */
 955         case CI_IFACEID:
 956             IPV6CPDEBUG(("ipv6cp: received interface identifier "));
 957
 958             if (!ao->neg_ifaceid ||
 959                 cilen != CILEN_IFACEID) {       /* Check CI length */
 960                 orc = CONFREJ;          /* Reject CI */
 961                 break;
 962             }
 963
 964             /*
 965              * If he has no interface identifier, or if we both have same
 966              * identifier then NAK it with new idea.
 967              * In particular, if we don't know his identifier, but he does,
 968              * then accept it.
 969              */
 970             eui64_get(ifaceid, p);
 971             IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid)));
 972             if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) {
 973                 orc = CONFREJ;          /* Reject CI */
 974                 break;
 975             }
 976             if (!eui64_iszero(wo->hisid) &&
 977                 !eui64_equals(ifaceid, wo->hisid) &&
 978                 eui64_iszero(go->hisid)) {
 979
 980                 orc = CONFNAK;
 981                 ifaceid = wo->hisid;
 982                 go->hisid = ifaceid;
 983                 DECPTR(sizeof(ifaceid), p);
 984                 eui64_put(ifaceid, p);
 985             } else
 986             if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) {
 987                 orc = CONFNAK;
 988                 if (eui64_iszero(go->hisid))    /* first time, try option */
 989                     ifaceid = wo->hisid;
 990                 while (eui64_iszero(ifaceid) ||
 991                        eui64_equals(ifaceid, go->ourid)) /* bad luck */
 992                     eui64_magic(ifaceid);
 993                 go->hisid = ifaceid;
 994                 DECPTR(sizeof(ifaceid), p);
 995                 eui64_put(ifaceid, p);
 996             }
 997
 998             ho->neg_ifaceid = 1;
 999             ho->hisid = ifaceid;
1000             break;
1001
1002         case CI_COMPRESSTYPE:
1003             IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE "));
1004             if (!ao->neg_vj ||
1005                 (cilen != CILEN_COMPRESS)) {
1006                 orc = CONFREJ;
1007                 break;
1008             }
1009             GETSHORT(cishort, p);
1010             IPV6CPDEBUG(("(%d)", cishort));
1011
1012 #ifdef IPV6CP_COMP
1013             if (!(cishort == IPV6CP_COMP)) {
1014                 orc = CONFREJ;
1015                 break;
1016             }
1017
1018             ho->neg_vj = 1;
1019             ho->vj_protocol = cishort;
1020             break;
1021 #else
1022             orc = CONFREJ;
1023             break;
1024 #endif
1025
1026         default:
1027             orc = CONFREJ;
1028             break;
1029         }
1030
1031 endswitch:
1032         IPV6CPDEBUG((" (%s)\n", CODENAME(orc)));
1033
1034         if (orc == CONFACK &&           /* Good CI */
1035             rc != CONFACK)              /*  but prior CI wasnt? */
1036             continue;                   /* Don't send this one */
1037
1038         if (orc == CONFNAK) {           /* Nak this CI? */
1039             if (reject_if_disagree)     /* Getting fed up with sending NAKs? */
1040                 orc = CONFREJ;          /* Get tough if so */
1041             else {
1042                 if (rc == CONFREJ)      /* Rejecting prior CI? */
1043                     continue;           /* Don't send this one */
1044                 if (rc == CONFACK) {    /* Ack'd all prior CIs? */
1045                     rc = CONFNAK;       /* Not anymore... */
1046                     ucp = inp;          /* Backup */
1047                 }
1048             }
1049         }
1050
1051         if (orc == CONFREJ &&           /* Reject this CI */
1052             rc != CONFREJ) {            /*  but no prior ones? */
1053             rc = CONFREJ;
1054             ucp = inp;                  /* Backup */
1055         }
1056
1057         /* Need to move CI? */
1058         if (ucp != cip)
1059             BCOPY(cip, ucp, cilen);     /* Move it */
1060
1061         /* Update output pointer */
1062         INCPTR(cilen, ucp);
1063     }
1064
1065     /*
1066      * If we aren't rejecting this packet, and we want to negotiate
1067      * their identifier and they didn't send their identifier, then we
1068      * send a NAK with a CI_IFACEID option appended.  We assume the
1069      * input buffer is long enough that we can append the extra
1070      * option safely.
1071      */
1072     if (rc != CONFREJ && !ho->neg_ifaceid &&
1073         wo->req_ifaceid && !reject_if_disagree) {
1074         if (rc == CONFACK) {
1075             rc = CONFNAK;
1076             ucp = inp;                          /* reset pointer */
1077             wo->req_ifaceid = 0;                /* don't ask again */
1078         }
1079         PUTCHAR(CI_IFACEID, ucp);
1080         PUTCHAR(CILEN_IFACEID, ucp);
1081         eui64_put(wo->hisid, ucp);
1082     }
1083
1084     *len = ucp - inp;                   /* Compute output length */
1085     IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc)));
1086     return (rc);                        /* Return final code */
1087 }
1088
1089
1090 /*
1091  * ipv6_check_options - check that any IP-related options are OK,
1092  * and assign appropriate defaults.
1093  */
1094 static void
1095 ipv6_check_options()
1096 {
1097     ipv6cp_options *wo = &ipv6cp_wantoptions[0];
1098
1099     if (!ipv6cp_protent.enabled_flag)
1100         return;
1101
1102     /*
1103      * Persistent link-local id is only used when user has not explicitly
1104      * configure/hard-code the id
1105      */
1106     if ((wo->use_persistent) && (!wo->opt_local) && (!wo->opt_remote)) {
1107
1108         /*
1109          * On systems where there are no Ethernet interfaces used, there
1110          * may be other ways to obtain a persistent id. Right now, it
1111          * will fall back to using magic [see eui64_magic] below when
1112          * an EUI-48 from MAC address can't be obtained. Other possibilities
1113          * include obtaining EEPROM serial numbers, or some other unique
1114          * yet persistent number. On Sparc platforms, this is possible,
1115          * but too bad there's no standards yet for x86 machines.
1116          */
1117         if (ether_to_eui64(&wo->ourid)) {
1118             wo->opt_local = 1;
1119         }
1120     }
1121
1122     if (!wo->opt_local) {       /* init interface identifier */
1123         if (wo->use_ip && eui64_iszero(wo->ourid)) {
1124             eui64_setlo32(wo->ourid, ntohl(ipcp_wantoptions[0].ouraddr));
1125             if (!eui64_iszero(wo->ourid))
1126                 wo->opt_local = 1;
1127         }
1128
1129         while (eui64_iszero(wo->ourid))
1130             eui64_magic(wo->ourid);
1131     }
1132
1133     if (!wo->opt_remote) {
1134         if (wo->use_ip && eui64_iszero(wo->hisid)) {
1135             eui64_setlo32(wo->hisid, ntohl(ipcp_wantoptions[0].hisaddr));
1136             if (!eui64_iszero(wo->hisid))
1137                 wo->opt_remote = 1;
1138         }
1139     }
1140
1141     if (demand && (eui64_iszero(wo->ourid) || eui64_iszero(wo->hisid))) {
1142         option_error("local/remote LL address required for demand-dialling\n");
1143         exit(EXIT_OPTION_ERROR);
1144     }
1145 }
1146
1147
1148 /*
1149  * ipv6_demand_conf - configure the interface as though
1150  * IPV6CP were up, for use with dial-on-demand.
1151  */
1152 static int
1153 ipv6_demand_conf(u)
1154     int u;
1155 {
1156     ipv6cp_options *wo = &ipv6cp_wantoptions[u];
1157
1158     if (!sif6up(u))
1159         return 0;
1160     if (!sif6addr(u, wo->ourid, wo->hisid))
1161         return 0;
1162 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1163     if (!sifup(u))
1164         return 0;
1165 #endif
1166     if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE))
1167         return 0;
1168     if (wo->default_route)
1169         if (sif6defaultroute(u, wo->ourid, wo->hisid))
1170             default_route_set[u] = 1;
1171
1172     notice("ipv6_demand_conf");
1173     notice("local  LL address %s", llv6_ntoa(wo->ourid));
1174     notice("remote LL address %s", llv6_ntoa(wo->hisid));
1175
1176     return 1;
1177 }
1178
1179
1180 /*
1181  * ipv6cp_up - IPV6CP has come UP.
1182  *
1183  * Configure the IPv6 network interface appropriately and bring it up.
1184  */
1185 static void
1186 ipv6cp_up(f)
1187     fsm *f;
1188 {
1189     ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
1190     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
1191     ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
1192
1193     IPV6CPDEBUG(("ipv6cp: up"));
1194
1195     /*
1196      * We must have a non-zero LL address for both ends of the link.
1197      */
1198     if (!ho->neg_ifaceid)
1199         ho->hisid = wo->hisid;
1200
1201     if(!no_ifaceid_neg) {
1202         if (eui64_iszero(ho->hisid)) {
1203             error("Could not determine remote LL address");
1204             ipv6cp_close(f->unit, "Could not determine remote LL address");
1205             return;
1206         }
1207         if (eui64_iszero(go->ourid)) {
1208             error("Could not determine local LL address");
1209             ipv6cp_close(f->unit, "Could not determine local LL address");
1210             return;
1211         }
1212         if (eui64_equals(go->ourid, ho->hisid)) {
1213             error("local and remote LL addresses are equal");
1214             ipv6cp_close(f->unit, "local and remote LL addresses are equal");
1215             return;
1216         }
1217     }
1218     script_setenv("LLLOCAL", llv6_ntoa(go->ourid), 0);
1219     script_setenv("LLREMOTE", llv6_ntoa(ho->hisid), 0);
1220
1221 #ifdef IPV6CP_COMP
1222     /* set tcp compression */
1223     sif6comp(f->unit, ho->neg_vj);
1224 #endif
1225
1226     /*
1227      * If we are doing dial-on-demand, the interface is already
1228      * configured, so we put out any saved-up packets, then set the
1229      * interface to pass IPv6 packets.
1230      */
1231     if (demand) {
1232         if (! eui64_equals(go->ourid, wo->ourid) ||
1233             ! eui64_equals(ho->hisid, wo->hisid)) {
1234             if (! eui64_equals(go->ourid, wo->ourid))
1235                 warn("Local LL address changed to %s",
1236                      llv6_ntoa(go->ourid));
1237             if (! eui64_equals(ho->hisid, wo->hisid))
1238                 warn("Remote LL address changed to %s",
1239                      llv6_ntoa(ho->hisid));
1240             ipv6cp_clear_addrs(f->unit, go->ourid, ho->hisid);
1241
1242             /* Set the interface to the new addresses */
1243             if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1244                 if (debug)
1245                     warn("sif6addr failed");
1246                 ipv6cp_close(f->unit, "Interface configuration failed");
1247                 return;
1248             }
1249
1250             /* assign a default route through the interface if required */
1251             if (ipv6cp_wantoptions[f->unit].default_route)
1252                 if (sif6defaultroute(f->unit, go->ourid, ho->hisid))
1253                     default_route_set[f->unit] = 1;
1254         }
1255         demand_rexmit(PPP_IPV6);
1256         sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1257
1258     } else {
1259         /* bring the interface up for IPv6 */
1260         if (!sif6up(f->unit)) {
1261             if (debug)
1262                 warn("sif6up failed (IPV6)");
1263             ipv6cp_close(f->unit, "Interface configuration failed");
1264             return;
1265         }
1266
1267         if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1268             if (debug)
1269                 warn("sif6addr failed");
1270             ipv6cp_close(f->unit, "Interface configuration failed");
1271             return;
1272         }
1273         sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1274
1275         /* assign a default route through the interface if required */
1276         if (ipv6cp_wantoptions[f->unit].default_route)
1277             if (sif6defaultroute(f->unit, go->ourid, ho->hisid))
1278                 default_route_set[f->unit] = 1;
1279
1280         notice("local  LL address %s", llv6_ntoa(go->ourid));
1281         notice("remote LL address %s", llv6_ntoa(ho->hisid));
1282     }
1283
1284     np_up(f->unit, PPP_IPV6);
1285     ipv6cp_is_up = 1;
1286
1287     notify(ipv6_up_notifier, 0);
1288     if (ipv6_up_hook)
1289        ipv6_up_hook();
1290
1291     /*
1292      * Execute the ipv6-up script, like this:
1293      *  /etc/ppp/ipv6-up interface tty speed local-LL remote-LL
1294      */
1295     if (ipv6cp_script_state == s_down && ipv6cp_script_pid == 0) {
1296         ipv6cp_script_state = s_up;
1297         ipv6cp_script(_PATH_IPV6UP);
1298     }
1299 }
1300
1301
1302 /*
1303  * ipv6cp_down - IPV6CP has gone DOWN.
1304  *
1305  * Take the IPv6 network interface down, clear its addresses
1306  * and delete routes through it.
1307  */
1308 static void
1309 ipv6cp_down(f)
1310     fsm *f;
1311 {
1312     IPV6CPDEBUG(("ipv6cp: down"));
1313     update_link_stats(f->unit);
1314     notify(ipv6_down_notifier, 0);
1315     if (ipv6_down_hook)
1316        ipv6_down_hook();
1317     if (ipv6cp_is_up) {
1318         ipv6cp_is_up = 0;
1319         np_down(f->unit, PPP_IPV6);
1320     }
1321 #ifdef IPV6CP_COMP
1322     sif6comp(f->unit, 0);
1323 #endif
1324
1325     /*
1326      * If we are doing dial-on-demand, set the interface
1327      * to queue up outgoing packets (for now).
1328      */
1329     if (demand) {
1330         sifnpmode(f->unit, PPP_IPV6, NPMODE_QUEUE);
1331     } else {
1332         sifnpmode(f->unit, PPP_IPV6, NPMODE_DROP);
1333 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC)))
1334         sif6down(f->unit);
1335 #endif
1336         ipv6cp_clear_addrs(f->unit,
1337                            ipv6cp_gotoptions[f->unit].ourid,
1338                            ipv6cp_hisoptions[f->unit].hisid);
1339 #if defined(__linux__)
1340         sif6down(f->unit);
1341 #elif defined(SVR4) && (defined(SNI) || defined(__USLC))
1342         sifdown(f->unit);
1343 #endif
1344     }
1345
1346     /* Execute the ipv6-down script */
1347     if (ipv6cp_script_state == s_up && ipv6cp_script_pid == 0) {
1348         ipv6cp_script_state = s_down;
1349         ipv6cp_script(_PATH_IPV6DOWN);
1350     }
1351 }
1352
1353
1354 /*
1355  * ipv6cp_clear_addrs() - clear the interface addresses, routes,
1356  * proxy neighbour discovery entries, etc.
1357  */
1358 static void
1359 ipv6cp_clear_addrs(unit, ourid, hisid)
1360     int unit;
1361     eui64_t ourid;
1362     eui64_t hisid;
1363 {
1364     cif6addr(unit, ourid, hisid);
1365 }
1366
1367
1368 /*
1369  * ipv6cp_finished - possibly shut down the lower layers.
1370  */
1371 static void
1372 ipv6cp_finished(f)
1373     fsm *f;
1374 {
1375     np_finished(f->unit, PPP_IPV6);
1376 }
1377
1378
1379 /*
1380  * ipv6cp_script_done - called when the ipv6-up or ipv6-down script
1381  * has finished.
1382  */
1383 static void
1384 ipv6cp_script_done(arg)
1385     void *arg;
1386 {
1387     ipv6cp_script_pid = 0;
1388     switch (ipv6cp_script_state) {
1389     case s_up:
1390         if (ipv6cp_fsm[0].state != OPENED) {
1391             ipv6cp_script_state = s_down;
1392             ipv6cp_script(_PATH_IPV6DOWN);
1393         }
1394         break;
1395     case s_down:
1396         if (ipv6cp_fsm[0].state == OPENED) {
1397             ipv6cp_script_state = s_up;
1398             ipv6cp_script(_PATH_IPV6UP);
1399         }
1400         break;
1401     }
1402 }
1403
1404
1405 /*
1406  * ipv6cp_script - Execute a script with arguments
1407  * interface-name tty-name speed local-LL remote-LL.
1408  */
1409 static void
1410 ipv6cp_script(script)
1411     char *script;
1412 {
1413     char strspeed[32], strlocal[32], strremote[32];
1414     char *argv[8];
1415
1416     sprintf(strspeed, "%d", baud_rate);
1417     strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid));
1418     strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid));
1419
1420     argv[0] = script;
1421     argv[1] = ifname;
1422     argv[2] = devnam;
1423     argv[3] = strspeed;
1424     argv[4] = strlocal;
1425     argv[5] = strremote;
1426     argv[6] = ipparam;
1427     argv[7] = NULL;
1428
1429     ipv6cp_script_pid = run_program(script, argv, 0, ipv6cp_script_done,
1430                                     NULL, 0);
1431 }
1432
1433 /*
1434  * ipv6cp_printpkt - print the contents of an IPV6CP packet.
1435  */
1436 static char *ipv6cp_codenames[] = {
1437     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1438     "TermReq", "TermAck", "CodeRej"
1439 };
1440
1441 static int
1442 ipv6cp_printpkt(p, plen, printer, arg)
1443     u_char *p;
1444     int plen;
1445     void (*printer) __P((void *, char *, ...));
1446     void *arg;
1447 {
1448     int code, id, len, olen;
1449     u_char *pstart, *optend;
1450     u_short cishort;
1451     eui64_t ifaceid;
1452
1453     if (plen < HEADERLEN)
1454         return 0;
1455     pstart = p;
1456     GETCHAR(code, p);
1457     GETCHAR(id, p);
1458     GETSHORT(len, p);
1459     if (len < HEADERLEN || len > plen)
1460         return 0;
1461
1462     if (code >= 1 && code <= sizeof(ipv6cp_codenames) / sizeof(char *))
1463         printer(arg, " %s", ipv6cp_codenames[code-1]);
1464     else
1465         printer(arg, " code=0x%x", code);
1466     printer(arg, " id=0x%x", id);
1467     len -= HEADERLEN;
1468     switch (code) {
1469     case CONFREQ:
1470     case CONFACK:
1471     case CONFNAK:
1472     case CONFREJ:
1473         /* print option list */
1474         while (len >= 2) {
1475             GETCHAR(code, p);
1476             GETCHAR(olen, p);
1477             p -= 2;
1478             if (olen < 2 || olen > len) {
1479                 break;
1480             }
1481             printer(arg, " <");
1482             len -= olen;
1483             optend = p + olen;
1484             switch (code) {
1485             case CI_COMPRESSTYPE:
1486                 if (olen >= CILEN_COMPRESS) {
1487                     p += 2;
1488                     GETSHORT(cishort, p);
1489                     printer(arg, "compress ");
1490                     printer(arg, "0x%x", cishort);
1491                 }
1492                 break;
1493             case CI_IFACEID:
1494                 if (olen == CILEN_IFACEID) {
1495                     p += 2;
1496                     eui64_get(ifaceid, p);
1497                     printer(arg, "addr %s", llv6_ntoa(ifaceid));
1498                 }
1499                 break;
1500             }
1501             while (p < optend) {
1502                 GETCHAR(code, p);
1503                 printer(arg, " %.2x", code);
1504             }
1505             printer(arg, ">");
1506         }
1507         break;
1508
1509     case TERMACK:
1510     case TERMREQ:
1511         if (len > 0 && *p >= ' ' && *p < 0x7f) {
1512             printer(arg, " ");
1513             print_string((char *)p, len, printer, arg);
1514             p += len;
1515             len = 0;
1516         }
1517         break;
1518     }
1519
1520     /* print the rest of the bytes in the packet */
1521     for (; len > 0; --len) {
1522         GETCHAR(code, p);
1523         printer(arg, " %.2x", code);
1524     }
1525
1526     return p - pstart;
1527 }
1528
1529 /*
1530  * ipv6_active_pkt - see if this IP packet is worth bringing the link up for.
1531  * We don't bring the link up for IP fragments or for TCP FIN packets
1532  * with no data.
1533  */
1534 #define IP6_HDRLEN      40      /* bytes */
1535 #define IP6_NHDR_FRAG   44      /* fragment IPv6 header */
1536 #define TCP_HDRLEN      20
1537 #define TH_FIN          0x01
1538
1539 /*
1540  * We use these macros because the IP header may be at an odd address,
1541  * and some compilers might use word loads to get th_off or ip_hl.
1542  */
1543
1544 #define get_ip6nh(x)    (((unsigned char *)(x))[6])
1545 #define get_tcpoff(x)   (((unsigned char *)(x))[12] >> 4)
1546 #define get_tcpflags(x) (((unsigned char *)(x))[13])
1547
1548 static int
1549 ipv6_active_pkt(pkt, len)
1550     u_char *pkt;
1551     int len;
1552 {
1553     u_char *tcp;
1554
1555     len -= PPP_HDRLEN;
1556     pkt += PPP_HDRLEN;
1557     if (len < IP6_HDRLEN)
1558         return 0;
1559     if (get_ip6nh(pkt) == IP6_NHDR_FRAG)
1560         return 0;
1561     if (get_ip6nh(pkt) != IPPROTO_TCP)
1562         return 1;
1563     if (len < IP6_HDRLEN + TCP_HDRLEN)
1564         return 0;
1565     tcp = pkt + IP6_HDRLEN;
1566     if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4)
1567         return 0;
1568     return 1;
1569 }