2 * ipv6cp.c - PPP IPV6 Control Protocol.
4 * Copyright (c) 1999 Tommi Komulainen. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
18 * 3. The name(s) of the authors of this software must not be used to
19 * endorse or promote products derived from this software without
20 * prior written permission.
22 * 4. Redistributions of any form whatsoever must retain the following
24 * "This product includes software developed by Tommi Komulainen
25 * <Tommi.Komulainen@iki.fi>".
27 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
28 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
29 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
30 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
31 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
32 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
33 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
37 /* Original version, based on RFC2023 :
39 Copyright (c) 1995, 1996, 1997 Francis.Dupont@inria.fr, INRIA Rocquencourt,
40 Alain.Durand@imag.fr, IMAG,
41 Jean-Luc.Richier@imag.fr, IMAG-LSR.
43 Copyright (c) 1998, 1999 Francis.Dupont@inria.fr, GIE DYADE,
44 Alain.Durand@imag.fr, IMAG,
45 Jean-Luc.Richier@imag.fr, IMAG-LSR.
47 Ce travail a été fait au sein du GIE DYADE (Groupement d'Intérêt
48 Économique ayant pour membres BULL S.A. et l'INRIA).
50 Ce logiciel informatique est disponible aux conditions
51 usuelles dans la recherche, c'est-à-dire qu'il peut
52 être utilisé, copié, modifié, distribué à l'unique
53 condition que ce texte soit conservé afin que
54 l'origine de ce logiciel soit reconnue.
56 Le nom de l'Institut National de Recherche en Informatique
57 et en Automatique (INRIA), de l'IMAG, ou d'une personne morale
58 ou physique ayant participé à l'élaboration de ce logiciel ne peut
59 être utilisé sans son accord préalable explicite.
61 Ce logiciel est fourni tel quel sans aucune garantie,
62 support ou responsabilité d'aucune sorte.
63 Ce logiciel est dérivé de sources d'origine
64 "University of California at Berkeley" et
65 "Digital Equipment Corporation" couvertes par des copyrights.
67 L'Institut d'Informatique et de Mathématiques Appliquées de Grenoble (IMAG)
68 est une fédération d'unités mixtes de recherche du CNRS, de l'Institut National
69 Polytechnique de Grenoble et de l'Université Joseph Fourier regroupant
70 sept laboratoires dont le laboratoire Logiciels, Systèmes, Réseaux (LSR).
72 This work has been done in the context of GIE DYADE (joint R & D venture
73 between BULL S.A. and INRIA).
75 This software is available with usual "research" terms
76 with the aim of retain credits of the software.
77 Permission to use, copy, modify and distribute this software for any
78 purpose and without fee is hereby granted, provided that the above
79 copyright notice and this permission notice appear in all copies,
80 and the name of INRIA, IMAG, or any contributor not be used in advertising
81 or publicity pertaining to this material without the prior explicit
82 permission. The software is provided "as is" without any
83 warranties, support or liabilities of any kind.
84 This software is derived from source code from
85 "University of California at Berkeley" and
86 "Digital Equipment Corporation" protected by copyrights.
88 Grenoble's Institute of Computer Science and Applied Mathematics (IMAG)
89 is a federation of seven research units funded by the CNRS, National
90 Polytechnic Institute of Grenoble and University Joseph Fourier.
91 The research unit in Software, Systems, Networks (LSR) is member of IMAG.
98 * ipcp.c - PPP IP Control Protocol.
100 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
102 * Redistribution and use in source and binary forms, with or without
103 * modification, are permitted provided that the following conditions
106 * 1. Redistributions of source code must retain the above copyright
107 * notice, this list of conditions and the following disclaimer.
109 * 2. Redistributions in binary form must reproduce the above copyright
110 * notice, this list of conditions and the following disclaimer in
111 * the documentation and/or other materials provided with the
114 * 3. The name "Carnegie Mellon University" must not be used to
115 * endorse or promote products derived from this software without
116 * prior written permission. For permission or any legal
117 * details, please contact
118 * Office of Technology Transfer
119 * Carnegie Mellon University
121 * Pittsburgh, PA 15213-3890
122 * (412) 268-4387, fax: (412) 268-7395
123 * tech-transfer@andrew.cmu.edu
125 * 4. Redistributions of any form whatsoever must retain the following
127 * "This product includes software developed by Computing Services
128 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
130 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
131 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
132 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
133 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
134 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
135 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
136 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
142 * Proxy Neighbour Discovery.
144 * Better defines for selecting the ordering of
145 * interface up / set address. (currently checks for __linux__,
146 * since SVR4 && (SNI || __USLC__) didn't work properly)
159 #include <sys/param.h>
160 #include <sys/types.h>
161 #include <sys/socket.h>
162 #include <netinet/in.h>
163 #include <arpa/inet.h>
171 #include "pathnames.h"
175 ipv6cp_options ipv6cp_wantoptions[NUM_PPP]; /* Options that we want to request */
176 ipv6cp_options ipv6cp_gotoptions[NUM_PPP]; /* Options that peer ack'd */
177 ipv6cp_options ipv6cp_allowoptions[NUM_PPP]; /* Options we allow peer to request */
178 ipv6cp_options ipv6cp_hisoptions[NUM_PPP]; /* Options that we ack'd */
179 int no_ifaceid_neg = 0;
182 static int default_route_set[NUM_PPP]; /* Have set up a default route */
183 static int ipv6cp_is_up;
184 static bool ipv6cp_noremote;
186 /* Hook for a plugin to know when IPv6 protocol has come up */
187 void (*ipv6_up_hook)(void) = NULL;
189 /* Hook for a plugin to know when IPv6 protocol has come down */
190 void (*ipv6_down_hook)(void) = NULL;
192 /* Notifiers for when IPCPv6 goes up and down */
193 struct notifier *ipv6_up_notifier = NULL;
194 struct notifier *ipv6_down_notifier = NULL;
197 * Callbacks for fsm code. (CI = Configuration Information)
199 static void ipv6cp_resetci (fsm *); /* Reset our CI */
200 static int ipv6cp_cilen (fsm *); /* Return length of our CI */
201 static void ipv6cp_addci (fsm *, u_char *, int *); /* Add our CI */
202 static int ipv6cp_ackci (fsm *, u_char *, int); /* Peer ack'd our CI */
203 static int ipv6cp_nakci (fsm *, u_char *, int, int);/* Peer nak'd our CI */
204 static int ipv6cp_rejci (fsm *, u_char *, int); /* Peer rej'd our CI */
205 static int ipv6cp_reqci (fsm *, u_char *, int *, int); /* Rcv CI */
206 static void ipv6cp_up (fsm *); /* We're UP */
207 static void ipv6cp_down (fsm *); /* We're DOWN */
208 static void ipv6cp_finished (fsm *); /* Don't need lower layer */
210 fsm ipv6cp_fsm[NUM_PPP]; /* IPV6CP fsm structure */
212 static fsm_callbacks ipv6cp_callbacks = { /* IPV6CP callback routines */
213 ipv6cp_resetci, /* Reset our Configuration Information */
214 ipv6cp_cilen, /* Length of our Configuration Information */
215 ipv6cp_addci, /* Add our Configuration Information */
216 ipv6cp_ackci, /* ACK our Configuration Information */
217 ipv6cp_nakci, /* NAK our Configuration Information */
218 ipv6cp_rejci, /* Reject our Configuration Information */
219 ipv6cp_reqci, /* Request peer's Configuration Information */
220 ipv6cp_up, /* Called when fsm reaches OPENED state */
221 ipv6cp_down, /* Called when fsm leaves OPENED state */
222 NULL, /* Called when we want the lower layer up */
223 ipv6cp_finished, /* Called when we want the lower layer down */
224 NULL, /* Called when Protocol-Reject received */
225 NULL, /* Retransmission is necessary */
226 NULL, /* Called to handle protocol-specific codes */
227 "IPV6CP" /* String name of protocol */
231 * Command-line options.
233 static int setifaceid (char **arg);
234 static void printifaceid (option_t *,
235 void (*)(void *, char *, ...), void *);
237 static option_t ipv6cp_option_list[] = {
238 { "ipv6", o_special, (void *)setifaceid,
239 "Set interface identifiers for IPV6",
240 OPT_A2PRINTER, (void *)printifaceid },
242 { "+ipv6", o_bool, &ipv6cp_protent.enabled_flag,
243 "Enable IPv6 and IPv6CP", OPT_PRIO | 1 },
244 { "noipv6", o_bool, &ipv6cp_protent.enabled_flag,
245 "Disable IPv6 and IPv6CP", OPT_PRIOSUB },
246 { "-ipv6", o_bool, &ipv6cp_protent.enabled_flag,
247 "Disable IPv6 and IPv6CP", OPT_PRIOSUB | OPT_ALIAS },
249 { "ipv6cp-accept-local", o_bool, &ipv6cp_wantoptions[0].accept_local,
250 "Accept peer's interface identifier for us", 1 },
251 { "ipv6cp-accept-remote", o_bool, &ipv6cp_wantoptions[0].accept_remote,
252 "Accept peer's interface identifier for itself", 1 },
254 { "defaultroute6", o_bool, &ipv6cp_wantoptions[0].default_route,
255 "Add default IPv6 route", OPT_ENABLE|1, &ipv6cp_allowoptions[0].default_route },
256 { "nodefaultroute6", o_bool, &ipv6cp_allowoptions[0].default_route,
257 "disable defaultroute6 option", OPT_A2CLR,
258 &ipv6cp_wantoptions[0].default_route },
259 { "-defaultroute6", o_bool, &ipv6cp_allowoptions[0].default_route,
260 "disable defaultroute6 option", OPT_ALIAS | OPT_A2CLR,
261 &ipv6cp_wantoptions[0].default_route },
263 { "ipv6cp-use-ipaddr", o_bool, &ipv6cp_allowoptions[0].use_ip,
264 "Use (default) IPv4 addresses for both local and remote interface identifiers", 1 },
265 { "ipv6cp-use-persistent", o_bool, &ipv6cp_wantoptions[0].use_persistent,
266 "Use uniquely-available persistent value for local interface identifier", 1 },
267 { "ipv6cp-use-remotenumber", o_bool, &ipv6cp_wantoptions[0].use_remotenumber,
268 "Use remotenumber value for remote interface identifier", 1 },
271 { "ipv6cp-noremote", o_bool, &ipv6cp_noremote,
272 "Allow peer to have no interface identifier", 1 },
274 { "ipv6cp-nosend", o_bool, &ipv6cp_wantoptions[0].neg_ifaceid,
275 "Don't send local interface identifier to peer", OPT_A2CLR },
277 { "ipv6cp-restart", o_int, &ipv6cp_fsm[0].timeouttime,
278 "Set timeout for IPv6CP", OPT_PRIO },
279 { "ipv6cp-max-terminate", o_int, &ipv6cp_fsm[0].maxtermtransmits,
280 "Set max #xmits for term-reqs", OPT_PRIO },
281 { "ipv6cp-max-configure", o_int, &ipv6cp_fsm[0].maxconfreqtransmits,
282 "Set max #xmits for conf-reqs", OPT_PRIO },
283 { "ipv6cp-max-failure", o_int, &ipv6cp_fsm[0].maxnakloops,
284 "Set max #conf-naks for IPv6CP", OPT_PRIO },
291 * Protocol entry points from main code.
293 static void ipv6cp_init (int);
294 static void ipv6cp_open (int);
295 static void ipv6cp_close (int, char *);
296 static void ipv6cp_lowerup (int);
297 static void ipv6cp_lowerdown (int);
298 static void ipv6cp_input (int, u_char *, int);
299 static void ipv6cp_protrej (int);
300 static int ipv6cp_printpkt (u_char *, int,
301 void (*) (void *, char *, ...), void *);
302 static void ipv6_check_options (void);
303 static int ipv6_demand_conf (int);
304 static int ipv6_active_pkt (u_char *, int);
306 struct protent ipv6cp_protent = {
326 static void ipv6cp_clear_addrs (int, eui64_t, eui64_t);
327 static void ipv6cp_script (char *);
328 static void ipv6cp_script_done (void *);
331 * Lengths of configuration options.
334 #define CILEN_COMPRESS 4 /* length for RFC2023 compress opt. */
335 #define CILEN_IFACEID 10 /* RFC2472, interface identifier */
337 #define CODENAME(x) ((x) == CONFACK ? "ACK" : \
338 (x) == CONFNAK ? "NAK" : "REJ")
341 * This state variable is used to ensure that we don't
342 * run an ipcp-up/down script while one is already running.
344 static enum script_state {
347 } ipv6cp_script_state;
348 static pid_t ipv6cp_script_pid;
351 * setifaceid - set the interface identifiers manually
354 setifaceid(char **argv)
356 char *comma, *arg, c;
357 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
358 struct in6_addr addr;
359 static int prio_local, prio_remote;
361 #define VALIDID(a) ( (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0)) && \
362 (((a).s6_addr32[2] != 0) || ((a).s6_addr32[3] != 0)) )
365 if ((comma = strchr(arg, ',')) == NULL)
366 comma = arg + strlen(arg);
369 * If comma first character, then no local identifier
375 if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) {
376 option_error("Illegal interface identifier (local): %s", arg);
380 if (option_priority >= prio_local) {
381 eui64_copy(addr.s6_addr32[2], wo->ourid);
383 prio_local = option_priority;
389 * If comma last character, the no remote identifier
391 if (*comma != 0 && *++comma != '\0') {
392 if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) {
393 option_error("Illegal interface identifier (remote): %s", comma);
396 if (option_priority >= prio_remote) {
397 eui64_copy(addr.s6_addr32[2], wo->hisid);
399 prio_remote = option_priority;
403 if (override_value("+ipv6", option_priority, option_source))
404 ipv6cp_protent.enabled_flag = 1;
408 char *llv6_ntoa(eui64_t ifaceid);
411 printifaceid(option_t *opt, void (*printer) (void *, char *, ...), void *arg)
413 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
416 printer(arg, "%s", llv6_ntoa(wo->ourid));
419 printer(arg, "%s", llv6_ntoa(wo->hisid));
423 * Make a string representation of a network address.
426 llv6_ntoa(eui64_t ifaceid)
430 sprintf(b, "fe80::%s", eui64_ntoa(ifaceid));
436 * ipv6cp_init - Initialize IPV6CP.
439 ipv6cp_init(int unit)
441 fsm *f = &ipv6cp_fsm[unit];
442 ipv6cp_options *wo = &ipv6cp_wantoptions[unit];
443 ipv6cp_options *ao = &ipv6cp_allowoptions[unit];
446 f->protocol = PPP_IPV6CP;
447 f->callbacks = &ipv6cp_callbacks;
448 fsm_init(&ipv6cp_fsm[unit]);
450 memset(wo, 0, sizeof(*wo));
451 memset(ao, 0, sizeof(*ao));
453 wo->accept_local = 0;
454 wo->accept_remote = 0;
461 wo->vj_protocol = IPV6CP_COMP;
465 * XXX This controls whether the user may use the defaultroute option.
467 ao->default_route = 1;
472 * ipv6cp_open - IPV6CP is allowed to come up.
475 ipv6cp_open(int unit)
477 fsm_open(&ipv6cp_fsm[unit]);
482 * ipv6cp_close - Take IPV6CP down.
485 ipv6cp_close(int unit, char *reason)
487 fsm_close(&ipv6cp_fsm[unit], reason);
492 * ipv6cp_lowerup - The lower layer is up.
495 ipv6cp_lowerup(int unit)
497 fsm_lowerup(&ipv6cp_fsm[unit]);
502 * ipv6cp_lowerdown - The lower layer is down.
505 ipv6cp_lowerdown(int unit)
507 fsm_lowerdown(&ipv6cp_fsm[unit]);
512 * ipv6cp_input - Input IPV6CP packet.
515 ipv6cp_input(int unit, u_char *p, int len)
517 fsm_input(&ipv6cp_fsm[unit], p, len);
522 * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP.
524 * Pretend the lower layer went down, so we shut up.
527 ipv6cp_protrej(int unit)
529 fsm_lowerdown(&ipv6cp_fsm[unit]);
534 * ipv6cp_resetci - Reset our CI.
537 ipv6cp_resetci(fsm *f)
539 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
540 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
542 wo->req_ifaceid = wo->neg_ifaceid && ipv6cp_allowoptions[f->unit].neg_ifaceid;
544 if (!wo->opt_local) {
545 wo->accept_local = 1;
547 eui64_magic_nz(wo->ourid);
550 wo->accept_remote = 1;
553 eui64_zero(go->hisid); /* last proposed interface identifier */
558 * ipv6cp_cilen - Return length of our CI.
563 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
565 #define LENCIVJ(neg) (neg ? CILEN_COMPRESS : 0)
566 #define LENCIIFACEID(neg) (neg ? CILEN_IFACEID : 0)
568 return (LENCIIFACEID(go->neg_ifaceid) +
569 LENCIVJ(go->neg_vj));
574 * ipv6cp_addci - Add our desired CIs to a packet.
577 ipv6cp_addci(fsm *f, u_char *ucp, int *lenp)
579 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
582 #define ADDCIVJ(opt, neg, val) \
584 int vjlen = CILEN_COMPRESS; \
585 if (len >= vjlen) { \
587 PUTCHAR(vjlen, ucp); \
588 PUTSHORT(val, ucp); \
594 #define ADDCIIFACEID(opt, neg, val1) \
596 int idlen = CILEN_IFACEID; \
597 if (len >= idlen) { \
599 PUTCHAR(idlen, ucp); \
600 eui64_put(val1, ucp); \
606 ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
608 ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
615 * ipv6cp_ackci - Ack our CIs.
622 ipv6cp_ackci(fsm *f, u_char *p, int len)
624 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
625 u_short cilen, citype, cishort;
629 * CIs must be in exactly the same order that we sent...
630 * Check packet length and CI length at each step.
631 * If we find any deviations, then this packet is bad.
634 #define ACKCIVJ(opt, neg, val) \
636 int vjlen = CILEN_COMPRESS; \
637 if ((len -= vjlen) < 0) \
639 GETCHAR(citype, p); \
641 if (cilen != vjlen || \
644 GETSHORT(cishort, p); \
645 if (cishort != val) \
649 #define ACKCIIFACEID(opt, neg, val1) \
651 int idlen = CILEN_IFACEID; \
652 if ((len -= idlen) < 0) \
654 GETCHAR(citype, p); \
656 if (cilen != idlen || \
659 eui64_get(ifaceid, p); \
660 if (! eui64_equals(val1, ifaceid)) \
664 ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
666 ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
669 * If there are any remaining CIs, then this packet is bad.
676 IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!"));
681 * ipv6cp_nakci - Peer has sent a NAK for some of our CIs.
682 * This should not modify any state if the Nak is bad
683 * or if IPV6CP is in the OPENED state.
690 ipv6cp_nakci(fsm *f, u_char *p, int len, int treat_as_reject)
692 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
693 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
694 u_char citype, cilen, *next;
697 ipv6cp_options no; /* options we've seen Naks for */
698 ipv6cp_options try; /* options to request next time */
700 BZERO(&no, sizeof(no));
704 * Any Nak'd CIs must be in exactly the same order that we sent.
705 * Check packet length and CI length at each step.
706 * If we find any deviations, then this packet is bad.
708 #define NAKCIIFACEID(opt, neg, code) \
710 len >= (cilen = CILEN_IFACEID) && \
715 eui64_get(ifaceid, p); \
720 #define NAKCIVJ(opt, neg, code) \
722 ((cilen = p[1]) == CILEN_COMPRESS) && \
727 GETSHORT(cishort, p); \
733 * Accept the peer's idea of {our,his} interface identifier, if different
734 * from our idea, only if the accept_{local,remote} flag is set.
736 NAKCIIFACEID(CI_IFACEID, neg_ifaceid,
737 if (treat_as_reject) {
739 } else if (go->accept_local && !eui64_iszero(ifaceid) && !eui64_equals(ifaceid, go->hisid)) {
741 } else if (eui64_iszero(ifaceid) && !go->opt_local && wo->neg_ifaceid) {
742 while (eui64_iszero(ifaceid) ||
743 eui64_equals(ifaceid, go->hisid)) /* bad luck */
744 eui64_magic(ifaceid);
746 IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid)));
751 NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
753 if (cishort == IPV6CP_COMP && !treat_as_reject) {
754 try.vj_protocol = cishort;
761 NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
769 * There may be remaining CIs, if the peer is requesting negotiation
770 * on an option that we didn't include in our request packet.
771 * If they want to negotiate about interface identifier, we comply.
772 * If they want us to ask for compression, we refuse.
774 while (len >= CILEN_VOID) {
777 if ( cilen < CILEN_VOID || (len -= cilen) < 0 )
779 next = p + cilen - 2;
782 case CI_COMPRESSTYPE:
783 if (go->neg_vj || no.neg_vj ||
784 (cilen != CILEN_COMPRESS))
789 if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID)
792 eui64_get(ifaceid, p);
793 if (go->accept_local && !eui64_iszero(ifaceid) && !eui64_equals(ifaceid, go->hisid)) {
795 } else if (eui64_iszero(ifaceid) && !go->opt_local && wo->neg_ifaceid) {
796 while (eui64_iszero(ifaceid) ||
797 eui64_equals(ifaceid, go->hisid)) /* bad luck */
798 eui64_magic(ifaceid);
809 /* If there is still anything left, this packet is bad. */
814 * OK, the Nak is good. Now we can update state.
816 if (f->state != OPENED)
822 IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!"));
828 * ipv6cp_rejci - Reject some of our CIs.
831 ipv6cp_rejci(fsm *f, u_char *p, int len)
833 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
837 ipv6cp_options try; /* options to request next time */
841 * Any Rejected CIs must be in exactly the same order that we sent.
842 * Check packet length and CI length at each step.
843 * If we find any deviations, then this packet is bad.
845 #define REJCIIFACEID(opt, neg, val1) \
847 len >= (cilen = CILEN_IFACEID) && \
852 eui64_get(ifaceid, p); \
853 /* Check rejected value. */ \
854 if (! eui64_equals(ifaceid, val1)) \
859 #define REJCIVJ(opt, neg, val) \
861 p[1] == CILEN_COMPRESS && \
866 GETSHORT(cishort, p); \
867 /* Check rejected value. */ \
868 if (cishort != val) \
873 REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid);
875 REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol);
878 * If there are any remaining CIs, then this packet is bad.
883 * Now we can update state.
885 if (f->state != OPENED)
890 IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!"));
896 * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response.
898 * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
899 * appropriately. If reject_if_disagree is non-zero, doesn't return
900 * CONFNAK; returns CONFREJ if it can't return CONFACK.
903 ipv6cp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree)
905 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
906 ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
907 ipv6cp_options *ao = &ipv6cp_allowoptions[f->unit];
908 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
909 u_char *cip, *next; /* Pointer to current and next CIs */
910 u_short cilen, citype; /* Parsed len, type */
911 u_short cishort; /* Parsed short value */
912 eui64_t ifaceid; /* Parsed interface identifier */
913 int rc = CONFACK; /* Final packet return code */
914 int orc; /* Individual option return code */
915 u_char *p; /* Pointer to next char to parse */
916 u_char *ucp = inp; /* Pointer to current output char */
917 int l = *len; /* Length left */
920 * Reset all his options.
922 BZERO(ho, sizeof(*ho));
925 * Process all his options.
929 orc = CONFACK; /* Assume success */
930 cip = p = next; /* Remember begining of CI */
931 if (l < 2 || /* Not enough data for CI header or */
932 p[1] < 2 || /* CI length too small or */
933 p[1] > l) { /* CI length too big? */
934 IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!"));
935 orc = CONFREJ; /* Reject bad CI */
936 cilen = l; /* Reject till end of packet */
937 l = 0; /* Don't loop again */
940 GETCHAR(citype, p); /* Parse CI type */
941 GETCHAR(cilen, p); /* Parse CI length */
942 l -= cilen; /* Adjust remaining length */
943 next += cilen; /* Step to next CI */
945 switch (citype) { /* Check CI type */
947 IPV6CPDEBUG(("ipv6cp: received interface identifier "));
949 if (!ao->neg_ifaceid ||
950 cilen != CILEN_IFACEID) { /* Check CI length */
951 orc = CONFREJ; /* Reject CI */
956 * If he has no interface identifier, or if we both have same
957 * identifier then NAK it with new idea.
958 * In particular, if we don't know his identifier, but he does,
961 eui64_get(ifaceid, p);
962 IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid)));
963 if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) {
964 orc = CONFREJ; /* Reject CI */
967 if (!eui64_iszero(wo->hisid) && !wo->accept_remote &&
968 !eui64_equals(ifaceid, wo->hisid)) {
973 DECPTR(sizeof(ifaceid), p);
974 eui64_put(ifaceid, p);
976 if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) {
978 if (eui64_iszero(go->hisid)) /* first time, try option */
980 if (eui64_equals(ifaceid, go->ourid)) /* bad luck */
982 if (eui64_iszero(ifaceid)) {
986 while (eui64_iszero(ifaceid) ||
987 eui64_equals(ifaceid, go->ourid)) /* bad luck */
988 eui64_magic(ifaceid);
992 DECPTR(sizeof(ifaceid), p);
993 eui64_put(ifaceid, p);
1000 case CI_COMPRESSTYPE:
1001 IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE "));
1003 (cilen != CILEN_COMPRESS)) {
1007 GETSHORT(cishort, p);
1008 IPV6CPDEBUG(("(%d)", cishort));
1011 if (!(cishort == IPV6CP_COMP)) {
1017 ho->vj_protocol = cishort;
1030 IPV6CPDEBUG((" (%s)\n", CODENAME(orc)));
1032 if (orc == CONFACK && /* Good CI */
1033 rc != CONFACK) /* but prior CI wasnt? */
1034 continue; /* Don't send this one */
1036 if (orc == CONFNAK) { /* Nak this CI? */
1037 if (reject_if_disagree) /* Getting fed up with sending NAKs? */
1038 orc = CONFREJ; /* Get tough if so */
1040 if (rc == CONFREJ) /* Rejecting prior CI? */
1041 continue; /* Don't send this one */
1042 if (rc == CONFACK) { /* Ack'd all prior CIs? */
1043 rc = CONFNAK; /* Not anymore... */
1044 ucp = inp; /* Backup */
1049 if (orc == CONFREJ && /* Reject this CI */
1050 rc != CONFREJ) { /* but no prior ones? */
1052 ucp = inp; /* Backup */
1055 /* Need to move CI? */
1057 BCOPY(cip, ucp, cilen); /* Move it */
1059 /* Update output pointer */
1064 * If we aren't rejecting this packet, and we want to negotiate
1065 * their identifier and they didn't send their identifier, then we
1066 * send a NAK with a CI_IFACEID option appended. We assume the
1067 * input buffer is long enough that we can append the extra
1070 if (rc != CONFREJ && !ho->neg_ifaceid &&
1071 wo->req_ifaceid && !reject_if_disagree) {
1072 if (rc == CONFACK) {
1074 ucp = inp; /* reset pointer */
1075 wo->req_ifaceid = 0; /* don't ask again */
1077 PUTCHAR(CI_IFACEID, ucp);
1078 PUTCHAR(CILEN_IFACEID, ucp);
1079 eui64_put(wo->hisid, ucp);
1082 *len = ucp - inp; /* Compute output length */
1083 IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc)));
1084 return (rc); /* Return final code */
1089 * eui48_to_eui64 - Convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
1092 eui48_to_eui64(eui64_t *p_eui64, const u_char addr[6])
1094 p_eui64->e8[0] = addr[0] | 0x02;
1095 p_eui64->e8[1] = addr[1];
1096 p_eui64->e8[2] = addr[2];
1097 p_eui64->e8[3] = 0xFF;
1098 p_eui64->e8[4] = 0xFE;
1099 p_eui64->e8[5] = addr[3];
1100 p_eui64->e8[6] = addr[4];
1101 p_eui64->e8[7] = addr[5];
1106 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
1108 * walks the list of valid ethernet interfaces, starting with devnam
1109 * (for PPPoE it is ethernet interface), and convert the first
1110 * found 48-bit MAC address into EUI 64. caller also assumes that
1111 * the system has a properly configured Ethernet interface for this
1112 * function to return non-zero.
1115 ether_to_eui64(eui64_t *p_eui64)
1119 if (get_if_hwaddr(addr, devnam) < 0 && get_first_ether_hwaddr(addr) < 0) {
1120 error("ipv6cp: no persistent id can be found");
1124 eui48_to_eui64(p_eui64, addr);
1130 * ipv6_check_options - check that any IP-related options are OK,
1131 * and assign appropriate defaults.
1134 ipv6_check_options(void)
1136 ipv6cp_options *wo = &ipv6cp_wantoptions[0];
1138 if (!ipv6cp_protent.enabled_flag)
1142 * Persistent link-local id is only used when user has not explicitly
1143 * configure/hard-code the id
1145 if ((wo->use_persistent) && (!wo->opt_local)) {
1148 * On systems where there are no Ethernet interfaces used, there
1149 * may be other ways to obtain a persistent id. Right now, it
1150 * will fall back to using magic [see eui64_magic] below when
1151 * an EUI-48 from MAC address can't be obtained. Other possibilities
1152 * include obtaining EEPROM serial numbers, or some other unique
1153 * yet persistent number. On Sparc platforms, this is possible,
1154 * but too bad there's no standards yet for x86 machines.
1156 if (ether_to_eui64(&wo->ourid)) {
1161 if (!wo->opt_remote && wo->use_remotenumber && *remote_number) {
1162 /* remote number can be either MAC address, IPv4 address, IPv6 address or telephone number */
1163 struct in_addr addr;
1164 struct in6_addr addr6;
1165 unsigned long long tel;
1166 unsigned char mac[6];
1169 if (sscanf(remote_number, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
1170 &mac[0], &mac[1], &mac[2],
1171 &mac[3], &mac[4], &mac[5]) == 6) {
1172 eui48_to_eui64(&wo->hisid, mac);
1173 } else if (inet_pton(AF_INET, remote_number, &addr) == 1) {
1174 eui64_setlo32(wo->hisid, ntohl(addr.s_addr));
1175 } else if (inet_pton(AF_INET6, remote_number, &addr6) == 1) {
1176 /* use low 64 bits of IPv6 address for interface identifier */
1177 wo->hisid.e8[0] = addr6.s6_addr[8];
1178 wo->hisid.e8[1] = addr6.s6_addr[9];
1179 wo->hisid.e8[2] = addr6.s6_addr[10];
1180 wo->hisid.e8[3] = addr6.s6_addr[11];
1181 wo->hisid.e8[4] = addr6.s6_addr[12];
1182 wo->hisid.e8[5] = addr6.s6_addr[13];
1183 wo->hisid.e8[6] = addr6.s6_addr[14];
1184 wo->hisid.e8[7] = addr6.s6_addr[15];
1186 str = remote_number;
1187 /* telephone number may start with leading '+' sign, so skip it */
1191 tel = strtoull(str, &endptr, 10);
1192 if (!errno && *str && !*endptr && tel) {
1193 wo->hisid.e32[0] = htonl(tel >> 32);
1194 wo->hisid.e32[1] = htonl(tel & 0xFFFFFFFF);
1197 if (!eui64_iszero(wo->hisid))
1201 if (!wo->opt_local) { /* init interface identifier */
1202 if (wo->use_ip && eui64_iszero(wo->ourid)) {
1203 eui64_setlo32(wo->ourid, ntohl(ipcp_wantoptions[0].ouraddr));
1204 if (!eui64_iszero(wo->ourid))
1208 while (eui64_iszero(wo->ourid))
1209 eui64_magic(wo->ourid);
1212 if (!wo->opt_remote) {
1213 if (wo->use_ip && eui64_iszero(wo->hisid)) {
1214 eui64_setlo32(wo->hisid, ntohl(ipcp_wantoptions[0].hisaddr));
1215 if (!eui64_iszero(wo->hisid))
1223 * ipv6_demand_conf - configure the interface as though
1224 * IPV6CP were up, for use with dial-on-demand.
1227 ipv6_demand_conf(int u)
1229 ipv6cp_options *wo = &ipv6cp_wantoptions[u];
1231 if (eui64_iszero(wo->hisid) && !ipv6cp_noremote) {
1232 /* make up an arbitrary identifier for the peer */
1233 eui64_magic_nz(wo->hisid);
1235 if (eui64_iszero(wo->ourid)) {
1236 /* make up an arbitrary identifier for us */
1237 eui64_magic_nz(wo->ourid);
1242 if (!sif6addr(u, wo->ourid, wo->hisid))
1244 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1248 if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE))
1250 if (wo->default_route)
1251 if (sif6defaultroute(u, wo->ourid, wo->hisid))
1252 default_route_set[u] = 1;
1254 notice("local LL address %s", llv6_ntoa(wo->ourid));
1255 if (!eui64_iszero(wo->hisid))
1256 notice("remote LL address %s", llv6_ntoa(wo->hisid));
1263 * ipv6cp_up - IPV6CP has come UP.
1265 * Configure the IPv6 network interface appropriately and bring it up.
1270 ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
1271 ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
1272 ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
1274 IPV6CPDEBUG(("ipv6cp: up"));
1277 * We must have a non-zero LL address for both ends of the link.
1280 if (!eui64_iszero(wo->hisid) && !wo->accept_remote && (!ho->neg_ifaceid || !eui64_equals(ho->hisid, wo->hisid))) {
1281 error("Peer refused to agree to his interface identifier");
1282 ipv6cp_close(f->unit, "Refused his interface identifier");
1285 if (!ho->neg_ifaceid)
1286 ho->hisid = wo->hisid;
1288 if(!no_ifaceid_neg) {
1289 if (eui64_iszero(ho->hisid) && !ipv6cp_noremote) {
1290 error("Could not determine remote LL address");
1291 ipv6cp_close(f->unit, "Could not determine remote LL address");
1294 if (eui64_iszero(go->ourid)) {
1295 error("Could not determine local LL address");
1296 ipv6cp_close(f->unit, "Could not determine local LL address");
1299 if (eui64_equals(go->ourid, ho->hisid)) {
1300 error("local and remote LL addresses are equal");
1301 ipv6cp_close(f->unit, "local and remote LL addresses are equal");
1305 script_setenv("LLLOCAL", llv6_ntoa(go->ourid), 0);
1306 if (!eui64_iszero(ho->hisid))
1307 script_setenv("LLREMOTE", llv6_ntoa(ho->hisid), 0);
1310 /* set tcp compression */
1311 sif6comp(f->unit, ho->neg_vj);
1315 * If we are doing dial-on-demand, the interface is already
1316 * configured, so we put out any saved-up packets, then set the
1317 * interface to pass IPv6 packets.
1320 if (! eui64_equals(go->ourid, wo->ourid) ||
1321 ! eui64_equals(ho->hisid, wo->hisid)) {
1322 if (! eui64_equals(go->ourid, wo->ourid))
1323 warn("Local LL address changed to %s",
1324 llv6_ntoa(go->ourid));
1325 if (! eui64_equals(ho->hisid, wo->hisid))
1326 warn("Remote LL address changed to %s",
1327 llv6_ntoa(ho->hisid));
1328 ipv6cp_clear_addrs(f->unit, wo->ourid, wo->hisid);
1330 /* Set the interface to the new addresses */
1331 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1333 warn("sif6addr failed");
1334 ipv6cp_close(f->unit, "Interface configuration failed");
1338 /* assign a default route through the interface if required */
1339 if (ipv6cp_wantoptions[f->unit].default_route)
1340 if (sif6defaultroute(f->unit, go->ourid, ho->hisid))
1341 default_route_set[f->unit] = 1;
1343 demand_rexmit(PPP_IPV6);
1344 sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1347 /* bring the interface up for IPv6 */
1348 if (!sif6up(f->unit)) {
1350 warn("sif6up failed (IPV6)");
1351 ipv6cp_close(f->unit, "Interface configuration failed");
1355 if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1357 warn("sif6addr failed");
1358 ipv6cp_close(f->unit, "Interface configuration failed");
1361 sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1363 /* assign a default route through the interface if required */
1364 if (ipv6cp_wantoptions[f->unit].default_route)
1365 if (sif6defaultroute(f->unit, go->ourid, ho->hisid))
1366 default_route_set[f->unit] = 1;
1368 notice("local LL address %s", llv6_ntoa(go->ourid));
1369 if (!eui64_iszero(ho->hisid))
1370 notice("remote LL address %s", llv6_ntoa(ho->hisid));
1373 np_up(f->unit, PPP_IPV6);
1376 notify(ipv6_up_notifier, 0);
1381 * Execute the ipv6-up script, like this:
1382 * /etc/ppp/ipv6-up interface tty speed local-LL remote-LL
1384 if (ipv6cp_script_state == s_down && ipv6cp_script_pid == 0) {
1385 ipv6cp_script_state = s_up;
1386 ipv6cp_script(path_ipv6up);
1392 * ipv6cp_down - IPV6CP has gone DOWN.
1394 * Take the IPv6 network interface down, clear its addresses
1395 * and delete routes through it.
1400 IPV6CPDEBUG(("ipv6cp: down"));
1401 update_link_stats(f->unit);
1402 notify(ipv6_down_notifier, 0);
1407 np_down(f->unit, PPP_IPV6);
1410 sif6comp(f->unit, 0);
1414 * If we are doing dial-on-demand, set the interface
1415 * to queue up outgoing packets (for now).
1418 sifnpmode(f->unit, PPP_IPV6, NPMODE_QUEUE);
1420 sifnpmode(f->unit, PPP_IPV6, NPMODE_DROP);
1421 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC)))
1424 ipv6cp_clear_addrs(f->unit,
1425 ipv6cp_gotoptions[f->unit].ourid,
1426 ipv6cp_hisoptions[f->unit].hisid);
1427 #if defined(__linux__)
1429 #elif defined(SVR4) && (defined(SNI) || defined(__USLC))
1434 /* Execute the ipv6-down script */
1435 if (ipv6cp_script_state == s_up && ipv6cp_script_pid == 0) {
1436 ipv6cp_script_state = s_down;
1437 ipv6cp_script(path_ipv6down);
1443 * ipv6cp_clear_addrs() - clear the interface addresses, routes,
1444 * proxy neighbour discovery entries, etc.
1447 ipv6cp_clear_addrs(int unit, eui64_t ourid, eui64_t hisid)
1449 cif6addr(unit, ourid, hisid);
1454 * ipv6cp_finished - possibly shut down the lower layers.
1457 ipv6cp_finished(fsm *f)
1459 np_finished(f->unit, PPP_IPV6);
1464 * ipv6cp_script_done - called when the ipv6-up or ipv6-down script
1468 ipv6cp_script_done(void *arg)
1470 ipv6cp_script_pid = 0;
1471 switch (ipv6cp_script_state) {
1473 if (ipv6cp_fsm[0].state != OPENED) {
1474 ipv6cp_script_state = s_down;
1475 ipv6cp_script(path_ipv6down);
1479 if (ipv6cp_fsm[0].state == OPENED) {
1480 ipv6cp_script_state = s_up;
1481 ipv6cp_script(path_ipv6up);
1489 * ipv6cp_script - Execute a script with arguments
1490 * interface-name tty-name speed local-LL remote-LL.
1493 ipv6cp_script(char *script)
1495 char strspeed[32], strlocal[32], strremote[32];
1498 sprintf(strspeed, "%d", baud_rate);
1499 strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid));
1500 strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid));
1507 argv[5] = strremote;
1511 ipv6cp_script_pid = run_program(script, argv, 0, ipv6cp_script_done,
1516 * ipv6cp_printpkt - print the contents of an IPV6CP packet.
1518 static char *ipv6cp_codenames[] = {
1519 "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1520 "TermReq", "TermAck", "CodeRej"
1524 ipv6cp_printpkt(u_char *p, int plen,
1525 void (*printer) (void *, char *, ...), void *arg)
1527 int code, id, len, olen;
1528 u_char *pstart, *optend;
1532 if (plen < HEADERLEN)
1538 if (len < HEADERLEN || len > plen)
1541 if (code >= 1 && code <= sizeof(ipv6cp_codenames) / sizeof(char *))
1542 printer(arg, " %s", ipv6cp_codenames[code-1]);
1544 printer(arg, " code=0x%x", code);
1545 printer(arg, " id=0x%x", id);
1552 /* print option list */
1557 if (olen < 2 || olen > len) {
1564 case CI_COMPRESSTYPE:
1565 if (olen >= CILEN_COMPRESS) {
1567 GETSHORT(cishort, p);
1568 printer(arg, "compress ");
1569 printer(arg, "0x%x", cishort);
1573 if (olen == CILEN_IFACEID) {
1575 eui64_get(ifaceid, p);
1576 printer(arg, "addr %s", llv6_ntoa(ifaceid));
1580 while (p < optend) {
1582 printer(arg, " %.2x", code);
1590 if (len > 0 && *p >= ' ' && *p < 0x7f) {
1592 print_string((char *)p, len, printer, arg);
1599 /* print the rest of the bytes in the packet */
1600 for (; len > 0; --len) {
1602 printer(arg, " %.2x", code);
1609 * ipv6_active_pkt - see if this IP packet is worth bringing the link up for.
1610 * We don't bring the link up for IP fragments or for TCP FIN packets
1613 #define IP6_HDRLEN 40 /* bytes */
1614 #define IP6_NHDR_FRAG 44 /* fragment IPv6 header */
1615 #define TCP_HDRLEN 20
1619 * We use these macros because the IP header may be at an odd address,
1620 * and some compilers might use word loads to get th_off or ip_hl.
1623 #define get_ip6nh(x) (((unsigned char *)(x))[6])
1624 #define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4)
1625 #define get_tcpflags(x) (((unsigned char *)(x))[13])
1628 ipv6_active_pkt(u_char *pkt, int len)
1634 if (len < IP6_HDRLEN)
1636 if (get_ip6nh(pkt) == IP6_NHDR_FRAG)
1638 if (get_ip6nh(pkt) != IPPROTO_TCP)
1640 if (len < IP6_HDRLEN + TCP_HDRLEN)
1642 tcp = pkt + IP6_HDRLEN;
1643 if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4)