#include "pg_backup_archiver.h"

Include dependency graph for compress_io.h:

This graph shows which files directly or indirectly include 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 21 of file compress_io.h.

Typedef Documentation

◆ CompressFileHandle

typedef struct CompressFileHandle CompressFileHandle

Definition at line 87 of file compress_io.h.

◆ CompressorState

typedef struct CompressorState CompressorState

Definition at line 41 of file compress_io.h.

◆ ReadFunc

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

Definition at line 41 of file compress_io.h.

◆ WriteFunc

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

Definition at line 28 of file compress_io.h.

Function Documentation

◆ AllocateCompressor()

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

Definition at line 118 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);
  
     return cs;
 }

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

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

◆ EndCompressFileHandle()

bool EndCompressFileHandle ( CompressFileHandle * CFH )

Definition at line 281 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 141 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 187 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);
  
     return CFH;
 }

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

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

◆ InitDiscoverCompressFileHandle()

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

Definition at line 217 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 = strdup(path);
  
     if (hasSuffix(fname, ".gz"))
         compression_spec.algorithm = PG_COMPRESSION_GZIP;
     else
     {
         bool        exists;
  
         exists = (stat(path, &st) == 0);
         /* avoid unused warning if it is not built with compression */
         if (exists)
             compression_spec.algorithm = PG_COMPRESSION_NONE;
 #ifdef HAVE_LIBZ
         if (!exists)
         {
             free_keep_errno(fname);
             fname = psprintf("%s.gz", path);
             exists = (stat(fname, &st) == 0);
  
             if (exists)
                 compression_spec.algorithm = PG_COMPRESSION_GZIP;
         }
 #endif
 #ifdef USE_LZ4
         if (!exists)
         {
             free_keep_errno(fname);
             fname = psprintf("%s.lz4", path);
             exists = (stat(fname, &st) == 0);
  
             if (exists)
                 compression_spec.algorithm = PG_COMPRESSION_LZ4;
         }
 #endif
     }
  
     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(), free_keep_errno(), hasSuffix(), InitCompressFileHandle(), mode, CompressFileHandle::open_func, PG_BINARY_R, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, psprintf(), and stat.

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

◆ supports_compression()

char* supports_compression ( const pg_compress_specification compression_spec )

Definition at line 86 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
  
     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, and psprintf().

Referenced by ReadHead(), and RestoreArchive().

Data Structures

Macros

Typedefs

Functions