#include <time.h>
#include "libpq-fe.h"
#include "pg_backup.h"
#include "pqexpbuffer.h"

Include dependency graph for pg_backup_archiver.h:

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

Data Structures
struct	_z_stream

struct	sqlparseInfo

struct	_archiveHandle

struct	_tocEntry

struct	_archiveOpts

Macros
#define	LOBBUFSIZE 16384

#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)

#define	Z_DEFAULT_COMPRESSION (-1)

#define	BLK_DATA 1

#define	BLK_BLOBS 3

#define	MAKE_ARCHIVE_VERSION(major, minor, rev) (((major) * 256 + (minor)) * 256 + (rev))

#define	ARCHIVE_MAJOR(version) (((version) >> 16) & 255)

#define	ARCHIVE_MINOR(version) (((version) >> 8) & 255)

#define	ARCHIVE_REV(version) (((version) ) & 255)

#define	K_VERS_1_0 MAKE_ARCHIVE_VERSION(1, 0, 0)

#define	K_VERS_1_2 MAKE_ARCHIVE_VERSION(1, 2, 0) /* Allow No ZLIB */

#define	K_VERS_1_3 MAKE_ARCHIVE_VERSION(1, 3, 0) /* BLOBs */

#define	K_VERS_1_4 MAKE_ARCHIVE_VERSION(1, 4, 0) /* Date & name in header */

#define	K_VERS_1_5 MAKE_ARCHIVE_VERSION(1, 5, 0) /* Handle dependencies */

#define	K_VERS_1_6 MAKE_ARCHIVE_VERSION(1, 6, 0) /* Schema field in TOCs */

#define	K_VERS_1_7

#define	K_VERS_1_8

#define	K_VERS_1_9

#define	K_VERS_1_10 MAKE_ARCHIVE_VERSION(1, 10, 0) /* add tablespace */

#define	K_VERS_1_11

#define	K_VERS_1_12

#define	K_VERS_1_13

#define	K_VERS_1_14 MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */

#define	K_VERS_MAJOR 1

#define	K_VERS_MINOR 14

#define	K_VERS_REV 0

#define	K_VERS_SELF MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV)

#define	K_VERS_MAX MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)

#define	K_OFFSET_POS_NOT_SET 1

#define	K_OFFSET_POS_SET 2

#define	K_OFFSET_NO_DATA 3

#define	WORKER_OK 0

#define	WORKER_CREATE_DONE 10

#define	WORKER_INHIBIT_DATA 11

#define	WORKER_IGNORED_ERRORS 12

#define	READ_ERROR_EXIT(fd)

#define	WRITE_ERROR_EXIT

#define	RESTORE_PASS_LAST RESTORE_PASS_POST_ACL

#define	ARCHIVE_OPTS(...) &(ArchiveOpts){__VA_ARGS__}

#define	appendStringLiteralAHX(buf, str, AH) appendStringLiteral(buf, str, (AH)->public.encoding, (AH)->public.std_strings)

#define	appendByteaLiteralAHX(buf, str, len, AH) appendByteaLiteral(buf, str, len, (AH)->public.std_strings)

Typedefs
typedef struct _z_stream	z_stream

typedef z_stream *	z_streamp

typedef struct _archiveHandle	ArchiveHandle

typedef struct _tocEntry	TocEntry

typedef enum T_Action	T_Action

typedef void(*	ClosePtrType) (ArchiveHandle *AH)

typedef void(*	ReopenPtrType) (ArchiveHandle *AH)

typedef void(*	ArchiveEntryPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	StartDataPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	WriteDataPtrType) (ArchiveHandle AH, const void data, size_t dLen)

typedef void(*	EndDataPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	StartBlobsPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	StartBlobPtrType) (ArchiveHandle AH, TocEntry te, Oid oid)

typedef void(*	EndBlobPtrType) (ArchiveHandle AH, TocEntry te, Oid oid)

typedef void(*	EndBlobsPtrType) (ArchiveHandle AH, TocEntry te)

typedef int(*	WriteBytePtrType) (ArchiveHandle *AH, const int i)

typedef int(*	ReadBytePtrType) (ArchiveHandle *AH)

typedef void(*	WriteBufPtrType) (ArchiveHandle AH, const void c, size_t len)

typedef void(*	ReadBufPtrType) (ArchiveHandle AH, void buf, size_t len)

typedef void(*	WriteExtraTocPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	ReadExtraTocPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	PrintExtraTocPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	PrintTocDataPtrType) (ArchiveHandle AH, TocEntry te)

typedef void(*	PrepParallelRestorePtrType) (ArchiveHandle *AH)

typedef void(*	ClonePtrType) (ArchiveHandle *AH)

typedef void(*	DeClonePtrType) (ArchiveHandle *AH)

typedef int(*	WorkerJobDumpPtrType) (ArchiveHandle AH, TocEntry te)

typedef int(*	WorkerJobRestorePtrType) (ArchiveHandle AH, TocEntry te)

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

typedef void struct _archiveOpts	ArchiveOpts

Enumerations
enum	T_Action { ACT_DUMP, ACT_RESTORE }

enum	sqlparseState { SQL_SCAN = 0, SQL_IN_SINGLE_QUOTE, SQL_IN_DOUBLE_QUOTE }

enum	ArchiverStage { STAGE_NONE = 0, STAGE_INITIALIZING, STAGE_PROCESSING, STAGE_FINALIZING }

enum	ArchiverOutput { OUTPUT_SQLCMDS = 0, OUTPUT_COPYDATA, OUTPUT_OTHERDATA }

enum	RestorePass { RESTORE_PASS_MAIN = 0, RESTORE_PASS_ACL }

enum	teReqs { REQ_SCHEMA = 0x01, REQ_DATA = 0x02, REQ_SPECIAL = 0x04 }

Functions
int	parallel_restore (ArchiveHandle AH, TocEntry te)

void	on_exit_close_archive (Archive *AHX)

void	warn_or_exit_horribly (ArchiveHandle AH, const char fmt,...) pg_attribute_printf(2

TocEntry *	ArchiveEntry (Archive AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts opts)

void	WriteHead (ArchiveHandle *AH)

void	ReadHead (ArchiveHandle *AH)

void	WriteToc (ArchiveHandle *AH)

void	ReadToc (ArchiveHandle *AH)

void	WriteDataChunks (ArchiveHandle AH, struct ParallelState pstate)

void	WriteDataChunksForTocEntry (ArchiveHandle AH, TocEntry te)

ArchiveHandle *	CloneArchive (ArchiveHandle *AH)

void	DeCloneArchive (ArchiveHandle *AH)

teReqs	TocIDRequired (ArchiveHandle *AH, DumpId id)

TocEntry *	getTocEntryByDumpId (ArchiveHandle *AH, DumpId id)

bool	checkSeek (FILE *fp)

size_t	WriteInt (ArchiveHandle *AH, int i)

int	ReadInt (ArchiveHandle *AH)

char *	ReadStr (ArchiveHandle *AH)

size_t	WriteStr (ArchiveHandle AH, const char s)

int	ReadOffset (ArchiveHandle , pgoff_t )

size_t	WriteOffset (ArchiveHandle *, pgoff_t, int)

void	StartRestoreBlobs (ArchiveHandle *AH)

void	StartRestoreBlob (ArchiveHandle *AH, Oid oid, bool drop)

void	EndRestoreBlob (ArchiveHandle *AH, Oid oid)

void	EndRestoreBlobs (ArchiveHandle *AH)

void	InitArchiveFmt_Custom (ArchiveHandle *AH)

void	InitArchiveFmt_Null (ArchiveHandle *AH)

void	InitArchiveFmt_Directory (ArchiveHandle *AH)

void	InitArchiveFmt_Tar (ArchiveHandle *AH)

bool	isValidTarHeader (char *header)

void	ReconnectToServer (ArchiveHandle AH, const char dbname, const char *newUser)

void	DropBlobIfExists (ArchiveHandle *AH, Oid oid)

void	ahwrite (const void ptr, size_t size, size_t nmemb, ArchiveHandle AH)

int	ahprintf (ArchiveHandle AH, const char fmt,...) pg_attribute_printf(2

Macro Definition Documentation

◆ appendByteaLiteralAHX

#define appendByteaLiteralAHX	(	buf,
		str,
		len,
		AH
	)	appendByteaLiteral(buf, str, len, (AH)->public.std_strings)

Definition at line 447 of file pg_backup_archiver.h.

Referenced by _WriteBlobData(), and dump_lo_buf().

◆ appendStringLiteralAHX

#define appendStringLiteralAHX	(	buf,
		str,
		AH
	)	appendStringLiteral(buf, str, (AH)->public.encoding, (AH)->public.std_strings)

Definition at line 444 of file pg_backup_archiver.h.

Referenced by _doSetSessionAuth().

◆ ARCHIVE_MAJOR

#define ARCHIVE_MAJOR ( version ) (((version) >> 16) & 255)

Definition at line 70 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_MINOR

#define ARCHIVE_MINOR ( version ) (((version) >> 8) & 255)

Definition at line 71 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_OPTS

#define ARCHIVE_OPTS ( ... ) &(ArchiveOpts){__VA_ARGS__}

Definition at line 426 of file pg_backup_archiver.h.

Referenced by dumpAccessMethod(), dumpACL(), dumpAgg(), dumpAttrDef(), dumpBaseType(), dumpBlob(), dumpCast(), dumpCollation(), dumpComment(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

◆ ARCHIVE_REV

#define ARCHIVE_REV ( version ) (((version) ) & 255)

Definition at line 72 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ BLK_BLOBS

#define BLK_BLOBS 3

Definition at line 65 of file pg_backup_archiver.h.

Referenced by _PrintTocData(), and _StartBlobs().

◆ BLK_DATA

#define BLK_DATA 1

Definition at line 64 of file pg_backup_archiver.h.

Referenced by _PrintTocData(), _readBlockHeader(), and _StartData().

◆ GZCLOSE

#define GZCLOSE ( fh ) fclose(fh)

Definition at line 46 of file pg_backup_archiver.h.

Referenced by CloseArchive(), RestoreOutput(), and tarClose().

◆ GZEOF

#define GZEOF ( fh ) feof(fh)

Definition at line 49 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZREAD

#define GZREAD	(	p,
		s,
		n,
		fh
	)	fread(p, s, n, fh)

