88 *
99 * Entry routines:
1010 *
11- * bool
12- * pglz_compress(const char *source, int32 slen, PGLZ_Header *dest,
11+ * int32
12+ * pglz_compress(const char *source, int32 slen, char *dest,
1313 * const PGLZ_Strategy *strategy);
1414 *
1515 * source is the input data to be compressed.
2323 * the compression algorithm. If NULL, the compiled
2424 * in default strategy is used.
2525 *
26- * The return value is TRUE if compression succeeded,
27- * FALSE if not ; in the latter case the contents of dest
28- * are undefined.
26+ * The return value is the number of bytes written in the
27+ * buffer dest, or -1 if compression fails ; in the latter
28+ * case the contents of dest are undefined.
2929 *
30- * void
31- * pglz_decompress(const PGLZ_Header *source, char *dest)
30+ * int32
31+ * pglz_decompress(const char *source, int32 slen, char *dest,
32+ * int32 rawsize)
3233 *
3334 * source is the compressed input.
3435 *
36+ * slen is the length of the compressed input.
37+ *
3538 * dest is the area where the uncompressed data will be
3639 * written to. It is the callers responsibility to
37- * provide enough space. The required amount can be
38- * obtained with the macro PGLZ_RAW_SIZE(source).
40+ * provide enough space.
3941 *
4042 * The data is written to buff exactly as it was handed
4143 * to pglz_compress(). No terminating zero byte is added.
4244 *
43- * The decompression algorithm and internal data format:
45+ * rawsize is the length of the uncompressed data.
4446 *
45- * PGLZ_Header is defined as
47+ * The return value is the number of bytes written in the
48+ * buffer dest, or -1 if decompression fails.
4649 *
47- * typedef struct PGLZ_Header {
48- * int32 vl_len_;
49- * int32 rawsize;
50- * }
50+ * The decompression algorithm and internal data format:
5151 *
52- * The header is followed by the compressed data itself.
52+ * It is made with the compressed data itself.
5353 *
5454 * The data representation is easiest explained by describing
5555 * the process of decompression.
5656 *
57- * If VARSIZE(x) == rawsize + sizeof(PGLZ_Header) , then the data
57+ * If compressed_size == rawsize, then the data
5858 * is stored uncompressed as plain bytes. Thus, the decompressor
59- * simply copies rawsize bytes from the location after the
60- * header to the destination.
59+ * simply copies rawsize bytes to the destination.
6160 *
62- * Otherwise the first byte after the header tells what to do
63- * the next 8 times. We call this the control byte.
61+ * Otherwise the first byte tells what to do the next 8 times.
62+ * We call this the control byte.
6463 *
6564 * An unset bit in the control byte means, that one uncompressed
6665 * byte follows, which is copied from input to output.
169168 *
170169 * Copyright (c) 1999-2015, PostgreSQL Global Development Group
171170 *
172- * src/backend/utils/adt /pg_lzcompress.c
171+ * src/common /pg_lzcompress.c
173172 * ----------
174173 */
174+ #ifndef FRONTEND
175175#include "postgres.h"
176+ #else
177+ #include "postgres_fe.h"
178+ #endif
176179
177180#include <limits.h>
178181
179- #include "utils /pg_lzcompress.h"
182+ #include "common /pg_lzcompress.h"
180183
181184
182185/* ----------
@@ -492,14 +495,15 @@ pglz_find_match(int16 *hstart, const char *input, const char *end,
492495/* ----------
493496 * pglz_compress -
494497 *
495- * Compresses source into dest using strategy.
498+ * Compresses source into dest using strategy. Returns the number of
499+ * bytes written in buffer dest, or -1 if compression fails.
496500 * ----------
497501 */
498- bool
499- pglz_compress (const char * source , int32 slen , PGLZ_Header * dest ,
502+ int32
503+ pglz_compress (const char * source , int32 slen , char * dest ,
500504 const PGLZ_Strategy * strategy )
501505{
502- unsigned char * bp = (( unsigned char * ) dest ) + sizeof ( PGLZ_Header ) ;
506+ unsigned char * bp = (unsigned char * ) dest ;
503507 unsigned char * bstart = bp ;
504508 int hist_next = 1 ;
505509 bool hist_recycle = false;
@@ -533,12 +537,7 @@ pglz_compress(const char *source, int32 slen, PGLZ_Header *dest,
533537 if (strategy -> match_size_good <= 0 ||
534538 slen < strategy -> min_input_size ||
535539 slen > strategy -> max_input_size )
536- return false;
537-
538- /*
539- * Save the original source size in the header.
540- */
541- dest -> rawsize = slen ;
540+ return -1 ;
542541
543542 /*
544543 * Limit the match parameters to the supported range.
@@ -611,7 +610,7 @@ pglz_compress(const char *source, int32 slen, PGLZ_Header *dest,
611610 * allow 4 slop bytes.
612611 */
613612 if (bp - bstart >= result_max )
614- return false ;
613+ return -1 ;
615614
616615 /*
617616 * If we've emitted more than first_success_by bytes without finding
@@ -620,7 +619,7 @@ pglz_compress(const char *source, int32 slen, PGLZ_Header *dest,
620619 * pre-compressed data).
621620 */
622621 if (!found_match && bp - bstart >= strategy -> first_success_by )
623- return false ;
622+ return -1 ;
624623
625624 /*
626625 * Try to find a match in the history
@@ -664,35 +663,34 @@ pglz_compress(const char *source, int32 slen, PGLZ_Header *dest,
664663 * ctrlp = ctrlb ;
665664 result_size = bp - bstart ;
666665 if (result_size >= result_max )
667- return false;
668-
669- /*
670- * Success - need only fill in the actual length of the compressed datum.
671- */
672- SET_VARSIZE_COMPRESSED (dest , result_size + sizeof (PGLZ_Header ));
666+ return -1 ;
673667
674- return true;
668+ /* success */
669+ return result_size ;
675670}
676671
677672
678673/* ----------
679674 * pglz_decompress -
680675 *
681- * Decompresses source into dest.
676+ * Decompresses source into dest. Returns the number of bytes
677+ * decompressed in the destination buffer, or -1 if decompression
678+ * fails.
682679 * ----------
683680 */
684- void
685- pglz_decompress (const PGLZ_Header * source , char * dest )
681+ int32
682+ pglz_decompress (const char * source , int32 slen , char * dest ,
683+ int32 rawsize )
686684{
687685 const unsigned char * sp ;
688686 const unsigned char * srcend ;
689687 unsigned char * dp ;
690688 unsigned char * destend ;
691689
692- sp = (( const unsigned char * ) source ) + sizeof ( PGLZ_Header ) ;
693- srcend = ((const unsigned char * ) source ) + VARSIZE ( source ) ;
690+ sp = (const unsigned char * ) source ;
691+ srcend = ((const unsigned char * ) source ) + slen ;
694692 dp = (unsigned char * ) dest ;
695- destend = dp + source -> rawsize ;
693+ destend = dp + rawsize ;
696694
697695 while (sp < srcend && dp < destend )
698696 {
@@ -771,9 +769,10 @@ pglz_decompress(const PGLZ_Header *source, char *dest)
771769 * Check we decompressed the right amount.
772770 */
773771 if (dp != destend || sp != srcend )
774- elog ( ERROR , "compressed data is corrupt" ) ;
772+ return -1 ;
775773
776774 /*
777775 * That's it.
778776 */
777+ return rawsize ;
779778}
0 commit comments