1 /* $OpenBSD: deflate.c,v 1.3 2001/08/20 02:45:22 hugh Exp $ */
4 * Copyright (c) 2001 Jean-Jacques Bernard-Gundol (jj@wabbitt.org)
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 * This file contains a wrapper around the deflate algo compression
32 * functions using the zlib library (see net/zlib.{c,h})
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
38 #include "opt_kdtrace.h"
40 #include <sys/types.h>
41 #include <sys/param.h>
42 #include <sys/malloc.h>
43 #include <sys/param.h>
44 #include <sys/kernel.h>
46 #include <sys/systm.h>
49 #include <opencrypto/cryptodev.h>
50 #include <opencrypto/deflate.h>
52 SDT_PROVIDER_DECLARE(opencrypto);
53 SDT_PROBE_DEFINE2(opencrypto, deflate, deflate_global, entry,
55 SDT_PROBE_DEFINE5(opencrypto, deflate, deflate_global, bad,
56 "int", "int", "int", "int", "int");
57 SDT_PROBE_DEFINE5(opencrypto, deflate, deflate_global, iter,
58 "int", "int", "int", "int", "int");
59 SDT_PROBE_DEFINE2(opencrypto, deflate, deflate_global, return,
62 int window_inflate = -1 * MAX_WBITS;
63 int window_deflate = -12;
66 * This function takes a block of data and (de)compress it using the deflate
71 deflate_global(data, size, decomp, out)
77 /* decomp indicates whether we compress (0) or decompress (1) */
81 u_int32_t count, result;
83 struct deflate_buf buf[ZBUF];
85 SDT_PROBE2(opencrypto, deflate, deflate_global, entry, decomp, size);
87 bzero(&zbuf, sizeof(z_stream));
88 for (j = 0; j < ZBUF; j++)
91 zbuf.next_in = data; /* data that is going to be processed */
92 zbuf.zalloc = z_alloc;
95 zbuf.avail_in = size; /* Total length of data to be processed */
98 buf[i].out = malloc((u_long) size, M_CRYPTO_DATA,
100 if (buf[i].out == NULL) {
101 SDT_PROBE3(opencrypto, deflate, deflate_global, bad,
102 decomp, 0, __LINE__);
110 * Choose a buffer with 4x the size of the input buffer
111 * for the size of the output buffer in the case of
112 * decompression. If it's not sufficient, it will need to be
113 * updated while the decompression is going on
116 buf[i].out = malloc((u_long) (size * 4),
117 M_CRYPTO_DATA, M_NOWAIT);
118 if (buf[i].out == NULL) {
119 SDT_PROBE3(opencrypto, deflate, deflate_global, bad,
120 decomp, 0, __LINE__);
123 buf[i].size = size * 4;
128 zbuf.next_out = buf[0].out;
129 zbuf.avail_out = buf[0].size;
131 error = decomp ? inflateInit2(&zbuf, window_inflate) :
132 deflateInit2(&zbuf, Z_DEFAULT_COMPRESSION, Z_METHOD,
133 window_deflate, Z_MEMLEVEL, Z_DEFAULT_STRATEGY);
136 SDT_PROBE3(opencrypto, deflate, deflate_global, bad,
137 decomp, error, __LINE__);
141 error = decomp ? inflate(&zbuf, Z_PARTIAL_FLUSH) :
142 deflate(&zbuf, Z_PARTIAL_FLUSH);
143 if (error != Z_OK && error != Z_STREAM_END) {
145 * Unfortunately we are limited to 5 arguments,
146 * thus use two probes.
148 SDT_PROBE5(opencrypto, deflate, deflate_global, bad,
149 decomp, error, __LINE__,
150 zbuf.avail_in, zbuf.avail_out);
151 SDT_PROBE5(opencrypto, deflate, deflate_global, bad,
152 decomp, error, __LINE__,
153 zbuf.state->dummy, zbuf.total_out);
156 else if (zbuf.avail_in == 0 && zbuf.avail_out != 0)
158 else if (zbuf.avail_out == 0 && i < (ZBUF - 1)) {
159 /* we need more output space, allocate size */
160 buf[i].out = malloc((u_long) size,
161 M_CRYPTO_DATA, M_NOWAIT);
162 if (buf[i].out == NULL) {
163 SDT_PROBE3(opencrypto, deflate, deflate_global,
164 bad, decomp, 0, __LINE__);
167 zbuf.next_out = buf[i].out;
170 zbuf.avail_out = buf[i].size;
174 * Unfortunately we are limited to 5 arguments,
175 * thus, again, use two probes.
177 SDT_PROBE5(opencrypto, deflate, deflate_global, bad,
178 decomp, error, __LINE__,
179 zbuf.avail_in, zbuf.avail_out);
180 SDT_PROBE5(opencrypto, deflate, deflate_global, bad,
181 decomp, error, __LINE__,
182 zbuf.state->dummy, zbuf.total_out);
188 result = count = zbuf.total_out;
190 *out = malloc((u_long) result, M_CRYPTO_DATA, M_NOWAIT);
192 SDT_PROBE3(opencrypto, deflate, deflate_global, bad,
193 decomp, 0, __LINE__);
201 for (j = 0; buf[j].flag != 0; j++) {
202 if (count > buf[j].size) {
203 bcopy(buf[j].out, *out, buf[j].size);
205 free(buf[j].out, M_CRYPTO_DATA);
206 count -= buf[j].size;
208 /* it should be the last buffer */
209 bcopy(buf[j].out, *out, count);
211 free(buf[j].out, M_CRYPTO_DATA);
216 SDT_PROBE2(opencrypto, deflate, deflate_global, return, decomp, result);
221 for (j = 0; buf[j].flag != 0; j++)
222 free(buf[j].out, M_CRYPTO_DATA);
231 z_alloc(nil, type, size)
237 ptr = malloc(type *size, M_CRYPTO_DATA, M_NOWAIT);
245 free(ptr, M_CRYPTO_DATA);