CAN: add controller hardware name for Softing cards
[linux-2.6.git] / drivers / net / ppp_deflate.c
1 /*
2  *  ==FILEVERSION 980319==
3  *
4  * ppp_deflate.c - interface the zlib procedures for Deflate compression
5  * and decompression (as used by gzip) to the PPP code.
6  * This version is for use with Linux kernel 1.3.X.
7  *
8  * Copyright (c) 1994 The Australian National University.
9  * All rights reserved.
10  *
11  * Permission to use, copy, modify, and distribute this software and its
12  * documentation is hereby granted, provided that the above copyright
13  * notice appears in all copies.  This software is provided without any
14  * warranty, express or implied. The Australian National University
15  * makes no representations about the suitability of this software for
16  * any purpose.
17  *
18  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
19  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
20  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
21  * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
22  * OF SUCH DAMAGE.
23  *
24  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
26  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
27  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
28  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
29  * OR MODIFICATIONS.
30  *
31  * From: deflate.c,v 1.1 1996/01/18 03:17:48 paulus Exp
32  */
33
34 #include <linux/module.h>
35 #include <linux/slab.h>
36 #include <linux/vmalloc.h>
37 #include <linux/init.h>
38 #include <linux/string.h>
39
40 #include <linux/ppp_defs.h>
41 #include <linux/ppp-comp.h>
42
43 #include <linux/zlib.h>
44 #include <asm/unaligned.h>
45
46 /*
47  * State for a Deflate (de)compressor.
48  */
49 struct ppp_deflate_state {
50     int         seqno;
51     int         w_size;
52     int         unit;
53     int         mru;
54     int         debug;
55     z_stream    strm;
56     struct compstat stats;
57 };
58
59 #define DEFLATE_OVHD    2               /* Deflate overhead/packet */
60
61 static void     *z_comp_alloc(unsigned char *options, int opt_len);
62 static void     *z_decomp_alloc(unsigned char *options, int opt_len);
63 static void     z_comp_free(void *state);
64 static void     z_decomp_free(void *state);
65 static int      z_comp_init(void *state, unsigned char *options,
66                                  int opt_len,
67                                  int unit, int hdrlen, int debug);
68 static int      z_decomp_init(void *state, unsigned char *options,
69                                    int opt_len,
70                                    int unit, int hdrlen, int mru, int debug);
71 static int      z_compress(void *state, unsigned char *rptr,
72                                 unsigned char *obuf,
73                                 int isize, int osize);
74 static void     z_incomp(void *state, unsigned char *ibuf, int icnt);
75 static int      z_decompress(void *state, unsigned char *ibuf,
76                                 int isize, unsigned char *obuf, int osize);
77 static void     z_comp_reset(void *state);
78 static void     z_decomp_reset(void *state);
79 static void     z_comp_stats(void *state, struct compstat *stats);
80
81 /**
82  *      z_comp_free - free the memory used by a compressor
83  *      @arg:   pointer to the private state for the compressor.
84  */
85 static void z_comp_free(void *arg)
86 {
87         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
88
89         if (state) {
90                 zlib_deflateEnd(&state->strm);
91                 vfree(state->strm.workspace);
92                 kfree(state);
93         }
94 }
95
96 /**
97  *      z_comp_alloc - allocate space for a compressor.
98  *      @options: pointer to CCP option data
99  *      @opt_len: length of the CCP option at @options.
100  *
101  *      The @options pointer points to the a buffer containing the
102  *      CCP option data for the compression being negotiated.  It is
103  *      formatted according to RFC1979, and describes the window
104  *      size that the peer is requesting that we use in compressing
105  *      data to be sent to it.
106  *
107  *      Returns the pointer to the private state for the compressor,
108  *      or NULL if we could not allocate enough memory.
109  */
110 static void *z_comp_alloc(unsigned char *options, int opt_len)
111 {
112         struct ppp_deflate_state *state;
113         int w_size;
114
115         if (opt_len != CILEN_DEFLATE ||
116             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
117             options[1] != CILEN_DEFLATE ||
118             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
119             options[3] != DEFLATE_CHK_SEQUENCE)
120                 return NULL;
121         w_size = DEFLATE_SIZE(options[2]);
122         if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
123                 return NULL;
124
125         state = kzalloc(sizeof(*state),
126                                                      GFP_KERNEL);
127         if (state == NULL)
128                 return NULL;
129
130         state->strm.next_in   = NULL;
131         state->w_size         = w_size;
132         state->strm.workspace = vmalloc(zlib_deflate_workspacesize());
133         if (state->strm.workspace == NULL)
134                 goto out_free;
135
136         if (zlib_deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION,
137                          DEFLATE_METHOD_VAL, -w_size, 8, Z_DEFAULT_STRATEGY)
138             != Z_OK)
139                 goto out_free;
140         return (void *) state;
141
142 out_free:
143         z_comp_free(state);
144         return NULL;
145 }
146
147 /**
148  *      z_comp_init - initialize a previously-allocated compressor.
149  *      @arg:   pointer to the private state for the compressor
150  *      @options: pointer to the CCP option data describing the
151  *              compression that was negotiated with the peer
152  *      @opt_len: length of the CCP option data at @options
153  *      @unit:  PPP unit number for diagnostic messages
154  *      @hdrlen: ignored (present for backwards compatibility)
155  *      @debug: debug flag; if non-zero, debug messages are printed.
156  *
157  *      The CCP options described by @options must match the options
158  *      specified when the compressor was allocated.  The compressor
159  *      history is reset.  Returns 0 for failure (CCP options don't
160  *      match) or 1 for success.
161  */
162 static int z_comp_init(void *arg, unsigned char *options, int opt_len,
163                        int unit, int hdrlen, int debug)
164 {
165         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
166
167         if (opt_len < CILEN_DEFLATE ||
168             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
169             options[1] != CILEN_DEFLATE ||
170             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
171             DEFLATE_SIZE(options[2]) != state->w_size ||
172             options[3] != DEFLATE_CHK_SEQUENCE)
173                 return 0;
174
175         state->seqno = 0;
176         state->unit  = unit;
177         state->debug = debug;
178
179         zlib_deflateReset(&state->strm);
180
181         return 1;
182 }
183
184 /**
185  *      z_comp_reset - reset a previously-allocated compressor.
186  *      @arg:   pointer to private state for the compressor.
187  *
188  *      This clears the history for the compressor and makes it
189  *      ready to start emitting a new compressed stream.
190  */
191 static void z_comp_reset(void *arg)
192 {
193         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
194
195         state->seqno = 0;
196         zlib_deflateReset(&state->strm);
197 }
198
199 /**
200  *      z_compress - compress a PPP packet with Deflate compression.
201  *      @arg:   pointer to private state for the compressor
202  *      @rptr:  uncompressed packet (input)
203  *      @obuf:  compressed packet (output)
204  *      @isize: size of uncompressed packet
205  *      @osize: space available at @obuf
206  *
207  *      Returns the length of the compressed packet, or 0 if the
208  *      packet is incompressible.
209  */
210 static int z_compress(void *arg, unsigned char *rptr, unsigned char *obuf,
211                int isize, int osize)
212 {
213         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
214         int r, proto, off, olen, oavail;
215         unsigned char *wptr;
216
217         /*
218          * Check that the protocol is in the range we handle.
219          */
220         proto = PPP_PROTOCOL(rptr);
221         if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
222                 return 0;
223
224         /* Don't generate compressed packets which are larger than
225            the uncompressed packet. */
226         if (osize > isize)
227                 osize = isize;
228
229         wptr = obuf;
230
231         /*
232          * Copy over the PPP header and store the 2-byte sequence number.
233          */
234         wptr[0] = PPP_ADDRESS(rptr);
235         wptr[1] = PPP_CONTROL(rptr);
236         put_unaligned_be16(PPP_COMP, wptr + 2);
237         wptr += PPP_HDRLEN;
238         put_unaligned_be16(state->seqno, wptr);
239         wptr += DEFLATE_OVHD;
240         olen = PPP_HDRLEN + DEFLATE_OVHD;
241         state->strm.next_out = wptr;
242         state->strm.avail_out = oavail = osize - olen;
243         ++state->seqno;
244
245         off = (proto > 0xff) ? 2 : 3;   /* skip 1st proto byte if 0 */
246         rptr += off;
247         state->strm.next_in = rptr;
248         state->strm.avail_in = (isize - off);
249
250         for (;;) {
251                 r = zlib_deflate(&state->strm, Z_PACKET_FLUSH);
252                 if (r != Z_OK) {
253                         if (state->debug)
254                                 printk(KERN_ERR
255                                        "z_compress: deflate returned %d\n", r);
256                         break;
257                 }
258                 if (state->strm.avail_out == 0) {
259                         olen += oavail;
260                         state->strm.next_out = NULL;
261                         state->strm.avail_out = oavail = 1000000;
262                 } else {
263                         break;          /* all done */
264                 }
265         }
266         olen += oavail - state->strm.avail_out;
267
268         /*
269          * See if we managed to reduce the size of the packet.
270          */
271         if (olen < isize) {
272                 state->stats.comp_bytes += olen;
273                 state->stats.comp_packets++;
274         } else {
275                 state->stats.inc_bytes += isize;
276                 state->stats.inc_packets++;
277                 olen = 0;
278         }
279         state->stats.unc_bytes += isize;
280         state->stats.unc_packets++;
281
282         return olen;
283 }
284
285 /**
286  *      z_comp_stats - return compression statistics for a compressor
287  *              or decompressor.
288  *      @arg:   pointer to private space for the (de)compressor
289  *      @stats: pointer to a struct compstat to receive the result.
290  */
291 static void z_comp_stats(void *arg, struct compstat *stats)
292 {
293         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
294
295         *stats = state->stats;
296 }
297
298 /**
299  *      z_decomp_free - Free the memory used by a decompressor.
300  *      @arg:   pointer to private space for the decompressor.
301  */
302 static void z_decomp_free(void *arg)
303 {
304         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
305
306         if (state) {
307                 zlib_inflateEnd(&state->strm);
308                 kfree(state->strm.workspace);
309                 kfree(state);
310         }
311 }
312
313 /**
314  *      z_decomp_alloc - allocate space for a decompressor.
315  *      @options: pointer to CCP option data
316  *      @opt_len: length of the CCP option at @options.
317  *
318  *      The @options pointer points to the a buffer containing the
319  *      CCP option data for the compression being negotiated.  It is
320  *      formatted according to RFC1979, and describes the window
321  *      size that we are requesting the peer to use in compressing
322  *      data to be sent to us.
323  *
324  *      Returns the pointer to the private state for the decompressor,
325  *      or NULL if we could not allocate enough memory.
326  */
327 static void *z_decomp_alloc(unsigned char *options, int opt_len)
328 {
329         struct ppp_deflate_state *state;
330         int w_size;
331
332         if (opt_len != CILEN_DEFLATE ||
333             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
334             options[1] != CILEN_DEFLATE ||
335             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
336             options[3] != DEFLATE_CHK_SEQUENCE)
337                 return NULL;
338         w_size = DEFLATE_SIZE(options[2]);
339         if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
340                 return NULL;
341
342         state = kzalloc(sizeof(*state), GFP_KERNEL);
343         if (state == NULL)
344                 return NULL;
345
346         state->w_size         = w_size;
347         state->strm.next_out  = NULL;
348         state->strm.workspace = kmalloc(zlib_inflate_workspacesize(),
349                                         GFP_KERNEL|__GFP_REPEAT);
350         if (state->strm.workspace == NULL)
351                 goto out_free;
352
353         if (zlib_inflateInit2(&state->strm, -w_size) != Z_OK)
354                 goto out_free;
355         return (void *) state;
356
357 out_free:
358         z_decomp_free(state);
359         return NULL;
360 }
361
362 /**
363  *      z_decomp_init - initialize a previously-allocated decompressor.
364  *      @arg:   pointer to the private state for the decompressor
365  *      @options: pointer to the CCP option data describing the
366  *              compression that was negotiated with the peer
367  *      @opt_len: length of the CCP option data at @options
368  *      @unit:  PPP unit number for diagnostic messages
369  *      @hdrlen: ignored (present for backwards compatibility)
370  *      @mru:   maximum length of decompressed packets
371  *      @debug: debug flag; if non-zero, debug messages are printed.
372  *
373  *      The CCP options described by @options must match the options
374  *      specified when the decompressor was allocated.  The decompressor
375  *      history is reset.  Returns 0 for failure (CCP options don't
376  *      match) or 1 for success.
377  */
378 static int z_decomp_init(void *arg, unsigned char *options, int opt_len,
379                          int unit, int hdrlen, int mru, int debug)
380 {
381         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
382
383         if (opt_len < CILEN_DEFLATE ||
384             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
385             options[1] != CILEN_DEFLATE ||
386             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
387             DEFLATE_SIZE(options[2]) != state->w_size ||
388             options[3] != DEFLATE_CHK_SEQUENCE)
389                 return 0;
390
391         state->seqno = 0;
392         state->unit  = unit;
393         state->debug = debug;
394         state->mru   = mru;
395
396         zlib_inflateReset(&state->strm);
397
398         return 1;
399 }
400
401 /**
402  *      z_decomp_reset - reset a previously-allocated decompressor.
403  *      @arg:   pointer to private state for the decompressor.
404  *
405  *      This clears the history for the decompressor and makes it
406  *      ready to receive a new compressed stream.
407  */
408 static void z_decomp_reset(void *arg)
409 {
410         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
411
412         state->seqno = 0;
413         zlib_inflateReset(&state->strm);
414 }
415
416 /**
417  *      z_decompress - decompress a Deflate-compressed packet.
418  *      @arg:   pointer to private state for the decompressor
419  *      @ibuf:  pointer to input (compressed) packet data
420  *      @isize: length of input packet
421  *      @obuf:  pointer to space for output (decompressed) packet
422  *      @osize: amount of space available at @obuf
423  *
424  * Because of patent problems, we return DECOMP_ERROR for errors
425  * found by inspecting the input data and for system problems, but
426  * DECOMP_FATALERROR for any errors which could possibly be said to
427  * be being detected "after" decompression.  For DECOMP_ERROR,
428  * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
429  * infringing a patent of Motorola's if we do, so we take CCP down
430  * instead.
431  *
432  * Given that the frame has the correct sequence number and a good FCS,
433  * errors such as invalid codes in the input most likely indicate a
434  * bug, so we return DECOMP_FATALERROR for them in order to turn off
435  * compression, even though they are detected by inspecting the input.
436  */
437 static int z_decompress(void *arg, unsigned char *ibuf, int isize,
438                  unsigned char *obuf, int osize)
439 {
440         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
441         int olen, seq, r;
442         int decode_proto, overflow;
443         unsigned char overflow_buf[1];
444
445         if (isize <= PPP_HDRLEN + DEFLATE_OVHD) {
446                 if (state->debug)
447                         printk(KERN_DEBUG "z_decompress%d: short pkt (%d)\n",
448                                state->unit, isize);
449                 return DECOMP_ERROR;
450         }
451
452         /* Check the sequence number. */
453         seq = get_unaligned_be16(ibuf + PPP_HDRLEN);
454         if (seq != (state->seqno & 0xffff)) {
455                 if (state->debug)
456                         printk(KERN_DEBUG "z_decompress%d: bad seq # %d, expected %d\n",
457                                state->unit, seq, state->seqno & 0xffff);
458                 return DECOMP_ERROR;
459         }
460         ++state->seqno;
461
462         /*
463          * Fill in the first part of the PPP header.  The protocol field
464          * comes from the decompressed data.
465          */
466         obuf[0] = PPP_ADDRESS(ibuf);
467         obuf[1] = PPP_CONTROL(ibuf);
468         obuf[2] = 0;
469
470         /*
471          * Set up to call inflate.  We set avail_out to 1 initially so we can
472          * look at the first byte of the output and decide whether we have
473          * a 1-byte or 2-byte protocol field.
474          */
475         state->strm.next_in = ibuf + PPP_HDRLEN + DEFLATE_OVHD;
476         state->strm.avail_in = isize - (PPP_HDRLEN + DEFLATE_OVHD);
477         state->strm.next_out = obuf + 3;
478         state->strm.avail_out = 1;
479         decode_proto = 1;
480         overflow = 0;
481
482         /*
483          * Call inflate, supplying more input or output as needed.
484          */
485         for (;;) {
486                 r = zlib_inflate(&state->strm, Z_PACKET_FLUSH);
487                 if (r != Z_OK) {
488                         if (state->debug)
489                                 printk(KERN_DEBUG "z_decompress%d: inflate returned %d (%s)\n",
490                                        state->unit, r, (state->strm.msg? state->strm.msg: ""));
491                         return DECOMP_FATALERROR;
492                 }
493                 if (state->strm.avail_out != 0)
494                         break;          /* all done */
495                 if (decode_proto) {
496                         state->strm.avail_out = osize - PPP_HDRLEN;
497                         if ((obuf[3] & 1) == 0) {
498                                 /* 2-byte protocol field */
499                                 obuf[2] = obuf[3];
500                                 --state->strm.next_out;
501                                 ++state->strm.avail_out;
502                         }
503                         decode_proto = 0;
504                 } else if (!overflow) {
505                         /*
506                          * We've filled up the output buffer; the only way to
507                          * find out whether inflate has any more characters
508                          * left is to give it another byte of output space.
509                          */
510                         state->strm.next_out = overflow_buf;
511                         state->strm.avail_out = 1;
512                         overflow = 1;
513                 } else {
514                         if (state->debug)
515                                 printk(KERN_DEBUG "z_decompress%d: ran out of mru\n",
516                                        state->unit);
517                         return DECOMP_FATALERROR;
518                 }
519         }
520
521         if (decode_proto) {
522                 if (state->debug)
523                         printk(KERN_DEBUG "z_decompress%d: didn't get proto\n",
524                                state->unit);
525                 return DECOMP_ERROR;
526         }
527
528         olen = osize + overflow - state->strm.avail_out;
529         state->stats.unc_bytes += olen;
530         state->stats.unc_packets++;
531         state->stats.comp_bytes += isize;
532         state->stats.comp_packets++;
533
534         return olen;
535 }
536
537 /**
538  *      z_incomp - add incompressible input data to the history.
539  *      @arg:   pointer to private state for the decompressor
540  *      @ibuf:  pointer to input packet data
541  *      @icnt:  length of input data.
542  */
543 static void z_incomp(void *arg, unsigned char *ibuf, int icnt)
544 {
545         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
546         int proto, r;
547
548         /*
549          * Check that the protocol is one we handle.
550          */
551         proto = PPP_PROTOCOL(ibuf);
552         if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
553                 return;
554
555         ++state->seqno;
556
557         /*
558          * We start at the either the 1st or 2nd byte of the protocol field,
559          * depending on whether the protocol value is compressible.
560          */
561         state->strm.next_in = ibuf + 3;
562         state->strm.avail_in = icnt - 3;
563         if (proto > 0xff) {
564                 --state->strm.next_in;
565                 ++state->strm.avail_in;
566         }
567
568         r = zlib_inflateIncomp(&state->strm);
569         if (r != Z_OK) {
570                 /* gak! */
571                 if (state->debug) {
572                         printk(KERN_DEBUG "z_incomp%d: inflateIncomp returned %d (%s)\n",
573                                state->unit, r, (state->strm.msg? state->strm.msg: ""));
574                 }
575                 return;
576         }
577
578         /*
579          * Update stats.
580          */
581         state->stats.inc_bytes += icnt;
582         state->stats.inc_packets++;
583         state->stats.unc_bytes += icnt;
584         state->stats.unc_packets++;
585 }
586
587 /*************************************************************
588  * Module interface table
589  *************************************************************/
590
591 /* These are in ppp_generic.c */
592 extern int  ppp_register_compressor   (struct compressor *cp);
593 extern void ppp_unregister_compressor (struct compressor *cp);
594
595 /*
596  * Procedures exported to if_ppp.c.
597  */
598 static struct compressor ppp_deflate = {
599         .compress_proto =       CI_DEFLATE,
600         .comp_alloc =           z_comp_alloc,
601         .comp_free =            z_comp_free,
602         .comp_init =            z_comp_init,
603         .comp_reset =           z_comp_reset,
604         .compress =             z_compress,
605         .comp_stat =            z_comp_stats,
606         .decomp_alloc =         z_decomp_alloc,
607         .decomp_free =          z_decomp_free,
608         .decomp_init =          z_decomp_init,
609         .decomp_reset =         z_decomp_reset,
610         .decompress =           z_decompress,
611         .incomp =               z_incomp,
612         .decomp_stat =          z_comp_stats,
613         .owner =                THIS_MODULE
614 };
615
616 static struct compressor ppp_deflate_draft = {
617         .compress_proto =       CI_DEFLATE_DRAFT,
618         .comp_alloc =           z_comp_alloc,
619         .comp_free =            z_comp_free,
620         .comp_init =            z_comp_init,
621         .comp_reset =           z_comp_reset,
622         .compress =             z_compress,
623         .comp_stat =            z_comp_stats,
624         .decomp_alloc =         z_decomp_alloc,
625         .decomp_free =          z_decomp_free,
626         .decomp_init =          z_decomp_init,
627         .decomp_reset =         z_decomp_reset,
628         .decompress =           z_decompress,
629         .incomp =               z_incomp,
630         .decomp_stat =          z_comp_stats,
631         .owner =                THIS_MODULE
632 };
633
634 static int __init deflate_init(void)
635 {
636         int answer = ppp_register_compressor(&ppp_deflate);
637         if (answer == 0)
638                 printk(KERN_INFO
639                        "PPP Deflate Compression module registered\n");
640         ppp_register_compressor(&ppp_deflate_draft);
641         return answer;
642 }
643
644 static void __exit deflate_cleanup(void)
645 {
646         ppp_unregister_compressor(&ppp_deflate);
647         ppp_unregister_compressor(&ppp_deflate_draft);
648 }
649
650 module_init(deflate_init);
651 module_exit(deflate_cleanup);
652 MODULE_LICENSE("Dual BSD/GPL");
653 MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE));
654 MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE_DRAFT));