astreamer_gzip.c File Reference

#include "postgres_fe.h"
#include <unistd.h>
#include "common/logging.h"
#include "fe_utils/astreamer.h"

Include dependency graph for astreamer_gzip.c:

Go to the source code of this file.

Functions
astreamer *	astreamer_gzip_writer_new (char *pathname, FILE *file, pg_compress_specification *compress)
astreamer *	astreamer_gzip_decompressor_new (astreamer *next)

Function Documentation

astreamer_gzip_decompressor_new()

astreamer * astreamer_gzip_decompressor_new

(

astreamer *

next

)

Definition at line 236 of file astreamer_gzip.c.

{
#ifdef HAVE_LIBZ
    astreamer_gzip_decompressor *streamer;
    z_stream   *zs;
 
    Assert(next != NULL);
 
    streamer = palloc0(sizeof(astreamer_gzip_decompressor));
    *((const astreamer_ops **) &streamer->base.bbs_ops) =
        &astreamer_gzip_decompressor_ops;
 
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
 
    /* Initialize internal stream state for decompression */
    zs = &streamer->zstream;
    zs->zalloc = gzip_palloc;
    zs->zfree = gzip_pfree;
    zs->next_out = (uint8 *) streamer->base.bbs_buffer.data;
    zs->avail_out = streamer->base.bbs_buffer.maxlen;
 
    /*
     * Data compression was initialized using deflateInit2 to request a gzip
     * header. Similarly, we are using inflateInit2 to initialize data
     * decompression.
     *
     * Per the documentation for inflateInit2, the second argument is
     * "windowBits" and its value must be greater than or equal to the value
     * provided while compressing the data, so we are using the maximum
     * possible value for safety.
     */
    if (inflateInit2(zs, 15 + 16) != Z_OK)
        pg_fatal("could not initialize compression library");
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "gzip");
    return NULL;                /* keep compiler quiet */
#endif
}

References Assert(), if(), initStringInfo(), next, palloc0(), and pg_fatal.

Referenced by create_archive_verifier(), and CreateBackupStreamer().

astreamer_gzip_writer_new()

astreamer * astreamer_gzip_writer_new	(	char *	pathname,
		FILE *	file,
		pg_compress_specification *	compress
	)

Definition at line 99 of file astreamer_gzip.c.

{
#ifdef HAVE_LIBZ
    astreamer_gzip_writer *streamer;
 
    streamer = palloc0(sizeof(astreamer_gzip_writer));
    *((const astreamer_ops **) &streamer->base.bbs_ops) =
        &astreamer_gzip_writer_ops;
 
    streamer->pathname = pstrdup(pathname);
 
    if (file == NULL)
    {
        streamer->gzfile = gzopen(pathname, "wb");
        if (streamer->gzfile == NULL)
            pg_fatal("could not create compressed file \"%s\": %m",
                     pathname);
    }
    else
    {
        /*
         * We must dup the file handle so that gzclose doesn't break the
         * caller's FILE.  See comment for astreamer_gzip_writer_finalize.
         */
        int         fd = dup(fileno(file));
 
        if (fd < 0)
            pg_fatal("could not duplicate stdout: %m");
 
        streamer->gzfile = gzdopen(fd, "wb");
        if (streamer->gzfile == NULL)
            pg_fatal("could not open output file: %m");
    }
 
    if (gzsetparams(streamer->gzfile, compress->level, Z_DEFAULT_STRATEGY) != Z_OK)
        pg_fatal("could not set compression level %d: %s",
                 compress->level, get_gz_error(streamer->gzfile));
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "gzip");
    return NULL;                /* keep compiler quiet */
#endif
}

References fd(), pg_compress_specification::level, palloc0(), pg_fatal, and pstrdup().

Referenced by CreateBackupStreamer().