Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/crypto/deflate.c

  1 /*
  2  * Cryptographic API.
  3  *
  4  * Deflate algorithm (RFC 1951), implemented here primarily for use
  5  * by IPCOMP (RFC 3173 & RFC 2394).
  6  *
  7  * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
  8  *
  9  * This program is free software; you can redistribute it and/or modify it
 10  * under the terms of the GNU General Public License as published by the Free
 11  * Software Foundation; either version 2 of the License, or (at your option)
 12  * any later version.
 13  *
 14  * FIXME: deflate transforms will require up to a total of about 436k of kernel
 15  * memory on i386 (390k for compression, the rest for decompression), as the
 16  * current zlib kernel code uses a worst case pre-allocation system by default.
 17  * This needs to be fixed so that the amount of memory required is properly
 18  * related to the  winbits and memlevel parameters.
 19  *
 20  * The default winbits of 11 should suit most packets, and it may be something
 21  * to configure on a per-tfm basis in the future.
 22  *
 23  * Currently, compression history is not maintained between tfm calls, as
 24  * it is not needed for IPCOMP and keeps the code simpler.  It can be
 25  * implemented if someone wants it.
 26  */
 27 #include <linux/init.h>
 28 #include <linux/module.h>
 29 #include <linux/crypto.h>
 30 #include <linux/zlib.h>
 31 #include <linux/vmalloc.h>
 32 #include <linux/interrupt.h>
 33 #include <linux/mm.h>
 34 #include <linux/net.h>
 35 #include <crypto/internal/scompress.h>
 36 
 37 #define DEFLATE_DEF_LEVEL               Z_DEFAULT_COMPRESSION
 38 #define DEFLATE_DEF_WINBITS             11
 39 #define DEFLATE_DEF_MEMLEVEL            MAX_MEM_LEVEL
 40 
 41 struct deflate_ctx {
 42         struct z_stream_s comp_stream;
 43         struct z_stream_s decomp_stream;
 44 };
 45 
 46 static int deflate_comp_init(struct deflate_ctx *ctx)
 47 {
 48         int ret = 0;
 49         struct z_stream_s *stream = &ctx->comp_stream;
 50 
 51         stream->workspace = vzalloc(zlib_deflate_workspacesize(
 52                                 -DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL));
 53         if (!stream->workspace) {
 54                 ret = -ENOMEM;
 55                 goto out;
 56         }
 57         ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
 58                                 -DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL,
 59                                 Z_DEFAULT_STRATEGY);
 60         if (ret != Z_OK) {
 61                 ret = -EINVAL;
 62                 goto out_free;
 63         }
 64 out:
 65         return ret;
 66 out_free:
 67         vfree(stream->workspace);
 68         goto out;
 69 }
 70 
 71 static int deflate_decomp_init(struct deflate_ctx *ctx)
 72 {
 73         int ret = 0;
 74         struct z_stream_s *stream = &ctx->decomp_stream;
 75 
 76         stream->workspace = vzalloc(zlib_inflate_workspacesize());
 77         if (!stream->workspace) {
 78                 ret = -ENOMEM;
 79                 goto out;
 80         }
 81         ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);
 82         if (ret != Z_OK) {
 83                 ret = -EINVAL;
 84                 goto out_free;
 85         }
 86 out:
 87         return ret;
 88 out_free:
 89         vfree(stream->workspace);
 90         goto out;
 91 }
 92 
 93 static void deflate_comp_exit(struct deflate_ctx *ctx)
 94 {
 95         zlib_deflateEnd(&ctx->comp_stream);
 96         vfree(ctx->comp_stream.workspace);
 97 }
 98 
 99 static void deflate_decomp_exit(struct deflate_ctx *ctx)
