]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/ppp_deflate.c
Pull pstorev4 into release branch
[mirror_ubuntu-bionic-kernel.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));