From 7f14216f4c46017f48efc73cb4e3021b573c5391 Mon Sep 17 00:00:00 2001 From: Georgios Kokolatos Date: Wed, 21 Dec 2022 09:49:23 +0000 Subject: [PATCH 2/8] Prepare pg_dump internals for additional compression methods. Commit bf9aa490db introduced cfp in compress_io.{c,h} with the intent of unifying compression related code and allow for the introduction of additional archive formats. However, pg_backup_archiver.c was not using that API. This commit teaches pg_backup_archiver.c about it and is using it throughout. --- src/bin/pg_dump/compress_io.c | 389 +++++++++++++++++++-------- src/bin/pg_dump/compress_io.h | 2 + src/bin/pg_dump/pg_backup_archiver.c | 128 +++------ src/bin/pg_dump/pg_backup_archiver.h | 27 +- 4 files changed, 320 insertions(+), 226 deletions(-) diff --git a/src/bin/pg_dump/compress_io.c b/src/bin/pg_dump/compress_io.c index e5107c75874..8d0bec08d7c 100644 --- a/src/bin/pg_dump/compress_io.c +++ b/src/bin/pg_dump/compress_io.c @@ -56,6 +56,10 @@ #include "compress_io.h" #include "pg_backup_utils.h" +#ifdef HAVE_LIBZ +#include +#endif + /*---------------------- * Compressor API *---------------------- @@ -128,15 +132,24 @@ ReadDataFromArchive(ArchiveHandle *AH, const pg_compress_specification *compression_spec, ReadFunc readF) { - if (compression_spec->algorithm == PG_COMPRESSION_NONE) - ReadDataFromArchiveNone(AH, readF); - if (compression_spec->algorithm == PG_COMPRESSION_GZIP) + switch (compression_spec->algorithm) { + case PG_COMPRESSION_NONE: + ReadDataFromArchiveNone(AH, readF); + break; + case PG_COMPRESSION_GZIP: #ifdef HAVE_LIBZ - ReadDataFromArchiveZlib(AH, readF); + ReadDataFromArchiveZlib(AH, readF); #else - pg_fatal("this build does not support compression with %s", "gzip"); + pg_fatal("this build does not support compression with %s", "gzip"); #endif + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; } } @@ -149,6 +162,9 @@ WriteDataToArchive(ArchiveHandle *AH, CompressorState *cs, { switch (cs->compression_spec.algorithm) { + case PG_COMPRESSION_NONE: + WriteDataToArchiveNone(AH, cs, data, dLen); + break; case PG_COMPRESSION_GZIP: #ifdef HAVE_LIBZ WriteDataToArchiveZlib(AH, cs, data, dLen); @@ -156,13 +172,11 @@ WriteDataToArchive(ArchiveHandle *AH, CompressorState *cs, pg_fatal("this build does not support compression with %s", "gzip"); #endif break; - case PG_COMPRESSION_NONE: - WriteDataToArchiveNone(AH, cs, data, dLen); - break; case PG_COMPRESSION_LZ4: - /* fallthrough */ + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; case PG_COMPRESSION_ZSTD: - pg_fatal("invalid compression method"); + pg_fatal("compression with %s is not yet supported", "ZSTD"); break; } } @@ -173,10 +187,26 @@ WriteDataToArchive(ArchiveHandle *AH, CompressorState *cs, void EndCompressor(ArchiveHandle *AH, CompressorState *cs) { + switch (cs->compression_spec.algorithm) + { + case PG_COMPRESSION_NONE: + break; + case PG_COMPRESSION_GZIP: #ifdef HAVE_LIBZ - if (cs->compression_spec.algorithm == PG_COMPRESSION_GZIP) - EndCompressorZlib(AH, cs); + EndCompressorZlib(AH, cs); +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; + } + free(cs); } @@ -391,10 +421,8 @@ WriteDataToArchiveNone(ArchiveHandle *AH, CompressorState *cs, */ struct cfp { - FILE *uncompressedfp; -#ifdef HAVE_LIBZ - gzFile compressedfp; -#endif + pg_compress_specification compression_spec; + void *fp; }; #ifdef HAVE_LIBZ @@ -490,127 +518,202 @@ cfopen_write(const char *path, const char *mode, } /* - * Opens file 'path' in 'mode'. If compression is GZIP, the file - * is opened with libz gzopen(), otherwise with plain fopen(). + * This is the workhorse for cfopen() or cfdopen(). It opens file 'path' or + * associates a stream 'fd', if 'fd' is a valid descriptor, in 'mode'. The + * descriptor is not dup'ed and it is the caller's responsibility to do so. + * The caller must verify that the 'compress_algorithm' is supported by the + * current build. * * On failure, return NULL with an error code in errno. */ -cfp * -cfopen(const char *path, const char *mode, - const pg_compress_specification *compression_spec) +static cfp * +cfopen_internal(const char *path, int fd, const char *mode, + const pg_compress_specification *compression_spec) { cfp *fp = pg_malloc(sizeof(cfp)); - if (compression_spec->algorithm == PG_COMPRESSION_GZIP) + fp->compression_spec = *compression_spec; + + switch (compression_spec->algorithm) { -#ifdef HAVE_LIBZ - if (compression_spec->level != Z_DEFAULT_COMPRESSION) - { - /* user has specified a compression level, so tell zlib to use it */ - char mode_compression[32]; + case PG_COMPRESSION_NONE: + if (fd >= 0) + fp->fp = fdopen(fd, mode); + else + fp->fp = fopen(path, mode); + if (fp->fp == NULL) + { + free_keep_errno(fp); + fp = NULL; + } - snprintf(mode_compression, sizeof(mode_compression), "%s%d", - mode, compression_spec->level); - fp->compressedfp = gzopen(path, mode_compression); - } - else - { - /* don't specify a level, just use the zlib default */ - fp->compressedfp = gzopen(path, mode); - } + break; + case PG_COMPRESSION_GZIP: +#ifdef HAVE_LIBZ + if (compression_spec->level != Z_DEFAULT_COMPRESSION) + { + /* + * user has specified a compression level, so tell zlib to use + * it + */ + char mode_compression[32]; + + snprintf(mode_compression, sizeof(mode_compression), "%s%d", + mode, compression_spec->level); + if (fd >= 0) + fp->fp = gzdopen(fd, mode_compression); + else + fp->fp = gzopen(path, mode_compression); + } + else + { + /* don't specify a level, just use the zlib default */ + if (fd >= 0) + fp->fp = gzdopen(fd, mode); + else + fp->fp = gzopen(path, mode); + } - fp->uncompressedfp = NULL; - if (fp->compressedfp == NULL) - { - free_keep_errno(fp); - fp = NULL; - } + if (fp->fp == NULL) + { + free_keep_errno(fp); + fp = NULL; + } #else - pg_fatal("this build does not support compression with %s", "gzip"); -#endif - } - else - { -#ifdef HAVE_LIBZ - fp->compressedfp = NULL; + pg_fatal("this build does not support compression with %s", "gzip"); #endif - fp->uncompressedfp = fopen(path, mode); - if (fp->uncompressedfp == NULL) - { - free_keep_errno(fp); - fp = NULL; - } + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; } return fp; } +cfp * +cfopen(const char *path, const char *mode, + const pg_compress_specification *compression_spec) +{ + return cfopen_internal(path, -1, mode, compression_spec); +} + +cfp * +cfdopen(int fd, const char *mode, + const pg_compress_specification *compression_spec) +{ + return cfopen_internal(NULL, fd, mode, compression_spec); +} int cfread(void *ptr, int size, cfp *fp) { - int ret; + int ret = 0; if (size == 0) return 0; -#ifdef HAVE_LIBZ - if (fp->compressedfp) + switch (fp->compression_spec.algorithm) { - ret = gzread(fp->compressedfp, ptr, size); - if (ret != size && !gzeof(fp->compressedfp)) - { - int errnum; - const char *errmsg = gzerror(fp->compressedfp, &errnum); + case PG_COMPRESSION_NONE: + ret = fread(ptr, 1, size, (FILE *) fp->fp); + if (ret != size && !feof((FILE *) fp->fp)) + READ_ERROR_EXIT((FILE *) fp->fp); - pg_fatal("could not read from input file: %s", - errnum == Z_ERRNO ? strerror(errno) : errmsg); - } - } - else + break; + case PG_COMPRESSION_GZIP: +#ifdef HAVE_LIBZ + ret = gzread((gzFile) fp->fp, ptr, size); + if (ret != size && !gzeof((gzFile) fp->fp)) + { + int errnum; + const char *errmsg = gzerror((gzFile) fp->fp, &errnum); + + pg_fatal("could not read from input file: %s", + errnum == Z_ERRNO ? strerror(errno) : errmsg); + } +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif - { - ret = fread(ptr, 1, size, fp->uncompressedfp); - if (ret != size && !feof(fp->uncompressedfp)) - READ_ERROR_EXIT(fp->uncompressedfp); + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; } + return ret; } int cfwrite(const void *ptr, int size, cfp *fp) { + int ret = 0; + + switch (fp->compression_spec.algorithm) + { + case PG_COMPRESSION_NONE: + ret = fwrite(ptr, 1, size, (FILE *) fp->fp); + break; + case PG_COMPRESSION_GZIP: #ifdef HAVE_LIBZ - if (fp->compressedfp) - return gzwrite(fp->compressedfp, ptr, size); - else + ret = gzwrite((gzFile) fp->fp, ptr, size); +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif - return fwrite(ptr, 1, size, fp->uncompressedfp); + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; + } + + return ret; } int cfgetc(cfp *fp) { - int ret; + int ret = 0; -#ifdef HAVE_LIBZ - if (fp->compressedfp) + switch (fp->compression_spec.algorithm) { - ret = gzgetc(fp->compressedfp); - if (ret == EOF) - { - if (!gzeof(fp->compressedfp)) - pg_fatal("could not read from input file: %s", strerror(errno)); - else - pg_fatal("could not read from input file: end of file"); - } - } - else + case PG_COMPRESSION_NONE: + ret = fgetc((FILE *) fp->fp); + if (ret == EOF) + READ_ERROR_EXIT((FILE *) fp->fp); + + break; + case PG_COMPRESSION_GZIP: +#ifdef HAVE_LIBZ + ret = gzgetc((gzFile) fp->fp); + if (ret == EOF) + { + if (!gzeof((gzFile) fp->fp)) + pg_fatal("could not read from input file: %s", strerror(errno)); + else + pg_fatal("could not read from input file: end of file"); + } +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif - { - ret = fgetc(fp->uncompressedfp); - if (ret == EOF) - READ_ERROR_EXIT(fp->uncompressedfp); + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; } return ret; @@ -619,65 +722,119 @@ cfgetc(cfp *fp) char * cfgets(cfp *fp, char *buf, int len) { + char *ret = NULL; + + switch (fp->compression_spec.algorithm) + { + case PG_COMPRESSION_NONE: + ret = fgets(buf, len, (FILE *) fp->fp); + + break; + case PG_COMPRESSION_GZIP: #ifdef HAVE_LIBZ - if (fp->compressedfp) - return gzgets(fp->compressedfp, buf, len); - else + ret = gzgets((gzFile) fp->fp, buf, len); +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif - return fgets(buf, len, fp->uncompressedfp); + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; + } + + return ret; } int cfclose(cfp *fp) { - int result; + int ret = 0; if (fp == NULL) { errno = EBADF; return EOF; } -#ifdef HAVE_LIBZ - if (fp->compressedfp) + + switch (fp->compression_spec.algorithm) { - result = gzclose(fp->compressedfp); - fp->compressedfp = NULL; - } - else + case PG_COMPRESSION_NONE: + ret = fclose((FILE *) fp->fp); + fp->fp = NULL; + + break; + case PG_COMPRESSION_GZIP: +#ifdef HAVE_LIBZ + ret = gzclose((gzFile) fp->fp); + fp->fp = NULL; +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif - { - result = fclose(fp->uncompressedfp); - fp->uncompressedfp = NULL; + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; } + free_keep_errno(fp); - return result; + return ret; } int cfeof(cfp *fp) { + int ret = 0; + + switch (fp->compression_spec.algorithm) + { + case PG_COMPRESSION_NONE: + ret = feof((FILE *) fp->fp); + + break; + case PG_COMPRESSION_GZIP: #ifdef HAVE_LIBZ - if (fp->compressedfp) - return gzeof(fp->compressedfp); - else + ret = gzeof((gzFile) fp->fp); +#else + pg_fatal("this build does not support compression with %s", + "gzip"); #endif - return feof(fp->uncompressedfp); + break; + case PG_COMPRESSION_LZ4: + pg_fatal("compression with %s is not yet supported", "LZ4"); + break; + case PG_COMPRESSION_ZSTD: + pg_fatal("compression with %s is not yet supported", "ZSTD"); + break; + } + + return ret; } const char * get_cfp_error(cfp *fp) { -#ifdef HAVE_LIBZ - if (fp->compressedfp) + if (fp->compression_spec.algorithm == PG_COMPRESSION_GZIP) { +#ifdef HAVE_LIBZ int errnum; - const char *errmsg = gzerror(fp->compressedfp, &errnum); + const char *errmsg = gzerror((gzFile) fp->fp, &errnum); if (errnum != Z_ERRNO) return errmsg; - } +#else + pg_fatal("this build does not support compression with %s", "gzip"); #endif + } + return strerror(errno); } diff --git a/src/bin/pg_dump/compress_io.h b/src/bin/pg_dump/compress_io.h index 34f4e5e1e14..768096c820d 100644 --- a/src/bin/pg_dump/compress_io.h +++ b/src/bin/pg_dump/compress_io.h @@ -54,6 +54,8 @@ typedef struct cfp cfp; extern cfp *cfopen(const char *path, const char *mode, const pg_compress_specification *compression_spec); +extern cfp *cfdopen(int fd, const char *mode, + const pg_compress_specification *compression_spec); extern cfp *cfopen_read(const char *path, const char *mode); extern cfp *cfopen_write(const char *path, const char *mode, const pg_compress_specification *compression_spec); diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c index b82bad107f8..5164b57f042 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -31,6 +31,7 @@ #endif #include "common/string.h" +#include "compress_io.h" #include "dumputils.h" #include "fe_utils/string_utils.h" #include "lib/stringinfo.h" @@ -43,13 +44,6 @@ #define TEXT_DUMP_HEADER "--\n-- PostgreSQL database dump\n--\n\n" #define TEXT_DUMPALL_HEADER "--\n-- PostgreSQL database cluster dump\n--\n\n" -/* state needed to save/restore an archive's output target */ -typedef struct _outputContext -{ - void *OF; - int gzOut; -} OutputContext; - /* * State for tracking TocEntrys that are ready to process during a parallel * restore. (This used to be a list, and we still call it that, though now @@ -101,8 +95,8 @@ static void dump_lo_buf(ArchiveHandle *AH); static void dumpTimestamp(ArchiveHandle *AH, const char *msg, time_t tim); static void SetOutput(ArchiveHandle *AH, const char *filename, const pg_compress_specification *compression_spec); -static OutputContext SaveOutput(ArchiveHandle *AH); -static void RestoreOutput(ArchiveHandle *AH, OutputContext savedContext); +static cfp *SaveOutput(ArchiveHandle *AH); +static void RestoreOutput(ArchiveHandle *AH, cfp *savedOutput); static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel); static void restore_toc_entries_prefork(ArchiveHandle *AH, @@ -277,11 +271,8 @@ CloseArchive(Archive *AHX) AH->ClosePtr(AH); /* Close the output */ - errno = 0; /* in case gzclose() doesn't set it */ - if (AH->gzOut) - res = GZCLOSE(AH->OF); - else if (AH->OF != stdout) - res = fclose(AH->OF); + errno = 0; + res = cfclose(AH->OF); if (res != 0) pg_fatal("could not close output file: %m"); @@ -362,8 +353,9 @@ RestoreArchive(Archive *AHX) ArchiveHandle *AH = (ArchiveHandle *) AHX; RestoreOptions *ropt = AH->public.ropt; bool parallel_mode; + bool supports_compression; TocEntry *te; - OutputContext sav; + cfp *sav; AH->stage = STAGE_INITIALIZING; @@ -391,17 +383,24 @@ RestoreArchive(Archive *AHX) /* * Make sure we won't need (de)compression we haven't got */ -#ifndef HAVE_LIBZ - if (AH->compression_spec.algorithm == PG_COMPRESSION_GZIP && + supports_compression = true; + if (AH->compression_spec.algorithm != PG_COMPRESSION_NONE && + AH->compression_spec.algorithm == PG_COMPRESSION_GZIP && AH->PrintTocDataPtr != NULL) { for (te = AH->toc->next; te != AH->toc; te = te->next) { if (te->hadDumper && (te->reqs & REQ_DATA) != 0) - pg_fatal("cannot restore from compressed archive (compression not supported in this installation)"); + { +#ifndef HAVE_LIBZ + if (AH->compression_spec.algorithm == PG_COMPRESSION_GZIP) + supports_compression = false; +#endif + if (supports_compression == false) + pg_fatal("cannot restore from compressed archive (compression not supported in this installation)"); + } } } -#endif /* * Prepare index arrays, so we can assume we have them throughout restore. @@ -1128,7 +1127,7 @@ PrintTOCSummary(Archive *AHX) TocEntry *te; pg_compress_specification out_compression_spec = {0}; teSection curSection; - OutputContext sav; + cfp *sav; const char *fmtName; char stamp_str[64]; @@ -1503,58 +1502,32 @@ static void SetOutput(ArchiveHandle *AH, const char *filename, const pg_compress_specification *compression_spec) { - int fn; + const char *mode; + int fn = -1; if (filename) { if (strcmp(filename, "-") == 0) fn = fileno(stdout); - else - fn = -1; } else if (AH->FH) fn = fileno(AH->FH); else if (AH->fSpec) { - fn = -1; filename = AH->fSpec; } else fn = fileno(stdout); - /* If compression explicitly requested, use gzopen */ -#ifdef HAVE_LIBZ - if (compression_spec->algorithm == PG_COMPRESSION_GZIP) - { - char fmode[14]; + if (AH->mode == archModeAppend) + mode = PG_BINARY_A; + else + mode = PG_BINARY_W; - /* Don't use PG_BINARY_x since this is zlib */ - sprintf(fmode, "wb%d", compression_spec->level); - if (fn >= 0) - AH->OF = gzdopen(dup(fn), fmode); - else - AH->OF = gzopen(filename, fmode); - AH->gzOut = 1; - } + if (fn >= 0) + AH->OF = cfdopen(dup(fn), mode, compression_spec); else -#endif - { /* Use fopen */ - if (AH->mode == archModeAppend) - { - if (fn >= 0) - AH->OF = fdopen(dup(fn), PG_BINARY_A); - else - AH->OF = fopen(filename, PG_BINARY_A); - } - else - { - if (fn >= 0) - AH->OF = fdopen(dup(fn), PG_BINARY_W); - else - AH->OF = fopen(filename, PG_BINARY_W); - } - AH->gzOut = 0; - } + AH->OF = cfopen(filename, mode, compression_spec); if (!AH->OF) { @@ -1565,33 +1538,24 @@ SetOutput(ArchiveHandle *AH, const char *filename, } } -static OutputContext +static cfp * SaveOutput(ArchiveHandle *AH) { - OutputContext sav; - - sav.OF = AH->OF; - sav.gzOut = AH->gzOut; - - return sav; + return (cfp *) AH->OF; } static void -RestoreOutput(ArchiveHandle *AH, OutputContext savedContext) +RestoreOutput(ArchiveHandle *AH, cfp *savedOutput) { int res; - errno = 0; /* in case gzclose() doesn't set it */ - if (AH->gzOut) - res = GZCLOSE(AH->OF); - else - res = fclose(AH->OF); + errno = 0; + res = cfclose(AH->OF); if (res != 0) pg_fatal("could not close output file: %m"); - AH->gzOut = savedContext.gzOut; - AH->OF = savedContext.OF; + AH->OF = savedOutput; } @@ -1715,22 +1679,17 @@ ahwrite(const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH) bytes_written = size * nmemb; } - else if (AH->gzOut) - bytes_written = GZWRITE(ptr, size, nmemb, AH->OF); else if (AH->CustomOutPtr) bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb); + /* + * If we're doing a restore, and it's direct to DB, and we're connected + * then send it to the DB. + */ + else if (RestoringToDB(AH)) + bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb); else - { - /* - * If we're doing a restore, and it's direct to DB, and we're - * connected then send it to the DB. - */ - if (RestoringToDB(AH)) - bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb); - else - bytes_written = fwrite(ptr, size, nmemb, AH->OF) * size; - } + bytes_written = cfwrite(ptr, size * nmemb, AH->OF); if (bytes_written != size * nmemb) WRITE_ERROR_EXIT; @@ -2219,6 +2178,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt, SetupWorkerPtrType setupWorkerPtr) { ArchiveHandle *AH; + pg_compress_specification out_compress_spec = {0}; pg_log_debug("allocating AH for %s, format %d", FileSpec ? FileSpec : "(stdio)", fmt); @@ -2272,8 +2232,8 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt, memset(&(AH->sqlparse), 0, sizeof(AH->sqlparse)); /* Open stdout with no compression for AH output handle */ - AH->gzOut = 0; - AH->OF = stdout; + out_compress_spec.algorithm = PG_COMPRESSION_NONE; + AH->OF = cfdopen(dup(fileno(stdout)), PG_BINARY_A, &out_compress_spec); /* * On Windows, we need to use binary mode to read/write non-text files, diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h index f72446ed5b4..4725e49747b 100644 --- a/src/bin/pg_dump/pg_backup_archiver.h +++ b/src/bin/pg_dump/pg_backup_archiver.h @@ -32,30 +32,6 @@ #define LOBBUFSIZE 16384 -#ifdef HAVE_LIBZ -#include -#define GZCLOSE(fh) gzclose(fh) -#define GZWRITE(p, s, n, fh) gzwrite(fh, p, (n) * (s)) -#define GZREAD(p, s, n, fh) gzread(fh, p, (n) * (s)) -#define GZEOF(fh) gzeof(fh) -#else -#define GZCLOSE(fh) fclose(fh) -#define GZWRITE(p, s, n, fh) (fwrite(p, s, n, fh) * (s)) -#define GZREAD(p, s, n, fh) fread(p, s, n, fh) -#define GZEOF(fh) feof(fh) -/* this is just the redefinition of a libz constant */ -#define Z_DEFAULT_COMPRESSION (-1) - -typedef struct _z_stream -{ - void *next_in; - void *next_out; - size_t avail_in; - size_t avail_out; -} z_stream; -typedef z_stream *z_streamp; -#endif - /* Data block types */ #define BLK_DATA 1 #define BLK_BLOBS 3 @@ -319,8 +295,7 @@ struct _archiveHandle char *fSpec; /* Archive File Spec */ FILE *FH; /* General purpose file handle */ - void *OF; - int gzOut; /* Output file */ + void *OF; /* Output file */ struct _tocEntry *toc; /* Header of circular list of TOC entries */ int tocCount; /* Number of TOC entries */ -- 2.25.1