Definition at line 48 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZWRITE

#define GZWRITE	(	p,
		s,
		n,
		fh
	)	(fwrite(p, s, n, fh) * (s))

Definition at line 47 of file pg_backup_archiver.h.

Referenced by ahwrite(), and tarWrite().

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA 3

Definition at line 110 of file pg_backup_archiver.h.

Referenced by _ArchiveEntry(), _PrintTocData(), and ReadOffset().

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET 1

Definition at line 108 of file pg_backup_archiver.h.

Referenced by _ArchiveEntry(), _PrintTocData(), and ReadOffset().

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET 2

Definition at line 109 of file pg_backup_archiver.h.

Referenced by _PrepParallelRestore(), _StartBlobs(), _StartData(), and ReadOffset().

◆ K_VERS_1_0

#define K_VERS_1_0 MAKE_ARCHIVE_VERSION(1, 0, 0)

Definition at line 75 of file pg_backup_archiver.h.

Referenced by ReadHead(), and ReadInt().

◆ K_VERS_1_10

#define K_VERS_1_10 MAKE_ARCHIVE_VERSION(1, 10, 0) /* add tablespace */

Definition at line 88 of file pg_backup_archiver.h.

Referenced by ReadHead(), and ReadToc().

◆ K_VERS_1_11

#define K_VERS_1_11

Value:

MAKE_ARCHIVE_VERSION(1, 11, 0) /* add toc section

* indicator */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:68

Definition at line 89 of file pg_backup_archiver.h.

Referenced by fix_dependencies(), and ReadToc().

◆ K_VERS_1_12

#define K_VERS_1_12

Value:

MAKE_ARCHIVE_VERSION(1, 12, 0) /* add separate BLOB

* entries */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:68

Definition at line 91 of file pg_backup_archiver.h.

Referenced by _StartBlob(), and StartRestoreBlob().

◆ K_VERS_1_13

#define K_VERS_1_13

Value:

MAKE_ARCHIVE_VERSION(1, 13, 0) /* change search_path

* behavior */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:68

Definition at line 93 of file pg_backup_archiver.h.

◆ K_VERS_1_14

#define K_VERS_1_14 MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */

Definition at line 95 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_2

#define K_VERS_1_2 MAKE_ARCHIVE_VERSION(1, 2, 0) /* Allow No ZLIB */

Definition at line 76 of file pg_backup_archiver.h.

Referenced by ReadHead().

◆ K_VERS_1_3

#define K_VERS_1_3 MAKE_ARCHIVE_VERSION(1, 3, 0) /* BLOBs */

Definition at line 77 of file pg_backup_archiver.h.

Referenced by _readBlockHeader(), ReadToc(), and RestoreArchive().

◆ K_VERS_1_4

#define K_VERS_1_4 MAKE_ARCHIVE_VERSION(1, 4, 0) /* Date & name in header */

Definition at line 78 of file pg_backup_archiver.h.

Referenced by ReadHead().

◆ K_VERS_1_5

#define K_VERS_1_5 MAKE_ARCHIVE_VERSION(1, 5, 0) /* Handle dependencies */

Definition at line 79 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_6

#define K_VERS_1_6 MAKE_ARCHIVE_VERSION(1, 6, 0) /* Schema field in TOCs */

Definition at line 80 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_7

#define K_VERS_1_7

Value:

MAKE_ARCHIVE_VERSION(1, 7, 0) /* File Offset size in

* header */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:68

Definition at line 81 of file pg_backup_archiver.h.

Referenced by _discoverArchiveFormat(), _ReadExtraToc(), ReadHead(), and ReadOffset().

◆ K_VERS_1_8

#define K_VERS_1_8

Value:

MAKE_ARCHIVE_VERSION(1, 8, 0)   /* change interpretation
                                                     * of ID numbers and
                                                     * dependencies */

Definition at line 83 of file pg_backup_archiver.h.

Referenced by ReadToc(), and RestoreArchive().

◆ K_VERS_1_9

#define K_VERS_1_9

Value:

MAKE_ARCHIVE_VERSION(1, 9, 0) /* add default_with_oids

* tracking */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:68

Definition at line 86 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_MAJOR

#define K_VERS_MAJOR 1

Definition at line 98 of file pg_backup_archiver.h.

◆ K_VERS_MAX

#define K_VERS_MAX MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)

Definition at line 104 of file pg_backup_archiver.h.

Referenced by ReadHead().

◆ K_VERS_MINOR

#define K_VERS_MINOR 14

Definition at line 99 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV 0

Definition at line 100 of file pg_backup_archiver.h.

◆ K_VERS_SELF

#define K_VERS_SELF MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV)

Definition at line 101 of file pg_backup_archiver.h.

Referenced by _allocAH().

◆ LOBBUFSIZE

#define LOBBUFSIZE 16384

Definition at line 33 of file pg_backup_archiver.h.

Referenced by dumpBlobs(), InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), InitArchiveFmt_Null(), and InitArchiveFmt_Tar().

◆ MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION	(	major,
		minor,
		rev
	)	(((major) * 256 + (minor)) * 256 + (rev))

Definition at line 68 of file pg_backup_archiver.h.

Referenced by _discoverArchiveFormat(), and ReadHead().

◆ READ_ERROR_EXIT

#define READ_ERROR_EXIT ( fd )

Value:

do { \
        if (feof(fd)) \
            fatal("could not read from input file: end of file"); \
		else \
			fatal("could not read from input file: %m"); \
    } while (0)

Definition at line 125 of file pg_backup_archiver.h.

Referenced by _discoverArchiveFormat(), _ReadBuf(), _ReadByte(), _tarAddFile(), _tarReadRaw(), cfgetc(), and cfread().

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST RESTORE_PASS_POST_ACL

Definition at line 229 of file pg_backup_archiver.h.

Referenced by restore_toc_entries_parallel().

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE 10

Definition at line 117 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS 12

Definition at line 119 of file pg_backup_archiver.h.

Referenced by buildWorkerResponse(), mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA 11

Definition at line 118 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_OK

#define WORKER_OK 0

Definition at line 116 of file pg_backup_archiver.h.

Referenced by restore_toc_entry().

◆ WRITE_ERROR_EXIT

#define WRITE_ERROR_EXIT

Value:

do { \
        fatal("could not write to output file: %m"); \
    } while (0)

Definition at line 133 of file pg_backup_archiver.h.

Referenced by _CloseArchive(), _tarAddFile(), _tarWriteHeader(), _WriteBuf(), _WriteByte(), _WriteData(), and ahwrite().

◆ Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION (-1)

Definition at line 51 of file pg_backup_archiver.h.

Referenced by cfopen(), main(), ParseCompressionOption(), and ReadHead().

Typedef Documentation

◆ ArchiveEntryPtrType

