compress_io.h File Reference

#include "pg_backup_archiver.h"

Include dependency graph for compress_io.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ZLIB_OUT_SIZE   4096
#define	ZLIB_IN_SIZE   4096

Typedefs
typedef void(*	WriteFunc) (ArchiveHandle *AH, const char *buf, size_t len)
typedef size_t(*	ReadFunc) (ArchiveHandle *AH, char **buf, size_t *buflen)
typedef struct CompressorState	CompressorState
typedef struct cfp	cfp

Enumerations
enum	CompressionAlgorithm { COMPR_ALG_NONE, COMPR_ALG_LIBZ }

Functions
CompressorState *	AllocateCompressor (int compression, WriteFunc writeF)
void	ReadDataFromArchive (ArchiveHandle *AH, int compression, ReadFunc readF)
void	WriteDataToArchive (ArchiveHandle *AH, CompressorState *cs, const void *data, size_t dLen)
void	EndCompressor (ArchiveHandle *AH, CompressorState *cs)
cfp *	cfopen (const char *path, const char *mode, int compression)
cfp *	cfopen_read (const char *path, const char *mode)
cfp *	cfopen_write (const char *path, const char *mode, int compression)
int	cfread (void *ptr, int size, cfp *fp)
int	cfwrite (const void *ptr, int size, cfp *fp)
int	cfgetc (cfp *fp)
char *	cfgets (cfp *fp, char *buf, int len)
int	cfclose (cfp *fp)
int	cfeof (cfp *fp)
const char *	get_cfp_error (cfp *fp)

Macro Definition Documentation

ZLIB_IN_SIZE

#define ZLIB_IN_SIZE   4096

Definition at line 22 of file compress_io.h.

Referenced by EndCompressor().

ZLIB_OUT_SIZE

#define ZLIB_OUT_SIZE   4096

Definition at line 21 of file compress_io.h.

Typedef Documentation

cfp

typedef struct cfp cfp

Definition at line 57 of file compress_io.h.

CompressorState

typedef struct CompressorState CompressorState

Definition at line 47 of file compress_io.h.

ReadFunc

typedef size_t(* ReadFunc) (ArchiveHandle *AH, char **buf, size_t *buflen)

Definition at line 44 of file compress_io.h.

WriteFunc

typedef void(* WriteFunc) (ArchiveHandle *AH, const char *buf, size_t len)

Definition at line 31 of file compress_io.h.

Enumeration Type Documentation

CompressionAlgorithm

enum CompressionAlgorithm

Enumerator
COMPR_ALG_NONE
COMPR_ALG_LIBZ

Definition at line 24 of file compress_io.h.

{
    COMPR_ALG_NONE,
    COMPR_ALG_LIBZ
} CompressionAlgorithm;

Function Documentation

AllocateCompressor()

CompressorState* AllocateCompressor	(	int	compression,
		WriteFunc	writeF
	)

Definition at line 128 of file compress_io.c.

References COMPR_ALG_LIBZ, CompressorState::comprAlg, exit_horribly(), modulename, ParseCompressionOption(), pg_malloc0(), and CompressorState::writeF.

Referenced by _StartBlob(), and _StartData().

{
    CompressorState *cs;
    CompressionAlgorithm alg;
    int         level;

    ParseCompressionOption(compression, &alg, &level);

#ifndef HAVE_LIBZ
    if (alg == COMPR_ALG_LIBZ)
        exit_horribly(modulename, "not built with zlib support\n");
#endif

    cs = (CompressorState *) pg_malloc0(sizeof(CompressorState));
    cs->writeF = writeF;
    cs->comprAlg = alg;

    /*
     * Perform compression algorithm specific initialization.
     */
#ifdef HAVE_LIBZ
    if (alg == COMPR_ALG_LIBZ)
        InitCompressorZlib(cs, level);
#endif

    return cs;
}

cfclose()

int cfclose

(

cfp *

fp

)

Definition at line 667 of file compress_io.c.

References free_keep_errno(), and cfp::uncompressedfp.

Referenced by _CloseArchive(), _EndBlob(), _EndBlobs(), _EndData(), _LoadBlobs(), _PrintFileData(), and InitArchiveFmt_Directory().

{
    int         result;

    if (fp == NULL)
    {
        errno = EBADF;
        return EOF;
    }
#ifdef HAVE_LIBZ
    if (fp->compressedfp)
    {
        result = gzclose(fp->compressedfp);
        fp->compressedfp = NULL;
    }
    else
#endif
    {
        result = fclose(fp->uncompressedfp);
        fp->uncompressedfp = NULL;
    }
    free_keep_errno(fp);

    return result;
}

