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.7 1999/10/08 01:08:18 masputra Exp $
97 #define RCSID "$Id: ipv6cp.c,v 1.7 1999/10/08 01:08:18 masputra Exp $"
99 #include <sys/cdefs.h>
100 __FBSDID("$FreeBSD$");
105 * Proxy Neighbour Discovery.
107 * Better defines for selecting the ordering of
108 * interface up / set address. (currently checks for __linux__,
109 * since SVR4 && (SNI || __USLC__) didn't work properly)
117 #include <sys/param.h>
118 #include <sys/types.h>
119 #include <sys/socket.h>
120 #include <netinet/in.h>
121 #include <arpa/inet.h>
128 #include "pathnames.h"
130 #define s6_addr32 __u6_addr.__u6_addr32
133 static const char rcsid[] = RCSID;
137 ipv6cp_options ipv6cp_wantoptions[NUM_PPP]; /* Options that we want to request */
138 ipv6cp_options ipv6cp_gotoptions[NUM_PPP]; /* Options that peer ack'd */
139 ipv6cp_options ipv6cp_allowoptions[NUM_PPP]; /* Options we allow peer to request */
140 ipv6cp_options ipv6cp_hisoptions[NUM_PPP]; /* Options that we ack'd */
141 int no_ifaceid_neg = 0;
144 static int ipv6cp_is_up;
147 * Callbacks for fsm code. (CI = Configuration Information)
149 static void ipv6cp_resetci __P((fsm *)); /* Reset our CI */
150 static int ipv6cp_cilen __P((fsm *)); /* Return length of our CI */
151 static void ipv6cp_addci __P((fsm *, u_char *, int *)); /* Add our CI */
152 static int ipv6cp_ackci __P((fsm *, u_char *, int)); /* Peer ack'd our CI */
153 static int ipv6cp_nakci __P((fsm *, u_char *, int)); /* Peer nak'd our CI */
154 static int ipv6cp_rejci __P((fsm *, u_char *, int)); /* Peer rej'd our CI */
155 static int ipv6cp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */
156 static void ipv6cp_up __P((fsm *)); /* We're UP */
157 static void ipv6cp_down __P((fsm *)); /* We're DOWN */
158 static void ipv6cp_finished __P((fsm *)); /* Don't need lower layer */
160 fsm ipv6cp_fsm[NUM_PPP]; /* IPV6CP fsm structure */
162 static fsm_callbacks ipv6cp_callbacks = { /* IPV6CP callback routines */
163 ipv6cp_resetci, /* Reset our Configuration Information */
164 ipv6cp_cilen, /* Length of our Configuration Information */
165 ipv6cp_addci, /* Add our Configuration Information */
166 ipv6cp_ackci, /* ACK our Configuration Information */
167 ipv6cp_nakci, /* NAK our Configuration Information */
168 ipv6cp_rejci, /* Reject our Configuration Information */
169 ipv6cp_reqci, /* Request peer's Configuration Information */
170 ipv6cp_up, /* Called when fsm reaches OPENED state */
171 ipv6cp_down, /* Called when fsm leaves OPENED state */
172 NULL, /* Called when we want the lower layer up */
173 ipv6cp_finished, /* Called when we want the lower layer down */
174 NULL, /* Called when Protocol-Reject received */
175 NULL, /* Retransmission is necessary */
176 NULL, /* Called to handle protocol-specific codes */
177 "IPV6CP" /* String name of protocol */
182 * Protocol entry points from main code.
184 static void ipv6cp_init __P((int));
185 static void ipv6cp_open __P((int));
186 static void ipv6cp_close __P((int, char *));
187 static void ipv6cp_lowerup __P((int));
188 static void ipv6cp_lowerdown __P((int));
189 static void ipv6cp_input __P((int, u_char *, int));
190 static void ipv6cp_protrej __P((int));
191 static int ipv6cp_printpkt __P((u_char *, int,
192 void (*) __P((void *, char *, ...)), void *));
193 static void ipv6_check_options __P((void));
194 static int ipv6_demand_conf __P((int));
195 static int ipv6_active_pkt __P((u_char *, int));
197 struct protent ipv6cp_protent = {
215 static void ipv6cp_clear_addrs __P((int, eui64_t, eui64_t));
216 static void ipv6cp_script __P((char *));
219 * Lengths of configuration options.
222 #define CILEN_COMPRESS 4 /* length for RFC2023 compress opt. */
223 #define CILEN_IFACEID 10 /* RFC2472, interface identifier */
225 #define CODENAME(x) ((x) == CONFACK ? "ACK" : \
226 (x) == CONFNAK ? "NAK" : "REJ")
229 * This state variable is used to ensure that we don't
230 * run an ipcp-up/down script while one is already running.
232 static enum script_state {
235 } ipv6cp_script_state;
238 * setifaceid - set the interface identifiers manually
245 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
246 struct in6_addr addr;
248 #define VALIDID(a) ( (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0)) && \
249 (((a).s6_addr32[2] != 0) || ((a).s6_addr32[3] != 0)) )
252 if ((comma = strchr(arg, ',')) == NULL)
253 comma = arg + strlen(arg);
256 * If comma first character, then no local identifier
261 if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) {
262 option_error("Illegal interface identifier (local): %s", arg);
266 eui64_copy(addr.s6_addr32[2], wo->ourid);
272 * If comma last character, the no remote identifier
274 if (*comma != 0 && *++comma != '\0') {
275 if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) {
276 option_error("Illegal interface identifier (remote): %s", comma);
279 eui64_copy(addr.s6_addr32[2], wo->hisid);
283 ipv6cp_protent.enabled_flag = 1;
288 * Make a string representation of a network address.
296 sprintf(b, "fe80::%s", eui64_ntoa(ifaceid));
302 * ipv6cp_init - Initialize IPV6CP.
308 fsm *f = &ipv6cp_fsm[unit];
309 ipv6cp_options *wo = &ipv6cp_wantoptions[unit];
310 ipv6cp_options *ao = &ipv6cp_allowoptions[unit];
313 f->protocol = PPP_IPV6CP;
314 f->callbacks = &ipv6cp_callbacks;
315 fsm_init(&ipv6cp_fsm[unit]);
317 memset(wo, 0, sizeof(*wo));
318 memset(ao, 0, sizeof(*ao));
320 wo->accept_local = 1;
327 wo->vj_protocol = IPV6CP_COMP;
334 * ipv6cp_open - IPV6CP is allowed to come up.
340 fsm_open(&ipv6cp_fsm[unit]);
345 * ipv6cp_close - Take IPV6CP down.
348 ipv6cp_close(unit, reason)
352 fsm_close(&ipv6cp_fsm[unit], reason);
357 * ipv6cp_lowerup - The lower layer is up.
363 fsm_lowerup(&ipv6cp_fsm[unit]);
368 * ipv6cp_lowerdown - The lower layer is down.
371 ipv6cp_lowerdown(unit)
374 fsm_lowerdown(&ipv6cp_fsm[unit]);
379 * ipv6cp_input - Input IPV6CP packet.
382 ipv6cp_input(unit, p, len)
387 fsm_input(&ipv6cp_fsm[unit], p, len);
392 * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP.
394 * Pretend the lower layer went down, so we shut up.
400 fsm_lowerdown(&ipv6cp_fsm[unit]);
405 * ipv6cp_resetci - Reset our CI.
411 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
412 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
414 wo->req_ifaceid = wo->neg_ifaceid && ipv6cp_allowoptions[f->unit].neg_ifaceid;
416 if (!wo->opt_local) {
417 eui64_magic_nz(wo->ourid);
421 eui64_zero(go->hisid); /* last proposed interface identifier */
426 * ipv6cp_cilen - Return length of our CI.
432 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
434 #define LENCIVJ(neg) (neg ? CILEN_COMPRESS : 0)
435 #define LENCIIFACEID(neg) (neg ? CILEN_IFACEID : 0)
437 return (LENCIIFACEID(go->neg_ifaceid) +
438 LENCIVJ(go->neg_vj));
443 * ipv6cp_addci - Add our desired CIs to a packet.
446 ipv6cp_addci(f, ucp, lenp)
451 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
454 #define ADDCIVJ(opt, neg, val) \
456 int vjlen = CILEN_COMPRESS; \
457 if (len >= vjlen) { \
459 PUTCHAR(vjlen, ucp); \
460 PUTSHORT(val, ucp); \
466 #define ADDCIIFACEID(opt, neg, val1) \
468 int idlen = CILEN_IFACEID; \
469 if (len >= idlen) { \
471 PUTCHAR(idlen, ucp); \
472 eui64_put(val1, ucp); \
478 ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
480 ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
487 * ipv6cp_ackci - Ack our CIs.
494 ipv6cp_ackci(f, p, len)
499 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
500 u_short cilen, citype, cishort;
504 * CIs must be in exactly the same order that we sent...
505 * Check packet length and CI length at each step.
506 * If we find any deviations, then this packet is bad.
509 #define ACKCIVJ(opt, neg, val) \
511 int vjlen = CILEN_COMPRESS; \
512 if ((len -= vjlen) < 0) \
514 GETCHAR(citype, p); \
516 if (cilen != vjlen || \
519 GETSHORT(cishort, p); \
520 if (cishort != val) \
524 #define ACKCIIFACEID(opt, neg, val1) \
526 int idlen = CILEN_IFACEID; \
527 if ((len -= idlen) < 0) \
529 GETCHAR(citype, p); \
531 if (cilen != idlen || \
534 eui64_get(ifaceid, p); \
535 if (! eui64_equals(val1, ifaceid)) \
539 ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
541 ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
544 * If there are any remaining CIs, then this packet is bad.
551 IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!"));
556 * ipv6cp_nakci - Peer has sent a NAK for some of our CIs.
557 * This should not modify any state if the Nak is bad
558 * or if IPV6CP is in the OPENED state.
565 ipv6cp_nakci(f, p, len)
570 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
571 u_char citype, cilen, *next;
574 ipv6cp_options no; /* options we've seen Naks for */
575 ipv6cp_options try; /* options to request next time */
577 BZERO(&no, sizeof(no));
581 * Any Nak'd CIs must be in exactly the same order that we sent.
582 * Check packet length and CI length at each step.
583 * If we find any deviations, then this packet is bad.
585 #define NAKCIIFACEID(opt, neg, code) \
587 len >= (cilen = CILEN_IFACEID) && \
592 eui64_get(ifaceid, p); \
597 #define NAKCIVJ(opt, neg, code) \
599 ((cilen = p[1]) == CILEN_COMPRESS) && \
604 GETSHORT(cishort, p); \
610 * Accept the peer's idea of {our,his} interface identifier, if different
611 * from our idea, only if the accept_{local,remote} flag is set.
613 NAKCIIFACEID(CI_IFACEID, neg_ifaceid,
614 if (go->accept_local) {
615 while (eui64_iszero(ifaceid) ||
616 eui64_equals(ifaceid, go->hisid)) /* bad luck */
617 eui64_magic(ifaceid);
619 IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid)));
624 NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
626 if (cishort == IPV6CP_COMP) {
627 try.vj_protocol = cishort;
634 NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
642 * There may be remaining CIs, if the peer is requesting negotiation
643 * on an option that we didn't include in our request packet.
644 * If they want to negotiate about interface identifier, we comply.
645 * If they want us to ask for compression, we refuse.
647 while (len > CILEN_VOID) {
650 if( (len -= cilen) < 0 )
652 next = p + cilen - 2;
655 case CI_COMPRESSTYPE:
656 if (go->neg_vj || no.neg_vj ||
657 (cilen != CILEN_COMPRESS))
662 if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID)
665 eui64_get(ifaceid, p);
666 if (go->accept_local) {
667 while (eui64_iszero(ifaceid) ||
668 eui64_equals(ifaceid, go->hisid)) /* bad luck */
669 eui64_magic(ifaceid);
678 /* If there is still anything left, this packet is bad. */
683 * OK, the Nak is good. Now we can update state.
685 if (f->state != OPENED)
691 IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!"));
697 * ipv6cp_rejci - Reject some of our CIs.
700 ipv6cp_rejci(f, p, len)
705 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
709 ipv6cp_options try; /* options to request next time */
713 * Any Rejected CIs must be in exactly the same order that we sent.
714 * Check packet length and CI length at each step.
715 * If we find any deviations, then this packet is bad.
717 #define REJCIIFACEID(opt, neg, val1) \
719 len >= (cilen = CILEN_IFACEID) && \
724 eui64_get(ifaceid, p); \
725 /* Check rejected value. */ \
726 if (! eui64_equals(ifaceid, val1)) \
731 #define REJCIVJ(opt, neg, val) \
733 p[1] == CILEN_COMPRESS && \
738 GETSHORT(cishort, p); \
739 /* Check rejected value. */ \
740 if (cishort != val) \
745 REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid);
747 REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol);
750 * If there are any remaining CIs, then this packet is bad.
755 * Now we can update state.
757 if (f->state != OPENED)
762 IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!"));
768 * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response.
770 * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
771 * appropriately. If reject_if_disagree is non-zero, doesn't return
772 * CONFNAK; returns CONFREJ if it can't return CONFACK.
775 ipv6cp_reqci(f, inp, len, reject_if_disagree)
777 u_char *inp; /* Requested CIs */
778 int *len; /* Length of requested CIs */
779 int reject_if_disagree;
781 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
782 ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
783 ipv6cp_options *ao = &ipv6cp_allowoptions[f->unit];
784 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
785 u_char *cip, *next; /* Pointer to current and next CIs */
786 u_short cilen, citype; /* Parsed len, type */
787 u_short cishort; /* Parsed short value */
788 eui64_t ifaceid; /* Parsed interface identifier */
789 int rc = CONFACK; /* Final packet return code */
790 int orc; /* Individual option return code */
791 u_char *p; /* Pointer to next char to parse */
792 u_char *ucp = inp; /* Pointer to current output char */
793 int l = *len; /* Length left */
796 * Reset all his options.
798 BZERO(ho, sizeof(*ho));
801 * Process all his options.
805 orc = CONFACK; /* Assume success */
806 cip = p = next; /* Remember begining of CI */
807 if (l < 2 || /* Not enough data for CI header or */
808 p[1] < 2 || /* CI length too small or */
809 p[1] > l) { /* CI length too big? */
810 IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!"));
811 orc = CONFREJ; /* Reject bad CI */
812 cilen = l; /* Reject till end of packet */
813 l = 0; /* Don't loop again */
816 GETCHAR(citype, p); /* Parse CI type */
817 GETCHAR(cilen, p); /* Parse CI length */
818 l -= cilen; /* Adjust remaining length */
819 next += cilen; /* Step to next CI */
821 switch (citype) { /* Check CI type */
823 IPV6CPDEBUG(("ipv6cp: received interface identifier "));
825 if (!ao->neg_ifaceid ||
826 cilen != CILEN_IFACEID) { /* Check CI length */
827 orc = CONFREJ; /* Reject CI */
832 * If he has no interface identifier, or if we both have same
833 * identifier then NAK it with new idea.
834 * In particular, if we don't know his identifier, but he does,
837 eui64_get(ifaceid, p);
838 IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid)));
839 if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) {
840 orc = CONFREJ; /* Reject CI */
843 if (!eui64_iszero(wo->hisid) &&
844 !eui64_equals(ifaceid, wo->hisid) &&
845 eui64_iszero(go->hisid)) {
850 DECPTR(sizeof(ifaceid), p);
851 eui64_put(ifaceid, p);
853 if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) {
855 if (eui64_iszero(go->hisid)) /* first time, try option */
857 while (eui64_iszero(ifaceid) ||
858 eui64_equals(ifaceid, go->ourid)) /* bad luck */
859 eui64_magic(ifaceid);
861 DECPTR(sizeof(ifaceid), p);
862 eui64_put(ifaceid, p);
869 case CI_COMPRESSTYPE:
870 IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE "));
872 (cilen != CILEN_COMPRESS)) {
876 GETSHORT(cishort, p);
877 IPV6CPDEBUG(("(%d)", cishort));
880 if (!(cishort == IPV6CP_COMP)) {
890 ho->vj_protocol = cishort;
899 IPV6CPDEBUG((" (%s)\n", CODENAME(orc)));
901 if (orc == CONFACK && /* Good CI */
902 rc != CONFACK) /* but prior CI wasnt? */
903 continue; /* Don't send this one */
905 if (orc == CONFNAK) { /* Nak this CI? */
906 if (reject_if_disagree) /* Getting fed up with sending NAKs? */
907 orc = CONFREJ; /* Get tough if so */
909 if (rc == CONFREJ) /* Rejecting prior CI? */
910 continue; /* Don't send this one */
911 if (rc == CONFACK) { /* Ack'd all prior CIs? */
912 rc = CONFNAK; /* Not anymore... */
913 ucp = inp; /* Backup */
918 if (orc == CONFREJ && /* Reject this CI */
919 rc != CONFREJ) { /* but no prior ones? */
921 ucp = inp; /* Backup */
924 /* Need to move CI? */
926 BCOPY(cip, ucp, cilen); /* Move it */
928 /* Update output pointer */
933 * If we aren't rejecting this packet, and we want to negotiate
934 * their identifier and they didn't send their identifier, then we
935 * send a NAK with a CI_IFACEID option appended. We assume the
936 * input buffer is long enough that we can append the extra
939 if (rc != CONFREJ && !ho->neg_ifaceid &&
940 wo->req_ifaceid && !reject_if_disagree) {
943 ucp = inp; /* reset pointer */
944 wo->req_ifaceid = 0; /* don't ask again */
946 PUTCHAR(CI_IFACEID, ucp);
947 PUTCHAR(CILEN_IFACEID, ucp);
948 eui64_put(wo->hisid, ucp);
951 *len = ucp - inp; /* Compute output length */
952 IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc)));
953 return (rc); /* Return final code */
958 * ipv6_check_options - check that any IP-related options are OK,
959 * and assign appropriate defaults.
964 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
968 * Persistent link-local id is only used when user has not explicitly
969 * configure/hard-code the id
971 if ((wo->use_persistent) && (!wo->opt_local) && (!wo->opt_remote)) {
974 * On systems where there are no Ethernet interfaces used, there
975 * may be other ways to obtain a persistent id. Right now, it
976 * will fall back to using magic [see eui64_magic] below when
977 * an EUI-48 from MAC address can't be obtained. Other possibilities
978 * include obtaining EEPROM serial numbers, or some other unique
979 * yet persistent number. On Sparc platforms, this is possible,
980 * but too bad there's no standards yet for x86 machines.
982 if (ether_to_eui64(&wo->ourid)) {
988 if (!wo->opt_local) { /* init interface identifier */
989 if (wo->use_ip && eui64_iszero(wo->ourid)) {
990 eui64_setlo32(wo->ourid, ntohl(ipcp_wantoptions[0].ouraddr));
991 if (!eui64_iszero(wo->ourid))
995 while (eui64_iszero(wo->ourid))
996 eui64_magic(wo->ourid);
999 if (!wo->opt_remote) {
1000 if (wo->use_ip && eui64_iszero(wo->hisid)) {
1001 eui64_setlo32(wo->hisid, ntohl(ipcp_wantoptions[0].hisaddr));
1002 if (!eui64_iszero(wo->hisid))
1007 if (demand && (eui64_iszero(wo->ourid) || eui64_iszero(wo->hisid))) {
1008 option_error("local/remote LL address required for demand-dialling\n");
1015 * ipv6_demand_conf - configure the interface as though
1016 * IPV6CP were up, for use with dial-on-demand.
1022 ipv6cp_options *wo = &ipv6cp_wantoptions[u];
1024 #if defined(__linux__) || defined(SOL2) || (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1031 #endif /* defined(SOL2) */
1033 if (!sif6addr(u, wo->ourid, wo->hisid))
1035 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1039 if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE))
1042 syslog(LOG_NOTICE, "ipv6_demand_conf");
1043 syslog(LOG_NOTICE, "local LL address %s", llv6_ntoa(wo->ourid));
1044 syslog(LOG_NOTICE, "remote LL address %s", llv6_ntoa(wo->hisid));
1051 * ipv6cp_up - IPV6CP has come UP.
1053 * Configure the IPv6 network interface appropriately and bring it up.
1059 ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
1060 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
1061 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
1063 IPV6CPDEBUG(("ipv6cp: up"));
1066 * We must have a non-zero LL address for both ends of the link.
1068 if (!ho->neg_ifaceid)
1069 ho->hisid = wo->hisid;
1071 if(!no_ifaceid_neg) {
1072 if (eui64_iszero(ho->hisid)) {
1073 syslog(LOG_ERR, "Could not determine remote LL address");
1074 ipv6cp_close(f->unit, "Could not determine remote LL address");
1077 if (eui64_iszero(go->ourid)) {
1078 syslog(LOG_ERR, "Could not determine local LL address");
1079 ipv6cp_close(f->unit, "Could not determine local LL address");
1082 if (eui64_equals(go->ourid, ho->hisid)) {
1083 syslog(LOG_ERR, "local and remote LL addresses are equal");
1084 ipv6cp_close(f->unit, "local and remote LL addresses are equal");
1088 script_setenv("LLLOCAL", llv6_ntoa(go->ourid));
1089 script_setenv("LLREMOTE", llv6_ntoa(ho->hisid));
1092 /* set tcp compression */
1093 sif6comp(f->unit, ho->neg_vj);
1097 * If we are doing dial-on-demand, the interface is already
1098 * configured, so we put out any saved-up packets, then set the
1099 * interface to pass IPv6 packets.
1102 if (! eui64_equals(go->ourid, wo->ourid) ||
1103 ! eui64_equals(ho->hisid, wo->hisid)) {
1104 if (! eui64_equals(go->ourid, wo->ourid))
1105 warn("Local LL address changed to %s",
1106 llv6_ntoa(go->ourid));
1107 if (! eui64_equals(ho->hisid, wo->hisid))
1108 warn("Remote LL address changed to %s",
1109 llv6_ntoa(ho->hisid));
1110 ipv6cp_clear_addrs(f->unit, go->ourid, ho->hisid);
1112 /* Set the interface to the new addresses */
1113 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1115 warn("sif6addr failed");
1116 ipv6cp_close(f->unit, "Interface configuration failed");
1121 demand_rexmit(PPP_IPV6);
1122 sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1128 #if !defined(__linux__) && !defined(SOL2) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1129 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1131 warn("sif6addr failed");
1132 ipv6cp_close(f->unit, "Interface configuration failed");
1137 /* bring the interface up for IPv6 */
1139 if (!sif6up(f->unit)) {
1141 warn("sifup failed (IPV6)");
1142 ipv6cp_close(f->unit, "Interface configuration failed");
1146 if (!sifup(f->unit)) {
1148 warn("sifup failed (IPV6)");
1149 ipv6cp_close(f->unit, "Interface configuration failed");
1152 #endif /* defined(SOL2) */
1154 #if defined(__linux__) || defined(SOL2) || (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1155 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1157 warn("sif6addr failed");
1158 ipv6cp_close(f->unit, "Interface configuration failed");
1162 sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1164 syslog(LOG_NOTICE, "local LL address %s", llv6_ntoa(go->ourid));
1165 syslog(LOG_NOTICE, "remote LL address %s", llv6_ntoa(ho->hisid));
1168 np_up(f->unit, PPP_IPV6);
1172 * Execute the ipv6-up script, like this:
1173 * /etc/ppp/ipv6-up interface tty speed local-LL remote-LL
1175 if (ipv6cp_script_state == s_down) {
1176 ipv6cp_script_state = s_up;
1177 ipv6cp_script(_PATH_IPV6UP);
1183 * ipv6cp_down - IPV6CP has gone DOWN.
1185 * Take the IPv6 network interface down, clear its addresses
1186 * and delete routes through it.
1192 IPV6CPDEBUG(("ipv6cp: down"));
1195 np_down(f->unit, PPP_IPV6);
1198 sif6comp(f->unit, 0);
1202 * If we are doing dial-on-demand, set the interface
1203 * to queue up outgoing packets (for now).
1206 sifnpmode(f->unit, PPP_IPV6, NPMODE_QUEUE);
1208 sifnpmode(f->unit, PPP_IPV6, NPMODE_DROP);
1209 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC)))
1214 #endif /* defined(SOL2) */
1216 ipv6cp_clear_addrs(f->unit,
1217 ipv6cp_gotoptions[f->unit].ourid,
1218 ipv6cp_hisoptions[f->unit].hisid);
1219 #if defined(__linux__) || (defined(SVR4) && (defined(SNI) || defined(__USLC)))
1224 /* Execute the ipv6-down script */
1225 if (ipv6cp_script_state == s_up) {
1226 ipv6cp_script_state = s_down;
1227 ipv6cp_script(_PATH_IPV6DOWN);
1233 * ipv6cp_clear_addrs() - clear the interface addresses, routes,
1234 * proxy neighbour discovery entries, etc.
1237 ipv6cp_clear_addrs(unit, ourid, hisid)
1242 cif6addr(unit, ourid, hisid);
1247 * ipv6cp_finished - possibly shut down the lower layers.
1253 np_finished(f->unit, PPP_IPV6);
1258 * ipv6cp_script - Execute a script with arguments
1259 * interface-name tty-name speed local-LL remote-LL.
1262 ipv6cp_script(script)
1265 char strspeed[32], strlocal[32], strremote[32];
1268 sprintf(strspeed, "%d", baud_rate);
1269 strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid));
1270 strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid));
1277 argv[5] = strremote;
1281 run_program(script, argv, 0);
1285 * ipv6cp_printpkt - print the contents of an IPV6CP packet.
1287 static char *ipv6cp_codenames[] = {
1288 "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1289 "TermReq", "TermAck", "CodeRej"
1293 ipv6cp_printpkt(p, plen, printer, arg)
1296 void (*printer) __P((void *, char *, ...));
1299 int code, id, len, olen;
1300 u_char *pstart, *optend;
1304 if (plen < HEADERLEN)
1310 if (len < HEADERLEN || len > plen)
1313 if (code >= 1 && code <= sizeof(ipv6cp_codenames) / sizeof(char *))
1314 printer(arg, " %s", ipv6cp_codenames[code-1]);
1316 printer(arg, " code=0x%x", code);
1317 printer(arg, " id=0x%x", id);
1324 /* print option list */
1329 if (olen < 2 || olen > len) {
1336 case CI_COMPRESSTYPE:
1337 if (olen >= CILEN_COMPRESS) {
1339 GETSHORT(cishort, p);
1340 printer(arg, "compress ");
1341 printer(arg, "0x%x", cishort);
1345 if (olen == CILEN_IFACEID) {
1347 eui64_get(ifaceid, p);
1348 printer(arg, "addr %s", llv6_ntoa(ifaceid));
1352 while (p < optend) {
1354 printer(arg, " %.2x", code);
1362 if (len > 0 && *p >= ' ' && *p < 0x7f) {
1364 print_string(p, len, printer, arg);
1371 /* print the rest of the bytes in the packet */
1372 for (; len > 0; --len) {
1374 printer(arg, " %.2x", code);
1381 * ipv6_active_pkt - see if this IP packet is worth bringing the link up for.
1382 * We don't bring the link up for IP fragments or for TCP FIN packets
1385 #define IP6_HDRLEN 40 /* bytes */
1386 #define IP6_NHDR_FRAG 44 /* fragment IPv6 header */
1387 #define IPPROTO_TCP 6
1388 #define TCP_HDRLEN 20
1392 * We use these macros because the IP header may be at an odd address,
1393 * and some compilers might use word loads to get th_off or ip_hl.
1396 #define get_ip6nh(x) (((unsigned char *)(x))[6])
1397 #define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4)
1398 #define get_tcpflags(x) (((unsigned char *)(x))[13])
1401 ipv6_active_pkt(pkt, len)
1409 if (len < IP6_HDRLEN)
1411 if (get_ip6nh(pkt) == IP6_NHDR_FRAG)
1413 if (get_ip6nh(pkt) != IPPROTO_TCP)
1415 if (len < IP6_HDRLEN + TCP_HDRLEN)
1417 tcp = pkt + IP6_HDRLEN;
1418 if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4)