pppd/ccp.c

   1 /*
   2  * ccp.c - PPP Compression Control Protocol.
   3  *
   4  * Copyright (c) 1994 The Australian National University.
   5  * All rights reserved.
   6  *
   7  * Permission to use, copy, modify, and distribute this software and its
   8  * documentation is hereby granted, provided that the above copyright
   9  * notice appears in all copies.  This software is provided without any
  10  * warranty, express or implied. The Australian National University
  11  * makes no representations about the suitability of this software for
  12  * any purpose.
  13  *
  14  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
  15  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  17  * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
  18  * OF SUCH DAMAGE.
  19  *
  20  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  22  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
  24  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  25  * OR MODIFICATIONS.
  26  */
  27
  28 #ifndef lint
  29 static char rcsid[] = "$Id: ccp.c,v 1.16 1996/04/04 03:35:37 paulus Exp $";
  30 #endif
  31
  32 #include <string.h>
  33 #include <syslog.h>
  34 #include <sys/ioctl.h>
  35 #include <net/ppp-comp.h>
  36
  37 #include "pppd.h"
  38 #include "fsm.h"
  39 #include "ccp.h"
  40
  41 struct protent ccp_protent = {
  42     PPP_CCP, ccp_init, ccp_input, ccp_protrej,
  43     ccp_lowerup, ccp_lowerdown, ccp_open, ccp_close,
  44     ccp_printpkt, ccp_datainput, 1, "CCP", NULL, NULL
  45 };
  46
  47 fsm ccp_fsm[NUM_PPP];
  48 ccp_options ccp_wantoptions[NUM_PPP];   /* what to request the peer to use */
  49 ccp_options ccp_gotoptions[NUM_PPP];    /* what the peer agreed to do */
  50 ccp_options ccp_allowoptions[NUM_PPP];  /* what we'll agree to do */
  51 ccp_options ccp_hisoptions[NUM_PPP];    /* what we agreed to do */
  52
  53 /*
  54  * Callbacks for fsm code.
  55  */
  56 static void ccp_resetci __P((fsm *));
  57 static int  ccp_cilen __P((fsm *));
  58 static void ccp_addci __P((fsm *, u_char *, int *));
  59 static int  ccp_ackci __P((fsm *, u_char *, int));
  60 static int  ccp_nakci __P((fsm *, u_char *, int));
  61 static int  ccp_rejci __P((fsm *, u_char *, int));
  62 static int  ccp_reqci __P((fsm *, u_char *, int *, int));
  63 static void ccp_up __P((fsm *));
  64 static void ccp_down __P((fsm *));
  65 static int  ccp_extcode __P((fsm *, int, int, u_char *, int));
  66 static void ccp_rack_timeout __P(());
  67
  68 static fsm_callbacks ccp_callbacks = {
  69     ccp_resetci,
  70     ccp_cilen,
  71     ccp_addci,
  72     ccp_ackci,
  73     ccp_nakci,
  74     ccp_rejci,
  75     ccp_reqci,
  76     ccp_up,
  77     ccp_down,
  78     NULL,
  79     NULL,
  80     NULL,
  81     NULL,
  82     ccp_extcode,
  83     "CCP"
  84 };
  85
  86 /*
  87  * Do we want / did we get any compression?
  88  */
  89 #define ANY_COMPRESS(opt)       ((opt).deflate || (opt).bsd_compress \
  90                                  || (opt).predictor_1 || (opt).predictor_2)
  91
  92 /*
  93  * Local state (mainly for handling reset-reqs and reset-acks).
  94  */
  95 static int ccp_localstate[NUM_PPP];
  96 #define RACK_PENDING    1       /* waiting for reset-ack */
  97 #define RREQ_REPEAT     2       /* send another reset-req if no reset-ack */
  98
  99 #define RACKTIMEOUT     1       /* second */
 100
 101 static int all_rejected[NUM_PPP];       /* we rejected all peer's options */
 102
 103 /*
 104  * ccp_init - initialize CCP.
 105  */
 106 void
 107 ccp_init(unit)
 108     int unit;
 109 {
 110     fsm *f = &ccp_fsm[unit];
 111
 112     f->unit = unit;
 113     f->protocol = PPP_CCP;
 114     f->callbacks = &ccp_callbacks;
 115     fsm_init(f);
 116
 117     memset(&ccp_wantoptions[unit],  0, sizeof(ccp_options));
 118     memset(&ccp_gotoptions[unit],   0, sizeof(ccp_options));
 119     memset(&ccp_allowoptions[unit], 0, sizeof(ccp_options));
 120     memset(&ccp_hisoptions[unit],   0, sizeof(ccp_options));
 121
 122     ccp_wantoptions[0].deflate = 1;
 123     ccp_wantoptions[0].deflate_size = DEFLATE_MAX_SIZE;
 124     ccp_allowoptions[0].deflate = 1;
 125     ccp_allowoptions[0].deflate_size = DEFLATE_MAX_SIZE;
 126
 127     ccp_wantoptions[0].bsd_compress = 1;
 128     ccp_wantoptions[0].bsd_bits = BSD_MAX_BITS;
 129     ccp_allowoptions[0].bsd_compress = 1;
 130     ccp_allowoptions[0].bsd_bits = BSD_MAX_BITS;
 131
 132     ccp_allowoptions[0].predictor_1 = 1;
 133 }
 134
 135 /*
 136  * ccp_open - CCP is allowed to come up.
 137  */
 138 void
 139 ccp_open(unit)
 140     int unit;
 141 {
 142     fsm *f = &ccp_fsm[unit];
 143
 144     if (f->state != OPENED)
 145         ccp_flags_set(unit, 1, 0);
 146
 147     /*
 148      * Find out which compressors the kernel supports before
 149      * deciding whether to open in silent mode.
 150      */
 151     ccp_resetci(f);
 152     if (!ANY_COMPRESS(ccp_gotoptions[unit]))
 153         f->flags |= OPT_SILENT;
 154
 155     fsm_open(f);
 156 }
 157
 158 /*
 159  * ccp_close - Terminate CCP.
 160  */
 161 void
 162 ccp_close(unit, reason)
 163     int unit;
 164     char *reason;
 165 {
 166     ccp_flags_set(unit, 0, 0);
 167     fsm_close(&ccp_fsm[unit], reason);
 168 }
 169
 170 /*
 171  * ccp_lowerup - we may now transmit CCP packets.
 172  */
 173 void
 174 ccp_lowerup(unit)
 175     int unit;
 176 {
 177     fsm_lowerup(&ccp_fsm[unit]);
 178 }
 179
 180 /*
 181  * ccp_lowerdown - we may not transmit CCP packets.
 182  */
 183 void
 184 ccp_lowerdown(unit)
 185     int unit;
 186 {
 187     fsm_lowerdown(&ccp_fsm[unit]);
 188 }
 189
 190 /*
 191  * ccp_input - process a received CCP packet.
 192  */
 193 void
 194 ccp_input(unit, p, len)
 195     int unit;
 196     u_char *p;
 197     int len;
 198 {
 199     fsm *f = &ccp_fsm[unit];
 200     int oldstate;
 201
 202     /*
 203      * Check for a terminate-request so we can print a message.
 204      */
 205     oldstate = f->state;
 206     fsm_input(f, p, len);
 207     if (oldstate == OPENED && p[0] == TERMREQ && f->state != OPENED)
 208         syslog(LOG_NOTICE, "Compression disabled by peer.");
 209
 210     /*
 211      * If we get a terminate-ack and we're not asking for compression,
 212      * close CCP.
 213      */
 214     if (oldstate == REQSENT && p[0] == TERMACK
 215         && !ANY_COMPRESS(ccp_gotoptions[unit]))
 216         ccp_close(unit, "No compression negotiated");
 217 }
 218
 219 /*
 220  * Handle a CCP-specific code.
 221  */
 222 static int
 223 ccp_extcode(f, code, id, p, len)
 224     fsm *f;
 225     int code, id;
 226     u_char *p;
 227     int len;
 228 {
 229     switch (code) {
 230     case CCP_RESETREQ:
 231         if (f->state != OPENED)
 232             break;
 233         /* send a reset-ack, which the transmitter will see and
 234            reset its compression state. */
 235         fsm_sdata(f, CCP_RESETACK, id, NULL, 0);
 236         break;
 237
 238     case CCP_RESETACK:
 239         if (ccp_localstate[f->unit] & RACK_PENDING && id == f->reqid) {
 240             ccp_localstate[f->unit] &= ~(RACK_PENDING | RREQ_REPEAT);
 241             UNTIMEOUT(ccp_rack_timeout, (caddr_t) f);
 242         }
 243         break;
 244
 245     default:
 246         return 0;
 247     }
 248
 249     return 1;
 250 }
 251
 252 /*
 253  * ccp_protrej - peer doesn't talk CCP.
 254  */
 255 void
 256 ccp_protrej(unit)
 257     int unit;
 258 {
 259     ccp_flags_set(unit, 0, 0);
 260     fsm_lowerdown(&ccp_fsm[unit]);
 261 }
 262
 263 /*
 264  * ccp_resetci - initialize at start of negotiation.
 265  */
 266 static void
 267 ccp_resetci(f)
 268     fsm *f;
 269 {
 270     ccp_options *go = &ccp_gotoptions[f->unit];
 271     u_char opt_buf[16];
 272
 273     *go = ccp_wantoptions[f->unit];
 274     all_rejected[f->unit] = 0;
 275
 276     /*
 277      * Check whether the kernel knows about the various
 278      * compression methods we might request.
 279      */
 280     if (go->bsd_compress) {
 281         opt_buf[0] = CI_BSD_COMPRESS;
 282         opt_buf[1] = CILEN_BSD_COMPRESS;
 283         opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, BSD_MIN_BITS);
 284         if (ccp_test(f->unit, opt_buf, CILEN_BSD_COMPRESS, 0) <= 0)
 285             go->bsd_compress = 0;
 286     }
 287     if (go->deflate) {
 288         opt_buf[0] = CI_DEFLATE;
 289         opt_buf[1] = CILEN_DEFLATE;
 290         opt_buf[2] = DEFLATE_MAKE_OPT(DEFLATE_MIN_SIZE);
 291         opt_buf[3] = DEFLATE_CHK_SEQUENCE;
 292         if (ccp_test(f->unit, opt_buf, CILEN_DEFLATE, 0) <= 0)
 293             go->deflate = 0;
 294     }
 295     if (go->predictor_1) {
 296         opt_buf[0] = CI_PREDICTOR_1;
 297         opt_buf[1] = CILEN_PREDICTOR_1;
 298         if (ccp_test(f->unit, opt_buf, CILEN_PREDICTOR_1, 0) <= 0)
 299             go->predictor_1 = 0;
 300     }
 301     if (go->predictor_2) {
 302         opt_buf[0] = CI_PREDICTOR_2;
 303         opt_buf[1] = CILEN_PREDICTOR_2;
 304         if (ccp_test(f->unit, opt_buf, CILEN_PREDICTOR_2, 0) <= 0)
 305             go->predictor_2 = 0;
 306     }
 307 }
 308
 309 /*
 310  * ccp_cilen - Return total length of our configuration info.
 311  */
 312 static int
 313 ccp_cilen(f)
 314     fsm *f;
 315 {
 316     ccp_options *go = &ccp_gotoptions[f->unit];
 317
 318     return (go->bsd_compress? CILEN_BSD_COMPRESS: 0)
 319         + (go->deflate? CILEN_DEFLATE: 0)
 320         + (go->predictor_1? CILEN_PREDICTOR_1: 0)
 321         + (go->predictor_2? CILEN_PREDICTOR_2: 0);
 322 }
 323
 324 /*
 325  * ccp_addci - put our requests in a packet.
 326  */
 327 static void
 328 ccp_addci(f, p, lenp)
 329     fsm *f;
 330     u_char *p;
 331     int *lenp;
 332 {
 333     int res;
 334     ccp_options *go = &ccp_gotoptions[f->unit];
 335     u_char *p0 = p;
 336
 337     /*
 338      * Add the compression types that we can receive, in decreasing
 339      * preference order.  Get the kernel to allocate the first one
 340      * in case it gets Acked.
 341      */
 342     if (go->deflate) {
 343         p[0] = CI_DEFLATE;
 344         p[1] = CILEN_DEFLATE;
 345         p[2] = DEFLATE_MAKE_OPT(go->deflate_size);
 346         p[3] = DEFLATE_CHK_SEQUENCE;
 347         for (;;) {
 348             res = ccp_test(f->unit, p, CILEN_DEFLATE, 0);
 349             if (res > 0) {
 350                 p += CILEN_DEFLATE;
 351                 break;
 352             }
 353             if (res < 0 || go->deflate_size <= DEFLATE_MIN_SIZE) {
 354                 go->deflate = 0;
 355                 break;
 356             }
 357             --go->deflate_size;
 358             p[2] = DEFLATE_MAKE_OPT(go->deflate_size);
 359         }
 360     }
 361     if (go->bsd_compress) {
 362         p[0] = CI_BSD_COMPRESS;
 363         p[1] = CILEN_BSD_COMPRESS;
 364         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
 365         if (p != p0) {
 366             p += CILEN_BSD_COMPRESS;    /* not the first option */
 367         } else {
 368             for (;;) {
 369                 res = ccp_test(f->unit, p, CILEN_BSD_COMPRESS, 0);
 370                 if (res > 0) {
 371                     p += CILEN_BSD_COMPRESS;
 372                     break;
 373                 }
 374                 if (res < 0 || go->bsd_bits <= BSD_MIN_BITS) {
 375                     go->bsd_compress = 0;
 376                     break;
 377                 }
 378                 --go->bsd_bits;
 379                 p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
 380             }
 381         }
 382     }
 383     /* XXX Should Predictor 2 be preferable to Predictor 1? */
 384     if (go->predictor_1) {
 385         p[0] = CI_PREDICTOR_1;
 386         p[1] = CILEN_PREDICTOR_1;
 387         if (p == p0 && ccp_test(f->unit, p, CILEN_PREDICTOR_1, 0) <= 0) {
 388             go->predictor_1 = 0;
 389         } else {
 390             p += CILEN_PREDICTOR_1;
 391         }
 392     }
 393     if (go->predictor_2) {
 394         p[0] = CI_PREDICTOR_2;
 395         p[1] = CILEN_PREDICTOR_2;
 396         if (p == p0 && ccp_test(f->unit, p, CILEN_PREDICTOR_2, 0) <= 0) {
 397             go->predictor_2 = 0;
 398         } else {
 399             p += CILEN_PREDICTOR_2;
 400         }
 401     }
 402
 403     *lenp = p - p0;
 404 }
 405
 406 /*
 407  * ccp_ackci - process a received configure-ack, and return
 408  * 1 iff the packet was OK.
 409  */
 410 static int
 411 ccp_ackci(f, p, len)
 412     fsm *f;
 413     u_char *p;
 414     int len;
 415 {
 416     ccp_options *go = &ccp_gotoptions[f->unit];
 417     u_char *p0 = p;
 418
 419     if (go->deflate) {
 420         if (len < CILEN_DEFLATE
 421             || p[0] != CI_DEFLATE || p[1] != CILEN_DEFLATE
 422             || p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
 423             || p[3] != DEFLATE_CHK_SEQUENCE)
 424             return 0;
 425         p += CILEN_DEFLATE;
 426         len -= CILEN_DEFLATE;
 427         /* XXX Cope with first/fast ack */
 428         if (len == 0)
 429             return 1;
 430     }
 431     if (go->bsd_compress) {
 432         if (len < CILEN_BSD_COMPRESS
 433             || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD_COMPRESS
 434             || p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
 435             return 0;
 436         p += CILEN_BSD_COMPRESS;
 437         len -= CILEN_BSD_COMPRESS;
 438         /* XXX Cope with first/fast ack */
 439         if (p == p0 && len == 0)
 440             return 1;
 441     }
 442     if (go->predictor_1) {
 443         if (len < CILEN_PREDICTOR_1
 444             || p[0] != CI_PREDICTOR_1 || p[1] != CILEN_PREDICTOR_1)
 445             return 0;
 446         p += CILEN_PREDICTOR_1;
 447         len -= CILEN_PREDICTOR_1;
 448         /* XXX Cope with first/fast ack */
 449         if (p == p0 && len == 0)
 450             return 1;
 451     }
 452     if (go->predictor_2) {
 453         if (len < CILEN_PREDICTOR_2
 454             || p[0] != CI_PREDICTOR_2 || p[1] != CILEN_PREDICTOR_2)
 455             return 0;
 456         p += CILEN_PREDICTOR_2;
 457         len -= CILEN_PREDICTOR_2;
 458         /* XXX Cope with first/fast ack */
 459         if (p == p0 && len == 0)
 460             return 1;
 461     }
 462
 463     if (len != 0)
 464         return 0;
 465     return 1;
 466 }
 467
 468 /*
 469  * ccp_nakci - process received configure-nak.
 470  * Returns 1 iff the nak was OK.
 471  */
 472 static int
 473 ccp_nakci(f, p, len)
 474     fsm *f;
 475     u_char *p;
 476     int len;
 477 {
 478     ccp_options *go = &ccp_gotoptions[f->unit];
 479     ccp_options no;             /* options we've seen already */
 480     ccp_options try;            /* options to ask for next time */
 481
 482     memset(&no, 0, sizeof(no));
 483     try = *go;
 484
 485     if (go->deflate && len >= CILEN_DEFLATE
 486         && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) {
 487         no.deflate = 1;
 488         /*
 489          * Peer wants us to use a different code size or something.
 490          * Stop asking for Deflate if we don't understand his suggestion.
 491          */
 492         if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL
 493             || DEFLATE_SIZE(p[2]) < DEFLATE_MIN_SIZE
 494             || p[3] != DEFLATE_CHK_SEQUENCE)
 495             try.deflate = 0;
 496         else if (DEFLATE_SIZE(p[2]) < go->deflate_size)
 497             go->deflate_size = DEFLATE_SIZE(p[2]);
 498         p += CILEN_DEFLATE;
 499         len -= CILEN_DEFLATE;
 500     }
 501
 502     if (go->bsd_compress && len >= CILEN_BSD_COMPRESS
 503         && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) {
 504         no.bsd_compress = 1;
 505         /*
 506          * Peer wants us to use a different number of bits
 507          * or a different version.
 508          */
 509         if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION)
 510             try.bsd_compress = 0;
 511         else if (BSD_NBITS(p[2]) < go->bsd_bits)
 512             try.bsd_bits = BSD_NBITS(p[2]);
 513         p += CILEN_BSD_COMPRESS;
 514         len -= CILEN_BSD_COMPRESS;
 515     }
 516
 517     /*
 518      * Predictor-1 and 2 have no options, so they can't be Naked.
 519      *
 520      * XXX What should we do with any remaining options?
 521      */
 522
 523     if (len != 0)
 524         return 0;
 525
 526     if (f->state != OPENED)
 527         *go = try;
 528     return 1;
 529 }
 530
 531 /*
 532  * ccp_rejci - reject some of our suggested compression methods.
 533  */
 534 static int
 535 ccp_rejci(f, p, len)
 536     fsm *f;
 537     u_char *p;
 538     int len;
 539 {
 540     ccp_options *go = &ccp_gotoptions[f->unit];
 541     ccp_options try;            /* options to request next time */
 542
 543     try = *go;
 544
 545     /*
 546      * Cope with empty configure-rejects by ceasing to send
 547      * configure-requests.
 548      */
 549     if (len == 0 && all_rejected[f->unit])
 550         return -1;
 551
 552     if (go->deflate && len >= CILEN_DEFLATE
 553         && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) {
 554         if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
 555             || p[3] != DEFLATE_CHK_SEQUENCE)
 556             return 0;           /* Rej is bad */
 557         try.deflate = 0;
 558         p += CILEN_DEFLATE;
 559         len -= CILEN_DEFLATE;
 560     }
 561     if (go->bsd_compress && len >= CILEN_BSD_COMPRESS
 562         && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) {
 563         if (p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
 564             return 0;
 565         try.bsd_compress = 0;
 566         p += CILEN_BSD_COMPRESS;
 567         len -= CILEN_BSD_COMPRESS;
 568     }
 569     if (go->predictor_1 && len >= CILEN_PREDICTOR_1
 570         && p[0] == CI_PREDICTOR_1 && p[1] == CILEN_PREDICTOR_1) {
 571         try.predictor_1 = 0;
 572         p += CILEN_PREDICTOR_1;
 573         len -= CILEN_PREDICTOR_1;
 574     }
 575     if (go->predictor_2 && len >= CILEN_PREDICTOR_2
 576         && p[0] == CI_PREDICTOR_2 && p[1] == CILEN_PREDICTOR_2) {
 577         try.predictor_2 = 0;
 578         p += CILEN_PREDICTOR_2;
 579         len -= CILEN_PREDICTOR_2;
 580     }
 581
 582     if (len != 0)
 583         return 0;
 584
 585     if (f->state != OPENED)
 586         *go = try;
 587
 588     return 1;
 589 }
 590
 591 /*
 592  * ccp_reqci - processed a received configure-request.
 593  * Returns CONFACK, CONFNAK or CONFREJ and the packet modified
 594  * appropriately.
 595  */
 596 static int
 597 ccp_reqci(f, p, lenp, dont_nak)
 598     fsm *f;
 599     u_char *p;
 600     int *lenp;
 601     int dont_nak;
 602 {
 603     int ret, newret, res;
 604     u_char *p0, *retp;
 605     int len, clen, type, nb;
 606     ccp_options *ho = &ccp_hisoptions[f->unit];
 607     ccp_options *ao = &ccp_allowoptions[f->unit];
 608
 609     ret = CONFACK;
 610     retp = p0 = p;
 611     len = *lenp;
 612
 613     memset(ho, 0, sizeof(ccp_options));
 614
 615     while (len > 0) {
 616         newret = CONFACK;
 617         if (len < 2 || p[1] < 2 || p[1] > len) {
 618             /* length is bad */
 619             clen = len;
 620             newret = CONFREJ;
 621
 622         } else {
 623             type = p[0];
 624             clen = p[1];
 625
 626             switch (type) {
 627             case CI_DEFLATE:
 628                 if (!ao->deflate || clen != CILEN_DEFLATE) {
 629                     newret = CONFREJ;
 630                     break;
 631                 }
 632
 633                 ho->deflate = 1;
 634                 ho->deflate_size = nb = DEFLATE_SIZE(p[2]);
 635                 if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL
 636                     || p[3] != DEFLATE_CHK_SEQUENCE
 637                     || nb > ao->deflate_size || nb < DEFLATE_MIN_SIZE) {
 638                     newret = CONFNAK;
 639                     if (!dont_nak) {
 640                         p[2] = DEFLATE_MAKE_OPT(ao->deflate_size);
 641                         p[3] = DEFLATE_CHK_SEQUENCE;
 642                     }
 643                     break;
 644                 }
 645
 646                 /*
 647                  * Check whether we can do Deflate with the window
 648                  * size they want.  If the window is too big, reduce
 649                  * it until the kernel can cope and nak with that.
 650                  * We only check this for the first option.
 651                  */
 652                 if (p == p0) {
 653                     for (;;) {
 654                         res = ccp_test(f->unit, p, CILEN_DEFLATE, 1);
 655                         if (res > 0)
 656                             break;              /* it's OK now */
 657                         if (res < 0 || nb == DEFLATE_MIN_SIZE || dont_nak) {
 658                             newret = CONFREJ;
 659                             p[2] = DEFLATE_MAKE_OPT(ho->deflate_size);
 660                             break;
 661                         }
 662                         newret = CONFNAK;
 663                         --nb;
 664                         p[2] = DEFLATE_MAKE_OPT(nb);
 665                     }
 666                 }
 667                 break;
 668
 669             case CI_BSD_COMPRESS:
 670                 if (!ao->bsd_compress || clen != CILEN_BSD_COMPRESS) {
 671                     newret = CONFREJ;
 672                     break;
 673                 }
 674
 675                 ho->bsd_compress = 1;
 676                 ho->bsd_bits = nb = BSD_NBITS(p[2]);
 677                 if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION
 678                     || nb > ao->bsd_bits || nb < BSD_MIN_BITS) {
 679                     newret = CONFNAK;
 680                     if (!dont_nak)
 681                         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, ao->bsd_bits);
 682                     break;
 683                 }
 684
 685                 /*
 686                  * Check whether we can do BSD-Compress with the code
 687                  * size they want.  If the code size is too big, reduce
 688                  * it until the kernel can cope and nak with that.
 689                  * We only check this for the first option.
 690                  */
 691                 if (p == p0) {
 692                     for (;;) {
 693                         res = ccp_test(f->unit, p, CILEN_BSD_COMPRESS, 1);
 694                         if (res > 0)
 695                             break;
 696                         if (res < 0 || nb == BSD_MIN_BITS || dont_nak) {
 697                             newret = CONFREJ;
 698                             p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION,
 699                                                 ho->bsd_bits);
 700                             break;
 701                         }
 702                         newret = CONFNAK;
 703                         --nb;
 704                         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb);
 705                     }
 706                 }
 707                 break;
 708
 709             case CI_PREDICTOR_1:
 710                 if (!ao->predictor_1 || clen != CILEN_PREDICTOR_1) {
 711                     newret = CONFREJ;
 712                     break;
 713                 }
 714
 715                 ho->predictor_1 = 1;
 716                 if (p == p0
 717                     && ccp_test(f->unit, p, CILEN_PREDICTOR_1, 1) <= 0) {
 718                     newret = CONFREJ;
 719                 }
 720                 break;
 721
 722             case CI_PREDICTOR_2:
 723                 if (!ao->predictor_2 || clen != CILEN_PREDICTOR_2) {
 724                     newret = CONFREJ;
 725                     break;
 726                 }
 727
 728                 ho->predictor_2 = 1;
 729                 if (p == p0
 730                     && ccp_test(f->unit, p, CILEN_PREDICTOR_2, 1) <= 0) {
 731                     newret = CONFREJ;
 732                 }
 733                 break;
 734
 735             default:
 736                 newret = CONFREJ;
 737             }
 738         }
 739
 740         if (newret == CONFNAK && dont_nak)
 741             newret = CONFREJ;
 742         if (!(newret == CONFACK || newret == CONFNAK && ret == CONFREJ)) {
 743             /* we're returning this option */
 744             if (newret == CONFREJ && ret == CONFNAK)
 745                 retp = p0;
 746             ret = newret;
 747             if (p != retp)
 748                 BCOPY(p, retp, clen);
 749             retp += clen;
 750         }
 751
 752         p += clen;
 753         len -= clen;
 754     }
 755
 756     if (ret != CONFACK) {
 757         if (ret == CONFREJ && *lenp == retp - p0)
 758             all_rejected[f->unit] = 1;
 759         else
 760             *lenp = retp - p0;
 761     }
 762     return ret;
 763 }
 764
 765 /*
 766  * CCP has come up - inform the kernel driver.
 767  */
 768 static void
 769 ccp_up(f)
 770     fsm *f;
 771 {
 772     ccp_options *go = &ccp_gotoptions[f->unit];
 773     ccp_options *ho = &ccp_hisoptions[f->unit];
 774
 775     ccp_flags_set(f->unit, 1, 1);
 776     if (ANY_COMPRESS(*go) || ANY_COMPRESS(*ho))
 777         syslog(LOG_NOTICE, "%s enabled",
 778                ANY_COMPRESS(*go)? ANY_COMPRESS(*ho)? "Compression":
 779                "Receive compression": "Transmit compression");
 780 }
 781
 782 /*
 783  * CCP has gone down - inform the kernel driver.
 784  */
 785 static void
 786 ccp_down(f)
 787     fsm *f;
 788 {
 789     if (ccp_localstate[f->unit] & RACK_PENDING)
 790         UNTIMEOUT(ccp_rack_timeout, (caddr_t) f);
 791     ccp_localstate[f->unit] = 0;
 792     ccp_flags_set(f->unit, 1, 0);
 793 }
 794
 795 /*
 796  * Print the contents of a CCP packet.
 797  */
 798 char *ccp_codenames[] = {
 799     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
 800     "TermReq", "TermAck", "CodeRej",
 801     NULL, NULL, NULL, NULL, NULL, NULL,
 802     "ResetReq", "ResetAck",
 803 };
 804
 805 int
 806 ccp_printpkt(p, plen, printer, arg)
 807     u_char *p;
 808     int plen;
 809     void (*printer) __P((void *, char *, ...));
 810     void *arg;
 811 {
 812     u_char *p0, *optend;
 813     int code, id, len;
 814     int optlen;
 815
 816     p0 = p;
 817     if (plen < HEADERLEN)
 818         return 0;
 819     code = p[0];
 820     id = p[1];
 821     len = (p[2] << 8) + p[3];
 822     if (len < HEADERLEN || len > plen)
 823         return 0;
 824
 825     if (code >= 1 && code <= sizeof(ccp_codenames) / sizeof(char *)
 826         && ccp_codenames[code-1] != NULL)
 827         printer(arg, " %s", ccp_codenames[code-1]);
 828     else
 829         printer(arg, " code=0x%x", code);
 830     printer(arg, " id=0x%x", id);
 831     len -= HEADERLEN;
 832     p += HEADERLEN;
 833
 834     switch (code) {
 835     case CONFREQ:
 836     case CONFACK:
 837     case CONFNAK:
 838     case CONFREJ:
 839         /* print list of possible compression methods */
 840         while (len >= 2) {
 841             code = p[0];
 842             optlen = p[1];
 843             if (optlen < 2 || optlen > len)
 844                 break;
 845             printer(arg, " <");
 846             len -= optlen;
 847             optend = p + optlen;
 848             switch (code) {
 849             case CI_DEFLATE:
 850                 if (optlen >= CILEN_DEFLATE) {
 851                     printer(arg, "deflate %d", DEFLATE_SIZE(p[2]));
 852                     if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL)
 853                         printer(arg, " method %d", DEFLATE_METHOD(p[2]));
 854                     if (p[3] != DEFLATE_CHK_SEQUENCE)
 855                         printer(arg, " check %d", p[3]);
 856                     p += CILEN_DEFLATE;
 857                 }
 858                 break;
 859             case CI_BSD_COMPRESS:
 860                 if (optlen >= CILEN_BSD_COMPRESS) {
 861                     printer(arg, "bsd v%d %d", BSD_VERSION(p[2]),
 862                             BSD_NBITS(p[2]));
 863                     p += CILEN_BSD_COMPRESS;
 864                 }
 865                 break;
 866             case CI_PREDICTOR_1:
 867                 if (optlen >= CILEN_PREDICTOR_1) {
 868                     printer(arg, "predictor 1");
 869                     p += CILEN_PREDICTOR_1;
 870                 }
 871                 break;
 872             case CI_PREDICTOR_2:
 873                 if (optlen >= CILEN_PREDICTOR_2) {
 874                     printer(arg, "predictor 2");
 875                     p += CILEN_PREDICTOR_2;
 876                 }
 877                 break;
 878             }
 879             while (p < optend)
 880                 printer(arg, " %.2x", *p++);
 881             printer(arg, ">");
 882         }
 883         break;
 884     }
 885
 886     /* dump out the rest of the packet in hex */
 887     while (--len >= 0)
 888         printer(arg, " %.2x", *p++);
 889
 890     return p - p0;
 891 }
 892
 893 /*
 894  * We have received a packet that the decompressor failed to
 895  * decompress.  Here we would expect to issue a reset-request, but
 896  * Motorola has a patent on resetting the compressor as a result of
 897  * detecting an error in the decompressed data after decompression.
 898  * (See US patent 5,130,993; international patent publication number
 899  * WO 91/10289; Australian patent 73296/91.)
 900  *
 901  * So we ask the kernel whether the error was detected after
 902  * decompression; if it was, we take CCP down, thus disabling
 903  * compression :-(, otherwise we issue the reset-request.
 904  */
 905 void
 906 ccp_datainput(unit, pkt, len)
 907     int unit;
 908     u_char *pkt;
 909     int len;
 910 {
 911     fsm *f;
 912
 913     f = &ccp_fsm[unit];
 914     if (f->state == OPENED) {
 915         if (ccp_fatal_error(unit)) {
 916             /*
 917              * Disable compression by taking CCP down.
 918              */
 919             syslog(LOG_ERR, "Lost compression sync: disabling compression");
 920             ccp_close(unit, "Lost compression sync");
 921         } else {
 922             /*
 923              * Send a reset-request to reset the peer's compressor.
 924              * We don't do that if we are still waiting for an
 925              * acknowledgement to a previous reset-request.
 926              */
 927             if (!(ccp_localstate[f->unit] & RACK_PENDING)) {
 928                 fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0);
 929                 TIMEOUT(ccp_rack_timeout, (caddr_t) f, RACKTIMEOUT);
 930                 ccp_localstate[f->unit] |= RACK_PENDING;
 931             } else
 932                 ccp_localstate[f->unit] |= RREQ_REPEAT;
 933         }
 934     }
 935 }
 936
 937 /*
 938  * Timeout waiting for reset-ack.
 939  */
 940 static void
 941 ccp_rack_timeout(arg)
 942     caddr_t arg;
 943 {
 944     fsm *f = (fsm *) arg;
 945
 946     if (f->state == OPENED && ccp_localstate[f->unit] & RREQ_REPEAT) {
 947         fsm_sdata(f, CCP_RESETREQ, f->reqid, NULL, 0);
 948         TIMEOUT(ccp_rack_timeout, (caddr_t) f, RACKTIMEOUT);
 949         ccp_localstate[f->unit] &= ~RREQ_REPEAT;
 950     } else
 951         ccp_localstate[f->unit] &= ~RACK_PENDING;
 952 }
 953