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