typedef void(* ArchiveEntryPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 146 of file pg_backup_archiver.h.

◆ ArchiveHandle

typedef struct _archiveHandle ArchiveHandle

Definition at line 121 of file pg_backup_archiver.h.

◆ ArchiveOpts

typedef void struct _archiveOpts ArchiveOpts

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 167 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 144 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 173 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 168 of file pg_backup_archiver.h.

◆ EndBlobPtrType

typedef void(* EndBlobPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)

Definition at line 154 of file pg_backup_archiver.h.

◆ EndBlobsPtrType

typedef void(* EndBlobsPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 155 of file pg_backup_archiver.h.

◆ EndDataPtrType

typedef void(* EndDataPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 150 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 166 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

typedef void(* PrintExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 163 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

typedef void(* PrintTocDataPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 164 of file pg_backup_archiver.h.

◆ ReadBufPtrType

typedef void(* ReadBufPtrType) (ArchiveHandle *AH, void *buf, size_t len)

Definition at line 160 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 158 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

typedef void(* ReadExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 162 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 145 of file pg_backup_archiver.h.

◆ StartBlobPtrType

typedef void(* StartBlobPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)

Definition at line 153 of file pg_backup_archiver.h.

◆ StartBlobsPtrType

typedef void(* StartBlobsPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 152 of file pg_backup_archiver.h.

◆ StartDataPtrType

typedef void(* StartDataPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 148 of file pg_backup_archiver.h.

◆ T_Action

typedef enum T_Action T_Action

◆ TocEntry

typedef struct _tocEntry TocEntry

Definition at line 122 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

typedef int(* WorkerJobDumpPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 170 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

typedef int(* WorkerJobRestorePtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 171 of file pg_backup_archiver.h.

◆ WriteBufPtrType

typedef void(* WriteBufPtrType) (ArchiveHandle *AH, const void *c, size_t len)

Definition at line 159 of file pg_backup_archiver.h.

◆ WriteBytePtrType

typedef int(* WriteBytePtrType) (ArchiveHandle *AH, const int i)

Definition at line 157 of file pg_backup_archiver.h.

◆ WriteDataPtrType

typedef void(* WriteDataPtrType) (ArchiveHandle *AH, const void *data, size_t dLen)

Definition at line 149 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

typedef void(* WriteExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 161 of file pg_backup_archiver.h.

◆ z_stream

typedef struct _z_stream z_stream

◆ z_streamp

typedef z_stream* z_streamp

Definition at line 60 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

enum ArchiverOutput

Enumerator
OUTPUT_SQLCMDS
OUTPUT_COPYDATA
OUTPUT_OTHERDATA

Definition at line 197 of file pg_backup_archiver.h.

 {
     OUTPUT_SQLCMDS = 0,         /* emitting general SQL commands */
     OUTPUT_COPYDATA,            /* writing COPY data */
     OUTPUT_OTHERDATA            /* writing data as INSERT commands */
 } ArchiverOutput;

◆ ArchiverStage

enum ArchiverStage

Enumerator
STAGE_NONE
STAGE_INITIALIZING
STAGE_PROCESSING
STAGE_FINALIZING

Definition at line 189 of file pg_backup_archiver.h.

 {
     STAGE_NONE = 0,
     STAGE_INITIALIZING,
     STAGE_PROCESSING,
     STAGE_FINALIZING
 } ArchiverStage;

◆ RestorePass

enum RestorePass

Enumerator
RESTORE_PASS_MAIN
RESTORE_PASS_ACL

Definition at line 223 of file pg_backup_archiver.h.

 {
     RESTORE_PASS_MAIN = 0,      /* Main pass (most TOC item types) */
     RESTORE_PASS_ACL,           /* ACL item types */
     RESTORE_PASS_POST_ACL       /* Event trigger and matview refresh items */
 
 #define RESTORE_PASS_LAST RESTORE_PASS_POST_ACL
 } RestorePass;

◆ sqlparseState

enum sqlparseState

Enumerator
SQL_SCAN
SQL_IN_SINGLE_QUOTE
SQL_IN_DOUBLE_QUOTE

Definition at line 175 of file pg_backup_archiver.h.

 {
     SQL_SCAN = 0,               /* normal */
     SQL_IN_SINGLE_QUOTE,        /* '...' literal */
     SQL_IN_DOUBLE_QUOTE         /* "..." identifier */
 } sqlparseState;

◆ T_Action

enum T_Action

Enumerator
ACT_DUMP
ACT_RESTORE

Definition at line 138 of file pg_backup_archiver.h.

 {
     ACT_DUMP,
     ACT_RESTORE
 } T_Action;

◆ teReqs

enum teReqs

Enumerator
REQ_SCHEMA
REQ_DATA
REQ_SPECIAL

Definition at line 232 of file pg_backup_archiver.h.

 {
     REQ_SCHEMA = 0x01,          /* want schema */
     REQ_DATA = 0x02,            /* want data */
     REQ_SPECIAL = 0x04          /* for special TOC entries */
 } teReqs;

Function Documentation

◆ ahprintf()

int ahprintf	(	ArchiveHandle *	AH,
		const char *	fmt,
			...
	)

◆ ahwrite()

void ahwrite	(	const void *	ptr,
		size_t	size,
		size_t	nmemb,
		ArchiveHandle *	AH
	)

Definition at line 1693 of file pg_backup_archiver.c.

References _archiveHandle::CustomOutPtr, dump_lo_buf(), ExecuteSqlCommandBuf(), _archiveHandle::gzOut, GZWRITE, _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, _archiveHandle::lo_buf_used, _archiveHandle::OF, _archiveHandle::public, remaining, RestoringToDB(), WRITE_ERROR_EXIT, and _archiveHandle::writingBlob.

Referenced by _LoadBlobs(), _PrintFileData(), _PrintTocData(), _WriteData(), ahprintf(), EndCompressor(), and ReadDataFromArchiveNone().

 {
     int         bytes_written = 0;
 
     if (AH->writingBlob)
     {
         size_t      remaining = size * nmemb;
 
         while (AH->lo_buf_used + remaining > AH->lo_buf_size)
         {
             size_t      avail = AH->lo_buf_size - AH->lo_buf_used;
 
             memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
             ptr = (const void *) ((const char *) ptr + avail);
             remaining -= avail;
             AH->lo_buf_used += avail;
             dump_lo_buf(AH);
         }
 
         memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
         AH->lo_buf_used += remaining;
 
         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);
 
     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;
     }
 
     if (bytes_written != size * nmemb)
         WRITE_ERROR_EXIT;
 }

◆ ArchiveEntry()

TocEntry* ArchiveEntry	(	Archive *	AHX,
		CatalogId	catalogId,
		DumpId	dumpId,
		ArchiveOpts *	opts
	)

Definition at line 1061 of file pg_backup_archiver.c.

References _archiveHandle::ArchiveEntryPtr, _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, _tocEntry::formatData, _tocEntry::hadDumper, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, _tocEntry::owner, pg_malloc(), pg_malloc0(), pg_strdup(), _tocEntry::prev, _tocEntry::section, _tocEntry::tableam, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and true.

Referenced by dumpAccessMethod(), dumpACL(), dumpAgg(), dumpAttrDef(), dumpBaseType(), dumpBlob(), dumpCast(), dumpCollation(), dumpComment(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

 {
     ArchiveHandle *AH = (ArchiveHandle *) AHX;
     TocEntry   *newToc;
 
     newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
     AH->tocCount++;
     if (dumpId > AH->maxDumpId)
         AH->maxDumpId = dumpId;
 
     newToc->prev = AH->toc->prev;
     newToc->next = AH->toc;
     AH->toc->prev->next = newToc;
     AH->toc->prev = newToc;
 
     newToc->catalogId = catalogId;
     newToc->dumpId = dumpId;
     newToc->section = opts->section;
 
     newToc->tag = pg_strdup(opts->tag);
     newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
     newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
     newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
     newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
     newToc->desc = pg_strdup(opts->description);
     newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
     newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
     newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
 
     if (opts->nDeps > 0)
     {
         newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
         memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
         newToc->nDeps = opts->nDeps;
     }
     else
     {
         newToc->dependencies = NULL;
         newToc->nDeps = 0;
     }
 
     newToc->dataDumper = opts->dumpFn;
     newToc->dataDumperArg = opts->dumpArg;
     newToc->hadDumper = opts->dumpFn ? true : false;
 
     newToc->formatData = NULL;
     newToc->dataLength = 0;
 
     if (AH->ArchiveEntryPtr != NULL)
         AH->ArchiveEntryPtr(AH, newToc);
 
     return newToc;
 }

◆ checkSeek()

bool checkSeek ( FILE * fp )

Definition at line 3884 of file pg_backup_archiver.c.

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

 {
     pgoff_t     tpos;
 
     /* Check that ftello works on this file */
     tpos = ftello(fp);
     if (tpos < 0)
         return false;
 
     /*
      * Check that fseeko(SEEK_SET) works, too.  NB: we used to try to test
      * this with fseeko(fp, 0, SEEK_CUR).  But some platforms treat that as a
      * successful no-op even on files that are otherwise unseekable.
      */
     if (fseeko(fp, tpos, SEEK_SET) != 0)
         return false;
 
     return true;
 }

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle * AH )

Definition at line 4810 of file pg_backup_archiver.c.

References _doSetFixedOutputState(), appendConnStrVal(), appendPQExpBufferStr(), archModeRead, Assert, _archiveHandle::ClonePtr, _archiveHandle::connCancel, ConnectDatabase(), _archiveHandle::connection, connstr, _archiveHandle::currSchema, _archiveHandle::currTablespace, _archiveHandle::currUser, PQExpBufferData::data, _restoreOptions::dbname, initPQExpBuffer(), _archiveHandle::mode, Archive::n_errors, pg_malloc(), pg_strdup(), _restoreOptions::pghost, pghost, _restoreOptions::pgport, pgport, PQdb(), PQhost(), PQport(), PQuser(), _restoreOptions::promptPassword, _archiveHandle::public, Archive::ropt, _archiveHandle::savedPassword, _archiveHandle::sqlparse, termPQExpBuffer(), TRI_NO, _restoreOptions::username, and username.

Referenced by RunWorker().

 {
     ArchiveHandle *clone;
 
     /* Make a "flat" copy */
     clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
     memcpy(clone, AH, sizeof(ArchiveHandle));
 
     /* Handle format-independent fields */
     memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
 
     /* The clone will have its own connection, so disregard connection state */
     clone->connection = NULL;
     clone->connCancel = NULL;
     clone->currUser = NULL;
     clone->currSchema = NULL;
     clone->currTablespace = NULL;
 
     /* savedPassword must be local in case we change it while connecting */
     if (clone->savedPassword)
         clone->savedPassword = pg_strdup(clone->savedPassword);
 
     /* clone has its own error count, too */
     clone->public.n_errors = 0;
 
     /*
      * Connect our new clone object to the database: In parallel restore the
      * parent is already disconnected, because we can connect the worker
      * processes independently to the database (no snapshot sync required). In
      * parallel backup we clone the parent's existing connection.
      */
     if (AH->mode == archModeRead)
     {
         RestoreOptions *ropt = AH->public.ropt;
 
         Assert(AH->connection == NULL);
 
         /* this also sets clone->connection */
         ConnectDatabase((Archive *) clone, ropt->dbname,
                         ropt->pghost, ropt->pgport, ropt->username,
                         ropt->promptPassword);
 
         /* re-establish fixed state */
         _doSetFixedOutputState(clone);
     }
     else
     {
         PQExpBufferData connstr;
         char       *pghost;
         char       *pgport;
         char       *username;
 
         Assert(AH->connection != NULL);
 
         /*
          * Even though we are technically accessing the parent's database
          * object here, these functions are fine to be called like that
          * because all just return a pointer and do not actually send/receive
          * any data to/from the database.
          */
         initPQExpBuffer(&connstr);
         appendPQExpBufferStr(&connstr, "dbname=");
         appendConnStrVal(&connstr, PQdb(AH->connection));
         pghost = PQhost(AH->connection);
         pgport = PQport(AH->connection);
         username = PQuser(AH->connection);
 
         /* this also sets clone->connection */
         ConnectDatabase((Archive *) clone, connstr.data,
                         pghost, pgport, username, TRI_NO);
 
         termPQExpBuffer(&connstr);
         /* setupDumpWorker will fix up connection state */
     }
 
     /* Let the format-specific code have a chance too */
     clone->ClonePtr(clone);
 
     Assert(clone->connection != NULL);
     return clone;
 }

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle * AH )

Definition at line 4898 of file pg_backup_archiver.c.

References Assert, _archiveHandle::connection, sqlparseInfo::curCmd, _archiveHandle::currSchema, _archiveHandle::currTableAm, _archiveHandle::currTablespace, _archiveHandle::currUser, _archiveHandle::DeClonePtr, destroyPQExpBuffer(), free, _archiveHandle::savedPassword, and _archiveHandle::sqlparse.

Referenced by RunWorker().

 {
     /* Should not have an open database connection */
     Assert(AH->connection == NULL);
 
     /* Clear format-specific state */
     AH->DeClonePtr(AH);
 
     /* Clear state allocated by CloneArchive */
     if (AH->sqlparse.curCmd)
         destroyPQExpBuffer(AH->sqlparse.curCmd);
 
     /* Clear any connection-local state */
     if (AH->currUser)
         free(AH->currUser);
     if (AH->currSchema)
         free(AH->currSchema);
     if (AH->currTablespace)
         free(AH->currTablespace);
     if (AH->currTableAm)
         free(AH->currTableAm);
     if (AH->savedPassword)
         free(AH->savedPassword);
 
     free(AH);
 }

◆ DropBlobIfExists()

void DropBlobIfExists	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 656 of file pg_backup_db.c.

References ahprintf(), _archiveHandle::connection, and PQserverVersion().

Referenced by _StartBlob(), RestoreArchive(), and StartRestoreBlob().

 {
     /*
      * If we are not restoring to a direct database connection, we have to
      * guess about how to detect whether the blob exists.  Assume new-style.
      */
     if (AH->connection == NULL ||
         PQserverVersion(AH->connection) >= 90000)
     {
         ahprintf(AH,
                  "SELECT pg_catalog.lo_unlink(oid) "
                  "FROM pg_catalog.pg_largeobject_metadata "
                  "WHERE oid = '%u';\n",
                  oid);
     }
     else
     {
         /* Restoring to pre-9.0 server, so do it the old way */
         ahprintf(AH,
                  "SELECT CASE WHEN EXISTS("
                  "SELECT 1 FROM pg_catalog.pg_largeobject WHERE loid = '%u'"
                  ") THEN pg_catalog.lo_unlink('%u') END;\n",
                  oid, oid);
     }
 }

◆ EndRestoreBlob()

void EndRestoreBlob	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 1341 of file pg_backup_archiver.c.

References ahprintf(), _archiveHandle::connection, dump_lo_buf(), _archiveHandle::lo_buf_used, lo_close(), _archiveHandle::loFd, and _archiveHandle::writingBlob.

Referenced by _LoadBlobs().

 {
     if (AH->lo_buf_used > 0)
     {
         /* Write remaining bytes from the LO buffer */
         dump_lo_buf(AH);
     }
 
     AH->writingBlob = 0;
 
     if (AH->connection)
     {
         lo_close(AH->connection, AH->loFd);
         AH->loFd = -1;
     }
     else
     {
         ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
     }
 }

◆ EndRestoreBlobs()

void EndRestoreBlobs ( ArchiveHandle * AH )

Definition at line 1274 of file pg_backup_archiver.c.

References ahprintf(), _archiveHandle::blobCount, CommitTransaction(), _archiveHandle::connection, ngettext, pg_log_info, _archiveHandle::public, Archive::ropt, and _restoreOptions::single_txn.

Referenced by _LoadBlobs().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     if (!ropt->single_txn)
     {
         if (AH->connection)
             CommitTransaction(&AH->public);
         else
             ahprintf(AH, "COMMIT;\n\n");
     }
 
     pg_log_info(ngettext("restored %d large object",
                          "restored %d large objects",
                          AH->blobCount),
                 AH->blobCount);
 }

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1873 of file pg_backup_archiver.c.

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

Referenced by parseWorkerCommand(), SortTocFromFile(), and TocIDRequired().

 {
     /* build index arrays if we didn't already */
     if (AH->tocsByDumpId == NULL)
         buildTocEntryArrays(AH);
 
     if (id > 0 && id <= AH->maxDumpId)
         return AH->tocsByDumpId[id];
 
     return NULL;
 }

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle * AH )

Definition at line 106 of file pg_backup_custom.c.

Referenced by _allocAH().

 {
     lclContext *ctx;
 
     /* Assuming static functions, this can be copied for each format. */
     AH->ArchiveEntryPtr = _ArchiveEntry;
     AH->StartDataPtr = _StartData;
     AH->WriteDataPtr = _WriteData;
     AH->EndDataPtr = _EndData;
     AH->WriteBytePtr = _WriteByte;
     AH->ReadBytePtr = _ReadByte;
     AH->WriteBufPtr = _WriteBuf;
     AH->ReadBufPtr = _ReadBuf;
     AH->ClosePtr = _CloseArchive;
     AH->ReopenPtr = _ReopenArchive;
     AH->PrintTocDataPtr = _PrintTocData;
     AH->ReadExtraTocPtr = _ReadExtraToc;
     AH->WriteExtraTocPtr = _WriteExtraToc;
     AH->PrintExtraTocPtr = _PrintExtraToc;
 
     AH->StartBlobsPtr = _StartBlobs;
     AH->StartBlobPtr = _StartBlob;
     AH->EndBlobPtr = _EndBlob;
     AH->EndBlobsPtr = _EndBlobs;
 
     AH->PrepParallelRestorePtr = _PrepParallelRestore;
     AH->ClonePtr = _Clone;
     AH->DeClonePtr = _DeClone;
 
     /* no parallel dump in the custom archive, only parallel restore */
     AH->WorkerJobDumpPtr = NULL;
     AH->WorkerJobRestorePtr = _WorkerJobRestoreCustom;
 
     /* Set up a private area. */
     ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
     AH->formatData = (void *) ctx;
 
     /* Initialize LO buffering */
     AH->lo_buf_size = LOBBUFSIZE;
     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
 
     ctx->filePos = 0;
 
     /*
      * Now open the file
      */
     if (AH->mode == archModeWrite)
     {
         if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
         {
             AH->FH = fopen(AH->fSpec, PG_BINARY_W);
             if (!AH->FH)
                 fatal("could not open output file \"%s\": %m", AH->fSpec);
         }
         else
         {
             AH->FH = stdout;
             if (!AH->FH)
                 fatal("could not open output file: %m");
         }
 
         ctx->hasSeek = checkSeek(AH->FH);
     }
     else
     {
         if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
         {
             AH->FH = fopen(AH->fSpec, PG_BINARY_R);
             if (!AH->FH)
                 fatal("could not open input file \"%s\": %m", AH->fSpec);
         }
         else
         {
             AH->FH = stdin;
             if (!AH->FH)
                 fatal("could not open input file: %m");
         }
 
         ctx->hasSeek = checkSeek(AH->FH);
 
         ReadHead(AH);
         ReadToc(AH);
         ctx->dataStart = _getFilePos(AH, ctx);
     }
 
 }

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle * AH )

Definition at line 108 of file pg_backup_directory.c.

References _ArchiveEntry(), _Clone(), _CloseArchive(), _DeClone(), _EndBlob(), _EndBlobs(), _EndData(), _PrepParallelRestore(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _ReopenArchive(), _StartBlob(), _StartBlobs(), _StartData(), _WorkerJobDumpDirectory(), _WorkerJobRestoreDirectory(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), archDirectory, _archiveHandle::ArchiveEntryPtr, archModeWrite, archTar, lclContext::blobsTocFH, cfclose(), cfopen_read(), _archiveHandle::ClonePtr, closedir(), _archiveHandle::ClosePtr, dirent::d_name, lclContext::dataFH, _archiveHandle::DeClonePtr, lclContext::directory, _archiveHandle::EndBlobPtr, _archiveHandle::EndBlobsPtr, _archiveHandle::EndDataPtr, fatal, _archiveHandle::format, _archiveHandle::formatData, _archiveHandle::fSpec, _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, LOBBUFSIZE, MAXPGPATH, mkdir, _archiveHandle::mode, opendir(), PG_BINARY_R, pg_malloc(), pg_malloc0(), _archiveHandle::PrepParallelRestorePtr, _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, readdir(), _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, S_ISDIR, setFilePath(), _archiveHandle::StartBlobPtr, _archiveHandle::StartBlobsPtr, _archiveHandle::StartDataPtr, stat, _archiveHandle::WorkerJobDumpPtr, _archiveHandle::WorkerJobRestorePtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, _archiveHandle::WriteDataPtr, and _archiveHandle::WriteExtraTocPtr.

Referenced by _allocAH().

 {
     lclContext *ctx;
 
     /* Assuming static functions, this can be copied for each format. */
     AH->ArchiveEntryPtr = _ArchiveEntry;
     AH->StartDataPtr = _StartData;
     AH->WriteDataPtr = _WriteData;
     AH->EndDataPtr = _EndData;
     AH->WriteBytePtr = _WriteByte;
     AH->ReadBytePtr = _ReadByte;
     AH->WriteBufPtr = _WriteBuf;
     AH->ReadBufPtr = _ReadBuf;
     AH->ClosePtr = _CloseArchive;
     AH->ReopenPtr = _ReopenArchive;
     AH->PrintTocDataPtr = _PrintTocData;
     AH->ReadExtraTocPtr = _ReadExtraToc;
     AH->WriteExtraTocPtr = _WriteExtraToc;
     AH->PrintExtraTocPtr = _PrintExtraToc;
 
     AH->StartBlobsPtr = _StartBlobs;
     AH->StartBlobPtr = _StartBlob;
     AH->EndBlobPtr = _EndBlob;
     AH->EndBlobsPtr = _EndBlobs;
 
     AH->PrepParallelRestorePtr = _PrepParallelRestore;
     AH->ClonePtr = _Clone;
     AH->DeClonePtr = _DeClone;
 
     AH->WorkerJobRestorePtr = _WorkerJobRestoreDirectory;
     AH->WorkerJobDumpPtr = _WorkerJobDumpDirectory;
 
     /* Set up our private context */
     ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
     AH->formatData = (void *) ctx;
 
     ctx->dataFH = NULL;
     ctx->blobsTocFH = NULL;
 
     /* Initialize LO buffering */
     AH->lo_buf_size = LOBBUFSIZE;
     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
 
     /*
      * Now open the TOC file
      */
 
     if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
         fatal("no output directory specified");
 
     ctx->directory = AH->fSpec;
 
     if (AH->mode == archModeWrite)
     {
         struct stat st;
         bool        is_empty = false;
 
         /* we accept an empty existing directory */
         if (stat(ctx->directory, &st) == 0 && S_ISDIR(st.st_mode))
         {
             DIR        *dir = opendir(ctx->directory);
 
             if (dir)
             {
                 struct dirent *d;
 
                 is_empty = true;
                 while (errno = 0, (d = readdir(dir)))
                 {
                     if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0)
                     {
                         is_empty = false;
                         break;
                     }
                 }
 
                 if (errno)
                     fatal("could not read directory \"%s\": %m",
                           ctx->directory);
 
                 if (closedir(dir))
                     fatal("could not close directory \"%s\": %m",
                           ctx->directory);
             }
         }
 
         if (!is_empty && mkdir(ctx->directory, 0700) < 0)
             fatal("could not create directory \"%s\": %m",
                   ctx->directory);
     }
     else
     {                           /* Read Mode */
         char        fname[MAXPGPATH];
         cfp        *tocFH;
 
         setFilePath(AH, fname, "toc.dat");
 
         tocFH = cfopen_read(fname, PG_BINARY_R);
         if (tocFH == NULL)
             fatal("could not open input file \"%s\": %m", fname);
 
         ctx->dataFH = tocFH;
 
         /*
          * The TOC of a directory format dump shares the format code of the
          * tar format.
          */
         AH->format = archTar;
         ReadHead(AH);
         AH->format = archDirectory;
         ReadToc(AH);
 
         /* Nothing else in the file, so close it again... */
         if (cfclose(tocFH) != 0)
             fatal("could not close TOC file: %m");
         ctx->dataFH = NULL;
     }
 }

◆ InitArchiveFmt_Null()

void InitArchiveFmt_Null ( ArchiveHandle * AH )

Definition at line 48 of file pg_backup_null.c.

References _CloseArchive(), _EndBlob(), _EndBlobs(), _EndData(), _PrintTocData(), _StartBlob(), _StartBlobs(), _WriteBuf(), _WriteByte(), _WriteData(), archModeRead, _archiveHandle::ClonePtr, _archiveHandle::ClosePtr, _archiveHandle::DeClonePtr, _archiveHandle::EndBlobPtr, _archiveHandle::EndBlobsPtr, _archiveHandle::EndDataPtr, fatal, _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, LOBBUFSIZE, _archiveHandle::mode, pg_malloc(), _archiveHandle::PrintTocDataPtr, _archiveHandle::ReopenPtr, _archiveHandle::StartBlobPtr, _archiveHandle::StartBlobsPtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, and _archiveHandle::WriteDataPtr.

Referenced by _allocAH().

 {
     /* Assuming static functions, this can be copied for each format. */
     AH->WriteDataPtr = _WriteData;
     AH->EndDataPtr = _EndData;
     AH->WriteBytePtr = _WriteByte;
     AH->WriteBufPtr = _WriteBuf;
     AH->ClosePtr = _CloseArchive;
     AH->ReopenPtr = NULL;
     AH->PrintTocDataPtr = _PrintTocData;
 
     AH->StartBlobsPtr = _StartBlobs;
     AH->StartBlobPtr = _StartBlob;
     AH->EndBlobPtr = _EndBlob;
     AH->EndBlobsPtr = _EndBlobs;
     AH->ClonePtr = NULL;
     AH->DeClonePtr = NULL;
 
     /* Initialize LO buffering */
     AH->lo_buf_size = LOBBUFSIZE;
     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
 
     /*
      * Now prevent reading...
      */
     if (AH->mode == archModeRead)
         fatal("this format cannot be read");
 }

◆ InitArchiveFmt_Tar()

void InitArchiveFmt_Tar ( ArchiveHandle * AH )

Definition at line 126 of file pg_backup_tar.c.

References _ArchiveEntry(), _CloseArchive(), _EndBlob(), _EndBlobs(), _EndData(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _StartBlob(), _StartBlobs(), _StartData(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), archModeWrite, checkSeek(), fatal, lclContext::FH, lclContext::filePos, lclContext::hasSeek, lclContext::isSpecialScript, LOBBUFSIZE, PG_BINARY_R, PG_BINARY_W, pg_malloc(), pg_malloc0(), ReadHead(), ReadToc(), generate_unaccent_rules::stdout, tarClose(), lclContext::tarFH, lclContext::tarFHpos, and tarOpen().

Referenced by _allocAH().

 {
     lclContext *ctx;
 
     /* Assuming static functions, this can be copied for each format. */
     AH->ArchiveEntryPtr = _ArchiveEntry;
     AH->StartDataPtr = _StartData;
     AH->WriteDataPtr = _WriteData;
     AH->EndDataPtr = _EndData;
     AH->WriteBytePtr = _WriteByte;
     AH->ReadBytePtr = _ReadByte;
     AH->WriteBufPtr = _WriteBuf;
     AH->ReadBufPtr = _ReadBuf;
     AH->ClosePtr = _CloseArchive;
     AH->ReopenPtr = NULL;
     AH->PrintTocDataPtr = _PrintTocData;
     AH->ReadExtraTocPtr = _ReadExtraToc;
     AH->WriteExtraTocPtr = _WriteExtraToc;
     AH->PrintExtraTocPtr = _PrintExtraToc;
 
     AH->StartBlobsPtr = _StartBlobs;
     AH->StartBlobPtr = _StartBlob;
     AH->EndBlobPtr = _EndBlob;
     AH->EndBlobsPtr = _EndBlobs;
     AH->ClonePtr = NULL;
     AH->DeClonePtr = NULL;
 
     AH->WorkerJobDumpPtr = NULL;
     AH->WorkerJobRestorePtr = NULL;
 
     /*
      * Set up some special context used in compressing data.
      */
     ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
     AH->formatData = (void *) ctx;
     ctx->filePos = 0;
     ctx->isSpecialScript = 0;
 
     /* Initialize LO buffering */
     AH->lo_buf_size = LOBBUFSIZE;
     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
 
     /*
      * Now open the tar file, and load the TOC if we're in read mode.
      */
     if (AH->mode == archModeWrite)
     {
         if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
         {
             ctx->tarFH = fopen(AH->fSpec, PG_BINARY_W);
             if (ctx->tarFH == NULL)
                 fatal("could not open TOC file \"%s\" for output: %m",
                       AH->fSpec);
         }
         else
         {
             ctx->tarFH = stdout;
             if (ctx->tarFH == NULL)
                 fatal("could not open TOC file for output: %m");
         }
 
         ctx->tarFHpos = 0;
 
         /*
          * Make unbuffered since we will dup() it, and the buffers screw each
          * other
          */
         /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
 
         ctx->hasSeek = checkSeek(ctx->tarFH);
 
         /*
          * We don't support compression because reading the files back is not
          * possible since gzdopen uses buffered IO which totally screws file
          * positioning.
          */
         if (AH->compression != 0)
             fatal("compression is not supported by tar archive format");
     }
     else
     {                           /* Read Mode */
         if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
         {
             ctx->tarFH = fopen(AH->fSpec, PG_BINARY_R);
             if (ctx->tarFH == NULL)
                 fatal("could not open TOC file \"%s\" for input: %m",
                       AH->fSpec);
         }
         else
         {
             ctx->tarFH = stdin;
             if (ctx->tarFH == NULL)
                 fatal("could not open TOC file for input: %m");
         }
 
         /*
          * Make unbuffered since we will dup() it, and the buffers screw each
          * other
          */
         /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
 
         ctx->tarFHpos = 0;
 
         ctx->hasSeek = checkSeek(ctx->tarFH);
 
         /*
          * Forcibly unmark the header as read since we use the lookahead
          * buffer
          */
         AH->readHeader = 0;
 
         ctx->FH = (void *) tarOpen(AH, "toc.dat", 'r');
         ReadHead(AH);
         ReadToc(AH);
         tarClose(AH, ctx->FH);  /* Nothing else in the file... */
     }
 }

◆ isValidTarHeader()

bool isValidTarHeader ( char * header )

Definition at line 1045 of file pg_backup_tar.c.

References read_tar_number(), and tarChecksum().

Referenced by _discoverArchiveFormat().

 {
     int         sum;
     int         chk = tarChecksum(header);
 
     sum = read_tar_number(&header[148], 8);
 
     if (sum != chk)
         return false;
 
     /* POSIX tar format */
     if (memcmp(&header[257], "ustar\0", 6) == 0 &&
         memcmp(&header[263], "00", 2) == 0)
         return true;
     /* GNU tar format */
     if (memcmp(&header[257], "ustar  \0", 8) == 0)
         return true;
     /* not-quite-POSIX format written by pre-9.3 pg_dump */
     if (memcmp(&header[257], "ustar00\0", 8) == 0)
         return true;
 
     return false;
 }

◆ on_exit_close_archive()

void on_exit_close_archive ( Archive * AHX )

Definition at line 347 of file parallel.c.

References ShutdownInformation::AHX, archive_close_connection(), and on_exit_nicely().

Referenced by main().

 {
     shutdown_info.AHX = AHX;
     on_exit_nicely(archive_close_connection, &shutdown_info);
 }

◆ parallel_restore()

int parallel_restore	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 4443 of file pg_backup_archiver.c.

References Assert, _archiveHandle::connection, Archive::n_errors, _archiveHandle::public, restore_toc_entry(), and status().

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

 {
     int         status;
 
     Assert(AH->connection != NULL);
 
     /* Count only errors associated with this TOC entry */
     AH->public.n_errors = 0;
 
     /* Restore the TOC item */
     status = restore_toc_entry(AH, te, true);
 
     return status;
 }

◆ ReadHead()

void ReadHead ( ArchiveHandle * AH )

Definition at line 3781 of file pg_backup_archiver.c.

References _archiveHandle::archdbname, _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, _archiveHandle::compression, _archiveHandle::createDate, fatal, _archiveHandle::format, _archiveHandle::intSize, K_VERS_1_0, K_VERS_1_10, K_VERS_1_2, K_VERS_1_4, K_VERS_1_7, K_VERS_MAX, MAKE_ARCHIVE_VERSION, _archiveHandle::offSize, pg_log_warning, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::readHeader, ReadInt(), ReadStr(), tm, _archiveHandle::version, and Z_DEFAULT_COMPRESSION.

Referenced by InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), and InitArchiveFmt_Tar().

 {
     char        tmpMag[7];
     int         fmt;
     struct tm   crtm;
 
     /*
      * If we haven't already read the header, do so.
      *
      * NB: this code must agree with _discoverArchiveFormat().  Maybe find a
      * way to unify the cases?
      */
     if (!AH->readHeader)
     {
         char        vmaj,
                     vmin,
                     vrev;
 
         AH->ReadBufPtr(AH, tmpMag, 5);
 
         if (strncmp(tmpMag, "PGDMP", 5) != 0)
             fatal("did not find magic string in file header");
 
         vmaj = AH->ReadBytePtr(AH);
         vmin = AH->ReadBytePtr(AH);
 
         if (vmaj > 1 || (vmaj == 1 && vmin > 0))    /* Version > 1.0 */
             vrev = AH->ReadBytePtr(AH);
         else
             vrev = 0;
 
         AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
 
         if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
             fatal("unsupported version (%d.%d) in file header",
                   vmaj, vmin);
 
         AH->intSize = AH->ReadBytePtr(AH);
         if (AH->intSize > 32)
             fatal("sanity check on integer size (%lu) failed",
                   (unsigned long) AH->intSize);
 
         if (AH->intSize > sizeof(int))
             pg_log_warning("archive was made on a machine with larger integers, some operations might fail");
 
         if (AH->version >= K_VERS_1_7)
             AH->offSize = AH->ReadBytePtr(AH);
         else
             AH->offSize = AH->intSize;
 
         fmt = AH->ReadBytePtr(AH);
 
         if (AH->format != fmt)
             fatal("expected format (%d) differs from format found in file (%d)",
                   AH->format, fmt);
     }
 
     if (AH->version >= K_VERS_1_2)
     {
         if (AH->version < K_VERS_1_4)
             AH->compression = AH->ReadBytePtr(AH);
         else
             AH->compression = ReadInt(AH);
     }
     else
         AH->compression = Z_DEFAULT_COMPRESSION;
 
 #ifndef HAVE_LIBZ
     if (AH->compression != 0)
         pg_log_warning("archive is compressed, but this installation does not support compression -- no data will be available");
 #endif
 
     if (AH->version >= K_VERS_1_4)
     {
         crtm.tm_sec = ReadInt(AH);
         crtm.tm_min = ReadInt(AH);
         crtm.tm_hour = ReadInt(AH);
         crtm.tm_mday = ReadInt(AH);
         crtm.tm_mon = ReadInt(AH);
         crtm.tm_year = ReadInt(AH);
         crtm.tm_isdst = ReadInt(AH);
 
         AH->archdbname = ReadStr(AH);
 
         AH->createDate = mktime(&crtm);
 
         if (AH->createDate == (time_t) -1)
             pg_log_warning("invalid creation date in header");
     }
 
     if (AH->version >= K_VERS_1_10)
     {
         AH->archiveRemoteVersion = ReadStr(AH);
         AH->archiveDumpVersion = ReadStr(AH);
     }
 }

◆ ReadInt()

int ReadInt ( ArchiveHandle * AH )

Definition at line 2009 of file pg_backup_archiver.c.

References _archiveHandle::intSize, K_VERS_1_0, _archiveHandle::ReadBytePtr, sign, and _archiveHandle::version.

Referenced by _CustomReadFunc(), _LoadBlobs(), _readBlockHeader(), _ReadExtraToc(), _skipBlobs(), _skipData(), ReadHead(), ReadOffset(), ReadStr(), and ReadToc().

 {
     int         res = 0;
     int         bv,
                 b;
     int         sign = 0;       /* Default positive */
     int         bitShift = 0;
 
     if (AH->version > K_VERS_1_0)
         /* Read a sign byte */
         sign = AH->ReadBytePtr(AH);
 
     for (b = 0; b < AH->intSize; b++)
     {
         bv = AH->ReadBytePtr(AH) & 0xFF;
         if (bv != 0)
             res = res + (bv << bitShift);
         bitShift += 8;
     }
 
     if (sign)
         res = -res;
 
     return res;
 }

◆ ReadOffset()

int ReadOffset	(	ArchiveHandle *	,
		pgoff_t *
	)

Definition at line 1914 of file pg_backup_archiver.c.

References fatal, i, K_OFFSET_NO_DATA, K_OFFSET_POS_NOT_SET, K_OFFSET_POS_SET, K_VERS_1_7, _archiveHandle::offSize, pgoff_t, _archiveHandle::ReadBytePtr, ReadInt(), and _archiveHandle::version.

Referenced by _ReadExtraToc().

 {
     int         i;
     int         off;
     int         offsetFlg;
 
     /* Initialize to zero */
     *o = 0;
 
     /* Check for old version */
     if (AH->version < K_VERS_1_7)
     {
         /* Prior versions wrote offsets using WriteInt */
         i = ReadInt(AH);
         /* -1 means not set */
         if (i < 0)
             return K_OFFSET_POS_NOT_SET;
         else if (i == 0)
             return K_OFFSET_NO_DATA;
 
         /* Cast to pgoff_t because it was written as an int. */
         *o = (pgoff_t) i;
         return K_OFFSET_POS_SET;
     }
 
     /*
      * Read the flag indicating the state of the data pointer. Check if valid
      * and die if not.
      *
      * This used to be handled by a negative or zero pointer, now we use an
      * extra byte specifically for the state.
      */
     offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
 
     switch (offsetFlg)
     {
         case K_OFFSET_POS_NOT_SET:
         case K_OFFSET_NO_DATA:
         case K_OFFSET_POS_SET:
 
             break;
 
         default:
             fatal("unexpected data offset flag %d", offsetFlg);
     }
 
     /*
      * Read the bytes
      */
     for (off = 0; off < AH->offSize; off++)
     {
         if (off < sizeof(pgoff_t))
             *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
         else
         {
             if (AH->ReadBytePtr(AH) != 0)
                 fatal("file offset in dump file is too large");
         }
     }
 
     return offsetFlg;
 }

◆ ReadStr()

char* ReadStr ( ArchiveHandle * AH )

Definition at line 2055 of file pg_backup_archiver.c.

References buf, pg_malloc(), _archiveHandle::ReadBufPtr, and ReadInt().

Referenced by _ReadExtraToc(), ReadHead(), and ReadToc().

 {
     char       *buf;
     int         l;
 
     l = ReadInt(AH);
     if (l < 0)
         buf = NULL;
     else
     {
         buf = (char *) pg_malloc(l + 1);
         AH->ReadBufPtr(AH, (void *) buf, l);
 
         buf[l] = '\0';
     }
 
     return buf;
 }

◆ ReadToc()

void ReadToc ( ArchiveHandle * AH )

Definition at line 2563 of file pg_backup_archiver.c.

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, fatal, free, _tocEntry::hadDumper, i, InvalidOid, K_VERS_1_10, K_VERS_1_11, K_VERS_1_14, K_VERS_1_3, K_VERS_1_5, K_VERS_1_6, K_VERS_1_8, K_VERS_1_9, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, CatalogId::oid, _tocEntry::owner, pg_log_debug, pg_log_warning, pg_malloc(), pg_malloc0(), pg_realloc(), _tocEntry::prev, processEncodingEntry(), processSearchPathEntry(), processStdStringsEntry(), _archiveHandle::ReadExtraTocPtr, ReadInt(), ReadStr(), _tocEntry::section, SECTION_DATA, SECTION_NONE, SECTION_POST_DATA, SECTION_PRE_DATA, _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and _archiveHandle::version.

Referenced by InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), and InitArchiveFmt_Tar().

 {
     int         i;
     char       *tmp;
     DumpId     *deps;
     int         depIdx;
     int         depSize;
     TocEntry   *te;
 
     AH->tocCount = ReadInt(AH);
     AH->maxDumpId = 0;
 
     for (i = 0; i < AH->tocCount; i++)
     {
         te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
         te->dumpId = ReadInt(AH);
 
         if (te->dumpId > AH->maxDumpId)
             AH->maxDumpId = te->dumpId;
 
         /* Sanity check */
         if (te->dumpId <= 0)
             fatal("entry ID %d out of range -- perhaps a corrupt TOC",
                   te->dumpId);
 
         te->hadDumper = ReadInt(AH);
 
         if (AH->version >= K_VERS_1_8)
         {
             tmp = ReadStr(AH);
             sscanf(tmp, "%u", &te->catalogId.tableoid);
             free(tmp);
         }
         else
             te->catalogId.tableoid = InvalidOid;
         tmp = ReadStr(AH);
         sscanf(tmp, "%u", &te->catalogId.oid);
         free(tmp);
 
         te->tag = ReadStr(AH);
         te->desc = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_11)
         {
             te->section = ReadInt(AH);
         }
         else
         {
             /*
              * Rules for pre-8.4 archives wherein pg_dump hasn't classified
              * the entries into sections.  This list need not cover entry
              * types added later than 8.4.
              */
             if (strcmp(te->desc, "COMMENT") == 0 ||
                 strcmp(te->desc, "ACL") == 0 ||
                 strcmp(te->desc, "ACL LANGUAGE") == 0)
                 te->section = SECTION_NONE;
             else if (strcmp(te->desc, "TABLE DATA") == 0 ||
                      strcmp(te->desc, "BLOBS") == 0 ||
                      strcmp(te->desc, "BLOB COMMENTS") == 0)
                 te->section = SECTION_DATA;
             else if (strcmp(te->desc, "CONSTRAINT") == 0 ||
                      strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
                      strcmp(te->desc, "FK CONSTRAINT") == 0 ||
                      strcmp(te->desc, "INDEX") == 0 ||
                      strcmp(te->desc, "RULE") == 0 ||
                      strcmp(te->desc, "TRIGGER") == 0)
                 te->section = SECTION_POST_DATA;
             else
                 te->section = SECTION_PRE_DATA;
         }
 
         te->defn = ReadStr(AH);
         te->dropStmt = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_3)
             te->copyStmt = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_6)
             te->namespace = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_10)
             te->tablespace = ReadStr(AH);
 
         if (AH->version >= K_VERS_1_14)
             te->tableam = ReadStr(AH);
 
         te->owner = ReadStr(AH);
         if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
             pg_log_warning("restoring tables WITH OIDS is not supported anymore");
 
         /* Read TOC entry dependencies */
         if (AH->version >= K_VERS_1_5)
         {
             depSize = 100;
             deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
             depIdx = 0;
             for (;;)
             {
                 tmp = ReadStr(AH);
                 if (!tmp)
                     break;      /* end of list */
                 if (depIdx >= depSize)
                 {
                     depSize *= 2;
                     deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depSize);
                 }
                 sscanf(tmp, "%d", &deps[depIdx]);
                 free(tmp);
                 depIdx++;
             }
 
             if (depIdx > 0)     /* We have a non-null entry */
             {
                 deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depIdx);
                 te->dependencies = deps;
                 te->nDeps = depIdx;
             }
             else
             {
                 free(deps);
                 te->dependencies = NULL;
                 te->nDeps = 0;
             }
         }
         else
         {
             te->dependencies = NULL;
             te->nDeps = 0;
         }
         te->dataLength = 0;
 
         if (AH->ReadExtraTocPtr)
             AH->ReadExtraTocPtr(AH, te);
 
         pg_log_debug("read TOC entry %d (ID %d) for %s %s",
                      i, te->dumpId, te->desc, te->tag);
 
         /* link completed entry into TOC circular list */
         te->prev = AH->toc->prev;
         AH->toc->prev->next = te;
         AH->toc->prev = te;
         te->next = AH->toc;
 
         /* special processing immediately upon read for some items */
         if (strcmp(te->desc, "ENCODING") == 0)
             processEncodingEntry(AH, te);
         else if (strcmp(te->desc, "STDSTRINGS") == 0)
             processStdStringsEntry(AH, te);
         else if (strcmp(te->desc, "SEARCHPATH") == 0)
             processSearchPathEntry(AH, te);
     }
 }

