2 ipv6cp.c - PPP IPV6 Control Protocol.
3 Copyright (C) 1999 Tommi Komulainen <Tommi.Komulainen@iki.fi>
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.
15 /* Original version, based on RFC2023 :
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.
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.
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).
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.
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.
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.
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).
50 This work has been done in the context of GIE DYADE (joint R & D venture
51 between BULL S.A. and INRIA).
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.
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.
76 * ipcp.c - PPP IP Control Protocol.
78 * Copyright (c) 1989 Carnegie Mellon University.
79 * All rights reserved.
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.
93 * $Id: ipv6cp.c,v 1.12 2001/02/22 03:15:16 paulus Exp $
96 #define RCSID "$Id: ipv6cp.c,v 1.12 2001/02/22 03:15:16 paulus Exp $"
101 * Proxy Neighbour Discovery.
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)
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>
123 #include "pathnames.h"
125 static const char rcsid[] = RCSID;
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;
135 static int ipv6cp_is_up;
138 * Callbacks for fsm code. (CI = Configuration Information)
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 */
151 fsm ipv6cp_fsm[NUM_PPP]; /* IPV6CP fsm structure */
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 */
172 * Command-line options.
174 static int setifaceid __P((char **arg));
176 static option_t ipv6cp_option_list[] = {
177 { "ipv6", o_special, (void *)setifaceid,
178 "Set interface identifiers for IPV6", OPT_MULTIPART },
179 { "noipv6", o_bool, &ipv6cp_protent.enabled_flag,
180 "Disable IPv6 and IPv6CP" },
181 { "-ipv6", o_bool, &ipv6cp_protent.enabled_flag,
182 "Disable IPv6 and IPv6CP" },
183 { "+ipv6", o_bool, &ipv6cp_protent.enabled_flag,
184 "Enable IPv6 and IPv6CP", 1 },
186 { "ipv6cp-accept-local", o_bool, &ipv6cp_allowoptions[0].accept_local,
187 "Accept peer's interface identifier for us", 1 },
188 { "ipv6cp-use-ipaddr", o_bool, &ipv6cp_allowoptions[0].use_ip,
189 "Use (default) IPv4 address as interface identifier", 0 },
191 { "ipv6cp-use-persistent", o_bool, &ipv6cp_wantoptions[0].use_persistent,
192 "Use uniquely-available persistent value for link local address", 1 },
193 #endif /* defined(SOL2) */
194 { "ipv6cp-restart", o_int, &ipv6cp_fsm[0].timeouttime,
195 "Set timeout for IPv6CP" },
196 { "ipv6cp-max-terminate", o_int, &ipv6cp_fsm[0].maxtermtransmits,
197 "Set max #xmits for term-reqs" },
198 { "ipv6cp-max-configure", o_int, &ipv6cp_fsm[0].maxconfreqtransmits,
199 "Set max #xmits for conf-reqs" },
200 { "ipv6cp-max-failure", o_int, &ipv6cp_fsm[0].maxnakloops,
201 "Set max #conf-naks for IPv6CP" },
208 * Protocol entry points from main code.
210 static void ipv6cp_init __P((int));
211 static void ipv6cp_open __P((int));
212 static void ipv6cp_close __P((int, char *));
213 static void ipv6cp_lowerup __P((int));
214 static void ipv6cp_lowerdown __P((int));
215 static void ipv6cp_input __P((int, u_char *, int));
216 static void ipv6cp_protrej __P((int));
217 static int ipv6cp_printpkt __P((u_char *, int,
218 void (*) __P((void *, char *, ...)), void *));
219 static void ipv6_check_options __P((void));
220 static int ipv6_demand_conf __P((int));
221 static int ipv6_active_pkt __P((u_char *, int));
223 struct protent ipv6cp_protent = {
243 static void ipv6cp_clear_addrs __P((int, eui64_t, eui64_t));
244 static void ipv6cp_script __P((char *));
245 static void ipv6cp_script_done __P((void *));
248 * Lengths of configuration options.
251 #define CILEN_COMPRESS 4 /* length for RFC2023 compress opt. */
252 #define CILEN_IFACEID 10 /* RFC2472, interface identifier */
254 #define CODENAME(x) ((x) == CONFACK ? "ACK" : \
255 (x) == CONFNAK ? "NAK" : "REJ")
258 * This state variable is used to ensure that we don't
259 * run an ipcp-up/down script while one is already running.
261 static enum script_state {
264 } ipv6cp_script_state;
265 static pid_t ipv6cp_script_pid;
268 * setifaceid - set the interface identifiers manually
274 char *comma, *arg, c;
275 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
276 struct in6_addr addr;
277 static int prio_local, prio_remote;
279 #define VALIDID(a) ( (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0)) && \
280 (((a).s6_addr32[2] != 0) || ((a).s6_addr32[3] != 0)) )
283 if ((comma = strchr(arg, ',')) == NULL)
284 comma = arg + strlen(arg);
287 * If comma first character, then no local identifier
293 if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) {
294 option_error("Illegal interface identifier (local): %s", arg);
298 if (option_priority >= prio_local) {
299 eui64_copy(addr.s6_addr32[2], wo->ourid);
301 prio_local = option_priority;
307 * If comma last character, the no remote identifier
309 if (*comma != 0 && *++comma != '\0') {
310 if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) {
311 option_error("Illegal interface identifier (remote): %s", comma);
314 if (option_priority >= prio_remote) {
315 eui64_copy(addr.s6_addr32[2], wo->hisid);
317 prio_remote = option_priority;
321 ipv6cp_protent.enabled_flag = 1;
326 * Make a string representation of a network address.
334 sprintf(b, "fe80::%s", eui64_ntoa(ifaceid));
340 * ipv6cp_init - Initialize IPV6CP.
346 fsm *f = &ipv6cp_fsm[unit];
347 ipv6cp_options *wo = &ipv6cp_wantoptions[unit];
348 ipv6cp_options *ao = &ipv6cp_allowoptions[unit];
351 f->protocol = PPP_IPV6CP;
352 f->callbacks = &ipv6cp_callbacks;
353 fsm_init(&ipv6cp_fsm[unit]);
355 memset(wo, 0, sizeof(*wo));
356 memset(ao, 0, sizeof(*ao));
358 wo->accept_local = 1;
365 wo->vj_protocol = IPV6CP_COMP;
372 * ipv6cp_open - IPV6CP is allowed to come up.
378 fsm_open(&ipv6cp_fsm[unit]);
383 * ipv6cp_close - Take IPV6CP down.
386 ipv6cp_close(unit, reason)
390 fsm_close(&ipv6cp_fsm[unit], reason);
395 * ipv6cp_lowerup - The lower layer is up.
401 fsm_lowerup(&ipv6cp_fsm[unit]);
406 * ipv6cp_lowerdown - The lower layer is down.
409 ipv6cp_lowerdown(unit)
412 fsm_lowerdown(&ipv6cp_fsm[unit]);
417 * ipv6cp_input - Input IPV6CP packet.
420 ipv6cp_input(unit, p, len)
425 fsm_input(&ipv6cp_fsm[unit], p, len);
430 * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP.
432 * Pretend the lower layer went down, so we shut up.
438 fsm_lowerdown(&ipv6cp_fsm[unit]);
443 * ipv6cp_resetci - Reset our CI.
449 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
450 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
452 wo->req_ifaceid = wo->neg_ifaceid && ipv6cp_allowoptions[f->unit].neg_ifaceid;
454 if (!wo->opt_local) {
455 eui64_magic_nz(wo->ourid);
459 eui64_zero(go->hisid); /* last proposed interface identifier */
464 * ipv6cp_cilen - Return length of our CI.
470 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
472 #define LENCIVJ(neg) (neg ? CILEN_COMPRESS : 0)
473 #define LENCIIFACEID(neg) (neg ? CILEN_IFACEID : 0)
475 return (LENCIIFACEID(go->neg_ifaceid) +
476 LENCIVJ(go->neg_vj));
481 * ipv6cp_addci - Add our desired CIs to a packet.
484 ipv6cp_addci(f, ucp, lenp)
489 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
492 #define ADDCIVJ(opt, neg, val) \
494 int vjlen = CILEN_COMPRESS; \
495 if (len >= vjlen) { \
497 PUTCHAR(vjlen, ucp); \
498 PUTSHORT(val, ucp); \
504 #define ADDCIIFACEID(opt, neg, val1) \
506 int idlen = CILEN_IFACEID; \
507 if (len >= idlen) { \
509 PUTCHAR(idlen, ucp); \
510 eui64_put(val1, ucp); \
516 ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
518 ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
525 * ipv6cp_ackci - Ack our CIs.
532 ipv6cp_ackci(f, p, len)
537 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
538 u_short cilen, citype, cishort;
542 * CIs must be in exactly the same order that we sent...
543 * Check packet length and CI length at each step.
544 * If we find any deviations, then this packet is bad.
547 #define ACKCIVJ(opt, neg, val) \
549 int vjlen = CILEN_COMPRESS; \
550 if ((len -= vjlen) < 0) \
552 GETCHAR(citype, p); \
554 if (cilen != vjlen || \
557 GETSHORT(cishort, p); \
558 if (cishort != val) \
562 #define ACKCIIFACEID(opt, neg, val1) \
564 int idlen = CILEN_IFACEID; \
565 if ((len -= idlen) < 0) \
567 GETCHAR(citype, p); \
569 if (cilen != idlen || \
572 eui64_get(ifaceid, p); \
573 if (! eui64_equals(val1, ifaceid)) \
577 ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
579 ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
582 * If there are any remaining CIs, then this packet is bad.
589 IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!"));
594 * ipv6cp_nakci - Peer has sent a NAK for some of our CIs.
595 * This should not modify any state if the Nak is bad
596 * or if IPV6CP is in the OPENED state.
603 ipv6cp_nakci(f, p, len)
608 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
609 u_char citype, cilen, *next;
612 ipv6cp_options no; /* options we've seen Naks for */
613 ipv6cp_options try; /* options to request next time */
615 BZERO(&no, sizeof(no));
619 * Any Nak'd CIs must be in exactly the same order that we sent.
620 * Check packet length and CI length at each step.
621 * If we find any deviations, then this packet is bad.
623 #define NAKCIIFACEID(opt, neg, code) \
625 len >= (cilen = CILEN_IFACEID) && \
630 eui64_get(ifaceid, p); \
635 #define NAKCIVJ(opt, neg, code) \
637 ((cilen = p[1]) == CILEN_COMPRESS) && \
642 GETSHORT(cishort, p); \
648 * Accept the peer's idea of {our,his} interface identifier, if different
649 * from our idea, only if the accept_{local,remote} flag is set.
651 NAKCIIFACEID(CI_IFACEID, neg_ifaceid,
652 if (go->accept_local) {
653 while (eui64_iszero(ifaceid) ||
654 eui64_equals(ifaceid, go->hisid)) /* bad luck */
655 eui64_magic(ifaceid);
657 IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid)));
662 NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
664 if (cishort == IPV6CP_COMP) {
665 try.vj_protocol = cishort;
672 NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
680 * There may be remaining CIs, if the peer is requesting negotiation
681 * on an option that we didn't include in our request packet.
682 * If they want to negotiate about interface identifier, we comply.
683 * If they want us to ask for compression, we refuse.
685 while (len > CILEN_VOID) {
688 if( (len -= cilen) < 0 )
690 next = p + cilen - 2;
693 case CI_COMPRESSTYPE:
694 if (go->neg_vj || no.neg_vj ||
695 (cilen != CILEN_COMPRESS))
700 if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID)
703 eui64_get(ifaceid, p);
704 if (go->accept_local) {
705 while (eui64_iszero(ifaceid) ||
706 eui64_equals(ifaceid, go->hisid)) /* bad luck */
707 eui64_magic(ifaceid);
716 /* If there is still anything left, this packet is bad. */
721 * OK, the Nak is good. Now we can update state.
723 if (f->state != OPENED)
729 IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!"));
735 * ipv6cp_rejci - Reject some of our CIs.
738 ipv6cp_rejci(f, p, len)
743 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
747 ipv6cp_options try; /* options to request next time */
751 * Any Rejected CIs must be in exactly the same order that we sent.
752 * Check packet length and CI length at each step.
753 * If we find any deviations, then this packet is bad.
755 #define REJCIIFACEID(opt, neg, val1) \
757 len >= (cilen = CILEN_IFACEID) && \
762 eui64_get(ifaceid, p); \
763 /* Check rejected value. */ \
764 if (! eui64_equals(ifaceid, val1)) \
769 #define REJCIVJ(opt, neg, val) \
771 p[1] == CILEN_COMPRESS && \
776 GETSHORT(cishort, p); \
777 /* Check rejected value. */ \
778 if (cishort != val) \
783 REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid);
785 REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol);
788 * If there are any remaining CIs, then this packet is bad.
793 * Now we can update state.
795 if (f->state != OPENED)
800 IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!"));
806 * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response.
808 * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
809 * appropriately. If reject_if_disagree is non-zero, doesn't return
810 * CONFNAK; returns CONFREJ if it can't return CONFACK.
813 ipv6cp_reqci(f, inp, len, reject_if_disagree)
815 u_char *inp; /* Requested CIs */
816 int *len; /* Length of requested CIs */
817 int reject_if_disagree;
819 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
820 ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
821 ipv6cp_options *ao = &ipv6cp_allowoptions[f->unit];
822 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
823 u_char *cip, *next; /* Pointer to current and next CIs */
824 u_short cilen, citype; /* Parsed len, type */
825 u_short cishort; /* Parsed short value */
826 eui64_t ifaceid; /* Parsed interface identifier */
827 int rc = CONFACK; /* Final packet return code */
828 int orc; /* Individual option return code */
829 u_char *p; /* Pointer to next char to parse */
830 u_char *ucp = inp; /* Pointer to current output char */
831 int l = *len; /* Length left */
834 * Reset all his options.
836 BZERO(ho, sizeof(*ho));
839 * Process all his options.
843 orc = CONFACK; /* Assume success */
844 cip = p = next; /* Remember begining of CI */
845 if (l < 2 || /* Not enough data for CI header or */
846 p[1] < 2 || /* CI length too small or */
847 p[1] > l) { /* CI length too big? */
848 IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!"));
849 orc = CONFREJ; /* Reject bad CI */
850 cilen = l; /* Reject till end of packet */
851 l = 0; /* Don't loop again */
854 GETCHAR(citype, p); /* Parse CI type */
855 GETCHAR(cilen, p); /* Parse CI length */
856 l -= cilen; /* Adjust remaining length */
857 next += cilen; /* Step to next CI */
859 switch (citype) { /* Check CI type */
861 IPV6CPDEBUG(("ipv6cp: received interface identifier "));
863 if (!ao->neg_ifaceid ||
864 cilen != CILEN_IFACEID) { /* Check CI length */
865 orc = CONFREJ; /* Reject CI */
870 * If he has no interface identifier, or if we both have same
871 * identifier then NAK it with new idea.
872 * In particular, if we don't know his identifier, but he does,
875 eui64_get(ifaceid, p);
876 IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid)));
877 if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) {
878 orc = CONFREJ; /* Reject CI */
881 if (!eui64_iszero(wo->hisid) &&
882 !eui64_equals(ifaceid, wo->hisid) &&
883 eui64_iszero(go->hisid)) {
888 DECPTR(sizeof(ifaceid), p);
889 eui64_put(ifaceid, p);
891 if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) {
893 if (eui64_iszero(go->hisid)) /* first time, try option */
895 while (eui64_iszero(ifaceid) ||
896 eui64_equals(ifaceid, go->ourid)) /* bad luck */
897 eui64_magic(ifaceid);
899 DECPTR(sizeof(ifaceid), p);
900 eui64_put(ifaceid, p);
907 case CI_COMPRESSTYPE:
908 IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE "));
910 (cilen != CILEN_COMPRESS)) {
914 GETSHORT(cishort, p);
915 IPV6CPDEBUG(("(%d)", cishort));
918 if (!(cishort == IPV6CP_COMP)) {
924 ho->vj_protocol = cishort;
937 IPV6CPDEBUG((" (%s)\n", CODENAME(orc)));
939 if (orc == CONFACK && /* Good CI */
940 rc != CONFACK) /* but prior CI wasnt? */
941 continue; /* Don't send this one */
943 if (orc == CONFNAK) { /* Nak this CI? */
944 if (reject_if_disagree) /* Getting fed up with sending NAKs? */
945 orc = CONFREJ; /* Get tough if so */
947 if (rc == CONFREJ) /* Rejecting prior CI? */
948 continue; /* Don't send this one */
949 if (rc == CONFACK) { /* Ack'd all prior CIs? */
950 rc = CONFNAK; /* Not anymore... */
951 ucp = inp; /* Backup */
956 if (orc == CONFREJ && /* Reject this CI */
957 rc != CONFREJ) { /* but no prior ones? */
959 ucp = inp; /* Backup */
962 /* Need to move CI? */
964 BCOPY(cip, ucp, cilen); /* Move it */
966 /* Update output pointer */
971 * If we aren't rejecting this packet, and we want to negotiate
972 * their identifier and they didn't send their identifier, then we
973 * send a NAK with a CI_IFACEID option appended. We assume the
974 * input buffer is long enough that we can append the extra
977 if (rc != CONFREJ && !ho->neg_ifaceid &&
978 wo->req_ifaceid && !reject_if_disagree) {
981 ucp = inp; /* reset pointer */
982 wo->req_ifaceid = 0; /* don't ask again */
984 PUTCHAR(CI_IFACEID, ucp);
985 PUTCHAR(CILEN_IFACEID, ucp);
986 eui64_put(wo->hisid, ucp);
989 *len = ucp - inp; /* Compute output length */
990 IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc)));
991 return (rc); /* Return final code */
996 * ipv6_check_options - check that any IP-related options are OK,
997 * and assign appropriate defaults.
1000 ipv6_check_options()
1002 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
1006 * Persistent link-local id is only used when user has not explicitly
1007 * configure/hard-code the id
1009 if ((wo->use_persistent) && (!wo->opt_local) && (!wo->opt_remote)) {
1012 * On systems where there are no Ethernet interfaces used, there
1013 * may be other ways to obtain a persistent id. Right now, it
1014 * will fall back to using magic [see eui64_magic] below when
1015 * an EUI-48 from MAC address can't be obtained. Other possibilities
1016 * include obtaining EEPROM serial numbers, or some other unique
1017 * yet persistent number. On Sparc platforms, this is possible,
1018 * but too bad there's no standards yet for x86 machines.
1020 if (ether_to_eui64(&wo->ourid)) {
1026 if (!wo->opt_local) { /* init interface identifier */
1027 if (wo->use_ip && eui64_iszero(wo->ourid)) {
1028 eui64_setlo32(wo->ourid, ntohl(ipcp_wantoptions[0].ouraddr));
1029 if (!eui64_iszero(wo->ourid))
1033 while (eui64_iszero(wo->ourid))
1034 eui64_magic(wo->ourid);
1037 if (!wo->opt_remote) {
1038 if (wo->use_ip && eui64_iszero(wo->hisid)) {
1039 eui64_setlo32(wo->hisid, ntohl(ipcp_wantoptions[0].hisaddr));
1040 if (!eui64_iszero(wo->hisid))
1045 if (demand && (eui64_iszero(wo->ourid) || eui64_iszero(wo->hisid))) {
1046 option_error("local/remote LL address required for demand-dialling\n");
1053 * ipv6_demand_conf - configure the interface as though
1054 * IPV6CP were up, for use with dial-on-demand.
1060 ipv6cp_options *wo = &ipv6cp_wantoptions[u];
1062 #if defined(__linux__) || defined(SOL2) || (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1069 #endif /* defined(SOL2) */
1071 if (!sif6addr(u, wo->ourid, wo->hisid))
1073 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1077 if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE))
1080 notice("ipv6_demand_conf");
1081 notice("local LL address %s", llv6_ntoa(wo->ourid));
1082 notice("remote LL address %s", llv6_ntoa(wo->hisid));
1089 * ipv6cp_up - IPV6CP has come UP.
1091 * Configure the IPv6 network interface appropriately and bring it up.
1097 ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
1098 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
1099 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
1101 IPV6CPDEBUG(("ipv6cp: up"));
1104 * We must have a non-zero LL address for both ends of the link.
1106 if (!ho->neg_ifaceid)
1107 ho->hisid = wo->hisid;
1109 if(!no_ifaceid_neg) {
1110 if (eui64_iszero(ho->hisid)) {
1111 error("Could not determine remote LL address");
1112 ipv6cp_close(f->unit, "Could not determine remote LL address");
1115 if (eui64_iszero(go->ourid)) {
1116 error("Could not determine local LL address");
1117 ipv6cp_close(f->unit, "Could not determine local LL address");
1120 if (eui64_equals(go->ourid, ho->hisid)) {
1121 error("local and remote LL addresses are equal");
1122 ipv6cp_close(f->unit, "local and remote LL addresses are equal");
1126 script_setenv("LLLOCAL", llv6_ntoa(go->ourid), 0);
1127 script_setenv("LLREMOTE", llv6_ntoa(ho->hisid), 0);
1130 /* set tcp compression */
1131 sif6comp(f->unit, ho->neg_vj);
1135 * If we are doing dial-on-demand, the interface is already
1136 * configured, so we put out any saved-up packets, then set the
1137 * interface to pass IPv6 packets.
1140 if (! eui64_equals(go->ourid, wo->ourid) ||
1141 ! eui64_equals(ho->hisid, wo->hisid)) {
1142 if (! eui64_equals(go->ourid, wo->ourid))
1143 warn("Local LL address changed to %s",
1144 llv6_ntoa(go->ourid));
1145 if (! eui64_equals(ho->hisid, wo->hisid))
1146 warn("Remote LL address changed to %s",
1147 llv6_ntoa(ho->hisid));
1148 ipv6cp_clear_addrs(f->unit, go->ourid, ho->hisid);
1150 /* Set the interface to the new addresses */
1151 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1153 warn("sif6addr failed");
1154 ipv6cp_close(f->unit, "Interface configuration failed");
1159 demand_rexmit(PPP_IPV6);
1160 sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1166 #if !defined(__linux__) && !defined(SOL2) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1167 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1169 warn("sif6addr failed");
1170 ipv6cp_close(f->unit, "Interface configuration failed");
1175 /* bring the interface up for IPv6 */
1177 if (!sif6up(f->unit)) {
1179 warn("sifup failed (IPV6)");
1180 ipv6cp_close(f->unit, "Interface configuration failed");
1184 if (!sifup(f->unit)) {
1186 warn("sifup failed (IPV6)");
1187 ipv6cp_close(f->unit, "Interface configuration failed");
1190 #endif /* defined(SOL2) */
1192 #if defined(__linux__) || defined(SOL2) || (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1193 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1195 warn("sif6addr failed");
1196 ipv6cp_close(f->unit, "Interface configuration failed");
1200 sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1202 notice("local LL address %s", llv6_ntoa(go->ourid));
1203 notice("remote LL address %s", llv6_ntoa(ho->hisid));
1206 np_up(f->unit, PPP_IPV6);
1210 * Execute the ipv6-up script, like this:
1211 * /etc/ppp/ipv6-up interface tty speed local-LL remote-LL
1213 if (ipv6cp_script_state == s_down && ipv6cp_script_pid == 0) {
1214 ipv6cp_script_state = s_up;
1215 ipv6cp_script(_PATH_IPV6UP);
1221 * ipv6cp_down - IPV6CP has gone DOWN.
1223 * Take the IPv6 network interface down, clear its addresses
1224 * and delete routes through it.
1230 IPV6CPDEBUG(("ipv6cp: down"));
1231 update_link_stats(f->unit);
1234 np_down(f->unit, PPP_IPV6);
1237 sif6comp(f->unit, 0);
1241 * If we are doing dial-on-demand, set the interface
1242 * to queue up outgoing packets (for now).
1245 sifnpmode(f->unit, PPP_IPV6, NPMODE_QUEUE);
1247 sifnpmode(f->unit, PPP_IPV6, NPMODE_DROP);
1248 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC)))
1253 #endif /* defined(SOL2) */
1255 ipv6cp_clear_addrs(f->unit,
1256 ipv6cp_gotoptions[f->unit].ourid,
1257 ipv6cp_hisoptions[f->unit].hisid);
1258 #if defined(__linux__) || (defined(SVR4) && (defined(SNI) || defined(__USLC)))
1263 /* Execute the ipv6-down script */
1264 if (ipv6cp_script_state == s_up && ipv6cp_script_pid == 0) {
1265 ipv6cp_script_state = s_down;
1266 ipv6cp_script(_PATH_IPV6DOWN);
1272 * ipv6cp_clear_addrs() - clear the interface addresses, routes,
1273 * proxy neighbour discovery entries, etc.
1276 ipv6cp_clear_addrs(unit, ourid, hisid)
1281 cif6addr(unit, ourid, hisid);
1286 * ipv6cp_finished - possibly shut down the lower layers.
1292 np_finished(f->unit, PPP_IPV6);
1297 * ipv6cp_script_done - called when the ipv6-up or ipv6-down script
1301 ipv6cp_script_done(arg)
1304 ipv6cp_script_pid = 0;
1305 switch (ipv6cp_script_state) {
1307 if (ipv6cp_fsm[0].state != OPENED) {
1308 ipv6cp_script_state = s_down;
1309 ipv6cp_script(_PATH_IPV6DOWN);
1313 if (ipv6cp_fsm[0].state == OPENED) {
1314 ipv6cp_script_state = s_up;
1315 ipv6cp_script(_PATH_IPV6UP);
1323 * ipv6cp_script - Execute a script with arguments
1324 * interface-name tty-name speed local-LL remote-LL.
1327 ipv6cp_script(script)
1330 char strspeed[32], strlocal[32], strremote[32];
1333 sprintf(strspeed, "%d", baud_rate);
1334 strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid));
1335 strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid));
1342 argv[5] = strremote;
1346 ipv6cp_script_pid = run_program(script, argv, 0, ipv6cp_script_done, NULL);
1350 * ipv6cp_printpkt - print the contents of an IPV6CP packet.
1352 static char *ipv6cp_codenames[] = {
1353 "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1354 "TermReq", "TermAck", "CodeRej"
1358 ipv6cp_printpkt(p, plen, printer, arg)
1361 void (*printer) __P((void *, char *, ...));
1364 int code, id, len, olen;
1365 u_char *pstart, *optend;
1369 if (plen < HEADERLEN)
1375 if (len < HEADERLEN || len > plen)
1378 if (code >= 1 && code <= sizeof(ipv6cp_codenames) / sizeof(char *))
1379 printer(arg, " %s", ipv6cp_codenames[code-1]);
1381 printer(arg, " code=0x%x", code);
1382 printer(arg, " id=0x%x", id);
1389 /* print option list */
1394 if (olen < 2 || olen > len) {
1401 case CI_COMPRESSTYPE:
1402 if (olen >= CILEN_COMPRESS) {
1404 GETSHORT(cishort, p);
1405 printer(arg, "compress ");
1406 printer(arg, "0x%x", cishort);
1410 if (olen == CILEN_IFACEID) {
1412 eui64_get(ifaceid, p);
1413 printer(arg, "addr %s", llv6_ntoa(ifaceid));
1417 while (p < optend) {
1419 printer(arg, " %.2x", code);
1427 if (len > 0 && *p >= ' ' && *p < 0x7f) {
1429 print_string((char *)p, len, printer, arg);
1436 /* print the rest of the bytes in the packet */
1437 for (; len > 0; --len) {
1439 printer(arg, " %.2x", code);
1446 * ipv6_active_pkt - see if this IP packet is worth bringing the link up for.
1447 * We don't bring the link up for IP fragments or for TCP FIN packets
1450 #define IP6_HDRLEN 40 /* bytes */
1451 #define IP6_NHDR_FRAG 44 /* fragment IPv6 header */
1452 #define IPPROTO_TCP 6
1453 #define TCP_HDRLEN 20
1457 * We use these macros because the IP header may be at an odd address,
1458 * and some compilers might use word loads to get th_off or ip_hl.
1461 #define get_ip6nh(x) (((unsigned char *)(x))[6])
1462 #define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4)
1463 #define get_tcpflags(x) (((unsigned char *)(x))[13])
1466 ipv6_active_pkt(pkt, len)
1474 if (len < IP6_HDRLEN)
1476 if (get_ip6nh(pkt) == IP6_NHDR_FRAG)
1478 if (get_ip6nh(pkt) != IPPROTO_TCP)
1480 if (len < IP6_HDRLEN + TCP_HDRLEN)
1482 tcp = pkt + IP6_HDRLEN;
1483 if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4)