crypto/lzo.c

   1 /*
   2  * Cryptographic API.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 as published by
   6  * the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  16  *
  17  */
  18
  19 #include <linux/init.h>
  20 #include <linux/module.h>
  21 #include <linux/crypto.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/lzo.h>
  24
  25 struct lzo_ctx {
  26         void *lzo_comp_mem;
  27 };
  28
  29 static int lzo_init(struct crypto_tfm *tfm)
  30 {
  31         struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
  32
  33         ctx->lzo_comp_mem = vmalloc(LZO1X_MEM_COMPRESS);
  34         if (!ctx->lzo_comp_mem)
  35                 return -ENOMEM;
  36
  37         return 0;
  38 }
  39
  40 static void lzo_exit(struct crypto_tfm *tfm)
  41 {
  42         struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
  43
  44         vfree(ctx->lzo_comp_mem);
  45 }
  46
  47 static int lzo_compress(struct crypto_tfm *tfm, const u8 *src,
  48                             unsigned int slen, u8 *dst, unsigned int *dlen)
  49 {
  50         struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
  51         size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */
  52         int err;
  53
  54         err = lzo1x_1_compress(src, slen, dst, &tmp_len, ctx->lzo_comp_mem);
  55
  56         if (err != LZO_E_OK)
  57                 return -EINVAL;
  58
  59         *dlen = tmp_len;
  60         return 0;
  61 }
  62
  63 static int lzo_decompress(struct crypto_tfm *tfm, const u8 *src,
  64                               unsigned int slen, u8 *dst, unsigned int *dlen)
  65 {
  66         int err;
  67         size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */
  68
  69         err = lzo1x_decompress_safe(src, slen, dst, &tmp_len);
  70
  71         if (err != LZO_E_OK)
  72                 return -EINVAL;
  73
  74         *dlen = tmp_len;
  75         return 0;
  76
  77 }
  78
  79 static struct crypto_alg alg = {
  80         .cra_name               = "lzo",
  81         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
  82         .cra_ctxsize            = sizeof(struct lzo_ctx),
  83         .cra_module             = THIS_MODULE,
  84         .cra_list               = LIST_HEAD_INIT(alg.cra_list),
  85         .cra_init               = lzo_init,
  86         .cra_exit               = lzo_exit,
  87         .cra_u                  = { .compress = {
  88         .coa_compress           = lzo_compress,
  89         .coa_decompress         = lzo_decompress } }
  90 };
  91
  92 static int __init lzo_mod_init(void)
  93 {
  94         return crypto_register_alg(&alg);
  95 }
  96
  97 static void __exit lzo_mod_fini(void)
  98 {
  99         crypto_unregister_alg(&alg);
 100 }
 101
 102 module_init(lzo_mod_init);
 103 module_exit(lzo_mod_fini);
 104
 105 MODULE_LICENSE("GPL");
 106 MODULE_DESCRIPTION("LZO Compression Algorithm");