pppd: Add lcp-echo-adaptive option
[ppp.git] / pppd / ccp.c
1 /*
2  * ccp.c - PPP Compression Control Protocol.
3  *
4  * Copyright (c) 1994-2002 Paul Mackerras. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. The name(s) of the authors of this software must not be used to
14  *    endorse or promote products derived from this software without
15  *    prior written permission.
16  *
17  * 3. Redistributions of any form whatsoever must retain the following
18  *    acknowledgment:
19  *    "This product includes software developed by Paul Mackerras
20  *     <paulus@samba.org>".
21  *
22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29  */
30
31 #define RCSID   "$Id: ccp.c,v 1.50 2005/06/26 19:34:41 carlsonj Exp $"
32
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include "pppd.h"
37 #include "fsm.h"
38 #include "ccp.h"
39 #include <net/ppp-comp.h>
40
41 #ifdef MPPE
42 #include "chap_ms.h"    /* mppe_xxxx_key, mppe_keys_set */
43 #include "lcp.h"        /* lcp_close(), lcp_fsm */
44 #endif
45
46
47 /*
48  * Unfortunately there is a bug in zlib which means that using a
49  * size of 8 (window size = 256) for Deflate compression will cause
50  * buffer overruns and kernel crashes in the deflate module.
51  * Until this is fixed we only accept sizes in the range 9 .. 15.
52  * Thanks to James Carlson for pointing this out.
53  */
54 #define DEFLATE_MIN_WORKS       9
55
56 /*
57  * Command-line options.
58  */
59 static int setbsdcomp __P((char **));
60 static int setdeflate __P((char **));
61 static char bsd_value[8];
62 static char deflate_value[8];
63
64 /*
65  * Option variables.
66  */
67 #ifdef MPPE
68 bool refuse_mppe_stateful = 1;          /* Allow stateful mode? */
69 #endif
70
71 static option_t ccp_option_list[] = {
72     { "noccp", o_bool, &ccp_protent.enabled_flag,
73       "Disable CCP negotiation" },
74     { "-ccp", o_bool, &ccp_protent.enabled_flag,
75       "Disable CCP negotiation", OPT_ALIAS },
76
77     { "bsdcomp", o_special, (void *)setbsdcomp,
78       "Request BSD-Compress packet compression",
79       OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, bsd_value },
80     { "nobsdcomp", o_bool, &ccp_wantoptions[0].bsd_compress,
81       "don't allow BSD-Compress", OPT_PRIOSUB | OPT_A2CLR,
82       &ccp_allowoptions[0].bsd_compress },
83     { "-bsdcomp", o_bool, &ccp_wantoptions[0].bsd_compress,
84       "don't allow BSD-Compress", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR,
85       &ccp_allowoptions[0].bsd_compress },
86
87     { "deflate", o_special, (void *)setdeflate,
88       "request Deflate compression",
89       OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, deflate_value },
90     { "nodeflate", o_bool, &ccp_wantoptions[0].deflate,
91       "don't allow Deflate compression", OPT_PRIOSUB | OPT_A2CLR,
92       &ccp_allowoptions[0].deflate },
93     { "-deflate", o_bool, &ccp_wantoptions[0].deflate,
94       "don't allow Deflate compression", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR,
95       &ccp_allowoptions[0].deflate },
96
97     { "nodeflatedraft", o_bool, &ccp_wantoptions[0].deflate_draft,
98       "don't use draft deflate #", OPT_A2COPY,
99       &ccp_allowoptions[0].deflate_draft },
100
101     { "predictor1", o_bool, &ccp_wantoptions[0].predictor_1,
102       "request Predictor-1", OPT_PRIO | 1 },
103     { "nopredictor1", o_bool, &ccp_wantoptions[0].predictor_1,
104       "don't allow Predictor-1", OPT_PRIOSUB | OPT_A2CLR,
105       &ccp_allowoptions[0].predictor_1 },
106     { "-predictor1", o_bool, &ccp_wantoptions[0].predictor_1,
107       "don't allow Predictor-1", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR,
108       &ccp_allowoptions[0].predictor_1 },
109
110 #ifdef MPPE
111     /* MPPE options are symmetrical ... we only set wantoptions here */
112     { "require-mppe", o_bool, &ccp_wantoptions[0].mppe,
113       "require MPPE encryption",
114       OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 },
115     { "+mppe", o_bool, &ccp_wantoptions[0].mppe,
116       "require MPPE encryption",
117       OPT_ALIAS | OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 },
118     { "nomppe", o_bool, &ccp_wantoptions[0].mppe,
119       "don't allow MPPE encryption", OPT_PRIO },
120     { "-mppe", o_bool, &ccp_wantoptions[0].mppe,
121       "don't allow MPPE encryption", OPT_ALIAS | OPT_PRIO },
122
123     /* We use ccp_allowoptions[0].mppe as a junk var ... it is reset later */
124     { "require-mppe-40", o_bool, &ccp_allowoptions[0].mppe,
125       "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40,
126       &ccp_wantoptions[0].mppe },
127     { "+mppe-40", o_bool, &ccp_allowoptions[0].mppe,
128       "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40,
129       &ccp_wantoptions[0].mppe },
130     { "nomppe-40", o_bool, &ccp_allowoptions[0].mppe,
131       "don't allow MPPE 40-bit encryption",
132       OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, &ccp_wantoptions[0].mppe },
133     { "-mppe-40", o_bool, &ccp_allowoptions[0].mppe,
134       "don't allow MPPE 40-bit encryption",
135       OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40,
136       &ccp_wantoptions[0].mppe },
137
138     { "require-mppe-128", o_bool, &ccp_allowoptions[0].mppe,
139       "require MPPE 128-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_128,
140       &ccp_wantoptions[0].mppe },
141     { "+mppe-128", o_bool, &ccp_allowoptions[0].mppe,
142       "require MPPE 128-bit encryption",
143       OPT_ALIAS | OPT_PRIO | OPT_A2OR | MPPE_OPT_128,
144       &ccp_wantoptions[0].mppe },
145     { "nomppe-128", o_bool, &ccp_allowoptions[0].mppe,
146       "don't allow MPPE 128-bit encryption",
147       OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, &ccp_wantoptions[0].mppe },
148     { "-mppe-128", o_bool, &ccp_allowoptions[0].mppe,
149       "don't allow MPPE 128-bit encryption",
150       OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128,
151       &ccp_wantoptions[0].mppe },
152
153     /* strange one; we always request stateless, but will we allow stateful? */
154     { "mppe-stateful", o_bool, &refuse_mppe_stateful,
155       "allow MPPE stateful mode", OPT_PRIO },
156     { "nomppe-stateful", o_bool, &refuse_mppe_stateful,
157       "disallow MPPE stateful mode", OPT_PRIO | 1 },
158 #endif /* MPPE */
159
160     { NULL }
161 };
162
163 /*
164  * Protocol entry points from main code.
165  */
166 static void ccp_init __P((int unit));
167 static void ccp_open __P((int unit));
168 static void ccp_close __P((int unit, char *));
169 static void ccp_lowerup __P((int unit));
170 static void ccp_lowerdown __P((int));
171 static void ccp_input __P((int unit, u_char *pkt, int len));
172 static void ccp_protrej __P((int unit));
173 static int  ccp_printpkt __P((u_char *pkt, int len,
174                               void (*printer) __P((void *, char *, ...)),
175                               void *arg));
176 static void ccp_datainput __P((int unit, u_char *pkt, int len));
177
178 struct protent ccp_protent = {
179     PPP_CCP,
180     ccp_init,
181     ccp_input,
182     ccp_protrej,
183     ccp_lowerup,
184     ccp_lowerdown,
185     ccp_open,
186     ccp_close,
187     ccp_printpkt,
188     ccp_datainput,
189     1,
190     "CCP",
191     "Compressed",
192     ccp_option_list,
193     NULL,
194     NULL,
195     NULL
196 };
197
198 fsm ccp_fsm[NUM_PPP];
199 ccp_options ccp_wantoptions[NUM_PPP];   /* what to request the peer to use */
200 ccp_options ccp_gotoptions[NUM_PPP];    /* what the peer agreed to do */
201 ccp_options ccp_allowoptions[NUM_PPP];  /* what we'll agree to do */
202 ccp_options ccp_hisoptions[NUM_PPP];    /* what we agreed to do */
203
204 /*
205  * Callbacks for fsm code.
206  */
207 static void ccp_resetci __P((fsm *));
208 static int  ccp_cilen __P((fsm *));
209 static void ccp_addci __P((fsm *, u_char *, int *));
210 static int  ccp_ackci __P((fsm *, u_char *, int));
211 static int  ccp_nakci __P((fsm *, u_char *, int, int));
212 static int  ccp_rejci __P((fsm *, u_char *, int));
213 static int  ccp_reqci __P((fsm *, u_char *, int *, int));
214 static void ccp_up __P((fsm *));
215 static void ccp_down __P((fsm *));
216 static int  ccp_extcode __P((fsm *, int, int, u_char *, int));
217 static void ccp_rack_timeout __P((void *));
218 static char *method_name __P((ccp_options *, ccp_options *));
219
220 static fsm_callbacks ccp_callbacks = {
221     ccp_resetci,
222     ccp_cilen,
223     ccp_addci,
224     ccp_ackci,
225     ccp_nakci,
226     ccp_rejci,
227     ccp_reqci,
228     ccp_up,
229     ccp_down,
230     NULL,
231     NULL,
232     NULL,
233     NULL,
234     ccp_extcode,
235     "CCP"
236 };
237
238 /*
239  * Do we want / did we get any compression?
240  */
241 #define ANY_COMPRESS(opt)       ((opt).deflate || (opt).bsd_compress \
242                                  || (opt).predictor_1 || (opt).predictor_2 \
243                                  || (opt).mppe)
244
245 /*
246  * Local state (mainly for handling reset-reqs and reset-acks).
247  */
248 static int ccp_localstate[NUM_PPP];
249 #define RACK_PENDING    1       /* waiting for reset-ack */
250 #define RREQ_REPEAT     2       /* send another reset-req if no reset-ack */
251
252 #define RACKTIMEOUT     1       /* second */
253
254 static int all_rejected[NUM_PPP];       /* we rejected all peer's options */
255
256 /*
257  * Option parsing.
258  */
259 static int
260 setbsdcomp(argv)
261     char **argv;
262 {
263     int rbits, abits;
264     char *str, *endp;
265
266     str = *argv;
267     abits = rbits = strtol(str, &endp, 0);
268     if (endp != str && *endp == ',') {
269         str = endp + 1;
270         abits = strtol(str, &endp, 0);
271     }
272     if (*endp != 0 || endp == str) {
273         option_error("invalid parameter '%s' for bsdcomp option", *argv);
274         return 0;
275     }
276     if ((rbits != 0 && (rbits < BSD_MIN_BITS || rbits > BSD_MAX_BITS))
277         || (abits != 0 && (abits < BSD_MIN_BITS || abits > BSD_MAX_BITS))) {
278         option_error("bsdcomp option values must be 0 or %d .. %d",
279                      BSD_MIN_BITS, BSD_MAX_BITS);
280         return 0;
281     }
282     if (rbits > 0) {
283         ccp_wantoptions[0].bsd_compress = 1;
284         ccp_wantoptions[0].bsd_bits = rbits;
285     } else
286         ccp_wantoptions[0].bsd_compress = 0;
287     if (abits > 0) {
288         ccp_allowoptions[0].bsd_compress = 1;
289         ccp_allowoptions[0].bsd_bits = abits;
290     } else
291         ccp_allowoptions[0].bsd_compress = 0;
292     slprintf(bsd_value, sizeof(bsd_value),
293              rbits == abits? "%d": "%d,%d", rbits, abits);
294
295     return 1;
296 }
297
298 static int
299 setdeflate(argv)
300     char **argv;
301 {
302     int rbits, abits;
303     char *str, *endp;
304
305     str = *argv;
306     abits = rbits = strtol(str, &endp, 0);
307     if (endp != str && *endp == ',') {
308         str = endp + 1;
309         abits = strtol(str, &endp, 0);
310     }
311     if (*endp != 0 || endp == str) {
312         option_error("invalid parameter '%s' for deflate option", *argv);
313         return 0;
314     }
315     if ((rbits != 0 && (rbits < DEFLATE_MIN_SIZE || rbits > DEFLATE_MAX_SIZE))
316         || (abits != 0 && (abits < DEFLATE_MIN_SIZE
317                           || abits > DEFLATE_MAX_SIZE))) {
318         option_error("deflate option values must be 0 or %d .. %d",
319                      DEFLATE_MIN_SIZE, DEFLATE_MAX_SIZE);
320         return 0;
321     }
322     if (rbits == DEFLATE_MIN_SIZE || abits == DEFLATE_MIN_SIZE) {
323         if (rbits == DEFLATE_MIN_SIZE)
324             rbits = DEFLATE_MIN_WORKS;
325         if (abits == DEFLATE_MIN_SIZE)
326             abits = DEFLATE_MIN_WORKS;
327         warn("deflate option value of %d changed to %d to avoid zlib bug",
328              DEFLATE_MIN_SIZE, DEFLATE_MIN_WORKS);
329     }
330     if (rbits > 0) {
331         ccp_wantoptions[0].deflate = 1;
332         ccp_wantoptions[0].deflate_size = rbits;
333     } else
334         ccp_wantoptions[0].deflate = 0;
335     if (abits > 0) {
336         ccp_allowoptions[0].deflate = 1;
337         ccp_allowoptions[0].deflate_size = abits;
338     } else
339         ccp_allowoptions[0].deflate = 0;
340     slprintf(deflate_value, sizeof(deflate_value),
341              rbits == abits? "%d": "%d,%d", rbits, abits);
342
343     return 1;
344 }
345
346 /*
347  * ccp_init - initialize CCP.
348  */
349 static void
350 ccp_init(unit)
351     int unit;
352 {
353     fsm *f = &ccp_fsm[unit];
354
355     f->unit = unit;
356     f->protocol = PPP_CCP;
357     f->callbacks = &ccp_callbacks;
358     fsm_init(f);
359
360     memset(&ccp_wantoptions[unit],  0, sizeof(ccp_options));
361     memset(&ccp_gotoptions[unit],   0, sizeof(ccp_options));
362     memset(&ccp_allowoptions[unit], 0, sizeof(ccp_options));
363     memset(&ccp_hisoptions[unit],   0, sizeof(ccp_options));
364
365     ccp_wantoptions[0].deflate = 1;
366     ccp_wantoptions[0].deflate_size = DEFLATE_MAX_SIZE;
367     ccp_wantoptions[0].deflate_correct = 1;
368     ccp_wantoptions[0].deflate_draft = 1;
369     ccp_allowoptions[0].deflate = 1;
370     ccp_allowoptions[0].deflate_size = DEFLATE_MAX_SIZE;
371     ccp_allowoptions[0].deflate_correct = 1;
372     ccp_allowoptions[0].deflate_draft = 1;
373
374     ccp_wantoptions[0].bsd_compress = 1;
375     ccp_wantoptions[0].bsd_bits = BSD_MAX_BITS;
376     ccp_allowoptions[0].bsd_compress = 1;
377     ccp_allowoptions[0].bsd_bits = BSD_MAX_BITS;
378
379     ccp_allowoptions[0].predictor_1 = 1;
380 }
381
382 /*
383  * ccp_open - CCP is allowed to come up.
384  */
385 static void
386 ccp_open(unit)
387     int unit;
388 {
389     fsm *f = &ccp_fsm[unit];
390
391     if (f->state != OPENED)
392         ccp_flags_set(unit, 1, 0);
393
394     /*
395      * Find out which compressors the kernel supports before
396      * deciding whether to open in silent mode.
397      */
398     ccp_resetci(f);
399     if (!ANY_COMPRESS(ccp_gotoptions[unit]))
400         f->flags |= OPT_SILENT;
401
402     fsm_open(f);
403 }
404
405 /*
406  * ccp_close - Terminate CCP.
407  */
408 static void
409 ccp_close(unit, reason)
410     int unit;
411     char *reason;
412 {
413     ccp_flags_set(unit, 0, 0);
414     fsm_close(&ccp_fsm[unit], reason);
415 }
416
417 /*
418  * ccp_lowerup - we may now transmit CCP packets.
419  */
420 static void
421 ccp_lowerup(unit)
422     int unit;
423 {
424     fsm_lowerup(&ccp_fsm[unit]);
425 }
426
427 /*
428  * ccp_lowerdown - we may not transmit CCP packets.
429  */
430 static void
431 ccp_lowerdown(unit)
432     int unit;
433 {
434     fsm_lowerdown(&ccp_fsm[unit]);
435 }
436
437 /*
438  * ccp_input - process a received CCP packet.
439  */
440 static void
441 ccp_input(unit, p, len)
442     int unit;
443     u_char *p;
444     int len;
445 {
446     fsm *f = &ccp_fsm[unit];
447     int oldstate;
448
449     /*
450      * Check for a terminate-request so we can print a message.
451      */
452     oldstate = f->state;
453     fsm_input(f, p, len);
454     if (oldstate == OPENED && p[0] == TERMREQ && f->state != OPENED) {
455         notice("Compression disabled by peer.");
456 #ifdef MPPE
457         if (ccp_gotoptions[unit].mppe) {
458             error("MPPE disabled, closing LCP");
459             lcp_close(unit, "MPPE disabled by peer");
460         }
461 #endif
462     }
463
464     /*
465      * If we get a terminate-ack and we're not asking for compression,
466      * close CCP.
467      */
468     if (oldstate == REQSENT && p[0] == TERMACK
469         && !ANY_COMPRESS(ccp_gotoptions[unit]))
470         ccp_close(unit, "No compression negotiated");
471 }
472
473 /*
474  * Handle a CCP-specific code.
475  */
476 static int
477 ccp_extcode(f, code, id, p, len)
478     fsm *f;
479     int code, id;
480     u_char *p;
481     int len;
482 {
483     switch (code) {
484     case CCP_RESETREQ:
485         if (f->state != OPENED)
486             break;
487         /* send a reset-ack, which the transmitter will see and
488            reset its compression state. */
489         fsm_sdata(f, CCP_RESETACK, id, NULL, 0);
490         break;
491
492     case CCP_RESETACK:
493         if (ccp_localstate[f->unit] & RACK_PENDING && id == f->reqid) {
494             ccp_localstate[f->unit] &= ~(RACK_PENDING | RREQ_REPEAT);
495             UNTIMEOUT(ccp_rack_timeout, f);
496         }
497         break;
498
499     default:
500         return 0;
501     }
502
503     return 1;
504 }
505
506 /*
507  * ccp_protrej - peer doesn't talk CCP.
508  */
509 static void
510 ccp_protrej(unit)
511     int unit;
512 {
513     ccp_flags_set(unit, 0, 0);
514     fsm_lowerdown(&ccp_fsm[unit]);
515
516 #ifdef MPPE
517     if (ccp_gotoptions[unit].mppe) {
518         error("MPPE required but peer negotiation failed");
519         lcp_close(unit, "MPPE required but peer negotiation failed");
520     }
521 #endif
522
523 }
524
525 /*
526  * ccp_resetci - initialize at start of negotiation.
527  */
528 static void
529 ccp_resetci(f)
530     fsm *f;
531 {
532     ccp_options *go = &ccp_gotoptions[f->unit];
533     u_char opt_buf[CCP_MAX_OPTION_LENGTH];
534
535     *go = ccp_wantoptions[f->unit];
536     all_rejected[f->unit] = 0;
537
538 #ifdef MPPE
539     if (go->mppe) {
540         ccp_options *ao = &ccp_allowoptions[f->unit];
541         int auth_mschap_bits = auth_done[f->unit];
542         int numbits;
543
544         /*
545          * Start with a basic sanity check: mschap[v2] auth must be in
546          * exactly one direction.  RFC 3079 says that the keys are
547          * 'derived from the credentials of the peer that initiated the call',
548          * however the PPP protocol doesn't have such a concept, and pppd
549          * cannot get this info externally.  Instead we do the best we can.
550          * NB: If MPPE is required, all other compression opts are invalid.
551          *     So, we return right away if we can't do it.
552          */
553
554         /* Leave only the mschap auth bits set */
555         auth_mschap_bits &= (CHAP_MS_WITHPEER  | CHAP_MS_PEER |
556                              CHAP_MS2_WITHPEER | CHAP_MS2_PEER);
557         /* Count the mschap auths */
558         auth_mschap_bits >>= CHAP_MS_SHIFT;
559         numbits = 0;
560         do {
561             numbits += auth_mschap_bits & 1;
562             auth_mschap_bits >>= 1;
563         } while (auth_mschap_bits);
564         if (numbits > 1) {
565             error("MPPE required, but auth done in both directions.");
566             lcp_close(f->unit, "MPPE required but not available");
567             return;
568         }
569         if (!numbits) {
570             error("MPPE required, but MS-CHAP[v2] auth not performed.");
571             lcp_close(f->unit, "MPPE required but not available");
572             return;
573         }
574
575         /* A plugin (eg radius) may not have obtained key material. */
576         if (!mppe_keys_set) {
577             error("MPPE required, but keys are not available.  "
578                   "Possible plugin problem?");
579             lcp_close(f->unit, "MPPE required but not available");
580             return;
581         }
582
583         /* LM auth not supported for MPPE */
584         if (auth_done[f->unit] & (CHAP_MS_WITHPEER | CHAP_MS_PEER)) {
585             /* This might be noise */
586             if (go->mppe & MPPE_OPT_40) {
587                 notice("Disabling 40-bit MPPE; MS-CHAP LM not supported");
588                 go->mppe &= ~MPPE_OPT_40;
589                 ccp_wantoptions[f->unit].mppe &= ~MPPE_OPT_40;
590             }
591         }
592
593         /* Last check: can we actually negotiate something? */
594         if (!(go->mppe & (MPPE_OPT_40 | MPPE_OPT_128))) {
595             /* Could be misconfig, could be 40-bit disabled above. */
596             error("MPPE required, but both 40-bit and 128-bit disabled.");
597             lcp_close(f->unit, "MPPE required but not available");
598             return;
599         }
600
601         /* sync options */
602         ao->mppe = go->mppe;
603         /* MPPE is not compatible with other compression types */
604         ao->bsd_compress = go->bsd_compress = 0;
605         ao->predictor_1  = go->predictor_1  = 0;
606         ao->predictor_2  = go->predictor_2  = 0;
607         ao->deflate      = go->deflate      = 0;
608     }
609 #endif /* MPPE */
610
611     /*
612      * Check whether the kernel knows about the various
613      * compression methods we might request.
614      */
615 #ifdef MPPE
616     if (go->mppe) {
617         opt_buf[0] = CI_MPPE;
618         opt_buf[1] = CILEN_MPPE;
619         MPPE_OPTS_TO_CI(go->mppe, &opt_buf[2]);
620         /* Key material unimportant here. */
621         if (ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0) <= 0) {
622             error("MPPE required, but kernel has no support.");
623             lcp_close(f->unit, "MPPE required but not available");
624         }
625     }
626 #endif
627     if (go->bsd_compress) {
628         opt_buf[0] = CI_BSD_COMPRESS;
629         opt_buf[1] = CILEN_BSD_COMPRESS;
630         opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, BSD_MIN_BITS);
631         if (ccp_test(f->unit, opt_buf, CILEN_BSD_COMPRESS, 0) <= 0)
632             go->bsd_compress = 0;
633     }
634     if (go->deflate) {
635         if (go->deflate_correct) {
636             opt_buf[0] = CI_DEFLATE;
637             opt_buf[1] = CILEN_DEFLATE;
638             opt_buf[2] = DEFLATE_MAKE_OPT(DEFLATE_MIN_WORKS);
639             opt_buf[3] = DEFLATE_CHK_SEQUENCE;
640             if (ccp_test(f->unit, opt_buf, CILEN_DEFLATE, 0) <= 0)
641                 go->deflate_correct = 0;
642         }
643         if (go->deflate_draft) {
644             opt_buf[0] = CI_DEFLATE_DRAFT;
645             opt_buf[1] = CILEN_DEFLATE;
646             opt_buf[2] = DEFLATE_MAKE_OPT(DEFLATE_MIN_WORKS);
647             opt_buf[3] = DEFLATE_CHK_SEQUENCE;
648             if (ccp_test(f->unit, opt_buf, CILEN_DEFLATE, 0) <= 0)
649                 go->deflate_draft = 0;
650         }
651         if (!go->deflate_correct && !go->deflate_draft)
652             go->deflate = 0;
653     }
654     if (go->predictor_1) {
655         opt_buf[0] = CI_PREDICTOR_1;
656         opt_buf[1] = CILEN_PREDICTOR_1;
657         if (ccp_test(f->unit, opt_buf, CILEN_PREDICTOR_1, 0) <= 0)
658             go->predictor_1 = 0;
659     }
660     if (go->predictor_2) {
661         opt_buf[0] = CI_PREDICTOR_2;
662         opt_buf[1] = CILEN_PREDICTOR_2;
663         if (ccp_test(f->unit, opt_buf, CILEN_PREDICTOR_2, 0) <= 0)
664             go->predictor_2 = 0;
665     }
666 }
667
668 /*
669  * ccp_cilen - Return total length of our configuration info.
670  */
671 static int
672 ccp_cilen(f)
673     fsm *f;
674 {
675     ccp_options *go = &ccp_gotoptions[f->unit];
676
677     return (go->bsd_compress? CILEN_BSD_COMPRESS: 0)
678         + (go->deflate && go->deflate_correct? CILEN_DEFLATE: 0)
679         + (go->deflate && go->deflate_draft? CILEN_DEFLATE: 0)
680         + (go->predictor_1? CILEN_PREDICTOR_1: 0)
681         + (go->predictor_2? CILEN_PREDICTOR_2: 0)
682         + (go->mppe? CILEN_MPPE: 0);
683 }
684
685 /*
686  * ccp_addci - put our requests in a packet.
687  */
688 static void
689 ccp_addci(f, p, lenp)
690     fsm *f;
691     u_char *p;
692     int *lenp;
693 {
694     int res;
695     ccp_options *go = &ccp_gotoptions[f->unit];
696     u_char *p0 = p;
697
698     /*
699      * Add the compression types that we can receive, in decreasing
700      * preference order.  Get the kernel to allocate the first one
701      * in case it gets Acked.
702      */
703 #ifdef MPPE
704     if (go->mppe) {
705         u_char opt_buf[CILEN_MPPE + MPPE_MAX_KEY_LEN];
706
707         p[0] = opt_buf[0] = CI_MPPE;
708         p[1] = opt_buf[1] = CILEN_MPPE;
709         MPPE_OPTS_TO_CI(go->mppe, &p[2]);
710         MPPE_OPTS_TO_CI(go->mppe, &opt_buf[2]);
711         BCOPY(mppe_recv_key, &opt_buf[CILEN_MPPE], MPPE_MAX_KEY_LEN);
712         res = ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0);
713         if (res > 0)
714             p += CILEN_MPPE;
715         else
716             /* This shouldn't happen, we've already tested it! */
717             lcp_close(f->unit, "MPPE required but not available in kernel");
718     }
719 #endif
720     if (go->deflate) {
721         p[0] = go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT;
722         p[1] = CILEN_DEFLATE;
723         p[2] = DEFLATE_MAKE_OPT(go->deflate_size);
724         p[3] = DEFLATE_CHK_SEQUENCE;
725         if (p != p0) {
726             p += CILEN_DEFLATE;
727         } else {
728             for (;;) {
729                 if (go->deflate_size < DEFLATE_MIN_WORKS) {
730                     go->deflate = 0;
731                     break;
732                 }
733                 res = ccp_test(f->unit, p, CILEN_DEFLATE, 0);
734                 if (res > 0) {
735                     p += CILEN_DEFLATE;
736                     break;
737                 } else if (res < 0) {
738                     go->deflate = 0;
739                     break;
740                 }
741                 --go->deflate_size;
742                 p[2] = DEFLATE_MAKE_OPT(go->deflate_size);
743             }
744         }
745         if (p != p0 && go->deflate_correct && go->deflate_draft) {
746             p[0] = CI_DEFLATE_DRAFT;
747             p[1] = CILEN_DEFLATE;
748             p[2] = p[2 - CILEN_DEFLATE];
749             p[3] = DEFLATE_CHK_SEQUENCE;
750             p += CILEN_DEFLATE;
751         }
752     }
753     if (go->bsd_compress) {
754         p[0] = CI_BSD_COMPRESS;
755         p[1] = CILEN_BSD_COMPRESS;
756         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
757         if (p != p0) {
758             p += CILEN_BSD_COMPRESS;    /* not the first option */
759         } else {
760             for (;;) {
761                 if (go->bsd_bits < BSD_MIN_BITS) {
762                     go->bsd_compress = 0;
763                     break;
764                 }
765                 res = ccp_test(f->unit, p, CILEN_BSD_COMPRESS, 0);
766                 if (res > 0) {
767                     p += CILEN_BSD_COMPRESS;
768                     break;
769                 } else if (res < 0) {
770                     go->bsd_compress = 0;
771                     break;
772                 }
773                 --go->bsd_bits;
774                 p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
775             }
776         }
777     }
778     /* XXX Should Predictor 2 be preferable to Predictor 1? */
779     if (go->predictor_1) {
780         p[0] = CI_PREDICTOR_1;
781         p[1] = CILEN_PREDICTOR_1;
782         if (p == p0 && ccp_test(f->unit, p, CILEN_PREDICTOR_1, 0) <= 0) {
783             go->predictor_1 = 0;
784         } else {
785             p += CILEN_PREDICTOR_1;
786         }
787     }
788     if (go->predictor_2) {
789         p[0] = CI_PREDICTOR_2;
790         p[1] = CILEN_PREDICTOR_2;
791         if (p == p0 && ccp_test(f->unit, p, CILEN_PREDICTOR_2, 0) <= 0) {
792             go->predictor_2 = 0;
793         } else {
794             p += CILEN_PREDICTOR_2;
795         }
796     }
797
798     go->method = (p > p0)? p0[0]: -1;
799
800     *lenp = p - p0;
801 }
802
803 /*
804  * ccp_ackci - process a received configure-ack, and return
805  * 1 iff the packet was OK.
806  */
807 static int
808 ccp_ackci(f, p, len)
809     fsm *f;
810     u_char *p;
811     int len;
812 {
813     ccp_options *go = &ccp_gotoptions[f->unit];
814     u_char *p0 = p;
815
816 #ifdef MPPE
817     if (go->mppe) {
818         u_char opt_buf[CILEN_MPPE];
819
820         opt_buf[0] = CI_MPPE;
821         opt_buf[1] = CILEN_MPPE;
822         MPPE_OPTS_TO_CI(go->mppe, &opt_buf[2]);
823         if (len < CILEN_MPPE || memcmp(opt_buf, p, CILEN_MPPE))
824             return 0;
825         p += CILEN_MPPE;
826         len -= CILEN_MPPE;
827         /* XXX Cope with first/fast ack */
828         if (len == 0)
829             return 1;
830     }
831 #endif
832     if (go->deflate) {
833         if (len < CILEN_DEFLATE
834             || p[0] != (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT)
835             || p[1] != CILEN_DEFLATE
836             || p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
837             || p[3] != DEFLATE_CHK_SEQUENCE)
838             return 0;
839         p += CILEN_DEFLATE;
840         len -= CILEN_DEFLATE;
841         /* XXX Cope with first/fast ack */
842         if (len == 0)
843             return 1;
844         if (go->deflate_correct && go->deflate_draft) {
845             if (len < CILEN_DEFLATE
846                 || p[0] != CI_DEFLATE_DRAFT
847                 || p[1] != CILEN_DEFLATE
848                 || p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
849                 || p[3] != DEFLATE_CHK_SEQUENCE)
850                 return 0;
851             p += CILEN_DEFLATE;
852             len -= CILEN_DEFLATE;
853         }
854     }
855     if (go->bsd_compress) {
856         if (len < CILEN_BSD_COMPRESS
857             || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD_COMPRESS
858             || p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
859             return 0;
860         p += CILEN_BSD_COMPRESS;
861         len -= CILEN_BSD_COMPRESS;
862         /* XXX Cope with first/fast ack */
863         if (p == p0 && len == 0)
864             return 1;
865     }
866     if (go->predictor_1) {
867         if (len < CILEN_PREDICTOR_1
868             || p[0] != CI_PREDICTOR_1 || p[1] != CILEN_PREDICTOR_1)
869             return 0;
870         p += CILEN_PREDICTOR_1;
871         len -= CILEN_PREDICTOR_1;
872         /* XXX Cope with first/fast ack */
873         if (p == p0 && len == 0)
874             return 1;
875     }
876     if (go->predictor_2) {
877         if (len < CILEN_PREDICTOR_2
878             || p[0] != CI_PREDICTOR_2 || p[1] != CILEN_PREDICTOR_2)
879             return 0;
880         p += CILEN_PREDICTOR_2;
881         len -= CILEN_PREDICTOR_2;
882         /* XXX Cope with first/fast ack */
883         if (p == p0 && len == 0)
884             return 1;
885     }
886
887     if (len != 0)
888         return 0;
889     return 1;
890 }
891
892 /*
893  * ccp_nakci - process received configure-nak.
894  * Returns 1 iff the nak was OK.
895  */
896 static int
897 ccp_nakci(f, p, len, treat_as_reject)
898     fsm *f;
899     u_char *p;
900     int len;
901     int treat_as_reject;
902 {
903     ccp_options *go = &ccp_gotoptions[f->unit];
904     ccp_options no;             /* options we've seen already */
905     ccp_options try;            /* options to ask for next time */
906
907     memset(&no, 0, sizeof(no));
908     try = *go;
909
910 #ifdef MPPE
911     if (go->mppe && len >= CILEN_MPPE
912         && p[0] == CI_MPPE && p[1] == CILEN_MPPE) {
913         no.mppe = 1;
914         /*
915          * Peer wants us to use a different strength or other setting.
916          * Fail if we aren't willing to use his suggestion.
917          */
918         MPPE_CI_TO_OPTS(&p[2], try.mppe);
919         if ((try.mppe & MPPE_OPT_STATEFUL) && refuse_mppe_stateful) {
920             error("Refusing MPPE stateful mode offered by peer");
921             try.mppe = 0;
922         } else if (((go->mppe | MPPE_OPT_STATEFUL) & try.mppe) != try.mppe) {
923             /* Peer must have set options we didn't request (suggest) */
924             try.mppe = 0;
925         }
926
927         if (!try.mppe) {
928             error("MPPE required but peer negotiation failed");
929             lcp_close(f->unit, "MPPE required but peer negotiation failed");
930         }
931     }
932 #endif /* MPPE */
933     if (go->deflate && len >= CILEN_DEFLATE
934         && p[0] == (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT)
935         && p[1] == CILEN_DEFLATE) {
936         no.deflate = 1;
937         /*
938          * Peer wants us to use a different code size or something.
939          * Stop asking for Deflate if we don't understand his suggestion.
940          */
941         if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL
942             || DEFLATE_SIZE(p[2]) < DEFLATE_MIN_WORKS
943             || p[3] != DEFLATE_CHK_SEQUENCE)
944             try.deflate = 0;
945         else if (DEFLATE_SIZE(p[2]) < go->deflate_size)
946             try.deflate_size = DEFLATE_SIZE(p[2]);
947         p += CILEN_DEFLATE;
948         len -= CILEN_DEFLATE;
949         if (go->deflate_correct && go->deflate_draft
950             && len >= CILEN_DEFLATE && p[0] == CI_DEFLATE_DRAFT
951             && p[1] == CILEN_DEFLATE) {
952             p += CILEN_DEFLATE;
953             len -= CILEN_DEFLATE;
954         }
955     }
956
957     if (go->bsd_compress && len >= CILEN_BSD_COMPRESS
958         && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) {
959         no.bsd_compress = 1;
960         /*
961          * Peer wants us to use a different number of bits
962          * or a different version.
963          */
964         if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION)
965             try.bsd_compress = 0;
966         else if (BSD_NBITS(p[2]) < go->bsd_bits)
967             try.bsd_bits = BSD_NBITS(p[2]);
968         p += CILEN_BSD_COMPRESS;
969         len -= CILEN_BSD_COMPRESS;
970     }
971
972     /*
973      * Predictor-1 and 2 have no options, so they can't be Naked.
974      *
975      * There may be remaining options but we ignore them.
976      */
977
978     if (f->state != OPENED)
979         *go = try;
980     return 1;
981 }
982
983 /*
984  * ccp_rejci - reject some of our suggested compression methods.
985  */
986 static int
987 ccp_rejci(f, p, len)
988     fsm *f;
989     u_char *p;
990     int len;
991 {
992     ccp_options *go = &ccp_gotoptions[f->unit];
993     ccp_options try;            /* options to request next time */
994
995     try = *go;
996
997     /*
998      * Cope with empty configure-rejects by ceasing to send
999      * configure-requests.
1000      */
1001     if (len == 0 && all_rejected[f->unit])
1002         return -1;
1003
1004 #ifdef MPPE
1005     if (go->mppe && len >= CILEN_MPPE
1006         && p[0] == CI_MPPE && p[1] == CILEN_MPPE) {
1007         error("MPPE required but peer refused");
1008         lcp_close(f->unit, "MPPE required but peer refused");
1009         p += CILEN_MPPE;
1010         len -= CILEN_MPPE;
1011     }
1012 #endif
1013     if (go->deflate_correct && len >= CILEN_DEFLATE
1014         && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) {
1015         if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
1016             || p[3] != DEFLATE_CHK_SEQUENCE)
1017             return 0;           /* Rej is bad */
1018         try.deflate_correct = 0;
1019         p += CILEN_DEFLATE;
1020         len -= CILEN_DEFLATE;
1021     }
1022     if (go->deflate_draft && len >= CILEN_DEFLATE
1023         && p[0] == CI_DEFLATE_DRAFT && p[1] == CILEN_DEFLATE) {
1024         if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
1025             || p[3] != DEFLATE_CHK_SEQUENCE)
1026             return 0;           /* Rej is bad */
1027         try.deflate_draft = 0;
1028         p += CILEN_DEFLATE;
1029         len -= CILEN_DEFLATE;
1030     }
1031     if (!try.deflate_correct && !try.deflate_draft)
1032         try.deflate = 0;
1033     if (go->bsd_compress && len >= CILEN_BSD_COMPRESS
1034         && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) {
1035         if (p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
1036             return 0;
1037         try.bsd_compress = 0;
1038         p += CILEN_BSD_COMPRESS;
1039         len -= CILEN_BSD_COMPRESS;
1040     }
1041     if (go->predictor_1 && len >= CILEN_PREDICTOR_1
1042         && p[0] == CI_PREDICTOR_1 && p[1] == CILEN_PREDICTOR_1) {
1043         try.predictor_1 = 0;
1044         p += CILEN_PREDICTOR_1;
1045         len -= CILEN_PREDICTOR_1;
1046     }
1047     if (go->predictor_2 && len >= CILEN_PREDICTOR_2
1048         && p[0] == CI_PREDICTOR_2 && p[1] == CILEN_PREDICTOR_2) {
1049         try.predictor_2 = 0;
1050         p += CILEN_PREDICTOR_2;
1051         len -= CILEN_PREDICTOR_2;
1052     }
1053
1054     if (len != 0)
1055         return 0;
1056
1057     if (f->state != OPENED)
1058         *go = try;
1059
1060     return 1;
1061 }
1062
1063 /*
1064  * ccp_reqci - processed a received configure-request.
1065  * Returns CONFACK, CONFNAK or CONFREJ and the packet modified
1066  * appropriately.
1067  */
1068 static int
1069 ccp_reqci(f, p, lenp, dont_nak)
1070     fsm *f;
1071     u_char *p;
1072     int *lenp;
1073     int dont_nak;
1074 {
1075     int ret, newret, res;
1076     u_char *p0, *retp;
1077     int len, clen, type, nb;
1078     ccp_options *ho = &ccp_hisoptions[f->unit];
1079     ccp_options *ao = &ccp_allowoptions[f->unit];
1080 #ifdef MPPE
1081     bool rej_for_ci_mppe = 1;   /* Are we rejecting based on a bad/missing */
1082                                 /* CI_MPPE, or due to other options?       */
1083 #endif
1084
1085     ret = CONFACK;
1086     retp = p0 = p;
1087     len = *lenp;
1088
1089     memset(ho, 0, sizeof(ccp_options));
1090     ho->method = (len > 0)? p[0]: -1;
1091
1092     while (len > 0) {
1093         newret = CONFACK;
1094         if (len < 2 || p[1] < 2 || p[1] > len) {
1095             /* length is bad */
1096             clen = len;
1097             newret = CONFREJ;
1098
1099         } else {
1100             type = p[0];
1101             clen = p[1];
1102
1103             switch (type) {
1104 #ifdef MPPE
1105             case CI_MPPE:
1106                 if (!ao->mppe || clen != CILEN_MPPE) {
1107                     newret = CONFREJ;
1108                     break;
1109                 }
1110                 MPPE_CI_TO_OPTS(&p[2], ho->mppe);
1111
1112                 /* Nak if anything unsupported or unknown are set. */
1113                 if (ho->mppe & MPPE_OPT_UNSUPPORTED) {
1114                     newret = CONFNAK;
1115                     ho->mppe &= ~MPPE_OPT_UNSUPPORTED;
1116                 }
1117                 if (ho->mppe & MPPE_OPT_UNKNOWN) {
1118                     newret = CONFNAK;
1119                     ho->mppe &= ~MPPE_OPT_UNKNOWN;
1120                 }
1121
1122                 /* Check state opt */
1123                 if (ho->mppe & MPPE_OPT_STATEFUL) {
1124                     /*
1125                      * We can Nak and request stateless, but it's a
1126                      * lot easier to just assume the peer will request
1127                      * it if he can do it; stateful mode is bad over
1128                      * the Internet -- which is where we expect MPPE.
1129                      */
1130                    if (refuse_mppe_stateful) {
1131                         error("Refusing MPPE stateful mode offered by peer");
1132                         newret = CONFREJ;
1133                         break;
1134                     }
1135                 }
1136
1137                 /* Find out which of {S,L} are set. */
1138                 if ((ho->mppe & MPPE_OPT_128)
1139                      && (ho->mppe & MPPE_OPT_40)) {
1140                     /* Both are set, negotiate the strongest. */
1141                     newret = CONFNAK;
1142                     if (ao->mppe & MPPE_OPT_128)
1143                         ho->mppe &= ~MPPE_OPT_40;
1144                     else if (ao->mppe & MPPE_OPT_40)
1145                         ho->mppe &= ~MPPE_OPT_128;
1146                     else {
1147                         newret = CONFREJ;
1148                         break;
1149                     }
1150                 } else if (ho->mppe & MPPE_OPT_128) {
1151                     if (!(ao->mppe & MPPE_OPT_128)) {
1152                         newret = CONFREJ;
1153                         break;
1154                     }
1155                 } else if (ho->mppe & MPPE_OPT_40) {
1156                     if (!(ao->mppe & MPPE_OPT_40)) {
1157                         newret = CONFREJ;
1158                         break;
1159                     }
1160                 } else {
1161                     /* Neither are set. */
1162                     /* We cannot accept this.  */
1163                     newret = CONFNAK;
1164                     /* Give the peer our idea of what can be used,
1165                        so it can choose and confirm */
1166                     ho->mppe = ao->mppe;
1167                 }
1168
1169                 /* rebuild the opts */
1170                 MPPE_OPTS_TO_CI(ho->mppe, &p[2]);
1171                 if (newret == CONFACK) {
1172                     u_char opt_buf[CILEN_MPPE + MPPE_MAX_KEY_LEN];
1173                     int mtu;
1174
1175                     BCOPY(p, opt_buf, CILEN_MPPE);
1176                     BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE],
1177                           MPPE_MAX_KEY_LEN);
1178                     if (ccp_test(f->unit, opt_buf,
1179                                  CILEN_MPPE + MPPE_MAX_KEY_LEN, 1) <= 0) {
1180                         /* This shouldn't happen, we've already tested it! */
1181                         error("MPPE required, but kernel has no support.");
1182                         lcp_close(f->unit, "MPPE required but not available");
1183                         newret = CONFREJ;
1184                         break;
1185                     }
1186                     /*
1187                      * We need to decrease the interface MTU by MPPE_PAD
1188                      * because MPPE frames **grow**.  The kernel [must]
1189                      * allocate MPPE_PAD extra bytes in xmit buffers.
1190                      */
1191                     mtu = netif_get_mtu(f->unit);
1192                     if (mtu)
1193                         netif_set_mtu(f->unit, mtu - MPPE_PAD);
1194                     else
1195                         newret = CONFREJ;
1196                 }
1197
1198                 /*
1199                  * We have accepted MPPE or are willing to negotiate
1200                  * MPPE parameters.  A CONFREJ is due to subsequent
1201                  * (non-MPPE) processing.
1202                  */
1203                 rej_for_ci_mppe = 0;
1204                 break;
1205 #endif /* MPPE */
1206             case CI_DEFLATE:
1207             case CI_DEFLATE_DRAFT:
1208                 if (!ao->deflate || clen != CILEN_DEFLATE
1209                     || (!ao->deflate_correct && type == CI_DEFLATE)
1210                     || (!ao->deflate_draft && type == CI_DEFLATE_DRAFT)) {
1211                     newret = CONFREJ;
1212                     break;
1213                 }
1214
1215                 ho->deflate = 1;
1216                 ho->deflate_size = nb = DEFLATE_SIZE(p[2]);
1217                 if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL
1218                     || p[3] != DEFLATE_CHK_SEQUENCE
1219                     || nb > ao->deflate_size || nb < DEFLATE_MIN_WORKS) {
1220                     newret = CONFNAK;
1221                     if (!dont_nak) {
1222                         p[2] = DEFLATE_MAKE_OPT(ao->deflate_size);
1223                         p[3] = DEFLATE_CHK_SEQUENCE;
1224                         /* fall through to test this #bits below */
1225                     } else
1226                         break;
1227                 }
1228
1229                 /*
1230                  * Check whether we can do Deflate with the window
1231                  * size they want.  If the window is too big, reduce
1232                  * it until the kernel can cope and nak with that.
1233                  * We only check this for the first option.
1234                  */
1235                 if (p == p0) {
1236                     for (;;) {
1237                         res = ccp_test(f->unit, p, CILEN_DEFLATE, 1);
1238                         if (res > 0)
1239                             break;              /* it's OK now */
1240                         if (res < 0 || nb == DEFLATE_MIN_WORKS || dont_nak) {
1241                             newret = CONFREJ;
1242                             p[2] = DEFLATE_MAKE_OPT(ho->deflate_size);
1243                             break;
1244                         }
1245                         newret = CONFNAK;
1246                         --nb;
1247                         p[2] = DEFLATE_MAKE_OPT(nb);
1248                     }
1249                 }
1250                 break;
1251
1252             case CI_BSD_COMPRESS:
1253                 if (!ao->bsd_compress || clen != CILEN_BSD_COMPRESS) {
1254                     newret = CONFREJ;
1255                     break;
1256                 }
1257
1258                 ho->bsd_compress = 1;
1259                 ho->bsd_bits = nb = BSD_NBITS(p[2]);
1260                 if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION
1261                     || nb > ao->bsd_bits || nb < BSD_MIN_BITS) {
1262                     newret = CONFNAK;
1263                     if (!dont_nak) {
1264                         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, ao->bsd_bits);
1265                         /* fall through to test this #bits below */
1266                     } else
1267                         break;
1268                 }
1269
1270                 /*
1271                  * Check whether we can do BSD-Compress with the code
1272                  * size they want.  If the code size is too big, reduce
1273                  * it until the kernel can cope and nak with that.
1274                  * We only check this for the first option.
1275                  */
1276                 if (p == p0) {
1277                     for (;;) {
1278                         res = ccp_test(f->unit, p, CILEN_BSD_COMPRESS, 1);
1279                         if (res > 0)
1280                             break;
1281                         if (res < 0 || nb == BSD_MIN_BITS || dont_nak) {
1282                             newret = CONFREJ;
1283                             p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION,
1284                                                 ho->bsd_bits);
1285                             break;
1286                         }
1287                         newret = CONFNAK;
1288                         --nb;
1289                         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb);
1290                     }
1291                 }
1292                 break;
1293
1294             case CI_PREDICTOR_1:
1295                 if (!ao->predictor_1 || clen != CILEN_PREDICTOR_1) {
1296                     newret = CONFREJ;
1297                     break;
1298                 }
1299
1300                 ho->predictor_1 = 1;
1301                 if (p == p0
1302                     && ccp_test(f->unit, p, CILEN_PREDICTOR_1, 1) <= 0) {
1303                     newret = CONFREJ;
1304                 }
1305                 break;
1306
1307             case CI_PREDICTOR_2:
1308                 if (!ao->predictor_2 || clen != CILEN_PREDICTOR_2) {
1309                     newret = CONFREJ;
1310                     break;
1311                 }
1312
1313                 ho->predictor_2 = 1;
1314                 if (p == p0
1315                     && ccp_test(f->unit, p, CILEN_PREDICTOR_2, 1) <= 0) {
1316                     newret = CONFREJ;
1317                 }
1318                 break;
1319
1320             default:
1321                 newret = CONFREJ;
1322             }
1323         }
1324
1325         if (newret == CONFNAK && dont_nak)
1326             newret = CONFREJ;
1327         if (!(newret == CONFACK || (newret == CONFNAK && ret == CONFREJ))) {
1328             /* we're returning this option */
1329             if (newret == CONFREJ && ret == CONFNAK)
1330                 retp = p0;
1331             ret = newret;
1332             if (p != retp)
1333                 BCOPY(p, retp, clen);
1334             retp += clen;
1335         }
1336
1337         p += clen;
1338         len -= clen;
1339     }
1340
1341     if (ret != CONFACK) {
1342         if (ret == CONFREJ && *lenp == retp - p0)
1343             all_rejected[f->unit] = 1;
1344         else
1345             *lenp = retp - p0;
1346     }
1347 #ifdef MPPE
1348     if (ret == CONFREJ && ao->mppe && rej_for_ci_mppe) {
1349         error("MPPE required but peer negotiation failed");
1350         lcp_close(f->unit, "MPPE required but peer negotiation failed");
1351     }
1352 #endif
1353     return ret;
1354 }
1355
1356 /*
1357  * Make a string name for a compression method (or 2).
1358  */
1359 static char *
1360 method_name(opt, opt2)
1361     ccp_options *opt, *opt2;
1362 {
1363     static char result[64];
1364
1365     if (!ANY_COMPRESS(*opt))
1366         return "(none)";
1367     switch (opt->method) {
1368 #ifdef MPPE
1369     case CI_MPPE:
1370     {
1371         char *p = result;
1372         char *q = result + sizeof(result); /* 1 past result */
1373
1374         slprintf(p, q - p, "MPPE ");
1375         p += 5;
1376         if (opt->mppe & MPPE_OPT_128) {
1377             slprintf(p, q - p, "128-bit ");
1378             p += 8;
1379         }
1380         if (opt->mppe & MPPE_OPT_40) {
1381             slprintf(p, q - p, "40-bit ");
1382             p += 7;
1383         }
1384         if (opt->mppe & MPPE_OPT_STATEFUL)
1385             slprintf(p, q - p, "stateful");
1386         else
1387             slprintf(p, q - p, "stateless");
1388
1389         break;
1390     }
1391 #endif
1392     case CI_DEFLATE:
1393     case CI_DEFLATE_DRAFT:
1394         if (opt2 != NULL && opt2->deflate_size != opt->deflate_size)
1395             slprintf(result, sizeof(result), "Deflate%s (%d/%d)",
1396                      (opt->method == CI_DEFLATE_DRAFT? "(old#)": ""),
1397                      opt->deflate_size, opt2->deflate_size);
1398         else
1399             slprintf(result, sizeof(result), "Deflate%s (%d)",
1400                      (opt->method == CI_DEFLATE_DRAFT? "(old#)": ""),
1401                      opt->deflate_size);
1402         break;
1403     case CI_BSD_COMPRESS:
1404         if (opt2 != NULL && opt2->bsd_bits != opt->bsd_bits)
1405             slprintf(result, sizeof(result), "BSD-Compress (%d/%d)",
1406                      opt->bsd_bits, opt2->bsd_bits);
1407         else
1408             slprintf(result, sizeof(result), "BSD-Compress (%d)",
1409                      opt->bsd_bits);
1410         break;
1411     case CI_PREDICTOR_1:
1412         return "Predictor 1";
1413     case CI_PREDICTOR_2:
1414         return "Predictor 2";
1415     default:
1416         slprintf(result, sizeof(result), "Method %d", opt->method);
1417     }
1418     return result;
1419 }
1420
1421 /*
1422  * CCP has come up - inform the kernel driver and log a message.
1423  */
1424 static void
1425 ccp_up(f)
1426     fsm *f;
1427 {
1428     ccp_options *go = &ccp_gotoptions[f->unit];
1429     ccp_options *ho = &ccp_hisoptions[f->unit];
1430     char method1[64];
1431
1432     ccp_flags_set(f->unit, 1, 1);
1433     if (ANY_COMPRESS(*go)) {
1434         if (ANY_COMPRESS(*ho)) {
1435             if (go->method == ho->method) {
1436                 notice("%s compression enabled", method_name(go, ho));
1437             } else {
1438                 strlcpy(method1, method_name(go, NULL), sizeof(method1));
1439                 notice("%s / %s compression enabled",
1440                        method1, method_name(ho, NULL));
1441             }
1442         } else
1443             notice("%s receive compression enabled", method_name(go, NULL));
1444     } else if (ANY_COMPRESS(*ho))
1445         notice("%s transmit compression enabled", method_name(ho, NULL));
1446 #ifdef MPPE
1447     if (go->mppe) {
1448         BZERO(mppe_recv_key, MPPE_MAX_KEY_LEN);
1449         BZERO(mppe_send_key, MPPE_MAX_KEY_LEN);
1450         continue_networks(f->unit);             /* Bring up IP et al */
1451     }
1452 #endif
1453 }
1454
1455 /*
1456  * CCP has gone down - inform the kernel driver.
1457  */
1458 static void
1459 ccp_down(f)
1460     fsm *f;
1461 {
1462     if (ccp_localstate[f->unit] & RACK_PENDING)
1463         UNTIMEOUT(ccp_rack_timeout, f);
1464     ccp_localstate[f->unit] = 0;
1465     ccp_flags_set(f->unit, 1, 0);
1466 #ifdef MPPE
1467     if (ccp_gotoptions[f->unit].mppe) {
1468         ccp_gotoptions[f->unit].mppe = 0;
1469         if (lcp_fsm[f->unit].state == OPENED) {
1470             /* If LCP is not already going down, make sure it does. */
1471             error("MPPE disabled");
1472             lcp_close(f->unit, "MPPE disabled");
1473         }
1474     }
1475 #endif
1476 }
1477
1478 /*
1479  * Print the contents of a CCP packet.
1480  */
1481 static char *ccp_codenames[] = {
1482     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1483     "TermReq", "TermAck", "CodeRej",
1484     NULL, NULL, NULL, NULL, NULL, NULL,
1485     "ResetReq", "ResetAck",
1486 };
1487
1488 static int
1489 ccp_printpkt(p, plen, printer, arg)
1490     u_char *p;
1491     int plen;
1492     void (*printer) __P((void *, char *, ...));
1493     void *arg;
1494 {
1495     u_char *p0, *optend;
1496     int code, id, len;
1497     int optlen;
1498
1499     p0 = p;
1500     if (plen < HEADERLEN)
1501         return 0;
1502     code = p[0];
1503     id = p[1];
1504     len = (p[2] << 8) + p[3];
1505     if (len < HEADERLEN || len > plen)
1506         return 0;
1507
1508     if (code >= 1 && code <= sizeof(ccp_codenames) / sizeof(char *)
1509         && ccp_codenames[code-1] != NULL)
1510         printer(arg, " %s", ccp_codenames[code-1]);
1511     else
1512         printer(arg, " code=0x%x", code);
1513     printer(arg, " id=0x%x", id);
1514     len -= HEADERLEN;
1515     p += HEADERLEN;
1516
1517     switch (code) {
1518     case CONFREQ:
1519     case CONFACK:
1520     case CONFNAK:
1521     case CONFREJ:
1522         /* print list of possible compression methods */
1523         while (len >= 2) {
1524             code = p[0];
1525             optlen = p[1];
1526             if (optlen < 2 || optlen > len)
1527                 break;
1528             printer(arg, " <");
1529             len -= optlen;
1530             optend = p + optlen;
1531             switch (code) {
1532 #ifdef MPPE
1533             case CI_MPPE:
1534                 if (optlen >= CILEN_MPPE) {
1535                     u_char mppe_opts;
1536
1537                     MPPE_CI_TO_OPTS(&p[2], mppe_opts);
1538                     printer(arg, "mppe %s %s %s %s %s %s%s",
1539                             (p[2] & MPPE_H_BIT)? "+H": "-H",
1540                             (p[5] & MPPE_M_BIT)? "+M": "-M",
1541                             (p[5] & MPPE_S_BIT)? "+S": "-S",
1542                             (p[5] & MPPE_L_BIT)? "+L": "-L",
1543                             (p[5] & MPPE_D_BIT)? "+D": "-D",
1544                             (p[5] & MPPE_C_BIT)? "+C": "-C",
1545                             (mppe_opts & MPPE_OPT_UNKNOWN)? " +U": "");
1546                     if (mppe_opts & MPPE_OPT_UNKNOWN)
1547                         printer(arg, " (%.2x %.2x %.2x %.2x)",
1548                                 p[2], p[3], p[4], p[5]);
1549                     p += CILEN_MPPE;
1550                 }
1551                 break;
1552 #endif
1553             case CI_DEFLATE:
1554             case CI_DEFLATE_DRAFT:
1555                 if (optlen >= CILEN_DEFLATE) {
1556                     printer(arg, "deflate%s %d",
1557                             (code == CI_DEFLATE_DRAFT? "(old#)": ""),
1558                             DEFLATE_SIZE(p[2]));
1559                     if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL)
1560                         printer(arg, " method %d", DEFLATE_METHOD(p[2]));
1561                     if (p[3] != DEFLATE_CHK_SEQUENCE)
1562                         printer(arg, " check %d", p[3]);
1563                     p += CILEN_DEFLATE;
1564                 }
1565                 break;
1566             case CI_BSD_COMPRESS:
1567                 if (optlen >= CILEN_BSD_COMPRESS) {
1568                     printer(arg, "bsd v%d %d", BSD_VERSION(p[2]),
1569                             BSD_NBITS(p[2]));
1570                     p += CILEN_BSD_COMPRESS;
1571                 }
1572                 break;
1573             case CI_PREDICTOR_1:
1574                 if (optlen >= CILEN_PREDICTOR_1) {
1575                     printer(arg, "predictor 1");
1576                     p += CILEN_PREDICTOR_1;
1577                 }
1578                 break;
1579             case CI_PREDICTOR_2:
1580                 if (optlen >= CILEN_PREDICTOR_2) {
1581                     printer(arg, "predictor 2");
1582                     p += CILEN_PREDICTOR_2;
1583                 }
1584                 break;
1585             }
1586             while (p < optend)
1587                 printer(arg, " %.2x", *p++);
1588             printer(arg, ">");
1589         }
1590         break;
1591
1592     case TERMACK:
1593     case TERMREQ:
1594         if (len > 0 && *p >= ' ' && *p < 0x7f) {
1595             print_string((char *)p, len, printer, arg);
1596             p += len;
1597             len = 0;
1598         }
1599         break;
1600     }
1601
1602     /* dump out the rest of the packet in hex */
1603     while (--len >= 0)
1604         printer(arg, " %.2x", *p++);
1605
1606     return p - p0;
1607 }
1608
1609 /*
1610  * We have received a packet that the decompressor failed to
1611  * decompress.  Here we would expect to issue a reset-request, but
1612  * Motorola has a patent on resetting the compressor as a result of
1613  * detecting an error in the decompressed data after decompression.
1614  * (See US patent 5,130,993; international patent publication number
1615  * WO 91/10289; Australian patent 73296/91.)
1616  *
1617  * So we ask the kernel whether the error was detected after
1618  * decompression; if it was, we take CCP down, thus disabling
1619  * compression :-(, otherwise we issue the reset-request.
1620  */
1621 static void
1622 ccp_datainput(unit, pkt, len)
1623     int unit;
1624     u_char *pkt;
1625     int len;
1626 {
1627     fsm *f;
1628
1629     f = &ccp_fsm[unit];
1630     if (f->state == OPENED) {
1631         if (ccp_fatal_error(unit)) {
1632             /*
1633              * Disable compression by taking CCP down.
1634              */
1635             error("Lost compression sync: disabling compression");
1636             ccp_close(unit, "Lost compression sync");
1637 #ifdef MPPE
1638             /*
1639              * If we were doing MPPE, we must also take the link down.
1640              */
1641             if (ccp_gotoptions[unit].mppe) {
1642                 error("Too many MPPE errors, closing LCP");
1643                 lcp_close(unit, "Too many MPPE errors");
1644             }
1645 #endif
1646         } else {
1647             /*
1648              * Send a reset-request to reset the peer's compressor.
1649              * We don't do that if we are still waiting for an
1650              * acknowledgement to a previous reset-request.
1651              */
1652             if (!(ccp_localstate[f->unit] & RACK_PENDING)) {
1653                 fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0);
1654                 TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT);
1655                 ccp_localstate[f->unit] |= RACK_PENDING;
1656             } else
1657                 ccp_localstate[f->unit] |= RREQ_REPEAT;
1658         }
1659     }
1660 }
1661
1662 /*
1663  * Timeout waiting for reset-ack.
1664  */
1665 static void
1666 ccp_rack_timeout(arg)
1667     void *arg;
1668 {
1669     fsm *f = arg;
1670
1671     if (f->state == OPENED && ccp_localstate[f->unit] & RREQ_REPEAT) {
1672         fsm_sdata(f, CCP_RESETREQ, f->reqid, NULL, 0);
1673         TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT);
1674         ccp_localstate[f->unit] &= ~RREQ_REPEAT;
1675     } else
1676         ccp_localstate[f->unit] &= ~RACK_PENDING;
1677 }
1678