100 {
101         zlib_inflateEnd(&ctx->decomp_stream);
102         vfree(ctx->decomp_stream.workspace);
103 }
104 
105 static int __deflate_init(void *ctx)
106 {
107         int ret;
108 
109         ret = deflate_comp_init(ctx);
110         if (ret)
111                 goto out;
112         ret = deflate_decomp_init(ctx);
113         if (ret)
114                 deflate_comp_exit(ctx);
115 out:
116         return ret;
117 }
118 
119 static void *deflate_alloc_ctx(struct crypto_scomp *tfm)
120 {
121         struct deflate_ctx *ctx;
122         int ret;
123 
124         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
125         if (!ctx)
126                 return ERR_PTR(-ENOMEM);
127 
128         ret = __deflate_init(ctx);
129         if (ret) {
130                 kfree(ctx);
131                 return ERR_PTR(ret);
132         }
133 
134         return ctx;
135 }
136 
137 static int deflate_init(struct crypto_tfm *tfm)
138 {
139         struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
140 
141         return __deflate_init(ctx);
142 }
143 
144 static void __deflate_exit(void *ctx)
145 {
146         deflate_comp_exit(ctx);
147         deflate_decomp_exit(ctx);
148 }
149 
150 static void deflate_free_ctx(struct crypto_scomp *tfm, void *ctx)
151 {
152         __deflate_exit(ctx);
153         kzfree(ctx);
154 }
155 
156 static void deflate_exit(struct crypto_tfm *tfm)
157 {
158         struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
159 
160         __deflate_exit(ctx);
161 }
162 
163 static int __deflate_compress(const u8 *src, unsigned int slen,
164                               u8 *dst, unsigned int *dlen, void *ctx)
165 {
166         int ret = 0;
167         struct deflate_ctx *dctx = ctx;
168         struct z_stream_s *stream = &dctx->comp_stream;
169 
170         ret = zlib_deflateReset(stream);
171         if (ret != Z_OK) {
172                 ret = -EINVAL;
173                 goto out;
174         }
175 
176         stream->next_in = (u8 *)src;
177         stream->avail_in = slen;
178         stream->next_out = (u8 *)dst;
179         stream->avail_out = *dlen;
180 
181         ret = zlib_deflate(stream, Z_FINISH);
182         if (ret != Z_STREAM_END) {
183                 ret = -EINVAL;
184                 goto out;
185         }
186         ret = 0;
187         *dlen = stream->total_out;
188 out:
189         return ret;
190 }
191 
192 static int deflate_compress(struct crypto_tfm *tfm, const u8 *src,
193                             unsigned int slen, u8 *dst, unsigned int *dlen)
194 {
195         struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
196 
197         return __deflate_compress(src, slen, dst, dlen, dctx);
198 }
199 
200 static int deflate_scompress(struct crypto_scomp *tfm, const u8 *src,
201                              unsigned int slen, u8 *dst, unsigned int *dlen,
202                              void *ctx)
203 {
204         return __deflate_compress(src, slen, dst, dlen, ctx);
205 }
206 
207 static int __deflate_decompress(const u8 *src, unsigned int slen,
208                                 u8 *dst, unsigned int *dlen, void *ctx)
209 {
210 
211         int ret = 0;
212         struct deflate_ctx *dctx = ctx;
213         struct z_stream_s *stream = &dctx->decomp_stream;
214 
215         ret = zlib_inflateReset(stream);
216         if (ret != Z_OK) {
217                 ret = -EINVAL;
218                 goto out;
219         }
220 
221         stream->next_in = (u8 *)src;
222         stream->avail_in = slen;
223         stream->next_out = (u8 *)dst;
224         stream->avail_out = *dlen;
225 
226         ret = zlib_inflate(stream, Z_SYNC_FLUSH);
227         /*
228          * Work around a bug in zlib, which sometimes wants to taste an extra
229          * byte when being used in the (undocumented) raw deflate mode.
230          * (From USAGI).
231          */
232         if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
233                 u8 zerostuff = 0;
234                 stream->next_in = &zerostuff;
235                 stream->avail_in = 1;
236                 ret = zlib_inflate(stream, Z_FINISH);
237         }
238         if (ret != Z_STREAM_END) {
239                 ret = -EINVAL;
240                 goto out;
241         }
242         ret = 0;
243         *dlen = stream->total_out;
244 out:
245         return ret;
246 }
247 
248 static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src,
249                               unsigned int slen, u8 *dst, unsigned int *dlen)
250 {
251         struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
252 
253         return __deflate_decompress(src, slen, dst, dlen, dctx);
254 }
255 
256 static int deflate_sdecompress(struct crypto_scomp *tfm, const u8 *src,
257                                unsigned int slen, u8 *dst, unsigned int *dlen,
258                                void *ctx)
259 {
260         return __deflate_decompress(src, slen, dst, dlen, ctx);
261 }
262 
263 static struct crypto_alg alg = {
264         .cra_name               = "deflate",
265         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
266         .cra_ctxsize            = sizeof(struct deflate_ctx),
267         .cra_module             = THIS_MODULE,
268         .cra_init               = deflate_init,
269         .cra_exit               = deflate_exit,
270         .cra_u                  = { .compress = {
271         .coa_compress           = deflate_compress,
272         .coa_decompress         = deflate_decompress } }
273 };
274 
275 static struct scomp_alg scomp = {
276         .alloc_ctx              = deflate_alloc_ctx,
277         .free_ctx               = deflate_free_ctx,
278         .compress               = deflate_scompress,
279         .decompress             = deflate_sdecompress,
280         .base                   = {
281                 .cra_name       = "deflate",
282                 .cra_driver_name = "deflate-scomp",
283                 .cra_module      = THIS_MODULE,
284         }
285 };
286 
287 static int __init deflate_mod_init(void)
288 {
289         int ret;
290 
291         ret = crypto_register_alg(&alg);
292         if (ret)
293                 return ret;
294 
295         ret = crypto_register_scomp(&scomp);
296         if (ret) {
297                 crypto_unregister_alg(&alg);
298                 return ret;
299         }
300 
301         return ret;
302 }
303 
304 static void __exit deflate_mod_fini(void)
305 {
306         crypto_unregister_alg(&alg);
307         crypto_unregister_scomp(&scomp);
308 }
309 
310 module_init(deflate_mod_init);
311 module_exit(deflate_mod_fini);
312 
313 MODULE_LICENSE("GPL");
314 MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
315 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
316 MODULE_ALIAS_CRYPTO("deflate");
317 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us