deflate.c 5.41 KB
Newer Older
1
/*
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7
 * Cryptographic API.
 *
 * Deflate algorithm (RFC 1951), implemented here primarily for use
 * by IPCOMP (RFC 3173 & RFC 2394).
 *
 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
8
 *
Linus Torvalds's avatar
Linus Torvalds committed
9 10
 * This program is free software; you can redistribute it and/or modify it
 * 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)
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
 * any later version.
 *
 * FIXME: deflate transforms will require up to a total of about 436k of kernel
 * memory on i386 (390k for compression, the rest for decompression), as the
 * current zlib kernel code uses a worst case pre-allocation system by default.
 * This needs to be fixed so that the amount of memory required is properly
 * related to the  winbits and memlevel parameters.
 *
 * The default winbits of 11 should suit most packets, and it may be something
 * to configure on a per-tfm basis in the future.
 *
 * Currently, compression history is not maintained between tfm calls, as
 * it is not needed for IPCOMP and keeps the code simpler.  It can be
 * implemented if someone wants it.
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/crypto.h>
#include <linux/zlib.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/net.h>

#define DEFLATE_DEF_LEVEL		Z_DEFAULT_COMPRESSION
#define DEFLATE_DEF_WINBITS		11
#define DEFLATE_DEF_MEMLEVEL		MAX_MEM_LEVEL

struct deflate_ctx {
	struct z_stream_s comp_stream;
	struct z_stream_s decomp_stream;
};

static int deflate_comp_init(struct deflate_ctx *ctx)
{
	int ret = 0;
	struct z_stream_s *stream = &ctx->comp_stream;

50 51
	stream->workspace = vzalloc(zlib_deflate_workspacesize(
				-DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL));
52
	if (!stream->workspace) {
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55 56 57 58 59 60 61 62
		ret = -ENOMEM;
		goto out;
	}
	ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
	                        -DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL,
	                        Z_DEFAULT_STRATEGY);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out_free;
	}
63
out:
Linus Torvalds's avatar
Linus Torvalds committed
64 65 66 67 68 69 70 71 72 73 74
	return ret;
out_free:
	vfree(stream->workspace);
	goto out;
}

static int deflate_decomp_init(struct deflate_ctx *ctx)
{
	int ret = 0;
	struct z_stream_s *stream = &ctx->decomp_stream;

75
	stream->workspace = vzalloc(zlib_inflate_workspacesize());
76
	if (!stream->workspace) {
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80 81 82 83 84 85 86 87
		ret = -ENOMEM;
		goto out;
	}
	ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out_free;
	}
out:
	return ret;
out_free:
88
	vfree(stream->workspace);
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92 93
	goto out;
}

static void deflate_comp_exit(struct deflate_ctx *ctx)
{
94
	zlib_deflateEnd(&ctx->comp_stream);
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99
	vfree(ctx->comp_stream.workspace);
}

static void deflate_decomp_exit(struct deflate_ctx *ctx)
{
100
	zlib_inflateEnd(&ctx->decomp_stream);
101
	vfree(ctx->decomp_stream.workspace);
Linus Torvalds's avatar
Linus Torvalds committed
102 103
}

104
static int deflate_init(struct crypto_tfm *tfm)
Linus Torvalds's avatar
Linus Torvalds committed
105
{
106
	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);
Linus Torvalds's avatar
Linus Torvalds committed
107
	int ret;
108

Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113 114 115 116 117 118
	ret = deflate_comp_init(ctx);
	if (ret)
		goto out;
	ret = deflate_decomp_init(ctx);
	if (ret)
		deflate_comp_exit(ctx);
out:
	return ret;
}

119
static void deflate_exit(struct crypto_tfm *tfm)
Linus Torvalds's avatar
Linus Torvalds committed
120
{
121 122
	struct deflate_ctx *ctx = crypto_tfm_ctx(tfm);

Linus Torvalds's avatar
Linus Torvalds committed
123 124 125 126
	deflate_comp_exit(ctx);
	deflate_decomp_exit(ctx);
}

127 128
static int deflate_compress(struct crypto_tfm *tfm, const u8 *src,
			    unsigned int slen, u8 *dst, unsigned int *dlen)
Linus Torvalds's avatar
Linus Torvalds committed
129 130
{
	int ret = 0;
131
	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
Linus Torvalds's avatar
Linus Torvalds committed
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
	struct z_stream_s *stream = &dctx->comp_stream;

	ret = zlib_deflateReset(stream);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out;
	}

	stream->next_in = (u8 *)src;
	stream->avail_in = slen;
	stream->next_out = (u8 *)dst;
	stream->avail_out = *dlen;

	ret = zlib_deflate(stream, Z_FINISH);
	if (ret != Z_STREAM_END) {
		ret = -EINVAL;
		goto out;
	}
	ret = 0;
	*dlen = stream->total_out;
out:
	return ret;
}
155

156 157
static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src,
			      unsigned int slen, u8 *dst, unsigned int *dlen)
Linus Torvalds's avatar
Linus Torvalds committed
158
{
159

Linus Torvalds's avatar
Linus Torvalds committed
160
	int ret = 0;
161
	struct deflate_ctx *dctx = crypto_tfm_ctx(tfm);
Linus Torvalds's avatar
Linus Torvalds committed
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
	struct z_stream_s *stream = &dctx->decomp_stream;

	ret = zlib_inflateReset(stream);
	if (ret != Z_OK) {
		ret = -EINVAL;
		goto out;
	}

	stream->next_in = (u8 *)src;
	stream->avail_in = slen;
	stream->next_out = (u8 *)dst;
	stream->avail_out = *dlen;

	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	/*
	 * Work around a bug in zlib, which sometimes wants to taste an extra
	 * byte when being used in the (undocumented) raw deflate mode.
	 * (From USAGI).
	 */
	if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
		u8 zerostuff = 0;
		stream->next_in = &zerostuff;
184
		stream->avail_in = 1;
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
		ret = zlib_inflate(stream, Z_FINISH);
	}
	if (ret != Z_STREAM_END) {
		ret = -EINVAL;
		goto out;
	}
	ret = 0;
	*dlen = stream->total_out;
out:
	return ret;
}

static struct crypto_alg alg = {
	.cra_name		= "deflate",
	.cra_flags		= CRYPTO_ALG_TYPE_COMPRESS,
	.cra_ctxsize		= sizeof(struct deflate_ctx),
	.cra_module		= THIS_MODULE,
202 203
	.cra_init		= deflate_init,
	.cra_exit		= deflate_exit,
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208
	.cra_u			= { .compress = {
	.coa_compress 		= deflate_compress,
	.coa_decompress  	= deflate_decompress } }
};

209
static int __init deflate_mod_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213
{
	return crypto_register_alg(&alg);
}

214
static void __exit deflate_mod_fini(void)
Linus Torvalds's avatar
Linus Torvalds committed
215 216 217 218
{
	crypto_unregister_alg(&alg);
}

219 220
module_init(deflate_mod_init);
module_exit(deflate_mod_fini);
Linus Torvalds's avatar
Linus Torvalds committed
221 222 223 224

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
225
MODULE_ALIAS_CRYPTO("deflate");