◆ ReconnectToServer()

void ReconnectToServer	(	ArchiveHandle *	AH,
		const char *	dbname,
		const char *	newUser
	)

Definition at line 79 of file pg_backup_db.c.

References _connectDB(), ALWAYS_SECURE_SEARCH_PATH_SQL, _archiveHandle::connection, dbname, ExecuteSqlQueryForSingleRow(), PQclear(), PQdb(), PQfinish(), PQuser(), set_archive_cancel_info(), and username.

Referenced by _reconnectToDB().

 {
     PGconn     *newConn;
     const char *newdbname;
     const char *newusername;
 
     if (!dbname)
         newdbname = PQdb(AH->connection);
     else
         newdbname = dbname;
 
     if (!username)
         newusername = PQuser(AH->connection);
     else
         newusername = username;
 
     newConn = _connectDB(AH, newdbname, newusername);
 
     /* Update ArchiveHandle's connCancel before closing old connection */
     set_archive_cancel_info(AH, newConn);
 
     PQfinish(AH->connection);
     AH->connection = newConn;
 
     /* Start strict; later phases may override this. */
     PQclear(ExecuteSqlQueryForSingleRow((Archive *) AH,
                                         ALWAYS_SECURE_SEARCH_PATH_SQL));
 }

◆ StartRestoreBlob()

