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, int format)
  47 {
  48         int ret = 0;
  49         struct z_stream_s *stream = &ctx->comp_stream;
  50
  51         stream->workspace = vzalloc(zlib_deflate_workspacesize(
  52                                     MAX_WBITS, MAX_MEM_LEVEL));
  53         if (!stream->workspace) {
  54                 ret = -ENOMEM;
  55                 goto out;
  56         }
  57         if (format)
  58                 ret = zlib_deflateInit(stream, 3);
  59         else
  60                 ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
  61                                         -DEFLATE_DEF_WINBITS,
  62                                         DEFLATE_DEF_MEMLEVEL,
  63                                         Z_DEFAULT_STRATEGY);
  64         if (ret != Z_OK) {
  65                 ret = -EINVAL;
  66                 goto out_free;
  67         }
  68 out:
  69         return ret;
  70 out_free:
  71         vfree(stream->workspace);
  72         goto out;
  73 }
  74
  75 static int deflate_decomp_init(struct deflate_ctx *ctx, int format)
  76 {
  77         int ret = 0;
  78         struct z_stream_s *stream = &ctx->decomp_stream;
  79
  80         stream->workspace = vzalloc(zlib_inflate_workspacesize());
  81         if (!stream->workspace) {
  82                 ret = -ENOMEM;
  83                 goto out;
  84         }
  85         if (format)
  86                 ret = zlib_inflateInit(stream);
  87         else
  88                 ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);
  89         if (ret != Z_OK) {
  90                 ret = -EINVAL;
  91                 goto out_free;
  92         }
  93 out:
  94         return ret;
  95 out_free:
  96         vfree(stream->workspace);
  97         goto out;
  98 }
  99
 100 static void deflate_comp_exit(struct deflate_ctx *ctx)
 101 {
 102         zlib_deflateEnd(&ctx->comp_stream);
 103         vfree(ctx->comp_stream.workspace);
 104 }
 105
 106 static void deflate_decomp_exit(struct deflate_ctx *ctx)
 107 {
 108         zlib_inflateEnd(&ctx->decomp_stream);
 109         vfree(ctx->decomp_stream.workspace);
 110 }
 111
 112 static int __deflate_init(void *ctx, int format)
 113 {
 114         int ret;
 115
 116         ret = deflate_comp_init(ctx, format);
 117         if (ret)
 118                 goto out;
 119         ret = deflate_decomp_init(ctx, format);
 120         if (ret)
 121                 deflate_comp_exit(ctx);
 122 out:
 123         return ret;
 124 }
 125
 126 static void *gen_deflate_alloc_ctx(struct crypto_scomp *tfm, int format)
 127 {
 128         struct deflate_ctx *ctx;
 129         int ret;
 130
 131         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 132         if (!ctx)
 133                 return ERR_PTR(-ENOMEM);
 134
 135         ret = __deflate_init(ctx, format);
 136         if (ret) {
 137                 kfree(ctx);
 138                 return ERR_PTR(ret);
 139         }
 140
 141         return ctx;
 142 }
 143
 144 static void *deflate_alloc_ctx(struct crypto_scomp *tfm)
 145 {
 146         return gen_deflate_alloc_ctx(tfm, 0);
 147 }
 148
 149 static void *zlib_deflate_alloc_ctx(struct crypto_scomp *tfm)
 150 {
 151         return gen_deflate_alloc_ctx(tfm, 1);
 152 }
 153
 154 static int deflate_init(struct crypto_tfm *tfm)
 155 {
 156         struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
 157
 158         return __deflate_init(ctx, 0);
 159 }
 160
 161 static void __deflate_exit(void *ctx)
 162 {
 163         deflate_comp_exit(ctx);
 164         deflate_decomp_exit(ctx);
 165 }
 166
 167 static void deflate_free_ctx(struct crypto_scomp *tfm, void *ctx)
 168 {
 169         __deflate_exit(ctx);
 170         kzfree(ctx);
 171 }
 172
 173 static void deflate_exit(struct crypto_tfm *tfm)
 174 {
 175         struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
 176
 177         __deflate_exit(ctx);
 178 }
 179
 180 static int __deflate_compress(const u8 *src, unsigned int slen,
 181                               u8 *dst, unsigned int *dlen, void *ctx)
 182 {
 183         int ret = 0;
 184         struct deflate_ctx *dctx = ctx;
 185         struct z_stream_s *stream = &dctx->comp_stream;
 186
 187         ret = zlib_deflateReset(stream);
 188         if (ret != Z_OK) {
 189                 ret = -EINVAL;
 190                 goto out;
 191         }
 192
 193         stream->next_in = (u8 *)src;
 194         stream->avail_in = slen;
 195         stream->next_out = (u8 *)dst;
 196         stream->avail_out = *dlen;
 197
 198         ret = zlib_deflate(stream, Z_FINISH);
 199         if (ret != Z_STREAM_END) {
 200                 ret = -EINVAL;
 201                 goto out;
 202         }
 203         ret = 0;
 204         *dlen = stream->total_out;
 205 out:
 206         return ret;
 207 }
 208
 209 static int deflate_compress(struct crypto_tfm *tfm, const u8 *src,
 210                             unsigned int slen, u8 *dst, unsigned int *dlen)
 211 {
 212         struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
 213
 214         return __deflate_compress(src, slen, dst, dlen, dctx);
 215 }
 216
 217 static int deflate_scompress(struct crypto_scomp *tfm, const u8 *src,
 218                              unsigned int slen, u8 *dst, unsigned int *dlen,
 219                              void *ctx)
 220 {
 221         return __deflate_compress(src, slen, dst, dlen, ctx);
 222 }
 223
 224 static int __deflate_decompress(const u8 *src, unsigned int slen,
 225                                 u8 *dst, unsigned int *dlen, void *ctx)
 226 {
 227
 228         int ret = 0;
 229         struct deflate_ctx *dctx = ctx;
 230         struct z_stream_s *stream = &dctx->decomp_stream;
 231
 232         ret = zlib_inflateReset(stream);
 233         if (ret != Z_OK) {
 234                 ret = -EINVAL;
 235                 goto out;
 236         }
 237
 238         stream->next_in = (u8 *)src;
 239         stream->avail_in = slen;
 240         stream->next_out = (u8 *)dst;
 241         stream->avail_out = *dlen;
 242
 243         ret = zlib_inflate(stream, Z_SYNC_FLUSH);
 244         /*
 245          * Work around a bug in zlib, which sometimes wants to taste an extra
 246          * byte when being used in the (undocumented) raw deflate mode.
 247          * (From USAGI).
 248          */
 249         if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
 250                 u8 zerostuff = 0;
 251                 stream->next_in = &zerostuff;
 252                 stream->avail_in = 1;
 253                 ret = zlib_inflate(stream, Z_FINISH);
 254         }
 255         if (ret != Z_STREAM_END) {
 256                 ret = -EINVAL;
 257                 goto out;
 258         }
 259         ret = 0;
 260         *dlen = stream->total_out;
 261 out:
 262         return ret;
 263 }
 264
 265 static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src,
 266                               unsigned int slen, u8 *dst, unsigned int *dlen)
 267 {
 268         struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
 269
 270         return __deflate_decompress(src, slen, dst, dlen, dctx);
 271 }
 272
 273 static int deflate_sdecompress(struct crypto_scomp *tfm, const u8 *src,
 274                                unsigned int slen, u8 *dst, unsigned int *dlen,
 275                                void *ctx)
 276 {
 277         return __deflate_decompress(src, slen, dst, dlen, ctx);
 278 }
 279
 280 static struct crypto_alg alg = {
 281         .cra_name               = "deflate",
 282         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
 283         .cra_ctxsize            = sizeof(struct deflate_ctx),
 284         .cra_module             = THIS_MODULE,
 285         .cra_init               = deflate_init,
 286         .cra_exit               = deflate_exit,
 287         .cra_u                  = { .compress = {
 288         .coa_compress           = deflate_compress,
 289         .coa_decompress         = deflate_decompress } }
 290 };
 291
 292 static struct scomp_alg scomp[] = { {
 293         .alloc_ctx              = deflate_alloc_ctx,
 294         .free_ctx               = deflate_free_ctx,
 295         .compress               = deflate_scompress,
 296         .decompress             = deflate_sdecompress,
 297         .base                   = {
 298                 .cra_name       = "deflate",
 299                 .cra_driver_name = "deflate-scomp",
 300                 .cra_module      = THIS_MODULE,
 301         }
 302 }, {
 303         .alloc_ctx              = zlib_deflate_alloc_ctx,
 304         .free_ctx               = deflate_free_ctx,
 305         .compress               = deflate_scompress,
 306         .decompress             = deflate_sdecompress,
 307         .base                   = {
 308                 .cra_name       = "zlib-deflate",
 309                 .cra_driver_name = "zlib-deflate-scomp",
 310                 .cra_module      = THIS_MODULE,
 311         }
 312 } };
 313
 314 static int __init deflate_mod_init(void)
 315 {
 316         int ret;
 317
 318         ret = crypto_register_alg(&alg);
 319         if (ret)
 320                 return ret;
 321
 322         ret = crypto_register_scomps(scomp, ARRAY_SIZE(scomp));
 323         if (ret) {
 324                 crypto_unregister_alg(&alg);
 325                 return ret;
 326         }
 327
 328         return ret;
 329 }
 330
 331 static void __exit deflate_mod_fini(void)
 332 {
 333         crypto_unregister_alg(&alg);
 334         crypto_unregister_scomps(scomp, ARRAY_SIZE(scomp));
 335 }
 336
 337 module_init(deflate_mod_init);
 338 module_exit(deflate_mod_fini);
 339
 340 MODULE_LICENSE("GPL");
 341 MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
 342 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
 343 MODULE_ALIAS_CRYPTO("deflate");