*/
#ifndef lint
-static char rcsid[] = "$Id: ccp.c,v 1.6 1994/10/24 04:31:11 paulus Exp $";
+static char rcsid[] = "$Id: ccp.c,v 1.13 1995/12/18 03:43:40 paulus Exp $";
#endif
#include <syslog.h>
#include <sys/ioctl.h>
+#include <net/ppp-comp.h>
#include "pppd.h"
#include "fsm.h"
#include "ccp.h"
+struct protent ccp_protent = {
+ PPP_CCP, ccp_init, ccp_input, ccp_protrej,
+ ccp_lowerup, ccp_lowerdown, ccp_open, ccp_close,
+ ccp_printpkt, NULL, 1, "CCP"
+};
+
fsm ccp_fsm[NUM_PPP];
ccp_options ccp_wantoptions[NUM_PPP]; /* what to request the peer to use */
ccp_options ccp_gotoptions[NUM_PPP]; /* what the peer agreed to do */
"CCP"
};
-/*
- * Length of configuration options, which describe possible
- * compression methods.
- */
-#define CILEN_BSD 3
-
-/*
- * Configuration option values for compression methods.
- */
-#define CI_BSD_COMPRESS 0x21
-
-/*
- * Information relating to BSD Compress configuration options.
- */
-#define BSD_NBITS(x) ((x) & 0x1F)
-#define BSD_VERSION(x) ((x) >> 5)
-#define BSD_CURRENT_VERSION 1
-#define BSD_MAKE_OPT(v, n) (((v) << 5) | (n))
-
/*
* Do we want / did we get any compression?
*/
-#define ANY_COMPRESS(opt) ((opt).bsd_compress)
+#define ANY_COMPRESS(opt) ((opt).deflate || (opt).bsd_compress \
+ || (opt).predictor_1 || (opt).predictor_2)
/*
- * Local state (mainly for handling reset-reqs and reset-acks
+ * Local state (mainly for handling reset-reqs and reset-acks).
*/
static int ccp_localstate[NUM_PPP];
#define RACK_PENDING 1 /* waiting for reset-ack */
#define RACKTIMEOUT 1 /* second */
+static int all_rejected[NUM_PPP]; /* we rejected all peer's options */
+
/*
* ccp_init - initialize CCP.
*/
memset(&ccp_allowoptions[unit], 0, sizeof(ccp_options));
memset(&ccp_hisoptions[unit], 0, sizeof(ccp_options));
+ ccp_wantoptions[0].bsd_compress = 1;
ccp_wantoptions[0].bsd_bits = 12; /* default value */
ccp_allowoptions[0].bsd_compress = 1;
- ccp_allowoptions[0].bsd_bits = MAX_BSD_BITS;
+ ccp_allowoptions[0].bsd_bits = BSD_MAX_BITS;
+
+ ccp_allowoptions[0].predictor_1 = 1;
}
/*
* ccp_close - Terminate CCP.
*/
void
-ccp_close(unit)
+ccp_close(unit, reason)
int unit;
+ char *reason;
{
ccp_flags_set(unit, 0, 0);
- fsm_close(&ccp_fsm[unit]);
+ fsm_close(&ccp_fsm[unit], reason);
}
/*
fsm_input(f, p, len);
if (oldstate == OPENED && p[0] == TERMREQ && f->state != OPENED)
syslog(LOG_NOTICE, "Compression disabled by peer.");
+
+ /*
+ * If we get a terminate-ack and we're not asking for compression,
+ * close CCP.
+ */
+ if (oldstate == REQSENT && p[0] == TERMACK
+ && !ANY_COMPRESS(ccp_gotoptions[unit]))
+ ccp_close(unit, "No compression negotiated");
}
/*
int len;
{
switch (code) {
- case RESETREQ:
+ case CCP_RESETREQ:
if (f->state != OPENED)
break;
/* send a reset-ack, which the transmitter will see and
reset its compression state. */
- fsm_sdata(f, RESETACK, id, NULL, 0);
+ fsm_sdata(f, CCP_RESETACK, id, NULL, 0);
break;
- case RESETACK:
+ case CCP_RESETACK:
if (ccp_localstate[f->unit] & RACK_PENDING && id == f->reqid) {
ccp_localstate[f->unit] &= ~(RACK_PENDING | RREQ_REPEAT);
UNTIMEOUT(ccp_rack_timeout, (caddr_t) f);
ccp_resetci(f)
fsm *f;
{
+ int ok;
ccp_options *go = &ccp_gotoptions[f->unit];
u_char opt_buf[16];
*go = ccp_wantoptions[f->unit];
+ all_rejected[f->unit] = 0;
+
+ /*
+ * Check whether the kernel knows about the various
+ * compression methods we might request.
+ */
if (go->bsd_compress) {
opt_buf[0] = CI_BSD_COMPRESS;
- opt_buf[1] = CILEN_BSD;
- opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
- if (!ccp_test(f->unit, opt_buf, CILEN_BSD, 0))
+ opt_buf[1] = CILEN_BSD_COMPRESS;
+ opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, BSD_MIN_BITS);
+ if (ccp_test(f->unit, opt_buf, CILEN_BSD_COMPRESS, 0) <= 0)
go->bsd_compress = 0;
}
+ if (go->deflate) {
+ opt_buf[0] = CI_DEFLATE;
+ opt_buf[1] = CILEN_DEFLATE;
+ opt_buf[2] = DEFLATE_MAKE_OPT(DEFLATE_MIN_SIZE);
+ opt_buf[3] = DEFLATE_CHK_SEQUENCE;
+ if (ccp_test(f->unit, opt_buf, CILEN_DEFLATE, 0) <= 0)
+ go->deflate = 0;
+ }
+ if (go->predictor_1) {
+ opt_buf[0] = CI_PREDICTOR_1;
+ opt_buf[1] = CILEN_PREDICTOR_1;
+ if (ccp_test(f->unit, opt_buf, CILEN_PREDICTOR_1, 0) <= 0)
+ go->predictor_1 = 0;
+ }
+ if (go->predictor_2) {
+ opt_buf[0] = CI_PREDICTOR_2;
+ opt_buf[1] = CILEN_PREDICTOR_2;
+ if (ccp_test(f->unit, opt_buf, CILEN_PREDICTOR_2, 0) <= 0)
+ go->predictor_2 = 0;
+ }
}
/*
{
ccp_options *go = &ccp_gotoptions[f->unit];
- return (go->bsd_compress? CILEN_BSD: 0);
+ return (go->bsd_compress? CILEN_BSD_COMPRESS: 0)
+ + (go->deflate? CILEN_DEFLATE: 0)
+ + (go->predictor_1? CILEN_PREDICTOR_1: 0)
+ + (go->predictor_2? CILEN_PREDICTOR_2: 0);
}
/*
u_char *p;
int *lenp;
{
+ int res;
ccp_options *go = &ccp_gotoptions[f->unit];
u_char *p0 = p;
+ /*
+ * Add the compression types that we can receive, in decreasing
+ * preference order. Get the kernel to allocate the first one
+ * in case it gets Acked.
+ */
+ if (go->deflate) {
+ p[0] = CI_DEFLATE;
+ p[1] = CILEN_DEFLATE;
+ p[2] = DEFLATE_MAKE_OPT(go->deflate_size);
+ p[3] = DEFLATE_CHK_SEQUENCE;
+ for (;;) {
+ res = ccp_test(f->unit, p, CILEN_DEFLATE, 0);
+ if (res > 0) {
+ p += CILEN_DEFLATE;
+ break;
+ }
+ if (res < 0 || go->deflate_size <= DEFLATE_MIN_SIZE) {
+ go->deflate = 0;
+ break;
+ }
+ --go->deflate_size;
+ p[2] = DEFLATE_MAKE_OPT(go->deflate_size);
+ }
+ }
if (go->bsd_compress) {
p[0] = CI_BSD_COMPRESS;
- p[1] = CILEN_BSD;
+ p[1] = CILEN_BSD_COMPRESS;
p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
- if (ccp_test(f->unit, p, CILEN_BSD, 0))
- p += CILEN_BSD;
- else
- go->bsd_compress = 0;
+ if (p != p0) {
+ p += CILEN_BSD_COMPRESS; /* not the first option */
+ } else {
+ for (;;) {
+ res = ccp_test(f->unit, p, CILEN_BSD_COMPRESS, 0);
+ if (res > 0) {
+ p += CILEN_BSD_COMPRESS;
+ break;
+ }
+ if (res < 0 || go->bsd_bits <= BSD_MIN_BITS) {
+ go->bsd_compress = 0;
+ break;
+ }
+ --go->bsd_bits;
+ p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
+ }
+ }
+ }
+ /* XXX Should Predictor 2 be preferable to Predictor 1? */
+ if (go->predictor_1) {
+ p[0] = CI_PREDICTOR_1;
+ p[1] = CILEN_PREDICTOR_1;
+ if (p == p0 && ccp_test(f->unit, p, CILEN_PREDICTOR_1, 0) <= 0) {
+ go->predictor_1 = 0;
+ } else {
+ p += CILEN_PREDICTOR_1;
+ }
}
+ if (go->predictor_2) {
+ p[0] = CI_PREDICTOR_2;
+ p[1] = CILEN_PREDICTOR_2;
+ if (p == p0 && ccp_test(f->unit, p, CILEN_PREDICTOR_2, 0) <= 0) {
+ go->predictor_2 = 0;
+ } else {
+ p += CILEN_PREDICTOR_2;
+ }
+ }
+
*lenp = p - p0;
}
int len;
{
ccp_options *go = &ccp_gotoptions[f->unit];
+ u_char *p0 = p;
+ if (go->deflate) {
+ if (len < CILEN_DEFLATE
+ || p[0] != CI_DEFLATE || p[1] != CILEN_DEFLATE
+ || p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
+ || p[3] != DEFLATE_CHK_SEQUENCE)
+ return 0;
+ p += CILEN_DEFLATE;
+ len -= CILEN_DEFLATE;
+ /* XXX Cope with first/fast ack */
+ if (len == 0)
+ return 1;
+ }
if (go->bsd_compress) {
- if (len < CILEN_BSD || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD
+ if (len < CILEN_BSD_COMPRESS
+ || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD_COMPRESS
|| p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
return 0;
- p += CILEN_BSD;
- len -= CILEN_BSD;
+ p += CILEN_BSD_COMPRESS;
+ len -= CILEN_BSD_COMPRESS;
+ /* XXX Cope with first/fast ack */
+ if (p == p0 && len == 0)
+ return 1;
+ }
+ if (go->predictor_1) {
+ if (len < CILEN_PREDICTOR_1
+ || p[0] != CI_PREDICTOR_1 || p[1] != CILEN_PREDICTOR_1)
+ return 0;
+ p += CILEN_PREDICTOR_1;
+ len -= CILEN_PREDICTOR_1;
+ /* XXX Cope with first/fast ack */
+ if (p == p0 && len == 0)
+ return 1;
+ }
+ if (go->predictor_2) {
+ if (len < CILEN_PREDICTOR_2
+ || p[0] != CI_PREDICTOR_2 || p[1] != CILEN_PREDICTOR_2)
+ return 0;
+ p += CILEN_PREDICTOR_2;
+ len -= CILEN_PREDICTOR_2;
+ /* XXX Cope with first/fast ack */
+ if (p == p0 && len == 0)
+ return 1;
}
+
if (len != 0)
return 0;
return 1;
memset(&no, 0, sizeof(no));
try = *go;
- if (go->bsd_compress && !no.bsd_compress && len >= CILEN_BSD
- && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD) {
+ if (go->deflate && len >= CILEN_DEFLATE
+ && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) {
+ no.deflate = 1;
+ /*
+ * Peer wants us to use a different code size or something.
+ * Stop asking for Deflate if we don't understand his suggestion.
+ */
+ if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL
+ || DEFLATE_SIZE(p[2]) < DEFLATE_MIN_SIZE
+ || p[3] != DEFLATE_CHK_SEQUENCE)
+ try.deflate = 0;
+ else if (DEFLATE_SIZE(p[2]) < go->deflate_size)
+ go->deflate_size = DEFLATE_SIZE(p[2]);
+ p += CILEN_DEFLATE;
+ len -= CILEN_DEFLATE;
+ }
+
+ if (go->bsd_compress && len >= CILEN_BSD_COMPRESS
+ && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) {
no.bsd_compress = 1;
/*
* Peer wants us to use a different number of bits
try.bsd_compress = 0;
else if (BSD_NBITS(p[2]) < go->bsd_bits)
try.bsd_bits = BSD_NBITS(p[2]);
- p += CILEN_BSD;
- len -= CILEN_BSD;
+ p += CILEN_BSD_COMPRESS;
+ len -= CILEN_BSD_COMPRESS;
}
/*
- * Have a look at any remaining options...???
+ * Predictor-1 and 2 have no options, so they can't be Naked.
+ *
+ * XXX What should we do with any remaining options?
*/
if (len != 0)
try = *go;
- if (go->bsd_compress && len >= CILEN_BSD
- && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD) {
+ /*
+ * Cope with empty configure-rejects by ceasing to send
+ * configure-requests.
+ */
+ if (len == 0 && all_rejected[f->unit])
+ return -1;
+
+ if (go->deflate && len >= CILEN_DEFLATE
+ && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) {
+ if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size)
+ || p[3] != DEFLATE_CHK_SEQUENCE)
+ return 0; /* Rej is bad */
+ try.deflate = 0;
+ p += CILEN_DEFLATE;
+ len -= CILEN_DEFLATE;
+ }
+ if (go->bsd_compress && len >= CILEN_BSD_COMPRESS
+ && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) {
if (p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
return 0;
try.bsd_compress = 0;
- p += CILEN_BSD;
- len -= CILEN_BSD;
+ p += CILEN_BSD_COMPRESS;
+ len -= CILEN_BSD_COMPRESS;
+ }
+ if (go->predictor_1 && len >= CILEN_PREDICTOR_1
+ && p[0] == CI_PREDICTOR_1 && p[1] == CILEN_PREDICTOR_1) {
+ try.predictor_1 = 0;
+ p += CILEN_PREDICTOR_1;
+ len -= CILEN_PREDICTOR_1;
+ }
+ if (go->predictor_2 && len >= CILEN_PREDICTOR_2
+ && p[0] == CI_PREDICTOR_2 && p[1] == CILEN_PREDICTOR_2) {
+ try.predictor_2 = 0;
+ p += CILEN_PREDICTOR_2;
+ len -= CILEN_PREDICTOR_2;
}
if (len != 0)
int *lenp;
int dont_nak;
{
- int ret, newret;
+ int ret, newret, res;
u_char *p0, *retp;
int len, clen, type, nb;
ccp_options *ho = &ccp_hisoptions[f->unit];
clen = p[1];
switch (type) {
+ case CI_DEFLATE:
+ if (!ao->deflate || clen != CILEN_DEFLATE) {
+ newret = CONFREJ;
+ break;
+ }
+
+ ho->deflate = 1;
+ ho->deflate_size = nb = DEFLATE_SIZE(p[2]);
+ if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL
+ || p[3] != DEFLATE_CHK_SEQUENCE
+ || nb > ao->deflate_size) {
+ newret = CONFNAK;
+ nb = ao->deflate_size;
+ } else {
+ /*
+ * Check whether we can do Deflate with the window
+ * size they want. If the window is too big, reduce
+ * it until the kernel can cope and nak with that.
+ */
+ for (;;) {
+ if (nb < DEFLATE_MIN_SIZE) {
+ newret = CONFREJ;
+ p[2] = DEFLATE_MAKE_OPT(ho->deflate_size);
+ break;
+ }
+ p[2] = DEFLATE_MAKE_OPT(nb);
+ res = ccp_test(f->unit, p, CILEN_DEFLATE, 1);
+ if (res != 0) {
+ if (res < 0)
+ newret = CONFREJ;
+ break;
+ }
+ newret = CONFNAK;
+ --nb;
+ }
+ }
+ if (newret == CONFNAK && !dont_nak) {
+ if (nb >= DEFLATE_MIN_SIZE) {
+ p[2] = DEFLATE_MAKE_OPT(nb);
+ p[3] = DEFLATE_CHK_SEQUENCE;
+ } else {
+ newret = CONFREJ;
+ }
+ }
+ break;
+
case CI_BSD_COMPRESS:
- if (!ao->bsd_compress || clen != CILEN_BSD) {
+ if (!ao->bsd_compress || clen != CILEN_BSD_COMPRESS) {
newret = CONFREJ;
break;
}
|| nb > ao->bsd_bits) {
newret = CONFNAK;
nb = ao->bsd_bits;
- } else if (nb < MIN_BSD_BITS) {
- newret = CONFREJ;
- } else if (!ccp_test(f->unit, p, CILEN_BSD, 1)) {
- if (nb > MIN_BSD_BITS) {
- --nb;
+ } else {
+ /*
+ * Check whether we can do BSD_Compress with the code
+ * size they want. If the code size is too big, reduce
+ * it until the kernel can cope and nak with that.
+ */
+ for (;;) {
+ if (nb < BSD_MIN_BITS) {
+ newret = CONFREJ;
+ p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION,
+ ho->bsd_bits);
+ break;
+ }
+ p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb);
+ res = ccp_test(f->unit, p, CILEN_BSD_COMPRESS, 1);
+ if (res != 0) {
+ if (res < 0)
+ newret = CONFREJ;
+ break;
+ }
newret = CONFNAK;
- } else
- newret = CONFREJ;
+ --nb;
+ }
}
if (newret == CONFNAK && !dont_nak) {
- p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb);
+ if (nb >= BSD_MIN_BITS) {
+ p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb);
+ } else {
+ newret = CONFREJ;
+ }
+ }
+ break;
+
+ case CI_PREDICTOR_1:
+ if (!ao->predictor_1 || clen != CILEN_PREDICTOR_1) {
+ newret = CONFREJ;
+ break;
+ }
+
+ ho->predictor_1 = 1;
+ if (ccp_test(f->unit, p, CILEN_PREDICTOR_1, 1) <= 0) {
+ newret = CONFREJ;
+ }
+ break;
+
+ case CI_PREDICTOR_2:
+ if (!ao->predictor_2 || clen != CILEN_PREDICTOR_2) {
+ newret = CONFREJ;
+ break;
}
+ ho->predictor_2 = 1;
+ if (ccp_test(f->unit, p, CILEN_PREDICTOR_2, 1) <= 0) {
+ newret = CONFREJ;
+ }
break;
default:
}
}
+ if (newret == CONFNAK && dont_nak)
+ newret = CONFREJ;
if (!(newret == CONFACK || newret == CONFNAK && ret == CONFREJ)) {
/* we're returning this option */
+ if (newret == CONFREJ && ret == CONFNAK)
+ retp = p0;
ret = newret;
if (p != retp)
BCOPY(p, retp, clen);
len -= clen;
}
- if (ret != CONFACK)
- *lenp = retp - p0;
+ if (ret != CONFACK) {
+ if (ret == CONFREJ && *lenp == retp - p0)
+ all_rejected[f->unit] = 1;
+ else
+ *lenp = retp - p0;
+ }
return ret;
}
ccp_options *ho = &ccp_hisoptions[f->unit];
ccp_flags_set(f->unit, 1, 1);
- if (go->bsd_compress || ho->bsd_compress)
+ if (ANY_COMPRESS(*go) || ANY_COMPRESS(*ho))
syslog(LOG_NOTICE, "%s enabled",
- go->bsd_compress? ho->bsd_compress? "Compression":
+ ANY_COMPRESS(*go)? ANY_COMPRESS(*ho)? "Compression":
"Receive compression": "Transmit compression");
}
len -= optlen;
optend = p + optlen;
switch (code) {
+ case CI_DEFLATE:
+ if (optlen >= CILEN_DEFLATE) {
+ printer(arg, "deflate %d", DEFLATE_SIZE(p[2]));
+ if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL)
+ printer(arg, " method %d", DEFLATE_METHOD(p[2]));
+ if (p[3] != DEFLATE_CHK_SEQUENCE)
+ printer(arg, " check %d", p[3]);
+ p += CILEN_DEFLATE;
+ }
+ break;
case CI_BSD_COMPRESS:
- if (optlen >= CILEN_BSD) {
+ if (optlen >= CILEN_BSD_COMPRESS) {
printer(arg, "bsd v%d %d", BSD_VERSION(p[2]),
BSD_NBITS(p[2]));
- p += CILEN_BSD;
+ p += CILEN_BSD_COMPRESS;
+ }
+ break;
+ case CI_PREDICTOR_1:
+ if (optlen >= CILEN_PREDICTOR_1) {
+ printer(arg, "predictor 1");
+ p += CILEN_PREDICTOR_1;
+ }
+ break;
+ case CI_PREDICTOR_2:
+ if (optlen >= CILEN_PREDICTOR_2) {
+ printer(arg, "predictor 2");
+ p += CILEN_PREDICTOR_2;
}
break;
}
* Disable compression by taking CCP down.
*/
syslog(LOG_ERR, "Lost compression sync: disabling compression");
- ccp_close(unit);
+ ccp_close(unit, "Lost compression sync");
} else {
/*
* Send a reset-request to reset the peer's compressor.
* acknowledgement to a previous reset-request.
*/
if (!(ccp_localstate[f->unit] & RACK_PENDING)) {
- fsm_sdata(f, RESETREQ, f->reqid = ++f->id, NULL, 0);
+ fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0);
TIMEOUT(ccp_rack_timeout, (caddr_t) f, RACKTIMEOUT);
ccp_localstate[f->unit] |= RACK_PENDING;
} else
fsm *f = (fsm *) arg;
if (f->state == OPENED && ccp_localstate[f->unit] & RREQ_REPEAT) {
- fsm_sdata(f, RESETREQ, f->reqid, NULL, 0);
+ fsm_sdata(f, CCP_RESETREQ, f->reqid, NULL, 0);
TIMEOUT(ccp_rack_timeout, (caddr_t) f, RACKTIMEOUT);
ccp_localstate[f->unit] &= ~RREQ_REPEAT;
} else
projects / ppp.git / blobdiff