void StartRestoreBlob	(	ArchiveHandle *	AH,
		Oid	oid,
		bool	drop
	)

Definition at line 1297 of file pg_backup_archiver.c.

References ahprintf(), _archiveHandle::blobCount, _archiveHandle::connection, DropBlobIfExists(), fatal, INV_WRITE, K_VERS_1_12, _archiveHandle::lo_buf_used, lo_create(), lo_open(), _archiveHandle::loFd, pg_log_info, PQerrorMessage(), _archiveHandle::version, and _archiveHandle::writingBlob.

Referenced by _LoadBlobs().

 {
     bool        old_blob_style = (AH->version < K_VERS_1_12);
     Oid         loOid;
 
     AH->blobCount++;
 
     /* Initialize the LO Buffer */
     AH->lo_buf_used = 0;
 
     pg_log_info("restoring large object with OID %u", oid);
 
     /* With an old archive we must do drop and create logic here */
     if (old_blob_style && drop)
         DropBlobIfExists(AH, oid);
 
     if (AH->connection)
     {
         if (old_blob_style)
         {
             loOid = lo_create(AH->connection, oid);
             if (loOid == 0 || loOid != oid)
                 fatal("could not create large object %u: %s",
                       oid, PQerrorMessage(AH->connection));
         }
         AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
         if (AH->loFd == -1)
             fatal("could not open large object %u: %s",
                   oid, PQerrorMessage(AH->connection));
     }
     else
     {
         if (old_blob_style)
             ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
                      oid, INV_WRITE);
         else
             ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
                      oid, INV_WRITE);
     }
 
     AH->writingBlob = 1;
 }

