projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[kernel] more linux kernel cygwin build fixes
[openwrt.git] / target / linux / generic-2.4 / patches / 106-mppe_mppc.patch
1 MPPE/MPPC kernel module for Linux
2
3 Microsoft Point-to-Point Encryption / Compression support
4
5 http://www.polbox.com/h/hs001/linux-2.4.29-mppe-mppc-1.3.patch.gz
6
7 --- a/Documentation/Configure.help
8 +++ b/Documentation/Configure.help
9 @@ -9986,6 +9986,28 @@ CONFIG_PPP_BSDCOMP
10 module; it is called bsd_comp.o and will show up in the directory
11 modules once you have said "make modules". If unsure, say N.
12
13 +Microsoft PPP compression/encryption (MPPC/MPPE)
14 +CONFIG_PPP_MPPE_MPPC
15 + Support for the Microsoft Point-To-Point Compression (RFC2118) and
16 + Microsoft Point-To-Point Encryption (RFC3078). These protocols are
17 + supported by Microsoft Windows and wide range of "hardware" access
18 + servers. MPPE is common protocol in Virtual Private Networks. According
19 + to RFC3078, MPPE supports 40, 56 and 128-bit key lengths. Depending on
20 + PPP daemon configuration on both ends of the link, following scenarios
21 + are possible:
22 + - only compression (MPPC) is used,
23 + - only encryption (MPPE) is used,
24 + - compression and encryption (MPPC+MPPE) are used.
25 +
26 + Please note that Hi/Fn (http://www.hifn.com) holds patent on MPPC so
27 + you should check if this patent is valid in your country in order to
28 + avoid legal problems.
29 +
30 + For more information please visit http://free.polbox.pl/h/hs001
31 +
32 + To compile this driver as a module, choose M here. The module will
33 + be called ppp_mppe_mppc.o.
34 +
35 PPP over Ethernet
36 CONFIG_PPPOE
37 Support for PPP over Ethernet.
38 --- a/crypto/Config.in
39 +++ b/crypto/Config.in
40 @@ -11,7 +11,9 @@ if [ "$CONFIG_INET_AH" = "y" -o \
41 "$CONFIG_INET6_AH" = "y" -o \
42 "$CONFIG_INET6_AH" = "m" -o \
43 "$CONFIG_INET6_ESP" = "y" -o \
44 - "$CONFIG_INET6_ESP" = "m" ]; then
45 + "$CONFIG_INET6_ESP" = "m" -o \
46 + "$CONFIG_PPP_MPPE_MPPC" = "y" -o \
47 + "$CONFIG_PPP_MPPE_MPPC" = "m" ]; then
48 define_bool CONFIG_CRYPTO y
49 else
50 bool 'Cryptographic API' CONFIG_CRYPTO
51 @@ -51,11 +53,24 @@ if [ "$CONFIG_CRYPTO" = "y" ]; then
52 "$CONFIG_INET6_AH" = "y" -o \
53 "$CONFIG_INET6_AH" = "m" -o \
54 "$CONFIG_INET6_ESP" = "y" -o \
55 - "$CONFIG_INET6_ESP" = "m" ]; then
56 - define_bool CONFIG_CRYPTO_SHA1 y
57 - else
58 - tristate ' SHA1 digest algorithm' CONFIG_CRYPTO_SHA1
59 + "$CONFIG_INET6_ESP" = "m" -o \
60 + "$CONFIG_PPP_MPPE_MPPC" = "y" -o \
61 + "$CONFIG_PPP_MPPE_MPPC" = "m" ]; then
62 + if [ "$CONFIG_INET_AH" = "y" -o \
63 + "$CONFIG_INET_ESP" = "y" -o \
64 + "$CONFIG_INET6_AH" = "y" -o \
65 + "$CONFIG_INET6_ESP" = "y" -o \
66 + "$CONFIG_PPP_MPPE_MPPC" = "y" ]; then
67 + define_tristate CONFIG_CRYPTO_SHA1 y
68 + else
69 + if [ "$CONFIG_CRYPTO_SHA1" != "y" -a \
70 + "$CONFIG_CRYPTO_SHA1" != "m" ]; then
71 + define_tristate CONFIG_CRYPTO_SHA1 m
72 + fi
73 + fi
74 fi
75 + tristate ' SHA1 digest algorithm' CONFIG_CRYPTO_SHA1
76 +
77 tristate ' SHA256 digest algorithm' CONFIG_CRYPTO_SHA256
78 tristate ' SHA384 and SHA512 digest algorithms' CONFIG_CRYPTO_SHA512
79 tristate ' Whirlpool digest algorithms' CONFIG_CRYPTO_WP512
80 @@ -76,7 +91,20 @@ if [ "$CONFIG_CRYPTO" = "y" ]; then
81 tristate ' TEA and XTEA cipher algorithms' CONFIG_CRYPTO_TEA
82 tristate ' Khazad cipher algorithm' CONFIG_CRYPTO_KHAZAD
83 tristate ' Anubis cipher algorithm' CONFIG_CRYPTO_ANUBIS
84 +
85 + if [ "$CONFIG_PPP_MPPE_MPPC" = "y" -o \
86 + "$CONFIG_PPP_MPPE_MPPC" = "m" ]; then
87 + if [ "$CONFIG_PPP_MPPE_MPPC" = "y" ]; then
88 + define_tristate CONFIG_CRYPTO_ARC4 y
89 + else
90 + if [ "$CONFIG_CRYPTO_ARC4" != "y" -a \
91 + "$CONFIG_CRYPTO_ARC4" != "m" ]; then
92 + define_tristate CONFIG_CRYPTO_ARC4 m
93 + fi
94 + fi
95 + fi
96 tristate ' ARC4 cipher algorithm' CONFIG_CRYPTO_ARC4
97 +
98 if [ "$CONFIG_INET_IPCOMP" = "y" -o \
99 "$CONFIG_INET_IPCOMP" = "m" -o \
100 "$CONFIG_INET6_IPCOMP" = "y" -o \
101 --- a/drivers/net/Config.in
102 +++ b/drivers/net/Config.in
103 @@ -336,6 +336,7 @@ if [ ! "$CONFIG_PPP" = "n" ]; then
104 dep_tristate ' PPP support for sync tty ports' CONFIG_PPP_SYNC_TTY $CONFIG_PPP
105 dep_tristate ' PPP Deflate compression' CONFIG_PPP_DEFLATE $CONFIG_PPP
106 dep_tristate ' PPP BSD-Compress compression' CONFIG_PPP_BSDCOMP $CONFIG_PPP
107 + dep_tristate ' Microsoft PPP compression/encryption (MPPC/MPPE)' CONFIG_PPP_MPPE_MPPC $CONFIG_PPP
108 if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
109 dep_tristate ' PPP over Ethernet (EXPERIMENTAL)' CONFIG_PPPOE $CONFIG_PPP
110 fi
111 --- a/drivers/net/Makefile
112 +++ b/drivers/net/Makefile
113 @@ -166,6 +166,7 @@ obj-$(CONFIG_PPP_ASYNC) += ppp_async.o
114 obj-$(CONFIG_PPP_SYNC_TTY) += ppp_synctty.o
115 obj-$(CONFIG_PPP_DEFLATE) += ppp_deflate.o
116 obj-$(CONFIG_PPP_BSDCOMP) += bsd_comp.o
117 +obj-$(CONFIG_PPP_MPPE_MPPC) += ppp_mppe_mppc.o
118 obj-$(CONFIG_PPPOE) += pppox.o pppoe.o
119
120 obj-$(CONFIG_SLIP) += slip.o
121 --- a/drivers/net/ppp_generic.c
122 +++ b/drivers/net/ppp_generic.c
123 @@ -19,7 +19,7 @@
124 * PPP driver, written by Michael Callahan and Al Longyear, and
125 * subsequently hacked by Paul Mackerras.
126 *
127 - * ==FILEVERSION 20020217==
128 + * ==FILEVERSION 20040509==
129 */
130
131 #include <linux/config.h>
132 @@ -102,6 +102,7 @@ struct ppp {
133 spinlock_t rlock; /* lock for receive side 58 */
134 spinlock_t wlock; /* lock for transmit side 5c */
135 int mru; /* max receive unit 60 */
136 + int mru_alloc; /* MAX(1500,MRU) for dev_alloc_skb() */
137 unsigned int flags; /* control bits 64 */
138 unsigned int xstate; /* transmit state bits 68 */
139 unsigned int rstate; /* receive state bits 6c */
140 @@ -552,7 +553,9 @@ static int ppp_ioctl(struct inode *inode
141 case PPPIOCSMRU:
142 if (get_user(val, (int *) arg))
143 break;
144 - ppp->mru = val;
145 + ppp->mru_alloc = ppp->mru = val;
146 + if (ppp->mru_alloc < PPP_MRU)
147 + ppp->mru_alloc = PPP_MRU; /* increase for broken peers */
148 err = 0;
149 break;
150
151 @@ -1025,14 +1028,37 @@ ppp_send_frame(struct ppp *ppp, struct s
152 case PPP_CCP:
153 /* peek at outbound CCP frames */
154 ppp_ccp_peek(ppp, skb, 0);
155 + /*
156 + * When LZS or MPPE/MPPC has been negotiated we don't send
157 + * CCP_RESETACK after receiving CCP_RESETREQ; in fact pppd
158 + * sends such a packet but we silently discard it here
159 + */
160 + if (CCP_CODE(skb->data+2) == CCP_RESETACK
161 + && (ppp->xcomp->compress_proto == CI_MPPE
162 + || ppp->xcomp->compress_proto == CI_LZS)) {
163 + --ppp->stats.tx_packets;
164 + ppp->stats.tx_bytes -= skb->len - 2;
165 + kfree_skb(skb);
166 + return;
167 + }
168 break;
169 }
170
171 /* try to do packet compression */
172 if ((ppp->xstate & SC_COMP_RUN) && ppp->xc_state != 0
173 && proto != PPP_LCP && proto != PPP_CCP) {
174 - new_skb = alloc_skb(ppp->dev->mtu + ppp->dev->hard_header_len,
175 - GFP_ATOMIC);
176 + int comp_ovhd = 0;
177 + /*
178 + * because of possible data expansion when MPPC or LZS
179 + * is used, allocate compressor's buffer 12.5% bigger
180 + * than MTU
181 + */
182 + if (ppp->xcomp->compress_proto == CI_MPPE)
183 + comp_ovhd = ((ppp->dev->mtu * 9) / 8) + 1 + MPPE_OVHD;
184 + else if (ppp->xcomp->compress_proto == CI_LZS)
185 + comp_ovhd = ((ppp->dev->mtu * 9) / 8) + 1 + LZS_OVHD;
186 + new_skb = alloc_skb(ppp->dev->mtu + ppp->dev->hard_header_len
187 + + comp_ovhd, GFP_ATOMIC);
188 if (new_skb == 0) {
189 printk(KERN_ERR "PPP: no memory (comp pkt)\n");
190 goto drop;
191 @@ -1050,9 +1076,21 @@ ppp_send_frame(struct ppp *ppp, struct s
192 skb = new_skb;
193 skb_put(skb, len);
194 skb_pull(skb, 2); /* pull off A/C bytes */
195 - } else {
196 + } else if (len == 0) {
197 /* didn't compress, or CCP not up yet */
198 kfree_skb(new_skb);
199 + } else {
200 + /*
201 + * (len < 0)
202 + * MPPE requires that we do not send unencrypted
203 + * frames. The compressor will return -1 if we
204 + * should drop the frame. We cannot simply test
205 + * the compress_proto because MPPE and MPPC share
206 + * the same number.
207 + */
208 + printk(KERN_ERR "ppp: compressor dropped pkt\n");
209 + kfree_skb(new_skb);
210 + goto drop;
211 }
212 }
213
214 @@ -1540,14 +1578,15 @@ ppp_decompress_frame(struct ppp *ppp, st
215 int len;
216
217 if (proto == PPP_COMP) {
218 - ns = dev_alloc_skb(ppp->mru + PPP_HDRLEN);
219 + ns = dev_alloc_skb(ppp->mru_alloc + PPP_HDRLEN);
220 if (ns == 0) {
221 printk(KERN_ERR "ppp_decompress_frame: no memory\n");
222 goto err;
223 }
224 /* the decompressor still expects the A/C bytes in the hdr */
225 len = ppp->rcomp->decompress(ppp->rc_state, skb->data - 2,
226 - skb->len + 2, ns->data, ppp->mru + PPP_HDRLEN);
227 + skb->len + 2, ns->data,
228 + ppp->mru_alloc + PPP_HDRLEN);
229 if (len < 0) {
230 /* Pass the compressed frame to pppd as an
231 error indication. */
232 @@ -1573,7 +1612,14 @@ ppp_decompress_frame(struct ppp *ppp, st
233 return skb;
234
235 err:
236 - ppp->rstate |= SC_DC_ERROR;
237 + if (ppp->rcomp->compress_proto != CI_MPPE
238 + && ppp->rcomp->compress_proto != CI_LZS) {
239 + /*
240 + * If decompression protocol isn't MPPE/MPPC or LZS, we set
241 + * SC_DC_ERROR flag and wait for CCP_RESETACK
242 + */
243 + ppp->rstate |= SC_DC_ERROR;
244 + }
245 ppp_receive_error(ppp);
246 return skb;
247 }
248 @@ -2253,6 +2299,7 @@ ppp_create_interface(int unit, int *retp
249 /* Initialize the new ppp unit */
250 ppp->file.index = unit;
251 ppp->mru = PPP_MRU;
252 + ppp->mru_alloc = PPP_MRU;
253 init_ppp_file(&ppp->file, INTERFACE);
254 ppp->file.hdrlen = PPP_HDRLEN - 2; /* don't count proto bytes */
255 for (i = 0; i < NUM_NP; ++i)
256 --- /dev/null
257 +++ b/drivers/net/ppp_mppe_mppc.c
258 @@ -0,0 +1,1312 @@
259 +/*
260 + * ppp_mppe_mppc.c - MPPC/MPPE "compressor/decompressor" module.
261 + *
262 + * Copyright (c) 1994 Árpád Magosányi <mag@bunuel.tii.matav.hu>
263 + * Copyright (c) 1999 Tim Hockin, Cobalt Networks Inc. <thockin@cobaltnet.com>
264 + * Copyright (c) 2002-2005 Jan Dubiec <jdx@slackware.pl>
265 + *
266 + * Permission to use, copy, modify, and distribute this software and its
267 + * documentation is hereby granted, provided that the above copyright
268 + * notice appears in all copies. This software is provided without any
269 + * warranty, express or implied.
270 + *
271 + * The code is based on MPPE kernel module written by Árpád Magosányi and
272 + * Tim Hockin which can be found on http://planetmirror.com/pub/mppe/.
273 + * I have added MPPC and 56 bit session keys support in MPPE.
274 + *
275 + * WARNING! Although this is open source code, its usage in some countries
276 + * (in particular in the USA) may violate Stac Inc. patent for MPPC.
277 + *
278 + * ==FILEVERSION 20050202==
279 + *
280 + */
281 +
282 +#include <linux/init.h>
283 +#include <linux/module.h>
284 +#include <linux/mm.h>
285 +#include <linux/slab.h>
286 +#include <asm/scatterlist.h>
287 +#include <linux/vmalloc.h>
288 +#include <linux/crypto.h>
289 +
290 +#include <linux/ppp_defs.h>
291 +#include <linux/ppp-comp.h>
292 +
293 +/*
294 + * In 2.4.x kernels macro offset_in_page() is not defined in linux/mm.h so
295 + * we define it here; PAGE_MASK is defined in asm/page.h which is included
296 + * by linux/mm.h.
297 + */
298 +#define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)
299 +
300 +/*
301 + * State for a mppc/mppe "(de)compressor".
302 + */
303 +struct ppp_mppe_state {
304 + struct crypto_tfm *arc4_tfm;
305 + struct crypto_tfm *sha1_tfm;
306 + u8 *sha1_digest;
307 + u8 master_key[MPPE_MAX_KEY_LEN];
308 + u8 session_key[MPPE_MAX_KEY_LEN];
309 + u8 mppc; /* do we use compression (MPPC)? */
310 + u8 mppe; /* do we use encryption (MPPE)? */
311 + u8 keylen; /* key length in bytes */
312 + u8 bitkeylen; /* key length in bits */
313 + u16 ccount; /* coherency counter */
314 + u16 bits; /* MPPC/MPPE control bits */
315 + u8 stateless; /* do we use stateless mode? */
316 + u8 nextflushed; /* set A bit in the next outgoing packet;
317 + used only by compressor*/
318 + u8 flushexpected; /* drop packets until A bit is received;
319 + used only by decompressor*/
320 + u8 *hist; /* MPPC history */
321 + u16 *hash; /* Hash table; used only by compressor */
322 + u16 histptr; /* history "cursor" */
323 + int unit;
324 + int debug;
325 + int mru;
326 + struct compstat stats;
327 +};
328 +
329 +#define MPPE_HIST_LEN 8192 /* MPPC history size */
330 +#define MPPE_MAX_CCOUNT 0x0FFF /* max. coherency counter value */
331 +
332 +#define MPPE_BIT_FLUSHED 0x80 /* bit A */
333 +#define MPPE_BIT_RESET 0x40 /* bit B */
334 +#define MPPE_BIT_COMP 0x20 /* bit C */
335 +#define MPPE_BIT_ENCRYPTED 0x10 /* bit D */
336 +
337 +#define MPPE_SALT0 0xD1 /* values used in MPPE key derivation */
338 +#define MPPE_SALT1 0x26 /* according to RFC3079 */
339 +#define MPPE_SALT2 0x9E
340 +
341 +#define MPPE_CCOUNT(x) ((((x)[4] & 0x0f) << 8) + (x)[5])
342 +#define MPPE_BITS(x) ((x)[4] & 0xf0)
343 +#define MPPE_CTRLHI(x) ((((x)->ccount & 0xf00)>>8)|((x)->bits))
344 +#define MPPE_CTRLLO(x) ((x)->ccount & 0xff)
345 +
346 +/*
347 + * Kernel Crypto API needs its arguments to be in kmalloc'd memory, not in the
348 + * module static data area. That means sha_pad needs to be kmalloc'd. It is done
349 + * in mppe_module_init(). This has been pointed out on 30th July 2004 by Oleg
350 + * Makarenko on pptpclient-devel mailing list.
351 + */
352 +#define SHA1_PAD_SIZE 40
353 +struct sha_pad {
354 + unsigned char sha_pad1[SHA1_PAD_SIZE];
355 + unsigned char sha_pad2[SHA1_PAD_SIZE];
356 +};
357 +static struct sha_pad *sha_pad;
358 +
359 +static inline void
360 +setup_sg(struct scatterlist *sg, const void *address, unsigned int length)
361 +{
362 + sg[0].page = virt_to_page(address);
363 + sg[0].offset = offset_in_page(address);
364 + sg[0].length = length;
365 +}
366 +
367 +static inline void
368 +arc4_setkey(struct ppp_mppe_state *state, const unsigned char *key,
369 + const unsigned int keylen)
370 +{
371 + crypto_cipher_setkey(state->arc4_tfm, key, keylen);
372 +}
373 +
374 +static inline void
375 +arc4_encrypt(struct ppp_mppe_state *state, const unsigned char *in,
376 + const unsigned int len, unsigned char *out)
377 +{
378 + struct scatterlist sgin[4], sgout[4];
379 +
380 + setup_sg(sgin, in, len);
381 + setup_sg(sgout, out, len);
382 + crypto_cipher_encrypt(state->arc4_tfm, sgout, sgin, len);
383 +}
384 +
385 +#define arc4_decrypt arc4_encrypt
386 +
387 +/*
388 + * Key Derivation, from RFC 3078, RFC 3079.
389 + * Equivalent to Get_Key() for MS-CHAP as described in RFC 3079.
390 + */
391 +static void
392 +get_new_key_from_sha(struct ppp_mppe_state *state, unsigned char *interim_key)
393 +{
394 + struct scatterlist sg[4];
395 +
396 + setup_sg(&sg[0], state->master_key, state->keylen);
397 + setup_sg(&sg[1], sha_pad->sha_pad1, sizeof(sha_pad->sha_pad1));
398 + setup_sg(&sg[2], state->session_key, state->keylen);
399 + setup_sg(&sg[3], sha_pad->sha_pad2, sizeof(sha_pad->sha_pad2));
400 +
401 + crypto_digest_digest (state->sha1_tfm, sg, 4, state->sha1_digest);
402 +
403 + memcpy(interim_key, state->sha1_digest, state->keylen);
404 +}
405 +
406 +static void
407 +mppe_change_key(struct ppp_mppe_state *state, int initialize)
408 +{
409 + unsigned char interim_key[MPPE_MAX_KEY_LEN];
410 +
411 + get_new_key_from_sha(state, interim_key);
412 + if (initialize) {
413 + memcpy(state->session_key, interim_key, state->keylen);
414 + } else {
415 + arc4_setkey(state, interim_key, state->keylen);
416 + arc4_encrypt(state, interim_key, state->keylen, state->session_key);
417 + }
418 + if (state->keylen == 8) {
419 + if (state->bitkeylen == 40) {
420 + state->session_key[0] = MPPE_SALT0;
421 + state->session_key[1] = MPPE_SALT1;
422 + state->session_key[2] = MPPE_SALT2;
423 + } else {
424 + state->session_key[0] = MPPE_SALT0;
425 + }
426 + }
427 + arc4_setkey(state, state->session_key, state->keylen);
428 +}
429 +
430 +/* increase 12-bit coherency counter */
431 +static inline void
432 +mppe_increase_ccount(struct ppp_mppe_state *state)
433 +{
434 + state->ccount = (state->ccount + 1) & MPPE_MAX_CCOUNT;
435 + if (state->mppe) {
436 + if (state->stateless) {
437 + mppe_change_key(state, 0);
438 + state->nextflushed = 1;
439 + } else {
440 + if ((state->ccount & 0xff) == 0xff) {
441 + mppe_change_key(state, 0);
442 + }
443 + }
444 + }
445 +}
446 +
447 +/* allocate space for a MPPE/MPPC (de)compressor. */
448 +/* comp != 0 -> init compressor */
449 +/* comp = 0 -> init decompressor */
450 +static void *
451 +mppe_alloc(unsigned char *options, int opt_len, int comp)
452 +{
453 + struct ppp_mppe_state *state;
454 + unsigned int digestsize;
455 + u8* fname;
456 +
457 + fname = comp ? "mppe_comp_alloc" : "mppe_decomp_alloc";
458 +
459 + /*
460 + * Hack warning - additionally to the standard MPPC/MPPE configuration
461 + * options, pppd passes to the (de)copressor 8 or 16 byte session key.
462 + * Therefore options[1] contains MPPC/MPPE configuration option length
463 + * (CILEN_MPPE = 6), but the real options length, depending on the key
464 + * length, is 6+8 or 6+16.
465 + */
466 + if (opt_len < CILEN_MPPE) {
467 + printk(KERN_WARNING "%s: wrong options length: %u\n", fname, opt_len);
468 + return NULL;
469 + }
470 +
471 + if (options[0] != CI_MPPE || options[1] != CILEN_MPPE ||
472 + (options[2] & ~MPPE_STATELESS) != 0 ||
473 + options[3] != 0 || options[4] != 0 ||
474 + (options[5] & ~(MPPE_128BIT|MPPE_56BIT|MPPE_40BIT|MPPE_MPPC)) != 0 ||
475 + (options[5] & (MPPE_128BIT|MPPE_56BIT|MPPE_40BIT|MPPE_MPPC)) == 0) {
476 + printk(KERN_WARNING "%s: options rejected: o[0]=%02x, o[1]=%02x, "
477 + "o[2]=%02x, o[3]=%02x, o[4]=%02x, o[5]=%02x\n", fname, options[0],
478 + options[1], options[2], options[3], options[4], options[5]);
479 + return NULL;
480 + }
481 +
482 + state = (struct ppp_mppe_state *)kmalloc(sizeof(*state), GFP_KERNEL);
483 + if (state == NULL) {
484 + printk(KERN_ERR "%s: cannot allocate space for %scompressor\n", fname,
485 + comp ? "" : "de");
486 + return NULL;
487 + }
488 + memset(state, 0, sizeof(struct ppp_mppe_state));
489 +
490 + state->mppc = options[5] & MPPE_MPPC; /* Do we use MPPC? */
491 + state->mppe = options[5] & (MPPE_128BIT | MPPE_56BIT |
492 + MPPE_40BIT); /* Do we use MPPE? */
493 +
494 + if (state->mppc) {
495 + /* allocate MPPC history */
496 + state->hist = (u8*)vmalloc(2*MPPE_HIST_LEN*sizeof(u8));
497 + if (state->hist == NULL) {
498 + kfree(state);
499 + printk(KERN_ERR "%s: cannot allocate space for MPPC history\n",
500 + fname);
501 + return NULL;
502 + }
503 +
504 + /* allocate hashtable for MPPC compressor */
505 + if (comp) {
506 + state->hash = (u16*)vmalloc(MPPE_HIST_LEN*sizeof(u16));
507 + if (state->hash == NULL) {
508 + vfree(state->hist);
509 + kfree(state);
510 + printk(KERN_ERR "%s: cannot allocate space for MPPC history\n",
511 + fname);
512 + return NULL;
513 + }
514 + }
515 + }
516 +
517 + if (state->mppe) { /* specific for MPPE */
518 + /* Load ARC4 algorithm */
519 + state->arc4_tfm = crypto_alloc_tfm("arc4", 0);
520 + if (state->arc4_tfm == NULL) {
521 + if (state->mppc) {
522 + vfree(state->hash);
523 + if (comp)
524 + vfree(state->hist);
525 + }
526 + kfree(state);
527 + printk(KERN_ERR "%s: cannot load ARC4 module\n", fname);
528 + return NULL;
529 + }
530 +
531 + /* Load SHA1 algorithm */
532 + state->sha1_tfm = crypto_alloc_tfm("sha1", 0);
533 + if (state->sha1_tfm == NULL) {
534 + crypto_free_tfm(state->arc4_tfm);
535 + if (state->mppc) {
536 + vfree(state->hash);
537 + if (comp)
538 + vfree(state->hist);
539 + }
540 + kfree(state);
541 + printk(KERN_ERR "%s: cannot load SHA1 module\n", fname);
542 + return NULL;
543 + }
544 +
545 + digestsize = crypto_tfm_alg_digestsize(state->sha1_tfm);
546 + if (digestsize < MPPE_MAX_KEY_LEN) {
547 + crypto_free_tfm(state->sha1_tfm);
548 + crypto_free_tfm(state->arc4_tfm);
549 + if (state->mppc) {
550 + vfree(state->hash);
551 + if (comp)
552 + vfree(state->hist);
553 + }
554 + kfree(state);
555 + printk(KERN_ERR "%s: CryptoAPI SHA1 digest size too small\n", fname);
556 + }
557 +
558 + state->sha1_digest = kmalloc(digestsize, GFP_KERNEL);
559 + if (!state->sha1_digest) {
560 + crypto_free_tfm(state->sha1_tfm);
561 + crypto_free_tfm(state->arc4_tfm);
562 + if (state->mppc) {
563 + vfree(state->hash);
564 + if (comp)
565 + vfree(state->hist);
566 + }
567 + kfree(state);
568 + printk(KERN_ERR "%s: cannot allocate space for SHA1 digest\n", fname);
569 + }
570 +
571 + memcpy(state->master_key, options+CILEN_MPPE, MPPE_MAX_KEY_LEN);
572 + memcpy(state->session_key, state->master_key, MPPE_MAX_KEY_LEN);
573 + /* initial key generation is done in mppe_init() */
574 + }
575 +
576 + MOD_INC_USE_COUNT;
577 +
578 + return (void *) state;
579 +}
580 +
581 +static void *
582 +mppe_comp_alloc(unsigned char *options, int opt_len)
583 +{
584 + return mppe_alloc(options, opt_len, 1);
585 +}
586 +
587 +static void *
588 +mppe_decomp_alloc(unsigned char *options, int opt_len)
589 +{
590 + return mppe_alloc(options, opt_len, 0);
591 +}
592 +
593 +/* cleanup the (de)compressor */
594 +static void
595 +mppe_comp_free(void *arg)
596 +{
597 + struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
598 +
599 + if (state != NULL) {
600 + if (state->mppe) {
601 + if (state->sha1_tfm != NULL)
602 + crypto_free_tfm(state->sha1_tfm);
603 + if (state->arc4_tfm != NULL)
604 + crypto_free_tfm(state->arc4_tfm);
605 + }
606 + if (state->hist != NULL)
607 + vfree(state->hist);
608 + if (state->hash != NULL)
609 + vfree(state->hash);
610 + kfree(state);
611 + }
612 +
613 + MOD_DEC_USE_COUNT;
614 +}
615 +
616 +/* init MPPC/MPPE (de)compresor */
617 +/* comp != 0 -> init compressor */
618 +/* comp = 0 -> init decompressor */
619 +static int
620 +mppe_init(void *arg, unsigned char *options, int opt_len, int unit,
621 + int hdrlen, int mru, int debug, int comp)
622 +{
623 + struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
624 + u8* fname;
625 +
626 + fname = comp ? "mppe_comp_init" : "mppe_decomp_init";
627 +
628 + if (opt_len < CILEN_MPPE) {
629 + if (debug)
630 + printk(KERN_WARNING "%s: wrong options length: %u\n",
631 + fname, opt_len);
632 + return 0;
633 + }
634 +
635 + if (options[0] != CI_MPPE || options[1] != CILEN_MPPE ||
636 + (options[2] & ~MPPE_STATELESS) != 0 ||
637 + options[3] != 0 || options[4] != 0 ||
638 + (options[5] & ~(MPPE_56BIT|MPPE_128BIT|MPPE_40BIT|MPPE_MPPC)) != 0 ||
639 + (options[5] & (MPPE_56BIT|MPPE_128BIT|MPPE_40BIT|MPPE_MPPC)) == 0) {
640 + if (debug)
641 + printk(KERN_WARNING "%s: options rejected: o[0]=%02x, o[1]=%02x, "
642 + "o[2]=%02x, o[3]=%02x, o[4]=%02x, o[5]=%02x\n", fname,
643 + options[0], options[1], options[2], options[3], options[4],
644 + options[5]);
645 + return 0;
646 + }
647 +
648 + if ((options[5] & ~MPPE_MPPC) != MPPE_128BIT &&
649 + (options[5] & ~MPPE_MPPC) != MPPE_56BIT &&
650 + (options[5] & ~MPPE_MPPC) != MPPE_40BIT &&
651 + (options[5] & MPPE_MPPC) != MPPE_MPPC) {
652 + if (debug)
653 + printk(KERN_WARNING "%s: don't know what to do: o[5]=%02x\n",
654 + fname, options[5]);
655 + return 0;
656 + }
657 +
658 + state->mppc = options[5] & MPPE_MPPC; /* Do we use MPPC? */
659 + state->mppe = options[5] & (MPPE_128BIT | MPPE_56BIT |
660 + MPPE_40BIT); /* Do we use MPPE? */
661 + state->stateless = options[2] & MPPE_STATELESS; /* Do we use stateless mode? */
662 +
663 + switch (state->mppe) {
664 + case MPPE_40BIT: /* 40 bit key */
665 + state->keylen = 8;
666 + state->bitkeylen = 40;
667 + break;
668 + case MPPE_56BIT: /* 56 bit key */
669 + state->keylen = 8;
670 + state->bitkeylen = 56;
671 + break;
672 + case MPPE_128BIT: /* 128 bit key */
673 + state->keylen = 16;
674 + state->bitkeylen = 128;
675 + break;
676 + default:
677 + state->keylen = 0;
678 + state->bitkeylen = 0;
679 + }
680 +
681 + state->ccount = MPPE_MAX_CCOUNT;
682 + state->bits = 0;
683 + state->unit = unit;
684 + state->debug = debug;
685 + state->histptr = MPPE_HIST_LEN;
686 + if (state->mppc) { /* reset history if MPPC was negotiated */
687 + memset(state->hist, 0, 2*MPPE_HIST_LEN*sizeof(u8));
688 + }
689 +
690 + if (state->mppe) { /* generate initial session keys */
691 + mppe_change_key(state, 1);
692 + }
693 +
694 + if (comp) { /* specific for compressor */
695 + state->nextflushed = 1;
696 + } else { /* specific for decompressor */
697 + state->mru = mru;
698 + state->flushexpected = 1;
699 + }
700 +
701 + return 1;
702 +}
703 +
704 +static int
705 +mppe_comp_init(void *arg, unsigned char *options, int opt_len, int unit,
706 + int hdrlen, int debug)
707 +{
708 + return mppe_init(arg, options, opt_len, unit, hdrlen, 0, debug, 1);
709 +}
710 +
711 +
712 +static int
713 +mppe_decomp_init(void *arg, unsigned char *options, int opt_len, int unit,
714 + int hdrlen, int mru, int debug)
715 +{
716 + return mppe_init(arg, options, opt_len, unit, hdrlen, mru, debug, 0);
717 +}
718 +
719 +static void
720 +mppe_comp_reset(void *arg)
721 +{
722 + struct ppp_mppe_state *state = (struct ppp_mppe_state *)arg;
723 +
724 + if (state->debug)
725 + printk(KERN_DEBUG "%s%d: resetting MPPC/MPPE compressor\n",
726 + __FUNCTION__, state->unit);
727 +
728 + state->nextflushed = 1;
729 + if (state->mppe)
730 + arc4_setkey(state, state->session_key, state->keylen);
731 +}
732 +
733 +static void
734 +mppe_decomp_reset(void *arg)
735 +{
736 + /* When MPPC/MPPE is in use, we shouldn't receive any CCP Reset-Ack.
737 + But when we receive such a packet, we just ignore it. */
738 + return;
739 +}
740 +
741 +static void
742 +mppe_stats(void *arg, struct compstat *stats)
743 +{
744 + struct ppp_mppe_state *state = (struct ppp_mppe_state *)arg;
745 +
746 + *stats = state->stats;
747 +}
748 +
749 +/***************************/
750 +/**** Compression stuff ****/
751 +/***************************/
752 +/* inserts 1 to 8 bits into the output buffer */
753 +static inline void putbits8(u8 *buf, u32 val, const u32 n, u32 *i, u32 *l)
754 +{
755 + buf += *i;
756 + if (*l >= n) {
757 + *l = (*l) - n;
758 + val <<= *l;
759 + *buf = *buf | (val & 0xff);
760 + if (*l == 0) {
761 + *l = 8;
762 + (*i)++;
763 + *(++buf) = 0;
764 + }
765 + } else {
766 + (*i)++;
767 + *l = 8 - n + (*l);
768 + val <<= *l;
769 + *buf = *buf | ((val >> 8) & 0xff);
770 + *(++buf) = val & 0xff;
771 + }
772 +}
773 +
774 +/* inserts 9 to 16 bits into the output buffer */
775 +static inline void putbits16(u8 *buf, u32 val, const u32 n, u32 *i, u32 *l)
776 +{
777 + buf += *i;
778 + if (*l >= n - 8) {
779 + (*i)++;
780 + *l = 8 - n + (*l);
781 + val <<= *l;
782 + *buf = *buf | ((val >> 8) & 0xff);
783 + *(++buf) = val & 0xff;
784 + if (*l == 0) {
785 + *l = 8;
786 + (*i)++;
787 + *(++buf) = 0;
788 + }
789 + } else {
790 + (*i)++; (*i)++;
791 + *l = 16 - n + (*l);
792 + val <<= *l;
793 + *buf = *buf | ((val >> 16) & 0xff);
794 + *(++buf) = (val >> 8) & 0xff;
795 + *(++buf) = val & 0xff;
796 + }
797 +}
798 +
799 +/* inserts 17 to 24 bits into the output buffer */
800 +static inline void putbits24(u8 *buf, u32 val, const u32 n, u32 *i, u32 *l)
801 +{
802 + buf += *i;
803 + if (*l >= n - 16) {
804 + (*i)++; (*i)++;
805 + *l = 16 - n + (*l);
806 + val <<= *l;
807 + *buf = *buf | ((val >> 16) & 0xff);
808 + *(++buf) = (val >> 8) & 0xff;
809 + *(++buf) = val & 0xff;
810 + if (*l == 0) {
811 + *l = 8;
812 + (*i)++;
813 + *(++buf) = 0;
814 + }
815 + } else {
816 + (*i)++; (*i)++; (*i)++;
817 + *l = 24 - n + (*l);
818 + val <<= *l;
819 + *buf = *buf | ((val >> 24) & 0xff);
820 + *(++buf) = (val >> 16) & 0xff;
821 + *(++buf) = (val >> 8) & 0xff;
822 + *(++buf) = val & 0xff;
823 + }
824 +}
825 +
826 +static int
827 +mppc_compress(struct ppp_mppe_state *state, unsigned char *ibuf,
828 + unsigned char *obuf, int isize, int osize)
829 +{
830 + u32 olen, off, len, idx, i, l;
831 + u8 *hist, *sbuf, *p, *q, *r, *s;
832 +
833 + /*
834 + At this point, to avoid possible buffer overflow caused by packet
835 + expansion during/after compression, we should make sure that
836 + osize >= (((isize*9)/8)+1)+2, but we don't do that because in
837 + ppp_generic.c we simply allocate bigger obuf.
838 +
839 + Maximum MPPC packet expansion is 12.5%. This is the worst case when
840 + all octets in the input buffer are >= 0x80 and we cannot find any
841 + repeated tokens. Additionally we have to reserve 2 bytes for MPPE/MPPC
842 + status bits and coherency counter.
843 + */
844 +
845 + hist = state->hist + MPPE_HIST_LEN;
846 + /* check if there is enough room at the end of the history */
847 + if (state->histptr + isize >= 2*MPPE_HIST_LEN) {
848 + state->bits |= MPPE_BIT_RESET;
849 + state->histptr = MPPE_HIST_LEN;
850 + memcpy(state->hist, hist, MPPE_HIST_LEN);
851 + }
852 + /* add packet to the history; isize must be <= MPPE_HIST_LEN */
853 + sbuf = state->hist + state->histptr;
854 + memcpy(sbuf, ibuf, isize);
855 + state->histptr += isize;
856 +
857 + /* compress data */
858 + r = sbuf + isize;
859 + *obuf = olen = i = 0;
860 + l = 8;
861 + while (i < isize - 2) {
862 + s = q = sbuf + i;
863 + idx = ((40543*((((s[0]<<4)^s[1])<<4)^s[2]))>>4) & 0x1fff;
864 + p = hist + state->hash[idx];
865 + state->hash[idx] = (u16) (s - hist);
866 + off = s - p;
867 + if (off > MPPE_HIST_LEN - 1 || off < 1 || *p++ != *s++ || *p++ != *s++ ||
868 + *p++ != *s++) {
869 + /* no match found; encode literal byte */
870 + if (ibuf[i] < 0x80) { /* literal byte < 0x80 */
871 + putbits8(obuf, (u32) ibuf[i], 8, &olen, &l);
872 + } else { /* literal byte >= 0x80 */
873 + putbits16(obuf, (u32) (0x100|(ibuf[i]&0x7f)), 9, &olen, &l);
874 + }
875 + ++i;
876 + continue;
877 + }
878 + if (r - q >= 64) {
879 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
880 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
881 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
882 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
883 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
884 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
885 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
886 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
887 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
888 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
889 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
890 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
891 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
892 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
893 + *p++ != *s++ || *p++ != *s++ || *p++ != *s++ || *p++ != *s++ ||
894 + *p++ != *s++;
895 + if (s - q == 64) {
896 + p--; s--;
897 + while((*p++ == *s++) && (s < r) && (p < q));
898 + }
899 + } else {
900 + while((*p++ == *s++) && (s < r) && (p < q));
901 + }
902 + len = s - q - 1;
903 + i += len;
904 +
905 + /* at least 3 character match found; code data */
906 + /* encode offset */
907 + if (off < 64) { /* 10-bit offset; 0 <= offset < 64 */
908 + putbits16(obuf, 0x3c0|off, 10, &olen, &l);
909 + } else if (off < 320) { /* 12-bit offset; 64 <= offset < 320 */
910 + putbits16(obuf, 0xe00|(off-64), 12, &olen, &l);
911 + } else if (off < 8192) { /* 16-bit offset; 320 <= offset < 8192 */
912 + putbits16(obuf, 0xc000|(off-320), 16, &olen, &l);
913 + } else {
914 + /* This shouldn't happen; we return 0 what means "packet expands",
915 + and we send packet uncompressed. */
916 + if (state->debug)
917 + printk(KERN_DEBUG "%s%d: wrong offset value: %d\n",
918 + __FUNCTION__, state->unit, off);
919 + return 0;
920 + }
921 + /* encode length of match */
922 + if (len < 4) { /* length = 3 */
923 + putbits8(obuf, 0, 1, &olen, &l);
924 + } else if (len < 8) { /* 4 <= length < 8 */
925 + putbits8(obuf, 0x08|(len&0x03), 4, &olen, &l);
926 + } else if (len < 16) { /* 8 <= length < 16 */
927 + putbits8(obuf, 0x30|(len&0x07), 6, &olen, &l);
928 + } else if (len < 32) { /* 16 <= length < 32 */
929 + putbits8(obuf, 0xe0|(len&0x0f), 8, &olen, &l);
930 + } else if (len < 64) { /* 32 <= length < 64 */
931 + putbits16(obuf, 0x3c0|(len&0x1f), 10, &olen, &l);
932 + } else if (len < 128) { /* 64 <= length < 128 */
933 + putbits16(obuf, 0xf80|(len&0x3f), 12, &olen, &l);
934 + } else if (len < 256) { /* 128 <= length < 256 */
935 + putbits16(obuf, 0x3f00|(len&0x7f), 14, &olen, &l);
936 + } else if (len < 512) { /* 256 <= length < 512 */
937 + putbits16(obuf, 0xfe00|(len&0xff), 16, &olen, &l);
938 + } else if (len < 1024) { /* 512 <= length < 1024 */
939 + putbits24(obuf, 0x3fc00|(len&0x1ff), 18, &olen, &l);
940 + } else if (len < 2048) { /* 1024 <= length < 2048 */
941 + putbits24(obuf, 0xff800|(len&0x3ff), 20, &olen, &l);
942 + } else if (len < 4096) { /* 2048 <= length < 4096 */
943 + putbits24(obuf, 0x3ff000|(len&0x7ff), 22, &olen, &l);
944 + } else if (len < 8192) { /* 4096 <= length < 8192 */
945 + putbits24(obuf, 0xffe000|(len&0xfff), 24, &olen, &l);
946 + } else {
947 + /* This shouldn't happen; we return 0 what means "packet expands",
948 + and send packet uncompressed. */
949 + if (state->debug)
950 + printk(KERN_DEBUG "%s%d: wrong length of match value: %d\n",
951 + __FUNCTION__, state->unit, len);
952 + return 0;
953 + }
954 + }
955 +
956 + /* Add remaining octets to the output */
957 + while(isize - i > 0) {
958 + if (ibuf[i] < 0x80) { /* literal byte < 0x80 */
959 + putbits8(obuf, (u32) ibuf[i++], 8, &olen, &l);
960 + } else { /* literal byte >= 0x80 */
961 + putbits16(obuf, (u32) (0x100|(ibuf[i++]&0x7f)), 9, &olen, &l);
962 + }
963 + }
964 + /* Reset unused bits of the last output octet */
965 + if ((l != 0) && (l != 8)) {
966 + putbits8(obuf, 0, l, &olen, &l);
967 + }
968 +
969 + return (int) olen;
970 +}
971 +
972 +int
973 +mppe_compress(void *arg, unsigned char *ibuf, unsigned char *obuf,
974 + int isize, int osize)
975 +{
976 + struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
977 + int proto, olen, complen, off;
978 + unsigned char *wptr;
979 +
980 + /* Check that the protocol is in the range we handle. */
981 + proto = PPP_PROTOCOL(ibuf);
982 + if (proto < 0x0021 || proto > 0x00fa)
983 + return 0;
984 +
985 + wptr = obuf;
986 + /* Copy over the PPP header */
987 + wptr[0] = PPP_ADDRESS(ibuf);
988 + wptr[1] = PPP_CONTROL(ibuf);
989 + wptr[2] = PPP_COMP >> 8;
990 + wptr[3] = PPP_COMP;
991 + wptr += PPP_HDRLEN + (MPPE_OVHD / 2); /* Leave two octets for MPPE/MPPC bits */
992 +
993 + /*
994 + * In ver. 0.99 protocol field was compressed. Deflate and BSD compress
995 + * do PFC before actual compression, RCF2118 and RFC3078 are not precise
996 + * on this topic so I decided to do PFC. Unfortunately this change caused
997 + * incompatibility with older/other MPPE/MPPC modules. I have received
998 + * a lot of complaints from unexperienced users so I have decided to revert
999 + * to previous state, i.e. the protocol field is sent uncompressed now.
1000 + * Although this may be changed in the future.
1001 + *
1002 + * Receiving side (mppe_decompress()) still accepts packets with compressed
1003 + * and uncompressed protocol field so you shouldn't get "Unsupported protocol
1004 + * 0x2145 received" messages anymore.
1005 + */
1006 + //off = (proto > 0xff) ? 2 : 3; /* PFC - skip first protocol byte if 0 */
1007 + off = 2;
1008 +
1009 + ibuf += off;
1010 +
1011 + mppe_increase_ccount(state);
1012 +
1013 + if (state->nextflushed) {
1014 + state->bits |= MPPE_BIT_FLUSHED;
1015 + state->nextflushed = 0;
1016 + if (state->mppe && !state->stateless) {
1017 + /*
1018 + * If this is the flag packet, the key has been already changed in
1019 + * mppe_increase_ccount() so we dont't do it once again.
1020 + */
1021 + if ((state->ccount & 0xff) != 0xff) {
1022 + arc4_setkey(state, state->session_key, state->keylen);
1023 + }
1024 + }
1025 + if (state->mppc) { /* reset history */
1026 + state->bits |= MPPE_BIT_RESET;
1027 + state->histptr = MPPE_HIST_LEN;
1028 + memset(state->hist + MPPE_HIST_LEN, 0, MPPE_HIST_LEN*sizeof(u8));
1029 + }
1030 + }
1031 +
1032 + if (state->mppc && !state->mppe) { /* Do only compression */
1033 + complen = mppc_compress(state, ibuf, wptr, isize - off,
1034 + osize - PPP_HDRLEN - (MPPE_OVHD / 2));
1035 + /*
1036 + * TODO: Implement an heuristics to handle packet expansion in a smart
1037 + * way. Now, when a packet expands, we send it as uncompressed and
1038 + * when next packet is sent we have to reset compressor's history.
1039 + * Maybe it would be better to send such packet as compressed in order
1040 + * to keep history's continuity.
1041 + */
1042 + if ((complen > isize) || (complen > osize - PPP_HDRLEN) ||
1043 + (complen == 0)) {
1044 + /* packet expands */
1045 + state->nextflushed = 1;
1046 + memcpy(wptr, ibuf, isize - off);
1047 + olen = isize - (off - 2) + MPPE_OVHD;
1048 + (state->stats).inc_bytes += olen;
1049 + (state->stats).inc_packets++;
1050 + } else {
1051 + state->bits |= MPPE_BIT_COMP;
1052 + olen = complen + PPP_HDRLEN + (MPPE_OVHD / 2);
1053 + (state->stats).comp_bytes += olen;
1054 + (state->stats).comp_packets++;
1055 + }
1056 + } else { /* Do encryption with or without compression */
1057 + state->bits |= MPPE_BIT_ENCRYPTED;
1058 + if (!state->mppc && state->mppe) { /* Do only encryption */
1059 + /* read from ibuf, write to wptr, adjust for PPP_HDRLEN */
1060 + arc4_encrypt(state, ibuf, isize - off, wptr);
1061 + olen = isize - (off - 2) + MPPE_OVHD;
1062 + (state->stats).inc_bytes += olen;
1063 + (state->stats).inc_packets++;
1064 + } else { /* Do compression and then encryption - RFC3078 */
1065 + complen = mppc_compress(state, ibuf, wptr, isize - off,
1066 + osize - PPP_HDRLEN - (MPPE_OVHD / 2));
1067 + /*
1068 + * TODO: Implement an heuristics to handle packet expansion in a smart
1069 + * way. Now, when a packet expands, we send it as uncompressed and
1070 + * when next packet is sent we have to reset compressor's history.
1071 + * Maybe it would be good to send such packet as compressed in order
1072 + * to keep history's continuity.
1073 + */
1074 + if ((complen > isize) || (complen > osize - PPP_HDRLEN) ||
1075 + (complen == 0)) {
1076 + /* packet expands */
1077 + state->nextflushed = 1;
1078 + arc4_encrypt(state, ibuf, isize - off, wptr);
1079 + olen = isize - (off - 2) + MPPE_OVHD;
1080 + (state->stats).inc_bytes += olen;
1081 + (state->stats).inc_packets++;
1082 + } else {
1083 + state->bits |= MPPE_BIT_COMP;
1084 + /* Hack warning !!! RC4 implementation which we use does
1085 + encryption "in place" - it means that input and output
1086 + buffers can be *the same* memory area. Therefore we don't
1087 + need to use a temporary buffer. But be careful - other
1088 + implementations don't have to be so nice.
1089 + I used to use ibuf as temporary buffer here, but it led
1090 + packet sniffers into error. Thanks to Wilfried Weissmann
1091 + for pointing that. */
1092 + arc4_encrypt(state, wptr, complen, wptr);
1093 + olen = complen + PPP_HDRLEN + (MPPE_OVHD / 2);
1094 + (state->stats).comp_bytes += olen;
1095 + (state->stats).comp_packets++;
1096 + }
1097 + }
1098 + }
1099 +
1100 + /* write status bits and coherency counter into the output buffer */
1101 + wptr = obuf + PPP_HDRLEN;
1102 + wptr[0] = MPPE_CTRLHI(state);
1103 + wptr[1] = MPPE_CTRLLO(state);
1104 +
1105 + state->bits = 0;
1106 +
1107 + (state->stats).unc_bytes += isize;
1108 + (state->stats).unc_packets++;
1109 +
1110 + return olen;
1111 +}
1112 +
1113 +/***************************/
1114 +/*** Decompression stuff ***/
1115 +/***************************/
1116 +static inline u32 getbits(const u8 *buf, const u32 n, u32 *i, u32 *l)
1117 +{
1118 + static const u32 m[] = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
1119 + u32 res, ol;
1120 +
1121 + ol = *l;
1122 + if (*l >= n) {
1123 + *l = (*l) - n;
1124 + res = (buf[*i] & m[ol]) >> (*l);
1125 + if (*l == 0) {
1126 + *l = 8;
1127 + (*i)++;
1128 + }
1129 + } else {
1130 + *l = 8 - n + (*l);
1131 + res = (buf[(*i)++] & m[ol]) << 8;
1132 + res = (res | buf[*i]) >> (*l);
1133 + }
1134 +
1135 + return res;
1136 +}
1137 +
1138 +static inline u32 getbyte(const u8 *buf, const u32 i, const u32 l)
1139 +{
1140 + if (l == 8) {
1141 + return buf[i];
1142 + } else {
1143 + return (((buf[i] << 8) | buf[i+1]) >> l) & 0xff;
1144 + }
1145 +}
1146 +
1147 +static inline void lamecopy(u8 *dst, u8 *src, u32 len)
1148 +{
1149 + while (len--)
1150 + *dst++ = *src++;
1151 +}
1152 +
1153 +static int
1154 +mppc_decompress(struct ppp_mppe_state *state, unsigned char *ibuf,
1155 + unsigned char *obuf, int isize, int osize)
1156 +{
1157 + u32 olen, off, len, bits, val, sig, i, l;
1158 + u8 *history, *s;
1159 +
1160 + history = state->hist + state->histptr;
1161 + olen = len = i = 0;
1162 + l = 8;
1163 + bits = isize * 8;
1164 + while (bits >= 8) {
1165 + val = getbyte(ibuf, i++, l);
1166 + if (val < 0x80) { /* literal byte < 0x80 */
1167 + if (state->histptr < 2*MPPE_HIST_LEN) {
1168 + /* copy uncompressed byte to the history */
1169 + (state->hist)[(state->histptr)++] = (u8) val;
1170 + } else {
1171 + /* buffer overflow; drop packet */
1172 + if (state->debug)
1173 + printk(KERN_ERR "%s%d: trying to write outside history "
1174 + "buffer\n", __FUNCTION__, state->unit);
1175 + return DECOMP_ERROR;
1176 + }
1177 + olen++;
1178 + bits -= 8;
1179 + continue;
1180 + }
1181 +
1182 + sig = val & 0xc0;
1183 + if (sig == 0x80) { /* literal byte >= 0x80 */
1184 + if (state->histptr < 2*MPPE_HIST_LEN) {
1185 + /* copy uncompressed byte to the history */
1186 + (state->hist)[(state->histptr)++] =
1187 + (u8) (0x80|((val&0x3f)<<1)|getbits(ibuf, 1 , &i ,&l));
1188 + } else {
1189 + /* buffer overflow; drop packet */
1190 + if (state->debug)
1191 + printk(KERN_ERR "%s%d: trying to write outside history "
1192 + "buffer\n", __FUNCTION__, state->unit);
1193 + return DECOMP_ERROR;
1194 + }
1195 + olen++;
1196 + bits -= 9;
1197 + continue;
1198 + }
1199 +
1200 + /* Not a literal byte so it must be an (offset,length) pair */
1201 + /* decode offset */
1202 + sig = val & 0xf0;
1203 + if (sig == 0xf0) { /* 10-bit offset; 0 <= offset < 64 */
1204 + off = (((val&0x0f)<<2)|getbits(ibuf, 2 , &i ,&l));
1205 + bits -= 10;
1206 + } else {
1207 + if (sig == 0xe0) { /* 12-bit offset; 64 <= offset < 320 */
1208 + off = ((((val&0x0f)<<4)|getbits(ibuf, 4 , &i ,&l))+64);
1209 + bits -= 12;
1210 + } else {
1211 + if ((sig&0xe0) == 0xc0) {/* 16-bit offset; 320 <= offset < 8192 */
1212 + off = ((((val&0x1f)<<8)|getbyte(ibuf, i++, l))+320);
1213 + bits -= 16;
1214 + if (off > MPPE_HIST_LEN - 1) {
1215 + if (state->debug)
1216 + printk(KERN_DEBUG "%s%d: too big offset value: %d\n",
1217 + __FUNCTION__, state->unit, off);
1218 + return DECOMP_ERROR;
1219 + }
1220 + } else { /* this shouldn't happen */
1221 + if (state->debug)
1222 + printk(KERN_DEBUG "%s%d: cannot decode offset value\n",
1223 + __FUNCTION__, state->unit);
1224 + return DECOMP_ERROR;
1225 + }
1226 + }
1227 + }
1228 + /* decode length of match */
1229 + val = getbyte(ibuf, i, l);
1230 + if ((val & 0x80) == 0x00) { /* len = 3 */
1231 + len = 3;
1232 + bits--;
1233 + getbits(ibuf, 1 , &i ,&l);
1234 + } else if ((val & 0xc0) == 0x80) { /* 4 <= len < 8 */
1235 + len = 0x04 | ((val>>4) & 0x03);
1236 + bits -= 4;
1237 + getbits(ibuf, 4 , &i ,&l);
1238 + } else if ((val & 0xe0) == 0xc0) { /* 8 <= len < 16 */
1239 + len = 0x08 | ((val>>2) & 0x07);
1240 + bits -= 6;
1241 + getbits(ibuf, 6 , &i ,&l);
1242 + } else if ((val & 0xf0) == 0xe0) { /* 16 <= len < 32 */
1243 + len = 0x10 | (val & 0x0f);
1244 + bits -= 8;
1245 + i++;
1246 + } else {
1247 + bits -= 8;
1248 + val = (val << 8) | getbyte(ibuf, ++i, l);
1249 + if ((val & 0xf800) == 0xf000) { /* 32 <= len < 64 */
1250 + len = 0x0020 | ((val >> 6) & 0x001f);
1251 + bits -= 2;
1252 + getbits(ibuf, 2 , &i ,&l);
1253 + } else if ((val & 0xfc00) == 0xf800) { /* 64 <= len < 128 */
1254 + len = 0x0040 | ((val >> 4) & 0x003f);
1255 + bits -= 4;
1256 + getbits(ibuf, 4 , &i ,&l);
1257 + } else if ((val & 0xfe00) == 0xfc00) { /* 128 <= len < 256 */
1258 + len = 0x0080 | ((val >> 2) & 0x007f);
1259 + bits -= 6;
1260 + getbits(ibuf, 6 , &i ,&l);
1261 + } else if ((val & 0xff00) == 0xfe00) { /* 256 <= len < 512 */
1262 + len = 0x0100 | (val & 0x00ff);
1263 + bits -= 8;
1264 + i++;
1265 + } else {
1266 + bits -= 8;
1267 + val = (val << 8) | getbyte(ibuf, ++i, l);
1268 + if ((val & 0xff8000) == 0xff0000) { /* 512 <= len < 1024 */
1269 + len = 0x000200 | ((val >> 6) & 0x0001ff);
1270 + bits -= 2;
1271 + getbits(ibuf, 2 , &i ,&l);
1272 + } else if ((val & 0xffc000) == 0xff8000) {/* 1024 <= len < 2048 */
1273 + len = 0x000400 | ((val >> 4) & 0x0003ff);
1274 + bits -= 4;
1275 + getbits(ibuf, 4 , &i ,&l);
1276 + } else if ((val & 0xffe000) == 0xffc000) {/* 2048 <= len < 4096 */
1277 + len = 0x000800 | ((val >> 2) & 0x0007ff);
1278 + bits -= 6;
1279 + getbits(ibuf, 6 , &i ,&l);
1280 + } else if ((val & 0xfff000) == 0xffe000) {/* 4096 <= len < 8192 */
1281 + len = 0x001000 | (val & 0x000fff);
1282 + bits -= 8;
1283 + i++;
1284 + } else { /* this shouldn't happen */
1285 + if (state->debug)
1286 + printk(KERN_DEBUG "%s%d: wrong length code: 0x%X\n",
1287 + __FUNCTION__, state->unit, val);
1288 + return DECOMP_ERROR;
1289 + }
1290 + }
1291 + }
1292 + s = state->hist + state->histptr;
1293 + state->histptr += len;
1294 + olen += len;
1295 + if (state->histptr < 2*MPPE_HIST_LEN) {
1296 + /* copy uncompressed bytes to the history */
1297 +
1298 + /* In some cases len may be greater than off. It means that memory
1299 + * areas pointed by s and s-off overlap. I had used memmove() here
1300 + * because I thought that it acts as libc's version. Unfortunately,
1301 + * I was wrong. :-) I got strange errors sometimes. Wilfried suggested
1302 + * using of byte by byte copying here and strange errors disappeared.
1303 + */
1304 + lamecopy(s, s - off, len);
1305 + } else {
1306 + /* buffer overflow; drop packet */
1307 + if (state->debug)
1308 + printk(KERN_ERR "%s%d: trying to write outside history "
1309 + "buffer\n", __FUNCTION__, state->unit);
1310 + return DECOMP_ERROR;
1311 + }
1312 + }
1313 +
1314 + /* Do PFC decompression */
1315 + len = olen;
1316 + if ((history[0] & 0x01) != 0) {
1317 + obuf[0] = 0;
1318 + obuf++;
1319 + len++;
1320 + }
1321 +
1322 + if (len <= osize) {
1323 + /* copy uncompressed packet to the output buffer */
1324 + memcpy(obuf, history, olen);
1325 + } else {
1326 + /* buffer overflow; drop packet */
1327 + if (state->debug)
1328 + printk(KERN_ERR "%s%d: too big uncompressed packet: %d\n",
1329 + __FUNCTION__, state->unit, len + (PPP_HDRLEN / 2));
1330 + return DECOMP_ERROR;
1331 + }
1332 +
1333 + return (int) len;
1334 +}
1335 +
1336 +int
1337 +mppe_decompress(void *arg, unsigned char *ibuf, int isize,
1338 + unsigned char *obuf, int osize)
1339 +{
1340 + struct ppp_mppe_state *state = (struct ppp_mppe_state *)arg;
1341 + int seq, bits, uncomplen;
1342 +
1343 + if (isize <= PPP_HDRLEN + MPPE_OVHD) {
1344 + if (state->debug) {
1345 + printk(KERN_DEBUG "%s%d: short packet (len=%d)\n", __FUNCTION__,
1346 + state->unit, isize);
1347 + }
1348 + return DECOMP_ERROR;
1349 + }
1350 +
1351 + /* Get coherency counter and control bits from input buffer */
1352 + seq = MPPE_CCOUNT(ibuf);
1353 + bits = MPPE_BITS(ibuf);
1354 +
1355 + if (state->stateless) {
1356 + /* RFC 3078, sec 8.1. */
1357 + mppe_increase_ccount(state);
1358 + if ((seq != state->ccount) && state->debug)
1359 + printk(KERN_DEBUG "%s%d: bad sequence number: %d, expected: %d\n",
1360 + __FUNCTION__, state->unit, seq, state->ccount);
1361 + while (seq != state->ccount)
1362 + mppe_increase_ccount(state);
1363 + } else {
1364 + /* RFC 3078, sec 8.2. */
1365 + if (state->flushexpected) { /* discard state */
1366 + if ((bits & MPPE_BIT_FLUSHED)) { /* we received expected FLUSH bit */
1367 + while (seq != state->ccount)
1368 + mppe_increase_ccount(state);
1369 + state->flushexpected = 0;
1370 + } else /* drop packet*/
1371 + return DECOMP_ERROR;
1372 + } else { /* normal state */
1373 + mppe_increase_ccount(state);
1374 + if (seq != state->ccount) {
1375 + /* Packet loss detected, enter the discard state. */
1376 + if (state->debug)
1377 + printk(KERN_DEBUG "%s%d: bad sequence number: %d, expected: %d\n",
1378 + __FUNCTION__, state->unit, seq, state->ccount);
1379 + state->flushexpected = 1;
1380 + return DECOMP_ERROR;
1381 + }
1382 + }
1383 + if (state->mppe && (bits & MPPE_BIT_FLUSHED)) {
1384 + arc4_setkey(state, state->session_key, state->keylen);
1385 + }
1386 + }
1387 +
1388 + if (state->mppc && (bits & (MPPE_BIT_FLUSHED | MPPE_BIT_RESET))) {
1389 + state->histptr = MPPE_HIST_LEN;
1390 + if ((bits & MPPE_BIT_FLUSHED)) {
1391 + memset(state->hist + MPPE_HIST_LEN, 0, MPPE_HIST_LEN*sizeof(u8));
1392 + } else
1393 + if ((bits & MPPE_BIT_RESET)) {
1394 + memcpy(state->hist, state->hist + MPPE_HIST_LEN, MPPE_HIST_LEN);
1395 + }
1396 + }
1397 +
1398 + /* Fill in the first part of the PPP header. The protocol field
1399 + comes from the decompressed data. */
1400 + obuf[0] = PPP_ADDRESS(ibuf);
1401 + obuf[1] = PPP_CONTROL(ibuf);
1402 + obuf += PPP_HDRLEN / 2;
1403 +
1404 + if (state->mppe) { /* process encrypted packet */
1405 + if ((bits & MPPE_BIT_ENCRYPTED)) {
1406 + /* OK, packet encrypted, so decrypt it */
1407 + if (state->mppc && (bits & MPPE_BIT_COMP)) {
1408 + /* Hack warning !!! RC4 implementation which we use does
1409 + decryption "in place" - it means that input and output
1410 + buffers can be *the same* memory area. Therefore we don't
1411 + need to use a temporary buffer. But be careful - other
1412 + implementations don't have to be so nice. */
1413 + arc4_decrypt(state, ibuf + PPP_HDRLEN + (MPPE_OVHD / 2), isize -
1414 + PPP_HDRLEN - (MPPE_OVHD / 2), ibuf + PPP_HDRLEN +
1415 + (MPPE_OVHD / 2));
1416 + uncomplen = mppc_decompress(state, ibuf + PPP_HDRLEN +
1417 + (MPPE_OVHD / 2), obuf, isize -
1418 + PPP_HDRLEN - (MPPE_OVHD / 2),
1419 + osize - (PPP_HDRLEN / 2));
1420 + if (uncomplen == DECOMP_ERROR) {
1421 + state->flushexpected = 1;
1422 + return DECOMP_ERROR;
1423 + }
1424 + uncomplen += PPP_HDRLEN / 2;
1425 + (state->stats).comp_bytes += isize;
1426 + (state->stats).comp_packets++;
1427 + } else {
1428 + uncomplen = isize - MPPE_OVHD;
1429 + /* Decrypt the first byte in order to check if it is
1430 + compressed or uncompressed protocol field */
1431 + arc4_decrypt(state, ibuf + PPP_HDRLEN + (MPPE_OVHD / 2), 1, obuf);
1432 + /* Do PFC decompression */
1433 + if ((obuf[0] & 0x01) != 0) {
1434 + obuf[1] = obuf[0];
1435 + obuf[0] = 0;
1436 + obuf++;
1437 + uncomplen++;
1438 + }
1439 + /* And finally, decrypt the rest of the frame. */
1440 + arc4_decrypt(state, ibuf + PPP_HDRLEN + (MPPE_OVHD / 2) + 1,
1441 + isize - PPP_HDRLEN - (MPPE_OVHD / 2) - 1, obuf + 1);
1442 + (state->stats).inc_bytes += isize;
1443 + (state->stats).inc_packets++;
1444 + }
1445 + } else { /* this shouldn't happen */
1446 + if (state->debug)
1447 + printk(KERN_ERR "%s%d: encryption negotiated but not an "
1448 + "encrypted packet received\n", __FUNCTION__, state->unit);
1449 + mppe_change_key(state, 0);
1450 + state->flushexpected = 1;
1451 + return DECOMP_ERROR;
1452 + }
1453 + } else {
1454 + if (state->mppc) { /* no MPPE, only MPPC */
1455 + if ((bits & MPPE_BIT_COMP)) {
1456 + uncomplen = mppc_decompress(state, ibuf + PPP_HDRLEN +
1457 + (MPPE_OVHD / 2), obuf, isize -
1458 + PPP_HDRLEN - (MPPE_OVHD / 2),
1459 + osize - (PPP_HDRLEN / 2));
1460 + if (uncomplen == DECOMP_ERROR) {
1461 + state->flushexpected = 1;
1462 + return DECOMP_ERROR;
1463 + }
1464 + uncomplen += PPP_HDRLEN / 2;
1465 + (state->stats).comp_bytes += isize;
1466 + (state->stats).comp_packets++;
1467 + } else {
1468 + memcpy(obuf, ibuf + PPP_HDRLEN + (MPPE_OVHD / 2), isize -
1469 + PPP_HDRLEN - (MPPE_OVHD / 2));
1470 + uncomplen = isize - MPPE_OVHD;
1471 + (state->stats).inc_bytes += isize;
1472 + (state->stats).inc_packets++;
1473 + }
1474 + } else { /* this shouldn't happen */
1475 + if (state->debug)
1476 + printk(KERN_ERR "%s%d: error - not an MPPC or MPPE frame "
1477 + "received\n", __FUNCTION__, state->unit);
1478 + state->flushexpected = 1;
1479 + return DECOMP_ERROR;
1480 + }
1481 + }
1482 +
1483 + (state->stats).unc_bytes += uncomplen;
1484 + (state->stats).unc_packets++;
1485 +
1486 + return uncomplen;
1487 +}
1488 +
1489 +
1490 +/************************************************************
1491 + * Module interface table
1492 + ************************************************************/
1493 +
1494 +/* These are in ppp_generic.c */
1495 +extern int ppp_register_compressor (struct compressor *cp);
1496 +extern void ppp_unregister_compressor (struct compressor *cp);
1497 +
1498 +/*
1499 + * Functions exported to ppp_generic.c.
1500 + *
1501 + * In case of MPPC/MPPE there is no need to process incompressible data
1502 + * because such a data is sent in MPPC/MPPE frame. Therefore the (*incomp)
1503 + * callback function isn't needed.
1504 + */
1505 +struct compressor ppp_mppe = {
1506 + CI_MPPE, /* compress_proto */
1507 + mppe_comp_alloc, /* comp_alloc */
1508 + mppe_comp_free, /* comp_free */
1509 + mppe_comp_init, /* comp_init */
1510 + mppe_comp_reset, /* comp_reset */
1511 + mppe_compress, /* compress */
1512 + mppe_stats, /* comp_stat */
1513 + mppe_decomp_alloc, /* decomp_alloc */
1514 + mppe_comp_free, /* decomp_free */
1515 + mppe_decomp_init, /* decomp_init */
1516 + mppe_decomp_reset, /* decomp_reset */
1517 + mppe_decompress, /* decompress */
1518 + NULL, /* incomp */
1519 + mppe_stats, /* decomp_stat */
1520 +};
1521 +
1522 +/************************************************************
1523 + * Module support routines
1524 + ************************************************************/
1525 +
1526 +int __init mppe_module_init(void)
1527 +{
1528 + int answer;
1529 +
1530 + /* When the module is compiled into kernel, it is initialized before
1531 + * CryptoAPI. Therefore the code below reports that there is no crypto
1532 + * stuff in the kernel. Marlon de Boer who has pointed out the problem,
1533 + * has sent also a message to CryptoAPI developers, so maybe in the future
1534 + * the code will be uncommented.
1535 + *
1536 + if (!(crypto_alg_available("arc4", 0) && crypto_alg_available("sha1", 0))) {
1537 + printk(KERN_ERR "Kernel doesn't provide ARC4 and/or SHA1 algorithms "
1538 + "required by MPPE/MPPC. Check CryptoAPI configuration.\n");
1539 + return -ENODEV;
1540 + }
1541 + */
1542 +
1543 + /* Allocate space for SHAPad1, SHAPad2 and ... */
1544 + sha_pad = kmalloc(sizeof(struct sha_pad), GFP_KERNEL);
1545 + if (sha_pad == NULL)
1546 + return -ENOMEM;
1547 + /* ... initialize them */
1548 + memset(sha_pad->sha_pad1, 0x00, sizeof(sha_pad->sha_pad1));
1549 + memset(sha_pad->sha_pad2, 0xf2, sizeof(sha_pad->sha_pad2));
1550 +
1551 + answer = ppp_register_compressor(&ppp_mppe);
1552 + if (answer == 0) {
1553 + printk(KERN_INFO "MPPE/MPPC encryption/compression module registered\n");
1554 + }
1555 + return answer;
1556 +}
1557 +
1558 +void __exit mppe_module_cleanup(void)
1559 +{
1560 + kfree(sha_pad);
1561 + ppp_unregister_compressor(&ppp_mppe);
1562 + printk(KERN_INFO "MPPE/MPPC encryption/compression module unregistered\n");
1563 +}
1564 +
1565 +module_init(mppe_module_init);
1566 +module_exit(mppe_module_cleanup);
1567 +
1568 +MODULE_AUTHOR("Jan Dubiec <jdx@slackware.pl>");
1569 +MODULE_DESCRIPTION("MPPE/MPPC encryption/compression module for Linux");
1570 +MODULE_LICENSE("Dual BSD/GPL");
1571 --- a/include/linux/ppp-comp.h
1572 +++ b/include/linux/ppp-comp.h
1573 @@ -28,7 +28,7 @@
1574 */
1575
1576 /*
1577 - * ==FILEVERSION 980319==
1578 + * ==FILEVERSION 20040509==
1579 *
1580 * NOTE TO MAINTAINERS:
1581 * If you modify this file at all, please set the above date.
1582 @@ -78,7 +78,7 @@ struct compressor {
1583
1584 /* Compress a packet */
1585 int (*compress) (void *state, unsigned char *rptr,
1586 - unsigned char *obuf, int isize, int osize);
1587 + unsigned char *obuf, int isize, int osize);
1588
1589 /* Return compression statistics */
1590 void (*comp_stat) (void *state, struct compstat *stats);
1591 @@ -99,7 +99,7 @@ struct compressor {
1592
1593 /* Decompress a packet. */
1594 int (*decompress) (void *state, unsigned char *ibuf, int isize,
1595 - unsigned char *obuf, int osize);
1596 + unsigned char *obuf, int osize);
1597
1598 /* Update state for an incompressible packet received */
1599 void (*incomp) (void *state, unsigned char *ibuf, int icnt);
1600 @@ -187,6 +187,42 @@ struct compressor {
1601 #define DEFLATE_CHK_SEQUENCE 0
1602
1603 /*
1604 + * Definitions for MPPE/MPPC.
1605 + */
1606 +
1607 +#define CI_MPPE 18 /* config option for MPPE */
1608 +#define CILEN_MPPE 6 /* length of config option */
1609 +
1610 +#define MPPE_OVHD 4 /* MPPE overhead */
1611 +#define MPPE_MAX_KEY_LEN 16 /* largest key length (128-bit) */
1612 +
1613 +#define MPPE_STATELESS 0x01 /* configuration bit H */
1614 +#define MPPE_40BIT 0x20 /* configuration bit L */
1615 +#define MPPE_56BIT 0x80 /* configuration bit M */
1616 +#define MPPE_128BIT 0x40 /* configuration bit S */
1617 +#define MPPE_MPPC 0x01 /* configuration bit C */
1618 +
1619 +/*
1620 + * Definitions for Stac LZS.
1621 + */
1622 +
1623 +#define CI_LZS 17 /* config option for Stac LZS */
1624 +#define CILEN_LZS 5 /* length of config option */
1625 +
1626 +#define LZS_OVHD 4 /* max. LZS overhead */
1627 +#define LZS_HIST_LEN 2048 /* LZS history size */
1628 +#define LZS_MAX_CCOUNT 0x0FFF /* max. coherency counter value */
1629 +
1630 +#define LZS_MODE_NONE 0
1631 +#define LZS_MODE_LCB 1
1632 +#define LZS_MODE_CRC 2
1633 +#define LZS_MODE_SEQ 3
1634 +#define LZS_MODE_EXT 4
1635 +
1636 +#define LZS_EXT_BIT_FLUSHED 0x80 /* bit A */
1637 +#define LZS_EXT_BIT_COMP 0x20 /* bit C */
1638 +
1639 +/*
1640 * Definitions for other, as yet unsupported, compression methods.
1641 */
1642
Personal OpenWRT clone
This page took 0.152439 seconds and 5 git commands to generate.