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