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 <linux/slab.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 = vmalloc(zlib_deflate_workspacesize());
  52         if (!stream->workspace) {
  53                 ret = -ENOMEM;
  54                 goto out;
  55         }
  56         memset(stream->workspace, 0, zlib_deflate_workspacesize());
  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 = kzalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
  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         kfree(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         kfree(ctx->decomp_stream.workspace);
 103 }
 104
 105 static int deflate_init(struct crypto_tfm *tfm)
 106 {
 107         struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
 108         int ret;
 109
 110         ret = deflate_comp_init(ctx);
 111         if (ret)
 112                 goto out;
 113         ret = deflate_decomp_init(ctx);
 114         if (ret)
 115                 deflate_comp_exit(ctx);
 116 out:
 117         return ret;
 118 }
 119
 120 static void deflate_exit(struct crypto_tfm *tfm)
 121 {
 122         struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
 123
 124         deflate_comp_exit(ctx);
 125         deflate_decomp_exit(ctx);
 126 }
 127
 128 static int deflate_compress(struct crypto_tfm *tfm, const u8 *src,
 129                             unsigned int slen, u8 *dst, unsigned int *dlen)
 130 {
 131         int ret = 0;
 132         struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
 133         struct z_stream_s *stream = &dctx->comp_stream;
 134
 135         ret = zlib_deflateReset(stream);
 136         if (ret != Z_OK) {
 137                 ret = -EINVAL;
 138                 goto out;
 139         }
 140
 141         stream->next_in = (u8 *)src;
 142         stream->avail_in = slen;
 143         stream->next_out = (u8 *)dst;
 144         stream->avail_out = *dlen;
 145
 146         ret = zlib_deflate(stream, Z_FINISH);
 147         if (ret != Z_STREAM_END) {
 148                 ret = -EINVAL;
 149                 goto out;
 150         }
 151         ret = 0;
 152         *dlen = stream->total_out;
 153 out:
 154         return ret;
 155 }
 156
 157 static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src,
 158                               unsigned int slen, u8 *dst, unsigned int *dlen)
 159 {
 160
 161         int ret = 0;
 162         struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
 163         struct z_stream_s *stream = &dctx->decomp_stream;
 164
 165         ret = zlib_inflateReset(stream);
 166         if (ret != Z_OK) {
 167                 ret = -EINVAL;
 168                 goto out;
 169         }
 170
 171         stream->next_in = (u8 *)src;
 172         stream->avail_in = slen;
 173         stream->next_out = (u8 *)dst;
 174         stream->avail_out = *dlen;
 175
 176         ret = zlib_inflate(stream, Z_SYNC_FLUSH);
 177         /*
 178          * Work around a bug in zlib, which sometimes wants to taste an extra
 179          * byte when being used in the (undocumented) raw deflate mode.
 180          * (From USAGI).
 181          */
 182         if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
 183                 u8 zerostuff = 0;
 184                 stream->next_in = &zerostuff;
 185                 stream->avail_in = 1;
 186                 ret = zlib_inflate(stream, Z_FINISH);
 187         }
 188         if (ret != Z_STREAM_END) {
 189                 ret = -EINVAL;
 190                 goto out;
 191         }
 192         ret = 0;
 193         *dlen = stream->total_out;
 194 out:
 195         return ret;
 196 }
 197
 198 static struct crypto_alg alg = {
 199         .cra_name               = "deflate",
 200         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
 201         .cra_ctxsize            = sizeof(struct deflate_ctx),
 202         .cra_module             = THIS_MODULE,
 203         .cra_list               = LIST_HEAD_INIT(alg.cra_list),
 204         .cra_init               = deflate_init,
 205         .cra_exit               = deflate_exit,
 206         .cra_u                  = { .compress = {
 207         .coa_compress           = deflate_compress,
 208         .coa_decompress         = deflate_decompress } }
 209 };
 210
 211 static int __init deflate_mod_init(void)
 212 {
 213         return crypto_register_alg(&alg);
 214 }
 215
 216 static void __exit deflate_mod_fini(void)
 217 {
 218         crypto_unregister_alg(&alg);
 219 }
 220
 221 module_init(deflate_mod_init);
 222 module_exit(deflate_mod_fini);
 223
 224 MODULE_LICENSE("GPL");
 225 MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
 226 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
 227