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