cfeof()

int cfeof

(

cfp *

fp

)

Definition at line 694 of file compress_io.c.

References cfp::uncompressedfp.

Referenced by _LoadBlobs().

{
#ifdef HAVE_LIBZ
    if (fp->compressedfp)
        return gzeof(fp->compressedfp);
    else
#endif
        return feof(fp->uncompressedfp);
}

cfgetc()

int cfgetc

(

cfp *

fp

)

Definition at line 626 of file compress_io.c.

References exit_horribly(), modulename, READ_ERROR_EXIT, strerror(), and cfp::uncompressedfp.

Referenced by _ReadByte().

{
    int         ret;

#ifdef HAVE_LIBZ
    if (fp->compressedfp)
    {
        ret = gzgetc(fp->compressedfp);
        if (ret == EOF)
        {
            if (!gzeof(fp->compressedfp))
                exit_horribly(modulename,
                              "could not read from input file: %s\n", strerror(errno));
            else
                exit_horribly(modulename,
                              "could not read from input file: end of file\n");
        }
    }
    else
#endif
    {
        ret = fgetc(fp->uncompressedfp);
        if (ret == EOF)
            READ_ERROR_EXIT(fp->uncompressedfp);
    }

    return ret;
}

cfgets()

char* cfgets	(	cfp *	fp,
		char *	buf,
		int	len
	)

Definition at line 656 of file compress_io.c.

References cfp::uncompressedfp.

Referenced by _LoadBlobs().

{
#ifdef HAVE_LIBZ
    if (fp->compressedfp)
        return gzgets(fp->compressedfp, buf, len);
    else
#endif
        return fgets(buf, len, fp->uncompressedfp);
}

cfopen()

cfp* cfopen	(	const char *	path,
		const char *	mode,
		int	compression
	)

Definition at line 533 of file compress_io.c.

References exit_horribly(), free_keep_errno(), modulename, pg_malloc(), snprintf(), cfp::uncompressedfp, and Z_DEFAULT_COMPRESSION.

Referenced by cfopen_read(), and cfopen_write().

{
    cfp        *fp = pg_malloc(sizeof(cfp));

    if (compression != 0)
    {
#ifdef HAVE_LIBZ
        if (compression != 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);
            fp->compressedfp = gzopen(path, mode_compression);
        }
        else
        {
            /* don't specify a level, just use the zlib default */
            fp->compressedfp = gzopen(path, mode);
        }

        fp->uncompressedfp = NULL;
        if (fp->compressedfp == NULL)
        {
            free_keep_errno(fp);
            fp = NULL;
        }
#else
        exit_horribly(modulename, "not built with zlib support\n");
#endif
    }
    else
    {
#ifdef HAVE_LIBZ
        fp->compressedfp = NULL;
#endif
        fp->uncompressedfp = fopen(path, mode);
        if (fp->uncompressedfp == NULL)
        {
            free_keep_errno(fp);
            fp = NULL;
        }
    }

    return fp;
}

cfopen_read()

cfp* cfopen_read	(	const char *	path,
		const char *	mode
	)

Definition at line 467 of file compress_io.c.

References cfopen(), free_keep_errno(), and psprintf().

Referenced by _LoadBlobs(), _PrintFileData(), and InitArchiveFmt_Directory().

{
    cfp        *fp;

#ifdef HAVE_LIBZ
    if (hasSuffix(path, ".gz"))
        fp = cfopen(path, mode, 1);
    else
#endif
    {
        fp = cfopen(path, mode, 0);
#ifdef HAVE_LIBZ
        if (fp == NULL)
        {
            char       *fname;

            fname = psprintf("%s.gz", path);
            fp = cfopen(fname, mode, 1);
            free_keep_errno(fname);
        }
#endif
    }
    return fp;
}

cfopen_write()

cfp* cfopen_write	(	const char *	path,
		const char *	mode,
		int	compression
	)

Definition at line 504 of file compress_io.c.

References cfopen(), exit_horribly(), free_keep_errno(), modulename, and psprintf().

Referenced by _CloseArchive(), _StartBlob(), _StartBlobs(), and _StartData().

{
    cfp        *fp;

    if (compression == 0)
        fp = cfopen(path, mode, 0);
    else
    {
#ifdef HAVE_LIBZ
        char       *fname;

        fname = psprintf("%s.gz", path);
        fp = cfopen(fname, mode, compression);
        free_keep_errno(fname);
#else
        exit_horribly(modulename, "not built with zlib support\n");
        fp = NULL;              /* keep compiler quiet */
#endif
    }
    return fp;
}

cfread()

