source: trunk/package/ppp/patches/201-mppe_mppc_1.1.patch @ 15958

Last change on this file since 15958 was 15958, checked in by hauke, 8 years ago

[ppp] refresh patches

  • Property svn:eol-style set to native
File size: 46.2 KB
  • include/linux/ppp-comp.h

    a b  
    3636 */ 
    3737 
    3838/* 
    39  *  ==FILEVERSION 20020319== 
     39 *  ==FILEVERSION 20020715== 
    4040 * 
    4141 *  NOTE TO MAINTAINERS: 
    4242 *     If you modify this file at all, please set the above date. 
    struct compressor { 
    8686 
    8787        /* Compress a packet */ 
    8888        int     (*compress) (void *state, unsigned char *rptr, 
    89                               unsigned char *obuf, int isize, int osize); 
     89                             unsigned char *obuf, int isize, int osize); 
    9090 
    9191        /* Return compression statistics */ 
    9292        void    (*comp_stat) (void *state, struct compstat *stats); 
    struct compressor { 
    107107 
    108108        /* Decompress a packet. */ 
    109109        int     (*decompress) (void *state, unsigned char *ibuf, int isize, 
    110                                 unsigned char *obuf, int osize); 
     110                               unsigned char *obuf, int osize); 
    111111 
    112112        /* Update state for an incompressible packet received */ 
    113113        void    (*incomp) (void *state, unsigned char *ibuf, int icnt); 
    struct compressor { 
    288288            opts |= MPPE_OPT_UNKNOWN;           \ 
    289289    } while (/* CONSTCOND */ 0) 
    290290 
     291/* MPPE/MPPC definitions by J.D.*/ 
     292#define MPPE_STATELESS          MPPE_H_BIT      /* configuration bit H */ 
     293#define MPPE_40BIT              MPPE_L_BIT      /* configuration bit L */ 
     294#define MPPE_56BIT              MPPE_M_BIT      /* configuration bit M */ 
     295#define MPPE_128BIT             MPPE_S_BIT      /* configuration bit S */ 
     296#define MPPE_MPPC               MPPE_C_BIT      /* configuration bit C */ 
     297 
     298/* 
     299 * Definitions for Stac LZS. 
     300 */ 
     301 
     302#define CI_LZS                  17      /* config option for Stac LZS */ 
     303#define CILEN_LZS               5       /* length of config option */ 
     304 
     305#define LZS_OVHD                4       /* max. LZS overhead */ 
     306#define LZS_HIST_LEN            2048    /* LZS history size */ 
     307#define LZS_MAX_CCOUNT          0x0FFF  /* max. coherency counter value */ 
     308 
     309#define LZS_MODE_NONE           0 
     310#define LZS_MODE_LCB            1 
     311#define LZS_MODE_CRC            2 
     312#define LZS_MODE_SEQ            3 
     313#define LZS_MODE_EXT            4 
     314 
     315#define LZS_EXT_BIT_FLUSHED     0x80    /* bit A */ 
     316#define LZS_EXT_BIT_COMP        0x20    /* bit C */ 
     317 
    291318/* 
    292319 * Definitions for other, as yet unsupported, compression methods. 
    293320 */ 
  • include/net/ppp-comp.h

    a b struct compressor { 
    255255            opts |= MPPE_OPT_UNKNOWN;           \ 
    256256    } while (/* CONSTCOND */ 0) 
    257257 
     258/* MPPE/MPPC definitions by J.D.*/ 
     259#define MPPE_STATELESS          MPPE_H_BIT      /* configuration bit H */ 
     260#define MPPE_40BIT              MPPE_L_BIT      /* configuration bit L */ 
     261#define MPPE_56BIT              MPPE_M_BIT      /* configuration bit M */ 
     262#define MPPE_128BIT             MPPE_S_BIT      /* configuration bit S */ 
     263#define MPPE_MPPC               MPPE_C_BIT      /* configuration bit C */ 
     264 
     265/* 
     266 * Definitions for Stac LZS. 
     267 */ 
     268 
     269#define CI_LZS                  17      /* config option for Stac LZS */ 
     270#define CILEN_LZS               5       /* length of config option */ 
     271 
     272#define LZS_OVHD                4       /* max. LZS overhead */ 
     273#define LZS_HIST_LEN            2048    /* LZS history size */ 
     274#define LZS_MAX_CCOUNT          0x0FFF  /* max. coherency counter value */ 
     275 
     276#define LZS_MODE_NONE           0 
     277#define LZS_MODE_LCB            1 
     278#define LZS_MODE_CRC            2 
     279#define LZS_MODE_SEQ            3 
     280#define LZS_MODE_EXT            4 
     281 
     282#define LZS_EXT_BIT_FLUSHED     0x80    /* bit A */ 
     283#define LZS_EXT_BIT_COMP        0x20    /* bit C */ 
     284 
    258285/* 
    259286 * Definitions for other, as yet unsupported, compression methods. 
    260287 */ 
  • pppd/ccp.c

    a b static int setdeflate __P((char **)); 
    6262static char bsd_value[8]; 
    6363static char deflate_value[8]; 
    6464 
    65 /* 
    66  * Option variables. 
    67  */ 
    6865#ifdef MPPE 
    69 bool refuse_mppe_stateful = 1;          /* Allow stateful mode? */ 
    70 #endif 
     66static int setmppe(char **); 
     67static int setnomppe(void); 
     68#endif /* MPPE */ 
    7169 
    7270static option_t ccp_option_list[] = { 
    7371    { "noccp", o_bool, &ccp_protent.enabled_flag, 
    static option_t ccp_option_list[] = { 
    108106      "don't allow Predictor-1", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, 
    109107      &ccp_allowoptions[0].predictor_1 }, 
    110108 
     109    { "lzs", o_bool, &ccp_wantoptions[0].lzs, 
     110      "request Stac LZS", 1, &ccp_allowoptions[0].lzs, OPT_PRIO }, 
     111    { "+lzs", o_bool, &ccp_wantoptions[0].lzs, 
     112      "request Stac LZS", 1, &ccp_allowoptions[0].lzs, OPT_ALIAS | OPT_PRIO }, 
     113    { "nolzs", o_bool, &ccp_wantoptions[0].lzs, 
     114      "don't allow Stac LZS", OPT_PRIOSUB | OPT_A2CLR, 
     115      &ccp_allowoptions[0].lzs }, 
     116    { "-lzs", o_bool, &ccp_wantoptions[0].lzs, 
     117      "don't allow Stac LZS", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, 
     118      &ccp_allowoptions[0].lzs }, 
     119 
    111120#ifdef MPPE 
    112     /* MPPE options are symmetrical ... we only set wantoptions here */ 
    113     { "require-mppe", o_bool, &ccp_wantoptions[0].mppe, 
    114       "require MPPE encryption", 
    115       OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 }, 
    116     { "+mppe", o_bool, &ccp_wantoptions[0].mppe, 
    117       "require MPPE encryption", 
    118       OPT_ALIAS | OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 }, 
    119     { "nomppe", o_bool, &ccp_wantoptions[0].mppe, 
    120       "don't allow MPPE encryption", OPT_PRIO }, 
    121     { "-mppe", o_bool, &ccp_wantoptions[0].mppe, 
    122       "don't allow MPPE encryption", OPT_ALIAS | OPT_PRIO }, 
    123  
    124     /* We use ccp_allowoptions[0].mppe as a junk var ... it is reset later */ 
    125     { "require-mppe-40", o_bool, &ccp_allowoptions[0].mppe, 
    126       "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40, 
    127       &ccp_wantoptions[0].mppe }, 
    128     { "+mppe-40", o_bool, &ccp_allowoptions[0].mppe, 
    129       "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40, 
    130       &ccp_wantoptions[0].mppe }, 
    131     { "nomppe-40", o_bool, &ccp_allowoptions[0].mppe, 
    132       "don't allow MPPE 40-bit encryption", 
    133       OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, &ccp_wantoptions[0].mppe }, 
    134     { "-mppe-40", o_bool, &ccp_allowoptions[0].mppe, 
    135       "don't allow MPPE 40-bit encryption", 
    136       OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, 
    137       &ccp_wantoptions[0].mppe }, 
    138  
    139     { "require-mppe-128", o_bool, &ccp_allowoptions[0].mppe, 
    140       "require MPPE 128-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_128, 
    141       &ccp_wantoptions[0].mppe }, 
    142     { "+mppe-128", o_bool, &ccp_allowoptions[0].mppe, 
    143       "require MPPE 128-bit encryption", 
    144       OPT_ALIAS | OPT_PRIO | OPT_A2OR | MPPE_OPT_128, 
    145       &ccp_wantoptions[0].mppe }, 
    146     { "nomppe-128", o_bool, &ccp_allowoptions[0].mppe, 
    147       "don't allow MPPE 128-bit encryption", 
    148       OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, &ccp_wantoptions[0].mppe }, 
    149     { "-mppe-128", o_bool, &ccp_allowoptions[0].mppe, 
    150       "don't allow MPPE 128-bit encryption", 
    151       OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, 
    152       &ccp_wantoptions[0].mppe }, 
    153  
    154     /* strange one; we always request stateless, but will we allow stateful? */ 
    155     { "mppe-stateful", o_bool, &refuse_mppe_stateful, 
    156       "allow MPPE stateful mode", OPT_PRIO }, 
    157     { "nomppe-stateful", o_bool, &refuse_mppe_stateful, 
    158       "disallow MPPE stateful mode", OPT_PRIO | 1 }, 
     121    { "mppc", o_bool, &ccp_wantoptions[0].mppc, 
     122      "request MPPC compression", 1, &ccp_allowoptions[0].mppc }, 
     123    { "+mppc", o_bool, &ccp_wantoptions[0].mppc, 
     124      "request MPPC compression", 1, &ccp_allowoptions[0].mppc, OPT_ALIAS }, 
     125    { "nomppc", o_bool, &ccp_wantoptions[0].mppc, 
     126      "don't allow MPPC compression", OPT_PRIOSUB | OPT_A2CLR, 
     127      &ccp_allowoptions[0].mppc }, 
     128    { "-mppc", o_bool, &ccp_wantoptions[0].mppc, 
     129      "don't allow MPPC compression", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, 
     130      &ccp_allowoptions[0].mppc }, 
     131    { "mppe", o_special, (void *)setmppe, 
     132      "request MPPE encryption" }, 
     133    { "+mppe", o_special, (void *)setmppe, 
     134      "request MPPE encryption" }, 
     135    { "nomppe", o_special_noarg, (void *)setnomppe, 
     136      "don't allow MPPE encryption" }, 
     137    { "-mppe", o_special_noarg, (void *)setnomppe, 
     138      "don't allow MPPE encryption" }, 
    159139#endif /* MPPE */ 
    160140 
    161141    { NULL } 
    static fsm_callbacks ccp_callbacks = { 
    241221 */ 
    242222#define ANY_COMPRESS(opt)       ((opt).deflate || (opt).bsd_compress \ 
    243223                                 || (opt).predictor_1 || (opt).predictor_2 \ 
    244                                  || (opt).mppe) 
     224                                 || (opt).lzs || (opt).mppc || (opt).mppe) 
    245225 
    246226/* 
    247227 * Local state (mainly for handling reset-reqs and reset-acks). 
    setdeflate(argv) 
    344324    return 1; 
    345325} 
    346326 
     327#ifdef MPPE 
     328/* 
     329 * Functions called from config options 
     330 */ 
     331/*  
     332   MPPE suboptions: 
     333        required - require MPPE; disconnect if peer doesn't support it 
     334        stateless - use stateless mode 
     335        no40 - disable 40 bit keys 
     336        no56 - disable 56 bit keys 
     337        no128 - disable 128 bit keys 
     338*/ 
     339int setmppe(char **argv) 
     340{ 
     341    int i; 
     342    char *str, cmdbuf[16]; 
     343 
     344    ccp_allowoptions[0].mppe = 1; 
     345    ccp_allowoptions[0].mppe_40 = 1; 
     346    ccp_allowoptions[0].mppe_56 = 1; 
     347    ccp_allowoptions[0].mppe_128 = 1; 
     348    ccp_allowoptions[0].mppe_stateless = 0; 
     349    ccp_wantoptions[0].mppe = 0; 
     350 
     351    str = *argv; 
     352 
     353    while (1) { 
     354        i = 0; 
     355        memset(cmdbuf, '\0', 16); 
     356        while ((i < 16) && (*str != ',') && (*str != '\0')) 
     357            cmdbuf[i++] = *str++; 
     358        cmdbuf[i] = '\0'; 
     359        if (!strncasecmp(cmdbuf, "no40", strlen("no40"))) { 
     360            ccp_allowoptions[0].mppe_40 = 0; 
     361            goto next_param; 
     362        } else if (!strncasecmp(cmdbuf, "no56", strlen("no56"))) { 
     363            ccp_allowoptions[0].mppe_56 = 0; 
     364            goto next_param; 
     365        } else if (!strncasecmp(cmdbuf, "no128", strlen("no128"))) { 
     366            ccp_allowoptions[0].mppe_128 = 0; 
     367            goto next_param; 
     368        } else if (!strncasecmp(cmdbuf, "stateless", strlen("stateless"))) { 
     369            ccp_allowoptions[0].mppe_stateless = 1; 
     370            goto next_param; 
     371        } else if (!strncasecmp(cmdbuf, "required", strlen("required"))) { 
     372            ccp_wantoptions[0].mppe = 1; 
     373            goto next_param; 
     374        } else { 
     375            option_error("invalid parameter '%s' for mppe option", cmdbuf); 
     376            return 0; 
     377        } 
     378 
     379    next_param: 
     380        if (*str == ',') { 
     381            str++; 
     382            continue; 
     383        } 
     384        if (*str == '\0') { 
     385            if (!(ccp_allowoptions[0].mppe_40 || ccp_allowoptions[0].mppe_56 || 
     386                  ccp_allowoptions[0].mppe_128)) { 
     387                if (ccp_wantoptions[0].mppe == 1) { 
     388                    option_error("You require MPPE but you have switched off " 
     389                                 "all encryption key lengths."); 
     390                    return 0; 
     391                } 
     392                ccp_wantoptions[0].mppe = ccp_allowoptions[0].mppe = 0; 
     393                ccp_wantoptions[0].mppe_stateless = 
     394                    ccp_allowoptions[0].mppe_stateless = 0; 
     395            } else { 
     396                ccp_allowoptions[0].mppe = 1; 
     397                ccp_wantoptions[0].mppe_stateless = 
     398                    ccp_allowoptions[0].mppe_stateless; 
     399                if (ccp_wantoptions[0].mppe == 1) { 
     400                    ccp_wantoptions[0].mppe_40 = ccp_allowoptions[0].mppe_40; 
     401                    ccp_wantoptions[0].mppe_56 = ccp_allowoptions[0].mppe_56; 
     402                    ccp_wantoptions[0].mppe_128 = ccp_allowoptions[0].mppe_128; 
     403                } 
     404            } 
     405            return 1; 
     406        } 
     407    } 
     408} 
     409 
     410int setnomppe(void) 
     411{ 
     412    ccp_wantoptions[0].mppe = ccp_allowoptions[0].mppe = 0; 
     413    ccp_wantoptions[0].mppe_40 = ccp_allowoptions[0].mppe_40 = 0; 
     414    ccp_wantoptions[0].mppe_56 = ccp_allowoptions[0].mppe_56 = 0; 
     415    ccp_wantoptions[0].mppe_128 = ccp_allowoptions[0].mppe_128 = 0; 
     416    ccp_wantoptions[0].mppe_stateless = ccp_allowoptions[0].mppe_stateless = 0; 
     417    return 1; 
     418} 
     419#endif /* MPPE */ 
     420 
    347421/* 
    348422 * ccp_init - initialize CCP. 
    349423 */ 
    ccp_init(unit) 
    378452    ccp_allowoptions[0].bsd_bits = BSD_MAX_BITS; 
    379453 
    380454    ccp_allowoptions[0].predictor_1 = 1; 
     455 
     456    ccp_wantoptions[0].lzs = 0; /* Stac LZS  - will be enabled in the future */ 
     457    ccp_wantoptions[0].lzs_mode = LZS_MODE_SEQ; 
     458    ccp_wantoptions[0].lzs_hists = 1; 
     459    ccp_allowoptions[0].lzs = 0; /* Stac LZS  - will be enabled in the future */ 
     460    ccp_allowoptions[0].lzs_mode = LZS_MODE_SEQ; 
     461    ccp_allowoptions[0].lzs_hists = 1; 
     462 
     463#ifdef MPPE 
     464    /* by default allow and request MPPC... */ 
     465    ccp_wantoptions[0].mppc = ccp_allowoptions[0].mppc = 1; 
     466 
     467    /* ... and allow but don't request MPPE */ 
     468    ccp_allowoptions[0].mppe = 1; 
     469    ccp_allowoptions[0].mppe_40 = 1; 
     470    ccp_allowoptions[0].mppe_56 = 1; 
     471    ccp_allowoptions[0].mppe_128 = 1; 
     472    ccp_allowoptions[0].mppe_stateless = 1; 
     473    ccp_wantoptions[0].mppe = 0; 
     474    ccp_wantoptions[0].mppe_40 = 0; 
     475    ccp_wantoptions[0].mppe_56 = 0; 
     476    ccp_wantoptions[0].mppe_128 = 0; 
     477    ccp_wantoptions[0].mppe_stateless = 0; 
     478#endif /* MPPE */ 
    381479} 
    382480 
    383481/* 
    ccp_input(unit, p, len) 
    455553    if (oldstate == OPENED && p[0] == TERMREQ && f->state != OPENED) { 
    456554        notice("Compression disabled by peer."); 
    457555#ifdef MPPE 
    458         if (ccp_gotoptions[unit].mppe) { 
     556        if (ccp_wantoptions[unit].mppe) { 
    459557            error("MPPE disabled, closing LCP"); 
    460558            lcp_close(unit, "MPPE disabled by peer"); 
    461559        } 
    462 #endif 
     560#endif /* MPPE */ 
    463561    } 
    464562 
    465563    /* 
    ccp_extcode(f, code, id, p, len) 
    487585            break; 
    488586        /* send a reset-ack, which the transmitter will see and 
    489587           reset its compression state. */ 
     588 
     589        /* In case of MPPE/MPPC or LZS we shouldn't send CCP_RESETACK, 
     590           but we do it in order to reset compressor; CCP_RESETACK is 
     591           then silently discarded. See functions ppp_send_frame and 
     592           ppp_ccp_peek in ppp_generic.c (Linux only !!!). All the 
     593           confusion is caused by the fact that CCP code is splited 
     594           into two parts - one part is handled by pppd, the other one 
     595           is handled by kernel. */ 
     596 
    490597        fsm_sdata(f, CCP_RESETACK, id, NULL, 0); 
    491598        break; 
    492599 
    ccp_protrej(unit) 
    515622    fsm_lowerdown(&ccp_fsm[unit]); 
    516623 
    517624#ifdef MPPE 
    518     if (ccp_gotoptions[unit].mppe) { 
     625    if (ccp_wantoptions[unit].mppe) { 
    519626        error("MPPE required but peer negotiation failed"); 
    520627        lcp_close(unit, "MPPE required but peer negotiation failed"); 
    521628    } 
    522 #endif 
    523  
     629#endif /* MPPE */ 
    524630} 
    525631 
    526632/* 
    ccp_resetci(f) 
    537643    all_rejected[f->unit] = 0; 
    538644 
    539645#ifdef MPPE 
    540     if (go->mppe) { 
     646    if (go->mppe || go->mppc) { 
    541647        ccp_options *ao = &ccp_allowoptions[f->unit]; 
    542648        int auth_mschap_bits = auth_done[f->unit]; 
    543649        int numbits; 
    ccp_resetci(f) 
    551657         * NB: If MPPE is required, all other compression opts are invalid. 
    552658         *     So, we return right away if we can't do it. 
    553659         */ 
     660        if (ccp_wantoptions[f->unit].mppe) { 
     661            /* Leave only the mschap auth bits set */ 
     662            auth_mschap_bits &= (CHAP_MS_WITHPEER  | CHAP_MS_PEER | 
     663                                 CHAP_MS2_WITHPEER | CHAP_MS2_PEER); 
     664            /* Count the mschap auths */ 
     665            auth_mschap_bits >>= CHAP_MS_SHIFT; 
     666            numbits = 0; 
     667            do { 
     668                numbits += auth_mschap_bits & 1; 
     669                auth_mschap_bits >>= 1; 
     670            } while (auth_mschap_bits); 
     671            if (numbits > 1) { 
     672                error("MPPE required, but auth done in both directions."); 
     673                lcp_close(f->unit, "MPPE required but not available"); 
     674                return; 
     675            } 
     676            if (!numbits) { 
     677                error("MPPE required, but MS-CHAP[v2] auth not performed."); 
     678                lcp_close(f->unit, "MPPE required but not available"); 
     679                return; 
     680            } 
    554681 
    555         /* Leave only the mschap auth bits set */ 
    556         auth_mschap_bits &= (CHAP_MS_WITHPEER  | CHAP_MS_PEER | 
    557                              CHAP_MS2_WITHPEER | CHAP_MS2_PEER); 
    558         /* Count the mschap auths */ 
    559         auth_mschap_bits >>= CHAP_MS_SHIFT; 
    560         numbits = 0; 
    561         do { 
    562             numbits += auth_mschap_bits & 1; 
    563             auth_mschap_bits >>= 1; 
    564         } while (auth_mschap_bits); 
    565         if (numbits > 1) { 
    566             error("MPPE required, but auth done in both directions."); 
    567             lcp_close(f->unit, "MPPE required but not available"); 
    568             return; 
    569         } 
    570         if (!numbits) { 
    571             error("MPPE required, but MS-CHAP[v2] auth not performed."); 
    572             lcp_close(f->unit, "MPPE required but not available"); 
    573             return; 
    574         } 
    575  
    576         /* A plugin (eg radius) may not have obtained key material. */ 
    577         if (!mppe_keys_set) { 
    578             error("MPPE required, but keys are not available.  " 
    579                   "Possible plugin problem?"); 
    580             lcp_close(f->unit, "MPPE required but not available"); 
    581             return; 
    582         } 
    583  
    584         /* LM auth not supported for MPPE */ 
    585         if (auth_done[f->unit] & (CHAP_MS_WITHPEER | CHAP_MS_PEER)) { 
    586             /* This might be noise */ 
    587             if (go->mppe & MPPE_OPT_40) { 
    588                 notice("Disabling 40-bit MPPE; MS-CHAP LM not supported"); 
    589                 go->mppe &= ~MPPE_OPT_40; 
    590                 ccp_wantoptions[f->unit].mppe &= ~MPPE_OPT_40; 
     682            /* A plugin (eg radius) may not have obtained key material. */ 
     683            if (!mppe_keys_set) { 
     684                error("MPPE required, but keys are not available.  " 
     685                      "Possible plugin problem?"); 
     686                lcp_close(f->unit, "MPPE required but not available"); 
     687                return; 
    591688            } 
    592689        } 
    593690 
    594         /* Last check: can we actually negotiate something? */ 
    595         if (!(go->mppe & (MPPE_OPT_40 | MPPE_OPT_128))) { 
    596             /* Could be misconfig, could be 40-bit disabled above. */ 
    597             error("MPPE required, but both 40-bit and 128-bit disabled."); 
    598             lcp_close(f->unit, "MPPE required but not available"); 
    599             return; 
     691        /* 
     692         * Check whether the kernel knows about the various 
     693         * compression methods we might request. Key material 
     694         * unimportant here. 
     695         */ 
     696        if (go->mppc) { 
     697            opt_buf[0] = CI_MPPE; 
     698            opt_buf[1] = CILEN_MPPE; 
     699            opt_buf[2] = 0; 
     700            opt_buf[3] = 0; 
     701            opt_buf[4] = 0; 
     702            opt_buf[5] = MPPE_MPPC; 
     703            if (ccp_test(f->unit, opt_buf, CILEN_MPPE, 0) <= 0) 
     704                go->mppc = 0; 
     705        } 
     706        if (go->mppe_40) { 
     707            opt_buf[0] = CI_MPPE; 
     708            opt_buf[1] = CILEN_MPPE; 
     709            opt_buf[2] = MPPE_STATELESS; 
     710            opt_buf[3] = 0; 
     711            opt_buf[4] = 0; 
     712            opt_buf[5] = MPPE_40BIT; 
     713            if (ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0) <= 0) 
     714                go->mppe_40 = 0; 
     715        } 
     716        if (go->mppe_56) { 
     717            opt_buf[0] = CI_MPPE; 
     718            opt_buf[1] = CILEN_MPPE; 
     719            opt_buf[2] = MPPE_STATELESS; 
     720            opt_buf[3] = 0; 
     721            opt_buf[4] = 0; 
     722            opt_buf[5] = MPPE_56BIT; 
     723            if (ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0) <= 0) 
     724                go->mppe_56 = 0; 
     725        } 
     726        if (go->mppe_128) { 
     727            opt_buf[0] = CI_MPPE; 
     728            opt_buf[1] = CILEN_MPPE; 
     729            opt_buf[2] = MPPE_STATELESS; 
     730            opt_buf[3] = 0; 
     731            opt_buf[4] = 0; 
     732            opt_buf[5] = MPPE_128BIT; 
     733            if (ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0) <= 0) 
     734                go->mppe_128 = 0; 
     735        } 
     736        if (!go->mppe_40 && !go->mppe_56 && !go->mppe_128) { 
     737            if (ccp_wantoptions[f->unit].mppe) { 
     738                error("MPPE required, but kernel has no support."); 
     739                lcp_close(f->unit, "MPPE required but not available"); 
     740            } 
     741            go->mppe = go->mppe_stateless = 0; 
     742        } else { 
     743            /* MPPE is not compatible with other compression types */ 
     744            if (ccp_wantoptions[f->unit].mppe) { 
     745                ao->bsd_compress = go->bsd_compress = 0; 
     746                ao->predictor_1  = go->predictor_1  = 0; 
     747                ao->predictor_2  = go->predictor_2  = 0; 
     748                ao->deflate      = go->deflate      = 0; 
     749                ao->lzs          = go->lzs          = 0; 
     750            } 
    600751        } 
    601  
    602         /* sync options */ 
    603         ao->mppe = go->mppe; 
    604         /* MPPE is not compatible with other compression types */ 
    605         ao->bsd_compress = go->bsd_compress = 0; 
    606         ao->predictor_1  = go->predictor_1  = 0; 
    607         ao->predictor_2  = go->predictor_2  = 0; 
    608         ao->deflate      = go->deflate      = 0; 
    609752    } 
    610753#endif /* MPPE */ 
    611  
    612     /* 
    613      * Check whether the kernel knows about the various 
    614      * compression methods we might request. 
    615      */ 
    616 #ifdef MPPE 
    617     if (go->mppe) { 
    618         opt_buf[0] = CI_MPPE; 
    619         opt_buf[1] = CILEN_MPPE; 
    620         MPPE_OPTS_TO_CI(go->mppe, &opt_buf[2]); 
    621         /* Key material unimportant here. */ 
    622         if (ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0) <= 0) { 
    623             error("MPPE required, but kernel has no support."); 
    624             lcp_close(f->unit, "MPPE required but not available"); 
    625         } 
     754    if (go->lzs) { 
     755        opt_buf[0] = CI_LZS; 
     756        opt_buf[1] = CILEN_LZS; 
     757        opt_buf[2] = go->lzs_hists >> 8; 
     758        opt_buf[3] = go->lzs_hists & 0xff; 
     759        opt_buf[4] = LZS_MODE_SEQ; 
     760        if (ccp_test(f->unit, opt_buf, CILEN_LZS, 0) <= 0) 
     761            go->lzs = 0; 
    626762    } 
    627 #endif 
    628763    if (go->bsd_compress) { 
    629764        opt_buf[0] = CI_BSD_COMPRESS; 
    630765        opt_buf[1] = CILEN_BSD_COMPRESS; 
    ccp_cilen(f) 
    679814        + (go->deflate? CILEN_DEFLATE: 0) 
    680815        + (go->predictor_1? CILEN_PREDICTOR_1: 0) 
    681816        + (go->predictor_2? CILEN_PREDICTOR_2: 0) 
    682         + (go->mppe? CILEN_MPPE: 0); 
     817        + (go->lzs? CILEN_LZS: 0) 
     818        + ((go->mppe || go->mppc)? CILEN_MPPE: 0); 
    683819} 
    684820 
    685821/* 
    ccp_addci(f, p, lenp) 
    693829{ 
    694830    int res; 
    695831    ccp_options *go = &ccp_gotoptions[f->unit]; 
     832    ccp_options *ao = &ccp_allowoptions[f->unit]; 
     833    ccp_options *wo = &ccp_wantoptions[f->unit]; 
    696834    u_char *p0 = p; 
    697835 
    698836    /* 
    ccp_addci(f, p, lenp) 
    701839     * in case it gets Acked. 
    702840     */ 
    703841#ifdef MPPE 
    704     if (go->mppe) { 
     842    if (go->mppe || go->mppc || (!wo->mppe && ao->mppe)) { 
    705843        u_char opt_buf[CILEN_MPPE + MPPE_MAX_KEY_LEN]; 
    706844 
    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]); 
     845        p[0] = CI_MPPE; 
     846        p[1] = CILEN_MPPE; 
     847        p[2] = (go->mppe_stateless ? MPPE_STATELESS : 0); 
     848        p[3] = 0; 
     849        p[4] = 0; 
     850        p[5] = (go->mppe_40 ? MPPE_40BIT : 0) | (go->mppe_56 ? MPPE_56BIT : 0) | 
     851            (go->mppe_128 ? MPPE_128BIT : 0) | (go->mppc ? MPPE_MPPC : 0); 
     852 
     853        BCOPY(p, opt_buf, CILEN_MPPE); 
    711854        BCOPY(mppe_recv_key, &opt_buf[CILEN_MPPE], MPPE_MAX_KEY_LEN); 
    712855        res = ccp_test(f->unit, opt_buf, CILEN_MPPE + MPPE_MAX_KEY_LEN, 0); 
    713         if (res > 0) 
     856        if (res > 0) { 
    714857            p += CILEN_MPPE; 
    715         else 
     858        } else { 
    716859            /* This shouldn't happen, we've already tested it! */ 
    717             lcp_close(f->unit, "MPPE required but not available in kernel"); 
     860            go->mppe = go->mppe_40 = go->mppe_56 = go->mppe_128 = 
     861                go->mppe_stateless = go->mppc = 0; 
     862            if (ccp_wantoptions[f->unit].mppe) 
     863                lcp_close(f->unit, "MPPE required but not available in kernel"); 
     864        } 
     865    } 
     866#endif /* MPPE */ 
     867    if (go->lzs) { 
     868        p[0] = CI_LZS; 
     869        p[1] = CILEN_LZS; 
     870        p[2] = go->lzs_hists >> 8; 
     871        p[3] = go->lzs_hists & 0xff; 
     872        p[4] = LZS_MODE_SEQ; 
     873        res = ccp_test(f->unit, p, CILEN_LZS, 0); 
     874        if (res > 0) { 
     875            p += CILEN_LZS; 
     876        } else 
     877            go->lzs = 0; 
    718878    } 
    719 #endif 
    720879    if (go->deflate) { 
    721880        p[0] = go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT; 
    722881        p[1] = CILEN_DEFLATE; 
    ccp_addci(f, p, lenp) 
    802961 
    803962/* 
    804963 * ccp_ackci - process a received configure-ack, and return 
    805  * 1 iff the packet was OK. 
     964 * 1 if the packet was OK. 
    806965 */ 
    807966static int 
    808967ccp_ackci(f, p, len) 
    ccp_ackci(f, p, len) 
    811970    int len; 
    812971{ 
    813972    ccp_options *go = &ccp_gotoptions[f->unit]; 
     973    ccp_options *ao = &ccp_allowoptions[f->unit]; 
     974    ccp_options *wo = &ccp_wantoptions[f->unit]; 
    814975    u_char *p0 = p; 
    815976 
    816977#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)) 
     978    if (go->mppe || go->mppc || (!wo->mppe && ao->mppe)) { 
     979        if (len < CILEN_MPPE 
     980            || p[1] != CILEN_MPPE || p[0] != CI_MPPE 
     981            || p[2] != (go->mppe_stateless ? MPPE_STATELESS : 0) 
     982            || p[3] != 0 
     983            || p[4] != 0 
     984            || (p[5] != ((go->mppe_40 ? MPPE_40BIT : 0) | 
     985                         (go->mppc ? MPPE_MPPC : 0)) 
     986                && p[5] != ((go->mppe_56 ? MPPE_56BIT : 0) | 
     987                            (go->mppc ? MPPE_MPPC : 0)) 
     988                && p[5] != ((go->mppe_128 ? MPPE_128BIT : 0) | 
     989                            (go->mppc ? MPPE_MPPC : 0)))) 
    824990            return 0; 
     991        if (go->mppe_40 || go->mppe_56 || go->mppe_128) 
     992            go->mppe = 1; 
    825993        p += CILEN_MPPE; 
    826994        len -= CILEN_MPPE; 
     995        /* Cope with first/fast ack */ 
     996        if (p == p0 && len == 0) 
     997            return 1; 
     998    } 
     999#endif /* MPPE */ 
     1000    if (go->lzs) { 
     1001        if (len < CILEN_LZS || p[0] != CI_LZS || p[1] != CILEN_LZS 
     1002            || p[2] != go->lzs_hists>>8 || p[3] != (go->lzs_hists&0xff) 
     1003            || p[4] != LZS_MODE_SEQ) 
     1004            return 0; 
     1005        p += CILEN_LZS; 
     1006        len -= CILEN_LZS; 
    8271007        /* XXX Cope with first/fast ack */ 
    828         if (len == 0) 
     1008        if (p == p0 && len == 0) 
    8291009            return 1; 
    8301010    } 
    831 #endif 
    8321011    if (go->deflate) { 
    8331012        if (len < CILEN_DEFLATE 
    8341013            || p[0] != (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT) 
    ccp_ackci(f, p, len) 
    8911070 
    8921071/* 
    8931072 * ccp_nakci - process received configure-nak. 
    894  * Returns 1 iff the nak was OK. 
     1073 * Returns 1 if the nak was OK. 
    8951074 */ 
    8961075static int 
    8971076ccp_nakci(f, p, len, treat_as_reject) 
    ccp_nakci(f, p, len, treat_as_reject) 
    9011080    int treat_as_reject; 
    9021081{ 
    9031082    ccp_options *go = &ccp_gotoptions[f->unit]; 
     1083    ccp_options *ao = &ccp_allowoptions[f->unit]; 
     1084    ccp_options *wo = &ccp_wantoptions[f->unit]; 
    9041085    ccp_options no;             /* options we've seen already */ 
    9051086    ccp_options try;            /* options to ask for next time */ 
    9061087 
    ccp_nakci(f, p, len, treat_as_reject) 
    9081089    try = *go; 
    9091090 
    9101091#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         } 
     1092    if ((go->mppe || go->mppc || (!wo->mppe && ao->mppe)) && 
     1093        len >= CILEN_MPPE && p[0] == CI_MPPE && p[1] == CILEN_MPPE) { 
    9261094 
    927         if (!try.mppe) { 
    928             error("MPPE required but peer negotiation failed"); 
    929             lcp_close(f->unit, "MPPE required but peer negotiation failed"); 
     1095        if (go->mppc) { 
     1096            no.mppc = 1; 
     1097            if (!(p[5] & MPPE_MPPC)) 
     1098                try.mppc = 0; 
     1099        } 
     1100 
     1101        if (go->mppe) 
     1102            no.mppe = 1; 
     1103        if (go->mppe_40) 
     1104            no.mppe_40 = 1; 
     1105        if (go->mppe_56) 
     1106            no.mppe_56 = 1; 
     1107        if (go->mppe_128) 
     1108            no.mppe_128 = 1; 
     1109        if (go->mppe_stateless) 
     1110            no.mppe_stateless = 1; 
     1111 
     1112        if (ao->mppe_40) { 
     1113            if ((p[5] & MPPE_40BIT)) 
     1114                try.mppe_40 = 1; 
     1115            else 
     1116                try.mppe_40 = (p[5] == 0) ? 1 : 0; 
     1117        } 
     1118        if (ao->mppe_56) { 
     1119            if ((p[5] & MPPE_56BIT)) 
     1120                try.mppe_56 = 1; 
     1121            else 
     1122                try.mppe_56 = (p[5] == 0) ? 1 : 0; 
     1123        } 
     1124        if (ao->mppe_128) { 
     1125            if ((p[5] & MPPE_128BIT)) 
     1126                try.mppe_128 = 1; 
     1127            else 
     1128                try.mppe_128 = (p[5] == 0) ? 1 : 0; 
     1129        } 
     1130 
     1131        if (ao->mppe_stateless) { 
     1132            if ((p[2] & MPPE_STATELESS) || wo->mppe_stateless) 
     1133                try.mppe_stateless = 1; 
     1134            else 
     1135                try.mppe_stateless = 0; 
     1136        } 
     1137 
     1138        if (!try.mppe_56 && !try.mppe_40 && !try.mppe_128) { 
     1139            try.mppe = try.mppe_stateless = 0; 
     1140            if (wo->mppe) { 
     1141                /* we require encryption, but peer doesn't support it 
     1142                   so we close connection */ 
     1143                wo->mppc = wo->mppe = wo->mppe_stateless = wo->mppe_40 = 
     1144                    wo->mppe_56 = wo->mppe_128 = 0; 
     1145                lcp_close(f->unit, "MPPE required but cannot negotiate MPPE " 
     1146                          "key length"); 
     1147            } 
     1148        } 
     1149        if (wo->mppe && (wo->mppe_40 != try.mppe_40) && 
     1150            (wo->mppe_56 != try.mppe_56) && (wo->mppe_128 != try.mppe_128)) { 
     1151            /* cannot negotiate key length */ 
     1152            wo->mppc = wo->mppe = wo->mppe_stateless = wo->mppe_40 = 
     1153                wo->mppe_56 = wo->mppe_128 = 0; 
     1154            lcp_close(f->unit, "Cannot negotiate MPPE key length"); 
    9301155        } 
     1156        if (try.mppe_40 && try.mppe_56 && try.mppe_128) 
     1157            try.mppe_40 = try.mppe_56 = 0; 
     1158        else 
     1159            if (try.mppe_56 && try.mppe_128) 
     1160                try.mppe_56 = 0; 
     1161            else 
     1162                if (try.mppe_40 && try.mppe_128) 
     1163                    try.mppe_40 = 0; 
     1164                else 
     1165                    if (try.mppe_40 && try.mppe_56) 
     1166                        try.mppe_40 = 0; 
     1167 
     1168        p += CILEN_MPPE; 
     1169        len -= CILEN_MPPE; 
    9311170    } 
    9321171#endif /* MPPE */ 
     1172 
     1173    if (go->lzs && len >= CILEN_LZS && p[0] == CI_LZS && p[1] == CILEN_LZS) { 
     1174        no.lzs = 1; 
     1175        if (((p[2]<<8)|p[3]) > 1 || (p[4] != LZS_MODE_SEQ && 
     1176                                     p[4] != LZS_MODE_EXT)) 
     1177            try.lzs = 0; 
     1178        else { 
     1179            try.lzs_mode = p[4]; 
     1180            try.lzs_hists = (p[2] << 8) | p[3]; 
     1181        } 
     1182        p += CILEN_LZS; 
     1183        len -= CILEN_LZS; 
     1184    } 
     1185 
    9331186    if (go->deflate && len >= CILEN_DEFLATE 
    9341187        && p[0] == (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT) 
    9351188        && p[1] == CILEN_DEFLATE) { 
    ccp_rejci(f, p, len) 
    10021255        return -1; 
    10031256 
    10041257#ifdef MPPE 
    1005     if (go->mppe && len >= CILEN_MPPE 
     1258    if ((go->mppe || go->mppc) && len >= CILEN_MPPE 
    10061259        && 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"); 
     1260        ccp_options *wo = &ccp_wantoptions[f->unit]; 
     1261        if (p[2] != (go->mppe_stateless ? MPPE_STATELESS : 0) || 
     1262            p[3] != 0 || 
     1263            p[4] != 0 || 
     1264            p[5] != ((go->mppe_40 ? MPPE_40BIT : 0) | 
     1265                     (go->mppe_56 ? MPPE_56BIT : 0) | 
     1266                     (go->mppe_128 ? MPPE_128BIT : 0) | 
     1267                     (go->mppc ? MPPE_MPPC : 0))) 
     1268            return 0; 
     1269        if (go->mppc) 
     1270            try.mppc = 0; 
     1271        if (go->mppe) { 
     1272            try.mppe = 0; 
     1273            if (go->mppe_40) 
     1274                try.mppe_40 = 0; 
     1275            if (go->mppe_56) 
     1276                try.mppe_56 = 0; 
     1277            if (go->mppe_128) 
     1278                try.mppe_128 = 0; 
     1279            if (go->mppe_stateless) 
     1280                try.mppe_stateless = 0; 
     1281            if (!try.mppe_56 && !try.mppe_40 && !try.mppe_128) 
     1282                try.mppe = try.mppe_stateless = 0; 
     1283            if (wo->mppe) { /* we want MPPE but cannot negotiate key length */ 
     1284                wo->mppc = wo->mppe = wo->mppe_stateless = wo->mppe_40 = 
     1285                    wo->mppe_56 = wo->mppe_128 = 0; 
     1286                lcp_close(f->unit, "MPPE required but cannot negotiate MPPE " 
     1287                          "key length"); 
     1288            } 
     1289        } 
    10091290        p += CILEN_MPPE; 
    10101291        len -= CILEN_MPPE; 
    10111292    } 
    1012 #endif 
     1293#endif /* MPPE */ 
     1294    if (go->lzs && len >= CILEN_LZS && p[0] == CI_LZS && p[1] == CILEN_LZS) { 
     1295        if (p[2] != go->lzs_hists>>8 || p[3] != (go->lzs_hists&0xff)  
     1296            || p[4] != go->lzs_mode) 
     1297            return 0; 
     1298        try.lzs = 0; 
     1299        p += CILEN_LZS; 
     1300        len -= CILEN_LZS; 
     1301    } 
    10131302    if (go->deflate_correct && len >= CILEN_DEFLATE 
    10141303        && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) { 
    10151304        if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size) 
    ccp_reqci(f, p, lenp, dont_nak) 
    10731362    int dont_nak; 
    10741363{ 
    10751364    int ret, newret, res; 
    1076     u_char *p0, *retp; 
     1365    u_char *p0, *retp, p2, p5; 
    10771366    int len, clen, type, nb; 
    10781367    ccp_options *ho = &ccp_hisoptions[f->unit]; 
    10791368    ccp_options *ao = &ccp_allowoptions[f->unit]; 
     1369    ccp_options *wo = &ccp_wantoptions[f->unit]; 
    10801370#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 
     1371    u_char opt_buf[CILEN_MPPE + MPPE_MAX_KEY_LEN]; 
     1372/*     int mtu; */ 
     1373#endif /* MPPE */ 
    10841374 
    10851375    ret = CONFACK; 
    10861376    retp = p0 = p; 
    ccp_reqci(f, p, lenp, dont_nak) 
    11031393            switch (type) { 
    11041394#ifdef MPPE 
    11051395            case CI_MPPE: 
    1106                 if (!ao->mppe || clen != CILEN_MPPE) { 
     1396                if ((!ao->mppc && !ao->mppe) || clen != CILEN_MPPE) { 
    11071397                    newret = CONFREJ; 
    11081398                    break; 
    11091399                } 
    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) { 
     1400                p2 = p[2]; 
     1401                p5 = p[5]; 
     1402                /* not sure what they want, tell 'em what we got */ 
     1403                if (((p[2] & ~MPPE_STATELESS) != 0 || p[3] != 0 || p[4] != 0 || 
     1404                     (p[5] & ~(MPPE_40BIT | MPPE_56BIT | MPPE_128BIT | 
     1405                               MPPE_MPPC)) != 0 || p[5] == 0) || 
     1406                    (p[2] == 0 && p[3] == 0 && p[4] == 0 &&  p[5] == 0)) { 
    11141407                    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; 
     1408                    p[2] = (wo->mppe_stateless ? MPPE_STATELESS : 0); 
     1409                    p[3] = 0; 
     1410                    p[4] = 0; 
     1411                    p[5] = (wo->mppe_40 ? MPPE_40BIT : 0) | 
     1412                        (wo->mppe_56 ? MPPE_56BIT : 0) | 
     1413                        (wo->mppe_128 ? MPPE_128BIT : 0) | 
     1414                        (wo->mppc ? MPPE_MPPC : 0); 
     1415                    break; 
     1416                } 
     1417 
     1418                if ((p[5] & MPPE_MPPC)) { 
     1419                    if (ao->mppc) { 
     1420                        ho->mppc = 1; 
     1421                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1422                        opt_buf[2] = opt_buf[3] = opt_buf[4] = 0; 
     1423                        opt_buf[5] = MPPE_MPPC; 
     1424                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE, 1) <= 0) { 
     1425                            ho->mppc = 0; 
     1426                            p[5] &= ~MPPE_MPPC; 
     1427                            newret = CONFNAK; 
     1428                        } 
     1429                    } else { 
     1430                      newret = CONFREJ; 
     1431                        if (wo->mppe || ao->mppe) { 
     1432                            p[5] &= ~MPPE_MPPC; 
     1433                            newret = CONFNAK; 
     1434                        } 
    11341435                    } 
    11351436                } 
    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                     } 
     1437                if (ao->mppe) 
     1438                    ho->mppe = 1; 
     1439  
     1440                if ((p[2] & MPPE_STATELESS)) { 
     1441                    if (ao->mppe_stateless) { 
     1442                        if (wo->mppe_stateless) 
     1443                            ho->mppe_stateless = 1; 
     1444                        else { 
     1445                            newret = CONFNAK; 
     1446                            if (!dont_nak) 
     1447                                p[2] &= ~MPPE_STATELESS; 
     1448                        } 
     1449                    } else { 
     1450                        newret = CONFNAK; 
     1451                        if (!dont_nak) 
     1452                            p[2] &= ~MPPE_STATELESS; 
     1453                    } 
     1454                } else { 
     1455                    if (wo->mppe_stateless && !dont_nak) { 
     1456                        wo->mppe_stateless = 0; 
     1457                        newret = CONFNAK; 
     1458                        p[2] |= MPPE_STATELESS; 
     1459                    } 
     1460                } 
     1461   
     1462                if ((p[5] & ~MPPE_MPPC) == (MPPE_40BIT|MPPE_56BIT|MPPE_128BIT)) { 
     1463                    newret = CONFNAK; 
     1464                    if (ao->mppe_128) { 
     1465                        ho->mppe_128 = 1; 
     1466                        p[5] &= ~(MPPE_40BIT|MPPE_56BIT); 
     1467                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1468                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1469                              MPPE_MAX_KEY_LEN); 
     1470                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1471                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1472                            ho->mppe_128 = 0; 
     1473                            p[5] |= (MPPE_40BIT|MPPE_56BIT); 
     1474                            p[5] &= ~MPPE_128BIT; 
     1475                            goto check_mppe_56_40; 
     1476                        } 
     1477                        goto check_mppe; 
     1478                    } 
     1479                    p[5] &= ~MPPE_128BIT; 
     1480                    goto check_mppe_56_40; 
     1481                } 
     1482                if ((p[5] & ~MPPE_MPPC) == (MPPE_56BIT|MPPE_128BIT)) { 
     1483                    newret = CONFNAK; 
     1484                    if (ao->mppe_128) { 
     1485                        ho->mppe_128 = 1; 
     1486                        p[5] &= ~MPPE_56BIT; 
     1487                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1488                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1489                              MPPE_MAX_KEY_LEN); 
     1490                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1491                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1492                            ho->mppe_128 = 0; 
     1493                            p[5] |= MPPE_56BIT; 
     1494                            p[5] &= ~MPPE_128BIT; 
     1495                            goto check_mppe_56; 
     1496                        } 
     1497                        goto check_mppe; 
     1498                    } 
     1499                    p[5] &= ~MPPE_128BIT; 
     1500                    goto check_mppe_56; 
     1501                } 
     1502                if ((p[5] & ~MPPE_MPPC) == (MPPE_40BIT|MPPE_128BIT)) { 
     1503                    newret = CONFNAK; 
     1504                    if (ao->mppe_128) { 
     1505                        ho->mppe_128 = 1; 
     1506                        p[5] &= ~MPPE_40BIT; 
     1507                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1508                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1509                              MPPE_MAX_KEY_LEN); 
     1510                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1511                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1512                            ho->mppe_128 = 0; 
     1513                            p[5] |= MPPE_40BIT; 
     1514                            p[5] &= ~MPPE_128BIT; 
     1515                            goto check_mppe_40; 
     1516                        } 
     1517                        goto check_mppe; 
     1518                    } 
     1519                    p[5] &= ~MPPE_128BIT; 
     1520                    goto check_mppe_40; 
     1521                } 
     1522                if ((p[5] & ~MPPE_MPPC) == MPPE_128BIT) { 
     1523                    if (ao->mppe_128) { 
     1524                        ho->mppe_128 = 1; 
     1525                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1526                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1527                              MPPE_MAX_KEY_LEN); 
     1528                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1529                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1530                            ho->mppe_128 = 0; 
     1531                            p[5] &= ~MPPE_128BIT; 
     1532                            newret = CONFNAK; 
     1533                        } 
     1534                        goto check_mppe; 
     1535                    } 
     1536                    p[5] &= ~MPPE_128BIT; 
     1537                    newret = CONFNAK; 
     1538                    goto check_mppe; 
     1539                } 
     1540            check_mppe_56_40: 
     1541                if ((p[5] & ~MPPE_MPPC) == (MPPE_40BIT|MPPE_56BIT)) { 
     1542                    newret = CONFNAK; 
     1543                    if (ao->mppe_56) { 
     1544                        ho->mppe_56 = 1; 
     1545                        p[5] &= ~MPPE_40BIT; 
     1546                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1547                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1548                              MPPE_MAX_KEY_LEN); 
     1549                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1550                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1551                            ho->mppe_56 = 0; 
     1552                            p[5] |= MPPE_40BIT; 
     1553                            p[5] &= ~MPPE_56BIT; 
     1554                            newret = CONFNAK; 
     1555                            goto check_mppe_40; 
     1556                        } 
     1557                        goto check_mppe; 
     1558                    } 
     1559                    p[5] &= ~MPPE_56BIT; 
     1560                    goto check_mppe_40; 
     1561                } 
     1562            check_mppe_56: 
     1563                if ((p[5] & ~MPPE_MPPC) == MPPE_56BIT) { 
     1564                    if (ao->mppe_56) { 
     1565                        ho->mppe_56 = 1; 
     1566                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1567                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1568                              MPPE_MAX_KEY_LEN); 
     1569                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1570                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1571                            ho->mppe_56 = 0; 
     1572                            p[5] &= ~MPPE_56BIT; 
     1573                            newret = CONFNAK; 
     1574                        } 
     1575                        goto check_mppe; 
     1576                    } 
     1577                    p[5] &= ~MPPE_56BIT; 
     1578                    newret = CONFNAK; 
     1579                    goto check_mppe; 
     1580                } 
     1581            check_mppe_40: 
     1582                if ((p[5] & ~MPPE_MPPC) == MPPE_40BIT) { 
     1583                    if (ao->mppe_40) { 
     1584                        ho->mppe_40 = 1; 
     1585                        BCOPY(p, opt_buf, CILEN_MPPE); 
     1586                        BCOPY(mppe_send_key, &opt_buf[CILEN_MPPE], 
     1587                              MPPE_MAX_KEY_LEN); 
     1588                        if (ccp_test(f->unit, opt_buf, CILEN_MPPE + 
     1589                                     MPPE_MAX_KEY_LEN, 1) <= 0) { 
     1590                            ho->mppe_40 = 0; 
     1591                            p[5] &= ~MPPE_40BIT; 
     1592                            newret = CONFNAK; 
     1593                        } 
     1594                        goto check_mppe; 
     1595                    } 
     1596                    p[5] &= ~MPPE_40BIT; 
     1597                } 
     1598  
     1599            check_mppe: 
     1600                if (!ho->mppe_40 && !ho->mppe_56 && !ho->mppe_128) { 
     1601                    if (wo->mppe_40 || wo->mppe_56 || wo->mppe_128) { 
     1602                        newret = CONFNAK; 
     1603                        p[2] |= (wo->mppe_stateless ? MPPE_STATELESS : 0); 
     1604                        p[5] |= (wo->mppe_40 ? MPPE_40BIT : 0) | 
     1605                            (wo->mppe_56 ? MPPE_56BIT : 0) | 
     1606                            (wo->mppe_128 ? MPPE_128BIT : 0) | 
     1607                            (wo->mppc ? MPPE_MPPC : 0); 
     1608                    } else { 
     1609                        ho->mppe = ho->mppe_stateless = 0; 
     1610                    } 
    11601611                } 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 */ 
     1612                    /* MPPE is not compatible with other compression types */ 
     1613                    if (wo->mppe) { 
     1614                        ao->bsd_compress = 0; 
     1615                        ao->predictor_1 = 0; 
     1616                        ao->predictor_2 = 0; 
     1617                        ao->deflate = 0; 
     1618                        ao->lzs = 0; 
     1619                    } 
     1620                } 
     1621                if ((!ho->mppc || !ao->mppc) && !ho->mppe) { 
     1622                    p[2] = p2; 
     1623                    p[5] = p5; 
     1624                    newret = CONFREJ; 
     1625                    break; 
     1626                } 
     1627   
     1628                /* 
     1629                 * I have commented the code below because according to RFC1547 
     1630                 * MTU is only information for higher level protocols about 
     1631                 * "the maximum allowable length for a packet (q.v.) transmitted 
     1632                 * over a point-to-point link without incurring network layer 
     1633                 * fragmentation." Of course a PPP implementation should be able 
     1634                 * to handle overhead added by MPPE - in our case apropriate code 
     1635                 * is located in drivers/net/ppp_generic.c in the kernel sources. 
     1636                 * 
     1637                 * According to RFC1661: 
     1638                 * - when negotiated MRU is less than 1500 octets, a PPP 
     1639                 *   implementation must still be able to receive at least 1500 
     1640                 *   octets, 
     1641                 * - when PFC is negotiated, a PPP implementation is still 
     1642                 *   required to receive frames with uncompressed protocol field. 
     1643                 * 
     1644                 * So why not to handle MPPE overhead without changing MTU value? 
     1645                 * I am sure that RFC3078, unfortunately silently, assumes that. 
     1646                 */ 
     1647  
     1648                /* 
     1649                 * We need to decrease the interface MTU by MPPE_PAD 
     1650                 * because MPPE frames **grow**.  The kernel [must] 
     1651                 * allocate MPPE_PAD extra bytes in xmit buffers. 
     1652                 */ 
     1653 /* 
     1654                mtu = netif_get_mtu(f->unit); 
     1655                if (mtu) { 
     1656                    netif_set_mtu(f->unit, mtu - MPPE_PAD); 
     1657                } else { 
     1658                    newret = CONFREJ; 
     1659                    if (ccp_wantoptions[f->unit].mppe) { 
     1660                        error("Cannot adjust MTU needed by MPPE."); 
     1661                        lcp_close(f->unit, "Cannot adjust MTU needed by MPPE."); 
     1662                    } 
     1663                } 
     1664 */ 
     1665                break; 
     1666  #endif /* MPPE */ 
     1667  
     1668            case CI_LZS: 
     1669                if (!ao->lzs || clen != CILEN_LZS) { 
     1670                    newret = CONFREJ; 
     1671                    break; 
     1672                } 
     1673  
     1674                ho->lzs = 1; 
     1675                ho->lzs_hists = (p[2] << 8) | p[3]; 
     1676                ho->lzs_mode = p[4]; 
     1677        if ((ho->lzs_hists != ao->lzs_hists) || 
     1678                    (ho->lzs_mode != ao->lzs_mode)) { 
     1679                    newret = CONFNAK; 
     1680                    if (!dont_nak) { 
     1681                        p[2] = ao->lzs_hists >> 8; 
     1682                        p[3] = ao->lzs_hists & 0xff; 
     1683                        p[4] = ao->lzs_mode; 
     1684            } else 
     1685                        break; 
     1686                } 
     1687  
     1688                if (p == p0 && ccp_test(f->unit, p, CILEN_LZS, 1) <= 0) { 
     1689                    newret = CONFREJ; 
     1690                } 
     1691                break; 
    12061692            case CI_DEFLATE: 
    12071693            case CI_DEFLATE_DRAFT: 
    12081694                if (!ao->deflate || clen != CILEN_DEFLATE 
    ccp_reqci(f, p, lenp, dont_nak) 
    13441830        else 
    13451831            *lenp = retp - p0; 
    13461832    } 
    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 
    13531833    return ret; 
    13541834} 
    13551835 
    method_name(opt, opt2) 
    13711851        char *p = result; 
    13721852        char *q = result + sizeof(result); /* 1 past result */ 
    13731853 
    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  
     1854        if (opt->mppe) { 
     1855            if (opt->mppc) { 
     1856                slprintf(p, q - p, "MPPC/MPPE "); 
     1857                p += 10; 
     1858            } else { 
     1859                slprintf(p, q - p, "MPPE "); 
     1860                p += 5; 
     1861            } 
     1862            if (opt->mppe_128) { 
     1863                slprintf(p, q - p, "128-bit "); 
     1864                p += 8; 
     1865            } else if (opt->mppe_56) { 
     1866                slprintf(p, q - p, "56-bit "); 
     1867                p += 7; 
     1868            } else if (opt->mppe_40) { 
     1869                slprintf(p, q - p, "40-bit "); 
     1870                p += 7; 
     1871            } 
     1872            if (opt->mppe_stateless) 
     1873                slprintf(p, q - p, "stateless"); 
     1874            else 
     1875                slprintf(p, q - p, "stateful"); 
     1876        } else if (opt->mppc) 
     1877            slprintf(p, q - p, "MPPC"); 
    13891878        break; 
    13901879    } 
    1391 #endif 
     1880#endif /* MPPE */ 
     1881    case CI_LZS: 
     1882        return "Stac LZS"; 
    13921883    case CI_DEFLATE: 
    13931884    case CI_DEFLATE_DRAFT: 
    13941885        if (opt2 != NULL && opt2->deflate_size != opt->deflate_size) 
    ccp_up(f) 
    14441935    } else if (ANY_COMPRESS(*ho)) 
    14451936        notice("%s transmit compression enabled", method_name(ho, NULL)); 
    14461937#ifdef MPPE 
    1447     if (go->mppe) { 
     1938    if (go->mppe || go->mppc) { 
    14481939        BZERO(mppe_recv_key, MPPE_MAX_KEY_LEN); 
    14491940        BZERO(mppe_send_key, MPPE_MAX_KEY_LEN); 
    14501941        continue_networks(f->unit);             /* Bring up IP et al */ 
    14511942    } 
    1452 #endif 
     1943#endif /* MPPE */ 
    14531944} 
    14541945 
    14551946/* 
    ccp_down(f) 
    14721963            lcp_close(f->unit, "MPPE disabled"); 
    14731964        } 
    14741965    } 
    1475 #endif 
     1966#endif /* MPPE */ 
    14761967} 
    14771968 
    14781969/* 
    ccp_printpkt(p, plen, printer, arg) 
    15322023#ifdef MPPE 
    15332024            case CI_MPPE: 
    15342025                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", 
     2026                    printer(arg, "mppe %s %s %s %s %s %s", 
     2027                            (p[2] & MPPE_STATELESS)? "+H": "-H", 
     2028                            (p[5] & MPPE_56BIT)? "+M": "-M", 
     2029                            (p[5] & MPPE_128BIT)? "+S": "-S", 
     2030                            (p[5] & MPPE_40BIT)? "+L": "-L", 
    15432031                            (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) 
     2032                            (p[5] & MPPE_MPPC)? "+C": "-C"); 
     2033                    if ((p[5] & ~(MPPE_56BIT | MPPE_128BIT | MPPE_40BIT | 
     2034                                  MPPE_D_BIT | MPPE_MPPC)) || 
     2035                        (p[2] & ~MPPE_STATELESS)) 
    15472036                        printer(arg, " (%.2x %.2x %.2x %.2x)", 
    15482037                                p[2], p[3], p[4], p[5]); 
    15492038                    p += CILEN_MPPE; 
    15502039                } 
    15512040                break; 
    1552 #endif 
     2041#endif /* MPPE */ 
     2042            case CI_LZS: 
     2043                if (optlen >= CILEN_LZS) { 
     2044                    printer(arg, "lzs %.2x %.2x %.2x", p[2], p[3], p[4]); 
     2045                    p += CILEN_LZS; 
     2046                } 
     2047                break; 
    15532048            case CI_DEFLATE: 
    15542049            case CI_DEFLATE_DRAFT: 
    15552050                if (optlen >= CILEN_DEFLATE) { 
    ccp_datainput(unit, pkt, len) 
    16352130            error("Lost compression sync: disabling compression"); 
    16362131            ccp_close(unit, "Lost compression sync"); 
    16372132#ifdef MPPE 
     2133            /* My module dosn't need this. J.D., 2003-07-06 */ 
    16382134            /* 
    16392135             * If we were doing MPPE, we must also take the link down. 
    16402136             */ 
    ccp_datainput(unit, pkt, len) 
    16422138                error("Too many MPPE errors, closing LCP"); 
    16432139                lcp_close(unit, "Too many MPPE errors"); 
    16442140            } 
    1645 #endif 
     2141#endif /* MPPE */ 
    16462142        } else { 
    16472143            /* 
     2144             * When LZS or MPPE/MPPC is negotiated we just send CCP_RESETREQ 
     2145             * and don't wait for CCP_RESETACK 
     2146             */ 
     2147            if ((ccp_gotoptions[f->unit].method == CI_LZS) || 
     2148                (ccp_gotoptions[f->unit].method == CI_MPPE)) { 
     2149                fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0); 
     2150                return; 
     2151            } 
     2152            /* 
    16482153             * Send a reset-request to reset the peer's compressor. 
    16492154             * We don't do that if we are still waiting for an 
    16502155             * acknowledgement to a previous reset-request. 
    ccp_rack_timeout(arg) 
    16752180    } else 
    16762181        ccp_localstate[f->unit] &= ~RACK_PENDING; 
    16772182} 
    1678  
  • pppd/ccp.h

    a b typedef struct ccp_options { 
    3737    bool predictor_2;           /* do Predictor-2? */ 
    3838    bool deflate_correct;       /* use correct code for deflate? */ 
    3939    bool deflate_draft;         /* use draft RFC code for deflate? */ 
     40    bool lzs;                   /* do Stac LZS? */ 
     41    bool mppc;                  /* do MPPC? */ 
    4042    bool mppe;                  /* do MPPE? */ 
     43    bool mppe_40;               /* allow 40 bit encryption? */ 
     44    bool mppe_56;               /* allow 56 bit encryption? */ 
     45    bool mppe_128;              /* allow 128 bit encryption? */ 
     46    bool mppe_stateless;        /* allow stateless encryption */ 
    4147    u_short bsd_bits;           /* # bits/code for BSD Compress */ 
    4248    u_short deflate_size;       /* lg(window size) for Deflate */ 
     49    u_short lzs_mode;           /* LZS check mode */ 
     50    u_short lzs_hists;          /* number of LZS histories */ 
    4351    short method;               /* code for chosen compression method */ 
    4452} ccp_options; 
    4553 
  • pppd/chap_ms.c

    a b set_mppe_enc_types(int policy, int types 
    897897    /* 
    898898     * Disable undesirable encryption types.  Note that we don't ENABLE 
    899899     * any encryption types, to avoid overriding manual configuration. 
     900     * 
     901     * It seems that 56 bit keys are unsupported in MS-RADIUS (see RFC 2548) 
    900902     */ 
    901903    switch(types) { 
    902904        case MPPE_ENC_TYPES_RC4_40: 
    903             ccp_wantoptions[0].mppe &= ~MPPE_OPT_128;   /* disable 128-bit */ 
     905            ccp_wantoptions[0].mppe_128 = 0;    /* disable 128-bit */ 
     906            ccp_wantoptions[0].mppe_56 = 0;     /* disable 56-bit */ 
    904907            break; 
    905908        case MPPE_ENC_TYPES_RC4_128: 
    906             ccp_wantoptions[0].mppe &= ~MPPE_OPT_40;    /* disable 40-bit */ 
     909            ccp_wantoptions[0].mppe_56 = 0;     /* disable 56-bit */ 
     910            ccp_wantoptions[0].mppe_40 = 0;     /* disable 40-bit */ 
    907911            break; 
    908912        default: 
    909913            break; 
Note: See TracBrowser for help on using the repository browser.