◆ StartRestoreBlobs()

void StartRestoreBlobs ( ArchiveHandle * AH )

Definition at line 1255 of file pg_backup_archiver.c.

References ahprintf(), _archiveHandle::blobCount, _archiveHandle::connection, _archiveHandle::public, Archive::ropt, _restoreOptions::single_txn, and StartTransaction().

Referenced by _LoadBlobs().

 {
     RestoreOptions *ropt = AH->public.ropt;
 
     if (!ropt->single_txn)
     {
         if (AH->connection)
             StartTransaction(&AH->public);
         else
             ahprintf(AH, "BEGIN;\n\n");
     }
 
     AH->blobCount = 0;
 }

◆ TocIDRequired()

teReqs TocIDRequired	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1886 of file pg_backup_archiver.c.

References getTocEntryByDumpId(), and _tocEntry::reqs.

Referenced by _tarPositionTo(), _tocEntryRequired(), and findDumpableDependencies().

 {
     TocEntry   *te = getTocEntryByDumpId(AH, id);
 
     if (!te)
         return 0;
 
     return te->reqs;
 }

◆ warn_or_exit_horribly()

void warn_or_exit_horribly	(	ArchiveHandle *	AH,
		const char *	fmt,
			...
	)

◆ WriteDataChunks()

void WriteDataChunks	(	ArchiveHandle *	AH,
		struct ParallelState *	pstate
	)