int cfread	(	void *	ptr,
		int	size,
		cfp *	fp
	)

Definition at line 583 of file compress_io.c.

References errmsg(), exit_horribly(), modulename, READ_ERROR_EXIT, strerror(), and cfp::uncompressedfp.

Referenced by _PrintFileData(), and _ReadBuf().

{
    int         ret;

    if (size == 0)
        return 0;

#ifdef HAVE_LIBZ
    if (fp->compressedfp)
    {
        ret = gzread(fp->compressedfp, ptr, size);
        if (ret != size && !gzeof(fp->compressedfp))
        {
            int         errnum;
            const char *errmsg = gzerror(fp->compressedfp, &errnum);

            exit_horribly(modulename,
                          "could not read from input file: %s\n",
                          errnum == Z_ERRNO ? strerror(errno) : errmsg);
        }
    }
    else
#endif
    {
        ret = fread(ptr, 1, size, fp->uncompressedfp);
        if (ret != size && !feof(fp->uncompressedfp))
            READ_ERROR_EXIT(fp->uncompressedfp);
    }
    return ret;
}

cfwrite()

int cfwrite	(	const void *	ptr,
		int	size,
		cfp *	fp
	)

Definition at line 615 of file compress_io.c.

References cfp::uncompressedfp.

Referenced by _EndBlob(), _WriteBuf(), _WriteByte(), and _WriteData().

{
#ifdef HAVE_LIBZ
    if (fp->compressedfp)
        return gzwrite(fp->compressedfp, ptr, size);
    else
#endif
        return fwrite(ptr, 1, size, fp->uncompressedfp);
}

EndCompressor()

void EndCompressor	(	ArchiveHandle *	AH,
		CompressorState *	cs
	)

Definition at line 206 of file compress_io.c.

References ahwrite(), _z_stream::avail_in, _z_stream::avail_out, buf, COMPR_ALG_LIBZ, CompressorState::comprAlg, exit_horribly(), free, modulename, _z_stream::next_in, _z_stream::next_out, pg_malloc(), CompressorState::writeF, ZLIB_IN_SIZE, and ZLIB_OUT_SIZE.

Referenced by _EndBlob(), and _EndData().

{
#ifdef HAVE_LIBZ
    if (cs->comprAlg == COMPR_ALG_LIBZ)
        EndCompressorZlib(AH, cs);
#endif
    free(cs);
}

get_cfp_error()

const char* get_cfp_error

(

cfp *

fp

)

Definition at line 705 of file compress_io.c.

References errmsg(), filename, and strerror().

Referenced by _WriteBuf(), _WriteByte(), and _WriteData().

{
#ifdef HAVE_LIBZ
    if (fp->compressedfp)
    {
        int         errnum;
        const char *errmsg = gzerror(fp->compressedfp, &errnum);

        if (errnum != Z_ERRNO)
            return errmsg;
    }
#endif
    return strerror(errno);
}

ReadDataFromArchive()

void ReadDataFromArchive	(	ArchiveHandle *	AH,
		int	compression,
		ReadFunc	readF
	)

Definition at line 161 of file compress_io.c.

References COMPR_ALG_LIBZ, COMPR_ALG_NONE, exit_horribly(), modulename, ParseCompressionOption(), and ReadDataFromArchiveNone().

Referenced by _PrintData().

{
    CompressionAlgorithm alg;

    ParseCompressionOption(compression, &alg, NULL);

    if (alg == COMPR_ALG_NONE)
        ReadDataFromArchiveNone(AH, readF);
    if (alg == COMPR_ALG_LIBZ)
    {
#ifdef HAVE_LIBZ
        ReadDataFromArchiveZlib(AH, readF);
#else
        exit_horribly(modulename, "not built with zlib support\n");
#endif
    }
}

WriteDataToArchive()

void WriteDataToArchive	(	ArchiveHandle *	AH,
		CompressorState *	cs,
		const void *	data,
		size_t	dLen
	)

Definition at line 183 of file compress_io.c.

References COMPR_ALG_LIBZ, COMPR_ALG_NONE, CompressorState::comprAlg, exit_horribly(), modulename, and WriteDataToArchiveNone().

Referenced by _WriteData().

{
    switch (cs->comprAlg)
    {
        case COMPR_ALG_LIBZ:
#ifdef HAVE_LIBZ
            WriteDataToArchiveZlib(AH, cs, data, dLen);
#else
            exit_horribly(modulename, "not built with zlib support\n");
#endif
            break;
        case COMPR_ALG_NONE:
            WriteDataToArchiveNone(AH, cs, data, dLen);
            break;
    }
    return;
}