]>
Commit | Line | Data |
---|---|---|
45ec975e DR |
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/mm.h> | |
24 | #include <linux/lzo.h> | |
25 | #include <crypto/internal/scompress.h> | |
26 | ||
27 | struct lzorle_ctx { | |
28 | void *lzorle_comp_mem; | |
29 | }; | |
30 | ||
31 | static void *lzorle_alloc_ctx(struct crypto_scomp *tfm) | |
32 | { | |
33 | void *ctx; | |
34 | ||
35 | ctx = kvmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL); | |
36 | if (!ctx) | |
37 | return ERR_PTR(-ENOMEM); | |
38 | ||
39 | return ctx; | |
40 | } | |
41 | ||
42 | static int lzorle_init(struct crypto_tfm *tfm) | |
43 | { | |
44 | struct lzorle_ctx *ctx = crypto_tfm_ctx(tfm); | |
45 | ||
46 | ctx->lzorle_comp_mem = lzorle_alloc_ctx(NULL); | |
47 | if (IS_ERR(ctx->lzorle_comp_mem)) | |
48 | return -ENOMEM; | |
49 | ||
50 | return 0; | |
51 | } | |
52 | ||
53 | static void lzorle_free_ctx(struct crypto_scomp *tfm, void *ctx) | |
54 | { | |
55 | kvfree(ctx); | |
56 | } | |
57 | ||
58 | static void lzorle_exit(struct crypto_tfm *tfm) | |
59 | { | |
60 | struct lzorle_ctx *ctx = crypto_tfm_ctx(tfm); | |
61 | ||
62 | lzorle_free_ctx(NULL, ctx->lzorle_comp_mem); | |
63 | } | |
64 | ||
65 | static int __lzorle_compress(const u8 *src, unsigned int slen, | |
66 | u8 *dst, unsigned int *dlen, void *ctx) | |
67 | { | |
68 | size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */ | |
69 | int err; | |
70 | ||
71 | err = lzorle1x_1_compress(src, slen, dst, &tmp_len, ctx); | |
72 | ||
73 | if (err != LZO_E_OK) | |
74 | return -EINVAL; | |
75 | ||
76 | *dlen = tmp_len; | |
77 | return 0; | |
78 | } | |
79 | ||
80 | static int lzorle_compress(struct crypto_tfm *tfm, const u8 *src, | |
81 | unsigned int slen, u8 *dst, unsigned int *dlen) | |
82 | { | |
83 | struct lzorle_ctx *ctx = crypto_tfm_ctx(tfm); | |
84 | ||
85 | return __lzorle_compress(src, slen, dst, dlen, ctx->lzorle_comp_mem); | |
86 | } | |
87 | ||
88 | static int lzorle_scompress(struct crypto_scomp *tfm, const u8 *src, | |
89 | unsigned int slen, u8 *dst, unsigned int *dlen, | |
90 | void *ctx) | |
91 | { | |
92 | return __lzorle_compress(src, slen, dst, dlen, ctx); | |
93 | } | |
94 | ||
95 | static int __lzorle_decompress(const u8 *src, unsigned int slen, | |
96 | u8 *dst, unsigned int *dlen) | |
97 | { | |
98 | int err; | |
99 | size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */ | |
100 | ||
101 | err = lzo1x_decompress_safe(src, slen, dst, &tmp_len); | |
102 | ||
103 | if (err != LZO_E_OK) | |
104 | return -EINVAL; | |
105 | ||
106 | *dlen = tmp_len; | |
107 | return 0; | |
108 | } | |
109 | ||
110 | static int lzorle_decompress(struct crypto_tfm *tfm, const u8 *src, | |
111 | unsigned int slen, u8 *dst, unsigned int *dlen) | |
112 | { | |
113 | return __lzorle_decompress(src, slen, dst, dlen); | |
114 | } | |
115 | ||
116 | static int lzorle_sdecompress(struct crypto_scomp *tfm, const u8 *src, | |
117 | unsigned int slen, u8 *dst, unsigned int *dlen, | |
118 | void *ctx) | |
119 | { | |
120 | return __lzorle_decompress(src, slen, dst, dlen); | |
121 | } | |
122 | ||
123 | static struct crypto_alg alg = { | |
124 | .cra_name = "lzo-rle", | |
125 | .cra_flags = CRYPTO_ALG_TYPE_COMPRESS, | |
126 | .cra_ctxsize = sizeof(struct lzorle_ctx), | |
127 | .cra_module = THIS_MODULE, | |
128 | .cra_init = lzorle_init, | |
129 | .cra_exit = lzorle_exit, | |
130 | .cra_u = { .compress = { | |
131 | .coa_compress = lzorle_compress, | |
132 | .coa_decompress = lzorle_decompress } } | |
133 | }; | |
134 | ||
135 | static struct scomp_alg scomp = { | |
136 | .alloc_ctx = lzorle_alloc_ctx, | |
137 | .free_ctx = lzorle_free_ctx, | |
138 | .compress = lzorle_scompress, | |
139 | .decompress = lzorle_sdecompress, | |
140 | .base = { | |
141 | .cra_name = "lzo-rle", | |
142 | .cra_driver_name = "lzo-rle-scomp", | |
143 | .cra_module = THIS_MODULE, | |
144 | } | |
145 | }; | |
146 | ||
147 | static int __init lzorle_mod_init(void) | |
148 | { | |
149 | int ret; | |
150 | ||
151 | ret = crypto_register_alg(&alg); | |
152 | if (ret) | |
153 | return ret; | |
154 | ||
155 | ret = crypto_register_scomp(&scomp); | |
156 | if (ret) { | |
157 | crypto_unregister_alg(&alg); | |
158 | return ret; | |
159 | } | |
160 | ||
161 | return ret; | |
162 | } | |
163 | ||
164 | static void __exit lzorle_mod_fini(void) | |
165 | { | |
166 | crypto_unregister_alg(&alg); | |
167 | crypto_unregister_scomp(&scomp); | |
168 | } | |
169 | ||
170 | module_init(lzorle_mod_init); | |
171 | module_exit(lzorle_mod_fini); | |
172 | ||
173 | MODULE_LICENSE("GPL"); | |
174 | MODULE_DESCRIPTION("LZO-RLE Compression Algorithm"); | |
175 | MODULE_ALIAS_CRYPTO("lzo-rle"); |