Definition at line 2389 of file pg_backup_archiver.c.

References ACT_DUMP, _tocEntry::dataDumper, DispatchJobForTocEntry(), i, mark_dump_job_done(), _tocEntry::next, ParallelState::numWorkers, pg_free(), pg_malloc(), qsort, REQ_DATA, _tocEntry::reqs, _archiveHandle::toc, _archiveHandle::tocCount, TocEntrySizeCompare(), WaitForWorkers(), WFW_ALL_IDLE, and WriteDataChunksForTocEntry().

Referenced by _CloseArchive().

 {
     TocEntry   *te;
 
     if (pstate && pstate->numWorkers > 1)
     {
         /*
          * In parallel mode, this code runs in the leader process.  We
          * construct an array of candidate TEs, then sort it into decreasing
          * size order, then dispatch each TE to a data-transfer worker.  By
          * dumping larger tables first, we avoid getting into a situation
          * where we're down to one job and it's big, losing parallelism.
          */
         TocEntry  **tes;
         int         ntes;
 
         tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
         ntes = 0;
         for (te = AH->toc->next; te != AH->toc; te = te->next)
         {
             /* Consider only TEs with dataDumper functions ... */
             if (!te->dataDumper)
                 continue;
             /* ... and ignore ones not enabled for dump */
             if ((te->reqs & REQ_DATA) == 0)
                 continue;
 
             tes[ntes++] = te;
         }
 
         if (ntes > 1)
             qsort((void *) tes, ntes, sizeof(TocEntry *),
                   TocEntrySizeCompare);
 
         for (int i = 0; i < ntes; i++)
             DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
                                    mark_dump_job_done, NULL);
 
         pg_free(tes);
 
         /* Now wait for workers to finish. */
         WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
     }
     else
     {
         /* Non-parallel mode: just dump all candidate TEs sequentially. */
         for (te = AH->toc->next; te != AH->toc; te = te->next)
         {
             /* Must have same filter conditions as above */
             if (!te->dataDumper)
                 continue;
             if ((te->reqs & REQ_DATA) == 0)
                 continue;
 
             WriteDataChunksForTocEntry(AH, te);
         }
     }
 }

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 2471 of file pg_backup_archiver.c.

