Line data Source code
1 : /*
2 : * pgp-compress.c
3 : * ZIP and ZLIB compression via zlib.
4 : *
5 : * Copyright (c) 2005 Marko Kreen
6 : * All rights reserved.
7 : *
8 : * Redistribution and use in source and binary forms, with or without
9 : * modification, are permitted provided that the following conditions
10 : * are met:
11 : * 1. Redistributions of source code must retain the above copyright
12 : * notice, this list of conditions and the following disclaimer.
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 : * SUCH DAMAGE.
28 : *
29 : * contrib/pgcrypto/pgp-compress.c
30 : */
31 :
32 : #include "postgres.h"
33 :
34 : #include "pgp.h"
35 : #include "px.h"
36 :
37 : /*
38 : * Compressed pkt writer
39 : */
40 :
41 : #ifdef HAVE_LIBZ
42 :
43 : #include <zlib.h>
44 :
45 : #define ZIP_OUT_BUF 8192
46 : #define ZIP_IN_BLOCK 8192
47 :
48 : struct ZipStat
49 : {
50 : uint8 type;
51 : int buf_len;
52 : int hdr_done;
53 : z_stream stream;
54 : uint8 buf[ZIP_OUT_BUF];
55 : };
56 :
57 : static void *
58 22 : z_alloc(void *priv, unsigned n_items, unsigned item_len)
59 : {
60 22 : return palloc(n_items * item_len);
61 : }
62 :
63 : static void
64 22 : z_free(void *priv, void *addr)
65 : {
66 22 : pfree(addr);
67 22 : }
68 :
69 : static int
70 3 : compress_init(PushFilter *next, void *init_arg, void **priv_p)
71 : {
72 : int res;
73 : struct ZipStat *st;
74 3 : PGP_Context *ctx = init_arg;
75 3 : uint8 type = ctx->compress_algo;
76 :
77 3 : if (type != PGP_COMPR_ZLIB && type != PGP_COMPR_ZIP)
78 0 : return PXE_PGP_UNSUPPORTED_COMPR;
79 :
80 : /*
81 : * init
82 : */
83 3 : st = palloc0_object(struct ZipStat);
84 3 : st->buf_len = ZIP_OUT_BUF;
85 3 : st->stream.zalloc = z_alloc;
86 3 : st->stream.zfree = z_free;
87 :
88 3 : if (type == PGP_COMPR_ZIP)
89 2 : res = deflateInit2(&st->stream, ctx->compress_level,
90 : Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
91 : else
92 1 : res = deflateInit(&st->stream, ctx->compress_level);
93 3 : if (res != Z_OK)
94 : {
95 0 : pfree(st);
96 0 : return PXE_PGP_COMPRESSION_ERROR;
97 : }
98 3 : *priv_p = st;
99 :
100 3 : return ZIP_IN_BLOCK;
101 : }
102 :
103 : /* writes compressed data packet */
104 :
105 : /* can handle zero-len incoming data, but shouldn't */
106 : static int
107 4 : compress_process(PushFilter *next, void *priv, const uint8 *data, int len)
108 : {
109 : int res,
110 : n_out;
111 4 : struct ZipStat *st = priv;
112 :
113 : /*
114 : * process data
115 : */
116 4 : st->stream.next_in = data;
117 4 : st->stream.avail_in = len;
118 12 : while (st->stream.avail_in > 0)
119 : {
120 4 : st->stream.next_out = st->buf;
121 4 : st->stream.avail_out = st->buf_len;
122 4 : res = deflate(&st->stream, Z_NO_FLUSH);
123 4 : if (res != Z_OK)
124 0 : return PXE_PGP_COMPRESSION_ERROR;
125 :
126 4 : n_out = st->buf_len - st->stream.avail_out;
127 4 : if (n_out > 0)
128 : {
129 1 : res = pushf_write(next, st->buf, n_out);
130 1 : if (res < 0)
131 0 : return res;
132 : }
133 : }
134 :
135 4 : return 0;
136 : }
137 :
138 : static int
139 3 : compress_flush(PushFilter *next, void *priv)
140 : {
141 : int res,
142 : zres,
143 : n_out;
144 3 : struct ZipStat *st = priv;
145 :
146 3 : st->stream.next_in = NULL;
147 3 : st->stream.avail_in = 0;
148 : while (1)
149 : {
150 4 : st->stream.next_out = st->buf;
151 4 : st->stream.avail_out = st->buf_len;
152 4 : zres = deflate(&st->stream, Z_FINISH);
153 4 : if (zres != Z_STREAM_END && zres != Z_OK)
154 0 : return PXE_PGP_COMPRESSION_ERROR;
155 :
156 4 : n_out = st->buf_len - st->stream.avail_out;
157 4 : if (n_out > 0)
158 : {
159 4 : res = pushf_write(next, st->buf, n_out);
160 4 : if (res < 0)
161 0 : return res;
162 : }
163 4 : if (zres == Z_STREAM_END)
164 3 : break;
165 : }
166 3 : return 0;
167 : }
168 :
169 : static void
170 3 : compress_free(void *priv)
171 : {
172 3 : struct ZipStat *st = priv;
173 :
174 3 : deflateEnd(&st->stream);
175 3 : px_memset(st, 0, sizeof(*st));
176 3 : pfree(st);
177 3 : }
178 :
179 : static const PushFilterOps
180 : compress_filter = {
181 : compress_init, compress_process, compress_flush, compress_free
182 : };
183 :
184 : int
185 3 : pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
186 : {
187 3 : return pushf_create(res, &compress_filter, ctx, dst);
188 : }
189 :
190 : /*
191 : * Decompress
192 : */
193 : struct DecomprData
194 : {
195 : int buf_len; /* = ZIP_OUT_BUF */
196 : int buf_data; /* available data */
197 : uint8 *pos;
198 : z_stream stream;
199 : int eof;
200 : uint8 buf[ZIP_OUT_BUF];
201 : };
202 :
203 : static int
204 4 : decompress_init(void **priv_p, void *arg, PullFilter *src)
205 : {
206 4 : PGP_Context *ctx = arg;
207 : struct DecomprData *dec;
208 : int res;
209 :
210 4 : if (ctx->compress_algo != PGP_COMPR_ZLIB
211 3 : && ctx->compress_algo != PGP_COMPR_ZIP)
212 0 : return PXE_PGP_UNSUPPORTED_COMPR;
213 :
214 4 : dec = palloc0_object(struct DecomprData);
215 4 : dec->buf_len = ZIP_OUT_BUF;
216 4 : *priv_p = dec;
217 :
218 4 : dec->stream.zalloc = z_alloc;
219 4 : dec->stream.zfree = z_free;
220 :
221 4 : if (ctx->compress_algo == PGP_COMPR_ZIP)
222 3 : res = inflateInit2(&dec->stream, -15);
223 : else
224 1 : res = inflateInit(&dec->stream);
225 4 : if (res != Z_OK)
226 : {
227 0 : pfree(dec);
228 0 : px_debug("decompress_init: inflateInit error");
229 0 : return PXE_PGP_COMPRESSION_ERROR;
230 : }
231 :
232 4 : return 0;
233 : }
234 :
235 : static int
236 36 : decompress_read(void *priv, PullFilter *src, int len,
237 : uint8 **data_p, uint8 *buf, int buflen)
238 : {
239 : int res;
240 : int flush;
241 36 : struct DecomprData *dec = priv;
242 :
243 44 : restart:
244 44 : if (dec->buf_data > 0)
245 : {
246 32 : if (len > dec->buf_data)
247 4 : len = dec->buf_data;
248 32 : *data_p = dec->pos;
249 32 : dec->pos += len;
250 32 : dec->buf_data -= len;
251 32 : return len;
252 : }
253 :
254 12 : if (dec->eof)
255 4 : return 0;
256 :
257 8 : if (dec->stream.avail_in == 0)
258 : {
259 : uint8 *tmp;
260 :
261 8 : res = pullf_read(src, 8192, &tmp);
262 8 : if (res < 0)
263 0 : return res;
264 8 : dec->stream.next_in = tmp;
265 8 : dec->stream.avail_in = res;
266 : }
267 :
268 8 : dec->stream.next_out = dec->buf;
269 8 : dec->stream.avail_out = dec->buf_len;
270 8 : dec->pos = dec->buf;
271 :
272 : /*
273 : * Z_SYNC_FLUSH is tell zlib to output as much as possible. It should do
274 : * it anyway (Z_NO_FLUSH), but seems to reserve the right not to. So lets
275 : * follow the API.
276 : */
277 8 : flush = dec->stream.avail_in ? Z_SYNC_FLUSH : Z_FINISH;
278 8 : res = inflate(&dec->stream, flush);
279 8 : if (res != Z_OK && res != Z_STREAM_END)
280 : {
281 0 : px_debug("decompress_read: inflate error: %d", res);
282 0 : return PXE_PGP_CORRUPT_DATA;
283 : }
284 :
285 8 : dec->buf_data = dec->buf_len - dec->stream.avail_out;
286 8 : if (res == Z_STREAM_END)
287 : {
288 : uint8 *tmp;
289 :
290 : /*
291 : * A stream must be terminated by a normal packet. If the last stream
292 : * packet in the source stream is a full packet, a normal empty packet
293 : * must follow. Since the underlying packet reader doesn't know that
294 : * the compressed stream has been ended, we need to consume the
295 : * terminating packet here. This read does not harm even if the
296 : * stream has already ended.
297 : */
298 4 : res = pullf_read(src, 1, &tmp);
299 :
300 4 : if (res < 0)
301 0 : return res;
302 4 : else if (res > 0)
303 : {
304 0 : px_debug("decompress_read: extra bytes after end of stream");
305 0 : return PXE_PGP_CORRUPT_DATA;
306 : }
307 4 : dec->eof = 1;
308 : }
309 8 : goto restart;
310 : }
311 :
312 : static void
313 4 : decompress_free(void *priv)
314 : {
315 4 : struct DecomprData *dec = priv;
316 :
317 4 : inflateEnd(&dec->stream);
318 4 : px_memset(dec, 0, sizeof(*dec));
319 4 : pfree(dec);
320 4 : }
321 :
322 : static const PullFilterOps
323 : decompress_filter = {
324 : decompress_init, decompress_read, decompress_free
325 : };
326 :
327 : int
328 4 : pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
329 : {
330 4 : return pullf_create(res, &decompress_filter, ctx, src);
331 : }
332 : #else /* !HAVE_LIBZ */
333 :
334 : int
335 : pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
336 : {
337 : return PXE_PGP_UNSUPPORTED_COMPR;
338 : }
339 :
340 : int
341 : pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
342 : {
343 : return PXE_PGP_UNSUPPORTED_COMPR;
344 : }
345 :
346 : #endif
|
