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.

Data Structures
struct	CompressorState
struct	CompressFileHandle

Macros
#define	DEFAULT_IO_BUFFER_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 CompressFileHandle	CompressFileHandle

Functions
char *	supports_compression (const pg_compress_specification compression_spec)
CompressorState *	AllocateCompressor (const pg_compress_specification compression_spec, ReadFunc readF, WriteFunc writeF)
void	EndCompressor (ArchiveHandle *AH, CompressorState *cs)
CompressFileHandle *	InitCompressFileHandle (const pg_compress_specification compression_spec)
CompressFileHandle *	InitDiscoverCompressFileHandle (const char *path, const char *mode)
bool	EndCompressFileHandle (CompressFileHandle *CFH)

Macro Definition Documentation

DEFAULT_IO_BUFFER_SIZE

#define DEFAULT_IO_BUFFER_SIZE   4096

Definition at line 27 of file compress_io.h.

Typedef Documentation

CompressFileHandle

typedef struct CompressFileHandle CompressFileHandle

Definition at line 98 of file compress_io.h.

CompressorState

typedef struct CompressorState CompressorState

Definition at line 49 of file compress_io.h.

ReadFunc

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

Definition at line 47 of file compress_io.h.

WriteFunc

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

Definition at line 34 of file compress_io.h.

Function Documentation

AllocateCompressor()

CompressorState * AllocateCompressor	(	const pg_compress_specification	compression_spec,
		ReadFunc	readF,
		WriteFunc	writeF
	)

Definition at line 123 of file compress_io.c.

{
    CompressorState *cs;
 
    cs = (CompressorState *) pg_malloc0(sizeof(CompressorState));
    cs->readF = readF;
    cs->writeF = writeF;
 
    if (compression_spec.algorithm == PG_COMPRESSION_NONE)
        InitCompressorNone(cs, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_GZIP)
        InitCompressorGzip(cs, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_LZ4)
        InitCompressorLZ4(cs, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_ZSTD)
        InitCompressorZstd(cs, compression_spec);
 
    return cs;
}

References pg_compress_specification::algorithm, InitCompressorGzip(), InitCompressorLZ4(), InitCompressorNone(), InitCompressorZstd(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, pg_malloc0(), CompressorState::readF, and CompressorState::writeF.

Referenced by _PrintData(), _StartData(), and _StartLO().

EndCompressFileHandle()

bool EndCompressFileHandle

(

CompressFileHandle *

CFH

)

Definition at line 288 of file compress_io.c.

{
    bool        ret = false;
 
    if (CFH->private_data)
        ret = CFH->close_func(CFH);
 
    free_keep_errno(CFH);
 
    return ret;
}

References CompressFileHandle::close_func, free_keep_errno(), and CompressFileHandle::private_data.

Referenced by _CloseArchive(), _EndData(), _EndLO(), _EndLOs(), _LoadLOs(), _PrintFileData(), CloseArchive(), InitArchiveFmt_Directory(), and RestoreOutput().

EndCompressor()

void EndCompressor	(	ArchiveHandle *	AH,
		CompressorState *	cs
	)

Definition at line 148 of file compress_io.c.

{
    cs->end(AH, cs);
    pg_free(cs);
}

References CompressorState::end, and pg_free().

Referenced by _EndData(), _EndLO(), and _PrintData().

InitCompressFileHandle()

CompressFileHandle * InitCompressFileHandle

(

const pg_compress_specification

compression_spec

)

Definition at line 194 of file compress_io.c.

{
    CompressFileHandle *CFH;
 
    CFH = pg_malloc0(sizeof(CompressFileHandle));
 
    if (compression_spec.algorithm == PG_COMPRESSION_NONE)
        InitCompressFileHandleNone(CFH, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_GZIP)
        InitCompressFileHandleGzip(CFH, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_LZ4)
        InitCompressFileHandleLZ4(CFH, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_ZSTD)
        InitCompressFileHandleZstd(CFH, compression_spec);
 
    return CFH;
}

References pg_compress_specification::algorithm, InitCompressFileHandleGzip(), InitCompressFileHandleLZ4(), InitCompressFileHandleNone(), InitCompressFileHandleZstd(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, and pg_malloc0().

Referenced by _allocAH(), _CloseArchive(), _StartData(), _StartLO(), _StartLOs(), InitDiscoverCompressFileHandle(), and SetOutput().

InitDiscoverCompressFileHandle()

CompressFileHandle * InitDiscoverCompressFileHandle	(	const char *	path,
		const char *	mode
	)

Definition at line 240 of file compress_io.c.

{
    CompressFileHandle *CFH = NULL;
    struct stat st;
    char       *fname;
    pg_compress_specification compression_spec = {0};
 
    compression_spec.algorithm = PG_COMPRESSION_NONE;
 
    Assert(strcmp(mode, PG_BINARY_R) == 0);
 
    fname = pg_strdup(path);
 
    if (hasSuffix(fname, ".gz"))
        compression_spec.algorithm = PG_COMPRESSION_GZIP;
    else if (hasSuffix(fname, ".lz4"))
        compression_spec.algorithm = PG_COMPRESSION_LZ4;
    else if (hasSuffix(fname, ".zst"))
        compression_spec.algorithm = PG_COMPRESSION_ZSTD;
    else
    {
        if (stat(path, &st) == 0)
            compression_spec.algorithm = PG_COMPRESSION_NONE;
        else if (check_compressed_file(path, &fname, "gz"))
            compression_spec.algorithm = PG_COMPRESSION_GZIP;
        else if (check_compressed_file(path, &fname, "lz4"))
            compression_spec.algorithm = PG_COMPRESSION_LZ4;
        else if (check_compressed_file(path, &fname, "zst"))
            compression_spec.algorithm = PG_COMPRESSION_ZSTD;
    }
 
    CFH = InitCompressFileHandle(compression_spec);
    if (!CFH->open_func(fname, -1, mode, CFH))
    {
        free_keep_errno(CFH);
        CFH = NULL;
    }
    free_keep_errno(fname);
 
    return CFH;
}

References pg_compress_specification::algorithm, Assert(), check_compressed_file(), free_keep_errno(), hasSuffix(), InitCompressFileHandle(), mode, CompressFileHandle::open_func, PG_BINARY_R, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, pg_strdup(), and stat.

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

supports_compression()

char * supports_compression

(

const pg_compress_specification

compression_spec

)

Definition at line 87 of file compress_io.c.

{
    const pg_compress_algorithm algorithm = compression_spec.algorithm;
    bool        supported = false;
 
    if (algorithm == PG_COMPRESSION_NONE)
        supported = true;
#ifdef HAVE_LIBZ
    if (algorithm == PG_COMPRESSION_GZIP)
        supported = true;
#endif
#ifdef USE_LZ4
    if (algorithm == PG_COMPRESSION_LZ4)
        supported = true;
#endif
#ifdef USE_ZSTD
    if (algorithm == PG_COMPRESSION_ZSTD)
        supported = true;
#endif
 
    if (!supported)
        return psprintf(_("this build does not support compression with %s"),
                        get_compress_algorithm_name(algorithm));
 
    return NULL;
}

References _, pg_compress_specification::algorithm, get_compress_algorithm_name(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, and psprintf().

Referenced by main(), ReadHead(), and RestoreArchive().