References _archiveHandle::currToc, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::desc, _archiveHandle::EndBlobsPtr, _archiveHandle::EndDataPtr, _archiveHandle::StartBlobsPtr, and _archiveHandle::StartDataPtr.

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

 {
     StartDataPtrType startPtr;
     EndDataPtrType endPtr;
 
     AH->currToc = te;
 
     if (strcmp(te->desc, "BLOBS") == 0)
     {
         startPtr = AH->StartBlobsPtr;
         endPtr = AH->EndBlobsPtr;
     }
     else
     {
         startPtr = AH->StartDataPtr;
         endPtr = AH->EndDataPtr;
     }
 
     if (startPtr != NULL)
         (*startPtr) (AH, te);
 
     /*
      * The user-provided DataDumper routine needs to call AH->WriteData
      */
     te->dataDumper((Archive *) AH, te->dataDumperArg);
 
     if (endPtr != NULL)
         (*endPtr) (AH, te);
 
     AH->currToc = NULL;
 }

◆ WriteHead()

void WriteHead ( ArchiveHandle * AH )

Definition at line 3755 of file pg_backup_archiver.c.

References ARCHIVE_MAJOR, ARCHIVE_MINOR, ARCHIVE_REV, _archiveHandle::compression, _archiveHandle::connection, _archiveHandle::createDate, _archiveHandle::format, _archiveHandle::intSize, _archiveHandle::offSize, PQdb(), _archiveHandle::public, Archive::remoteVersionStr, tm, _archiveHandle::version, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, WriteInt(), and WriteStr().

Referenced by _CloseArchive().

 {
     struct tm   crtm;
 
     AH->WriteBufPtr(AH, "PGDMP", 5);    /* Magic code */
     AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
     AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
     AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
     AH->WriteBytePtr(AH, AH->intSize);
     AH->WriteBytePtr(AH, AH->offSize);
     AH->WriteBytePtr(AH, AH->format);
     WriteInt(AH, AH->compression);
     crtm = *localtime(&AH->createDate);
     WriteInt(AH, crtm.tm_sec);
     WriteInt(AH, crtm.tm_min);
     WriteInt(AH, crtm.tm_hour);
     WriteInt(AH, crtm.tm_mday);
     WriteInt(AH, crtm.tm_mon);
     WriteInt(AH, crtm.tm_year);
     WriteInt(AH, crtm.tm_isdst);
     WriteStr(AH, PQdb(AH->connection));
     WriteStr(AH, AH->public.remoteVersionStr);
     WriteStr(AH, PG_VERSION);
 }

◆ WriteInt()

size_t WriteInt	(	ArchiveHandle *	AH,
		int	i
	)

Definition at line 1978 of file pg_backup_archiver.c.

References i, _archiveHandle::intSize, and _archiveHandle::WriteBytePtr.

Referenced by _CustomWriteFunc(), _EndBlob(), _EndBlobs(), _EndData(), _StartBlob(), _StartBlobs(), _StartData(), WriteHead(), WriteStr(), and WriteToc().

 {
     int         b;
 
     /*
      * This is a bit yucky, but I don't want to make the binary format very
      * dependent on representation, and not knowing much about it, I write out
      * a sign byte. If you change this, don't forget to change the file
      * version #, and modify ReadInt to read the new format AS WELL AS the old
      * formats.
      */
 
     /* SIGN byte */
     if (i < 0)
     {
         AH->WriteBytePtr(AH, 1);
         i = -i;
     }
     else
         AH->WriteBytePtr(AH, 0);
 
     for (b = 0; b < AH->intSize; b++)
     {
         AH->WriteBytePtr(AH, i & 0xFF);
         i >>= 8;
     }
 
     return AH->intSize + 1;
 }

◆ WriteOffset()

size_t WriteOffset	(	ArchiveHandle *	,
		pgoff_t	,
		int
	)

Definition at line 1897 of file pg_backup_archiver.c.

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

 {
     int         off;
 
     /* Save the flag */
     AH->WriteBytePtr(AH, wasSet);
 
     /* Write out pgoff_t smallest byte first, prevents endian mismatch */
     for (off = 0; off < sizeof(pgoff_t); off++)
     {
         AH->WriteBytePtr(AH, o & 0xFF);
         o >>= 8;
     }
     return sizeof(pgoff_t) + 1;
 }

◆ WriteStr()

size_t WriteStr	(	ArchiveHandle *	AH,
		const char *	s
	)

Definition at line 2036 of file pg_backup_archiver.c.

References _archiveHandle::WriteBufPtr, and WriteInt().

Referenced by _WriteExtraToc(), WriteHead(), and WriteToc().

 {
     size_t      res;
 
     if (c)
     {
         int         len = strlen(c);
 
         res = WriteInt(AH, len);
         AH->WriteBufPtr(AH, c, len);
         res += len;
     }
     else
         res = WriteInt(AH, -1);
 
     return res;
 }

◆ WriteToc()

void WriteToc ( ArchiveHandle * AH )

Definition at line 2504 of file pg_backup_archiver.c.

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, i, _tocEntry::nDeps, _tocEntry::next, CatalogId::oid, _tocEntry::owner, REQ_DATA, REQ_SCHEMA, REQ_SPECIAL, _tocEntry::reqs, _tocEntry::section, sprintf, _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::WriteExtraTocPtr, WriteInt(), and WriteStr().

Referenced by _CloseArchive().

 {
     TocEntry   *te;
     char        workbuf[32];
     int         tocCount;
     int         i;
 
     /* count entries that will actually be dumped */
     tocCount = 0;
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
             tocCount++;
     }
 
     /* printf("%d TOC Entries to save\n", tocCount); */
 
     WriteInt(AH, tocCount);
 
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) == 0)
             continue;
 
         WriteInt(AH, te->dumpId);
         WriteInt(AH, te->dataDumper ? 1 : 0);
 
         /* OID is recorded as a string for historical reasons */
         sprintf(workbuf, "%u", te->catalogId.tableoid);
         WriteStr(AH, workbuf);
         sprintf(workbuf, "%u", te->catalogId.oid);
         WriteStr(AH, workbuf);
 
         WriteStr(AH, te->tag);
         WriteStr(AH, te->desc);
         WriteInt(AH, te->section);
         WriteStr(AH, te->defn);
         WriteStr(AH, te->dropStmt);
         WriteStr(AH, te->copyStmt);
         WriteStr(AH, te->namespace);
         WriteStr(AH, te->tablespace);
         WriteStr(AH, te->tableam);
         WriteStr(AH, te->owner);
         WriteStr(AH, "false");
 
         /* Dump list of dependencies */
         for (i = 0; i < te->nDeps; i++)
         {
             sprintf(workbuf, "%d", te->dependencies[i]);
             WriteStr(AH, workbuf);
         }
         WriteStr(AH, NULL);     /* Terminate List */
 
         if (AH->WriteExtraTocPtr)
             AH->WriteExtraTocPtr(AH, te);
     }
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ appendByteaLiteralAHX

◆ appendStringLiteralAHX

◆ ARCHIVE_MAJOR

◆ ARCHIVE_MINOR

◆ ARCHIVE_OPTS

◆ ARCHIVE_REV

◆ BLK_BLOBS

◆ BLK_DATA

◆ GZCLOSE

◆ GZEOF

◆ GZREAD

◆ GZWRITE

◆ K_OFFSET_NO_DATA

◆ K_OFFSET_POS_NOT_SET

◆ K_OFFSET_POS_SET

◆ K_VERS_1_0

◆ K_VERS_1_10

◆ K_VERS_1_11

◆ K_VERS_1_12

◆ K_VERS_1_13

◆ K_VERS_1_14

◆ K_VERS_1_2

◆ K_VERS_1_3

◆ K_VERS_1_4

◆ K_VERS_1_5

◆ K_VERS_1_6

◆ K_VERS_1_7

◆ K_VERS_1_8

◆ K_VERS_1_9

◆ K_VERS_MAJOR

◆ K_VERS_MAX

◆ K_VERS_MINOR

◆ K_VERS_REV

◆ K_VERS_SELF

◆ LOBBUFSIZE

◆ MAKE_ARCHIVE_VERSION

◆ READ_ERROR_EXIT

◆ RESTORE_PASS_LAST

◆ WORKER_CREATE_DONE

◆ WORKER_IGNORED_ERRORS

◆ WORKER_INHIBIT_DATA

◆ WORKER_OK

◆ WRITE_ERROR_EXIT

◆ Z_DEFAULT_COMPRESSION

Typedef Documentation

◆ ArchiveEntryPtrType

◆ ArchiveHandle

◆ ArchiveOpts

◆ ClonePtrType

◆ ClosePtrType

◆ CustomOutPtrType

◆ DeClonePtrType

◆ EndBlobPtrType

◆ EndBlobsPtrType

◆ EndDataPtrType

◆ PrepParallelRestorePtrType

◆ PrintExtraTocPtrType

◆ PrintTocDataPtrType

◆ ReadBufPtrType

◆ ReadBytePtrType

◆ ReadExtraTocPtrType

◆ ReopenPtrType

◆ StartBlobPtrType

◆ StartBlobsPtrType

◆ StartDataPtrType

◆ T_Action

◆ TocEntry

◆ WorkerJobDumpPtrType

◆ WorkerJobRestorePtrType

◆ WriteBufPtrType

◆ WriteBytePtrType

◆ WriteDataPtrType

◆ WriteExtraTocPtrType

◆ z_stream