PostgreSQL Source Code  git master
pgp-compress.c
Go to the documentation of this file.
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 z_alloc(void *priv, unsigned n_items, unsigned item_len)
59 {
60  return palloc(n_items * item_len);
61 }
62 
63 static void
64 z_free(void *priv, void *addr)
65 {
66  pfree(addr);
67 }
68 
69 static int
70 compress_init(PushFilter *next, void *init_arg, void **priv_p)
71 {
72  int res;
73  struct ZipStat *st;
74  PGP_Context *ctx = init_arg;
75  uint8 type = ctx->compress_algo;
76 
79 
80  /*
81  * init
82  */
83  st = palloc0(sizeof(*st));
84  st->buf_len = ZIP_OUT_BUF;
85  st->stream.zalloc = z_alloc;
86  st->stream.zfree = z_free;
87 
88  if (type == PGP_COMPR_ZIP)
89  res = deflateInit2(&st->stream, ctx->compress_level,
90  Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
91  else
92  res = deflateInit(&st->stream, ctx->compress_level);
93  if (res != Z_OK)
94  {
95  pfree(st);
97  }
98  *priv_p = st;
99 
100  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 compress_process(PushFilter *next, void *priv, const uint8 *data, int len)
108 {
109  int res,
110  n_out;
111  struct ZipStat *st = priv;
112 
113  /*
114  * process data
115  */
116  st->stream.next_in = unconstify(uint8 *, data);
117  st->stream.avail_in = len;
118  while (st->stream.avail_in > 0)
119  {
120  st->stream.next_out = st->buf;
121  st->stream.avail_out = st->buf_len;
122  res = deflate(&st->stream, Z_NO_FLUSH);
123  if (res != Z_OK)
125 
126  n_out = st->buf_len - st->stream.avail_out;
127  if (n_out > 0)
128  {
129  res = pushf_write(next, st->buf, n_out);
130  if (res < 0)
131  return res;
132  }
133  }
134 
135  return 0;
136 }
137 
138 static int
139 compress_flush(PushFilter *next, void *priv)
140 {
141  int res,
142  zres,
143  n_out;
144  struct ZipStat *st = priv;
145 
146  st->stream.next_in = NULL;
147  st->stream.avail_in = 0;
148  while (1)
149  {
150  st->stream.next_out = st->buf;
151  st->stream.avail_out = st->buf_len;
152  zres = deflate(&st->stream, Z_FINISH);
153  if (zres != Z_STREAM_END && zres != Z_OK)
155 
156  n_out = st->buf_len - st->stream.avail_out;
157  if (n_out > 0)
158  {
159  res = pushf_write(next, st->buf, n_out);
160  if (res < 0)
161  return res;
162  }
163  if (zres == Z_STREAM_END)
164  break;
165  }
166  return 0;
167 }
168 
169 static void
170 compress_free(void *priv)
171 {
172  struct ZipStat *st = priv;
173 
174  deflateEnd(&st->stream);
175  px_memset(st, 0, sizeof(*st));
176  pfree(st);
177 }
178 
179 static const PushFilterOps
180  compress_filter = {
181  compress_init, compress_process, compress_flush, compress_free
182 };
183 
184 int
186 {
187  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 decompress_init(void **priv_p, void *arg, PullFilter *src)
205 {
206  PGP_Context *ctx = arg;
207  struct DecomprData *dec;
208  int res;
209 
210  if (ctx->compress_algo != PGP_COMPR_ZLIB
211  && ctx->compress_algo != PGP_COMPR_ZIP)
213 
214  dec = palloc0(sizeof(*dec));
215  dec->buf_len = ZIP_OUT_BUF;
216  *priv_p = dec;
217 
218  dec->stream.zalloc = z_alloc;
219  dec->stream.zfree = z_free;
220 
221  if (ctx->compress_algo == PGP_COMPR_ZIP)
222  res = inflateInit2(&dec->stream, -15);
223  else
224  res = inflateInit(&dec->stream);
225  if (res != Z_OK)
226  {
227  pfree(dec);
228  px_debug("decompress_init: inflateInit error");
230  }
231 
232  return 0;
233 }
234 
235 static int
236 decompress_read(void *priv, PullFilter *src, int len,
237  uint8 **data_p, uint8 *buf, int buflen)
238 {
239  int res;
240  int flush;
241  struct DecomprData *dec = priv;
242 
243 restart:
244  if (dec->buf_data > 0)
245  {
246  if (len > dec->buf_data)
247  len = dec->buf_data;
248  *data_p = dec->pos;
249  dec->pos += len;
250  dec->buf_data -= len;
251  return len;
252  }
253 
254  if (dec->eof)
255  return 0;
256 
257  if (dec->stream.avail_in == 0)
258  {
259  uint8 *tmp;
260 
261  res = pullf_read(src, 8192, &tmp);
262  if (res < 0)
263  return res;
264  dec->stream.next_in = tmp;
265  dec->stream.avail_in = res;
266  }
267 
268  dec->stream.next_out = dec->buf;
269  dec->stream.avail_out = dec->buf_len;
270  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  flush = dec->stream.avail_in ? Z_SYNC_FLUSH : Z_FINISH;
278  res = inflate(&dec->stream, flush);
279  if (res != Z_OK && res != Z_STREAM_END)
280  {
281  px_debug("decompress_read: inflate error: %d", res);
282  return PXE_PGP_CORRUPT_DATA;
283  }
284 
285  dec->buf_data = dec->buf_len - dec->stream.avail_out;
286  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  res = pullf_read(src, 1, &tmp);
299 
300  if (res < 0)
301  return res;
302  else if (res > 0)
303  {
304  px_debug("decompress_read: extra bytes after end of stream");
305  return PXE_PGP_CORRUPT_DATA;
306  }
307  dec->eof = 1;
308  }
309  goto restart;
310 }
311 
312 static void
313 decompress_free(void *priv)
314 {
315  struct DecomprData *dec = priv;
316 
317  inflateEnd(&dec->stream);
318  px_memset(dec, 0, sizeof(*dec));
319  pfree(dec);
320 }
321 
322 static const PullFilterOps
323  decompress_filter = {
324  decompress_init, decompress_read, decompress_free
325 };
326 
327 int
329 {
330  return pullf_create(res, &decompress_filter, ctx, src);
331 }
332 #else /* !HAVE_LIBZ */
333 
334 int
336 {
338 }
339 
340 int
342 {
344 }
345 
346 #endif
static int32 next
Definition: blutils.c:219
#define unconstify(underlying_type, expr)
Definition: c.h:1240
unsigned char uint8
Definition: c.h:439
int pullf_create(PullFilter **pf_p, const PullFilterOps *op, void *init_arg, PullFilter *src)
Definition: mbuf.c:204
int pushf_write(PushFilter *mp, const uint8 *data, int len)
Definition: mbuf.c:452
int pushf_create(PushFilter **mp_p, const PushFilterOps *op, void *init_arg, PushFilter *next)
Definition: mbuf.c:370
int pullf_read(PullFilter *pf, int len, uint8 **data_p)
Definition: mbuf.c:259
void pfree(void *pointer)
Definition: mcxt.c:1169
void * palloc0(Size size)
Definition: mcxt.c:1093
void * palloc(Size size)
Definition: mcxt.c:1062
void * arg
const void size_t len
const void * data
static char * buf
Definition: pg_test_fsync.c:70
int pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
Definition: pgp-compress.c:335
int pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
Definition: pgp-compress.c:341
@ PGP_COMPR_ZLIB
Definition: pgp.h:94
@ PGP_COMPR_ZIP
Definition: pgp.h:93
void px_debug(const char *fmt,...)
Definition: px.c:153
void px_memset(void *ptr, int c, size_t len)
Definition: px.c:127
#define PXE_PGP_UNSUPPORTED_COMPR
Definition: px.h:68
#define PXE_PGP_COMPRESSION_ERROR
Definition: px.h:71
#define PXE_PGP_CORRUPT_DATA
Definition: px.h:66
int compress_level
Definition: pgp.h:146
int compress_algo
Definition: pgp.h:145