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

struct	_archiveHandle

struct	_tocEntry

struct	_archiveOpts

Macros
#define	LOBBUFSIZE 16384

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

#define	K_VERS_MAJOR 1

#define	K_VERS_MINOR 15

#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	REQ_SCHEMA 0x01 /* want schema */

#define	REQ_DATA 0x02 /* want data */

#define	REQ_SPECIAL 0x04 /* for special TOC entries */

#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 _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(*	StartLOsPtrType) (ArchiveHandle AH, TocEntry te)

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

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

typedef void(*	EndLOsPtrType) (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 }

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)

int	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 c)

int	ReadOffset (ArchiveHandle , pgoff_t )

size_t	WriteOffset (ArchiveHandle *, pgoff_t, int)

void	StartRestoreLOs (ArchiveHandle *AH)

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

void	EndRestoreLO (ArchiveHandle *AH, Oid oid)

void	EndRestoreLOs (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)

void	DropLOIfExists (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 413 of file pg_backup_archiver.h.

◆ appendStringLiteralAHX

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

Definition at line 410 of file pg_backup_archiver.h.

◆ ARCHIVE_MAJOR

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

Definition at line 42 of file pg_backup_archiver.h.

◆ ARCHIVE_MINOR

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

Definition at line 43 of file pg_backup_archiver.h.

◆ ARCHIVE_OPTS

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

Definition at line 392 of file pg_backup_archiver.h.

◆ ARCHIVE_REV

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

Definition at line 44 of file pg_backup_archiver.h.

◆ BLK_BLOBS

#define BLK_BLOBS 3

Definition at line 37 of file pg_backup_archiver.h.

◆ BLK_DATA

#define BLK_DATA 1

Definition at line 36 of file pg_backup_archiver.h.

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA 3

Definition at line 76 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET 1

Definition at line 74 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET 2

Definition at line 75 of file pg_backup_archiver.h.

◆ K_VERS_1_0

#define K_VERS_1_0 MAKE_ARCHIVE_VERSION(1, 0, 0)

Definition at line 47 of file pg_backup_archiver.h.

◆ K_VERS_1_10

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

Definition at line 56 of file pg_backup_archiver.h.

◆ 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:40

Definition at line 57 of file pg_backup_archiver.h.

◆ K_VERS_1_12

#define K_VERS_1_12

Value:

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

* entries */

Definition at line 58 of file pg_backup_archiver.h.

◆ K_VERS_1_13

#define K_VERS_1_13

Value:

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

* behavior */

Definition at line 59 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 60 of file pg_backup_archiver.h.

◆ K_VERS_1_15

#define K_VERS_1_15

Value:

                                                     MAKE_ARCHIVE_VERSION(1, 15, 0) /* add
                                                     * compression_algorithm
                                                     * in header */

Definition at line 61 of file pg_backup_archiver.h.

◆ K_VERS_1_2

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

Definition at line 48 of file pg_backup_archiver.h.

◆ K_VERS_1_3

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

Definition at line 49 of file pg_backup_archiver.h.

◆ K_VERS_1_4

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

Definition at line 50 of file pg_backup_archiver.h.

◆ K_VERS_1_5

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

Definition at line 51 of file pg_backup_archiver.h.

◆ K_VERS_1_6

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

Definition at line 52 of file pg_backup_archiver.h.

◆ K_VERS_1_7

#define K_VERS_1_7

Value:

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

* header */

Definition at line 53 of file pg_backup_archiver.h.

◆ 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 54 of file pg_backup_archiver.h.

◆ K_VERS_1_9

#define K_VERS_1_9

Value:

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

* tracking */

Definition at line 55 of file pg_backup_archiver.h.

◆ K_VERS_MAJOR

#define K_VERS_MAJOR 1

Definition at line 64 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 70 of file pg_backup_archiver.h.

◆ K_VERS_MINOR

#define K_VERS_MINOR 15

Definition at line 65 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV 0

Definition at line 66 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 67 of file pg_backup_archiver.h.

◆ LOBBUFSIZE

#define LOBBUFSIZE 16384

Definition at line 33 of file pg_backup_archiver.h.

◆ MAKE_ARCHIVE_VERSION

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

Definition at line 40 of file pg_backup_archiver.h.

◆ READ_ERROR_EXIT

#define READ_ERROR_EXIT ( fd )

Value:

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

Definition at line 91 of file pg_backup_archiver.h.

◆ REQ_DATA

#define REQ_DATA 0x02 /* want data */

Definition at line 199 of file pg_backup_archiver.h.

◆ REQ_SCHEMA

#define REQ_SCHEMA 0x01 /* want schema */

Definition at line 198 of file pg_backup_archiver.h.

◆ REQ_SPECIAL

#define REQ_SPECIAL 0x04 /* for special TOC entries */

Definition at line 200 of file pg_backup_archiver.h.

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST RESTORE_PASS_POST_ACL

Definition at line 195 of file pg_backup_archiver.h.

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE 10

Definition at line 83 of file pg_backup_archiver.h.

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS 12

Definition at line 85 of file pg_backup_archiver.h.

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA 11

Definition at line 84 of file pg_backup_archiver.h.

◆ WORKER_OK

#define WORKER_OK 0

Definition at line 82 of file pg_backup_archiver.h.

◆ WRITE_ERROR_EXIT

#define WRITE_ERROR_EXIT

Value:

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

Definition at line 99 of file pg_backup_archiver.h.

Typedef Documentation

◆ ArchiveEntryPtrType

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

Definition at line 112 of file pg_backup_archiver.h.

◆ ArchiveHandle

typedef struct _archiveHandle ArchiveHandle

Definition at line 1 of file pg_backup_archiver.h.

◆ ArchiveOpts

typedef void struct _archiveOpts ArchiveOpts

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 133 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 110 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 139 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 134 of file pg_backup_archiver.h.

◆ EndDataPtrType

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

Definition at line 116 of file pg_backup_archiver.h.

◆ EndLOPtrType

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

Definition at line 120 of file pg_backup_archiver.h.

◆ EndLOsPtrType

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

Definition at line 121 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 132 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

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

Definition at line 129 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

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

Definition at line 130 of file pg_backup_archiver.h.

◆ ReadBufPtrType

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

Definition at line 126 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 124 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

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

Definition at line 128 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 111 of file pg_backup_archiver.h.

◆ StartDataPtrType

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

Definition at line 114 of file pg_backup_archiver.h.

◆ StartLOPtrType

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

Definition at line 119 of file pg_backup_archiver.h.

◆ StartLOsPtrType

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

Definition at line 118 of file pg_backup_archiver.h.

◆ T_Action

typedef enum T_Action T_Action

◆ TocEntry

typedef struct _tocEntry TocEntry

Definition at line 1 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

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

Definition at line 136 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

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

Definition at line 137 of file pg_backup_archiver.h.

◆ WriteBufPtrType

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

Definition at line 125 of file pg_backup_archiver.h.

◆ WriteBytePtrType

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

Definition at line 123 of file pg_backup_archiver.h.

◆ WriteDataPtrType

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

Definition at line 115 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

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

Definition at line 127 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

enum ArchiverOutput

Enumerator
OUTPUT_SQLCMDS
OUTPUT_COPYDATA
OUTPUT_OTHERDATA

Definition at line 163 of file pg_backup_archiver.h.

 {
     STAGE_NONE = 0,
     STAGE_INITIALIZING,
     STAGE_PROCESSING,

◆ ArchiverStage

enum ArchiverStage

Enumerator
STAGE_NONE
STAGE_INITIALIZING
STAGE_PROCESSING
STAGE_FINALIZING

Definition at line 155 of file pg_backup_archiver.h.

 {
     sqlparseState state;        /* see above */
     bool        backSlash;      /* next char is backslash quoted? */
     PQExpBuffer curCmd;         /* incomplete line (NULL if not created) */

◆ RestorePass

enum RestorePass

Enumerator
RESTORE_PASS_MAIN
RESTORE_PASS_ACL

Definition at line 189 of file pg_backup_archiver.h.

199 {

◆ sqlparseState

enum sqlparseState

Enumerator
SQL_SCAN
SQL_IN_SINGLE_QUOTE
SQL_IN_DOUBLE_QUOTE

Definition at line 141 of file pg_backup_archiver.h.

151 {

◆ T_Action

enum T_Action

Enumerator
ACT_DUMP
ACT_RESTORE

Definition at line 104 of file pg_backup_archiver.h.

                                                     : %m"); \
     } while (0)
  
 #define WRITE_ERROR_EXIT \

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 1705 of file pg_backup_archiver.c.

 {
     int         bytes_written = 0;
  
     if (AH->writingLO)
     {
         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->CustomOutPtr)
         bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
  
     /*
      * If we're doing a restore, and it's direct to DB, and we're connected
      * then send it to the DB.
      */
     else if (RestoringToDB(AH))
         bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
     else
     {
         CompressFileHandle *CFH = (CompressFileHandle *) AH->OF;
  
         if (CFH->write_func(ptr, size * nmemb, CFH))
             bytes_written = size * nmemb;
     }
  
     if (bytes_written != size * nmemb)
         WRITE_ERROR_EXIT;
 }

References _archiveHandle::CustomOutPtr, dump_lo_buf(), ExecuteSqlCommandBuf(), if(), _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, _archiveHandle::lo_buf_used, _archiveHandle::OF, _archiveHandle::public, remaining, RestoringToDB(), WRITE_ERROR_EXIT, CompressFileHandle::write_func, and _archiveHandle::writingLO.

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

◆ ArchiveEntry()

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

Definition at line 1115 of file pg_backup_archiver.c.

 {
     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;
 }

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, opts, _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(), dumpCast(), dumpCollation(), dumpCommentExtended(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpLO(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationNamespace(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpTableAttach(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

◆ checkSeek()

bool checkSeek ( FILE * fp )

Definition at line 3865 of file pg_backup_archiver.c.

 {
     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;
 }

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle * AH )

Definition at line 4785 of file pg_backup_archiver.c.

 {
     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->currTableAm = 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, using the same connection
      * parameters used for the original connection.
      */
     ConnectDatabase((Archive *) clone, &clone->public.ropt->cparams, true);
  
     /* re-establish fixed state */
     if (AH->mode == archModeRead)
         _doSetFixedOutputState(clone);
     /* in write case, setupDumpWorker will fix up connection state */
  
     /* Let the format-specific code have a chance too */
     clone->ClonePtr(clone);
  
     Assert(clone->connection != NULL);
     return clone;
 }

References _doSetFixedOutputState(), archModeRead, Assert(), _archiveHandle::ClonePtr, _archiveHandle::connCancel, ConnectDatabase(), _archiveHandle::connection, _restoreOptions::cparams, _archiveHandle::currSchema, _archiveHandle::currTableAm, _archiveHandle::currTablespace, _archiveHandle::currUser, _archiveHandle::mode, Archive::n_errors, pg_malloc(), pg_strdup(), _archiveHandle::public, Archive::ropt, _archiveHandle::savedPassword, and _archiveHandle::sqlparse.

Referenced by RunWorker().

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle * AH )

Definition at line 4835 of file pg_backup_archiver.c.

 {
     /* 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 */
     free(AH->currUser);
     free(AH->currSchema);
     free(AH->currTablespace);
     free(AH->currTableAm);
     free(AH->savedPassword);
  
     free(AH);
 }

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().

◆ DropLOIfExists()

void DropLOIfExists	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 545 of file pg_backup_db.c.

 {
     /*
      * If we are not restoring to a direct database connection, we have to
      * guess about how to detect whether the LO 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);
     }
 }

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

Referenced by _StartLO(), RestoreArchive(), and StartRestoreLO().

◆ EndRestoreLO()

void EndRestoreLO	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 1400 of file pg_backup_archiver.c.

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

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

Referenced by _LoadLOs().

◆ EndRestoreLOs()

void EndRestoreLOs ( ArchiveHandle * AH )

Definition at line 1333 of file pg_backup_archiver.c.

 {
     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->loCount),
                 AH->loCount);
 }

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

Referenced by _LoadLOs().

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1885 of file pg_backup_archiver.c.

 {
     /* 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;
 }

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

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

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle * AH )

Definition at line 106 of file pg_backup_custom.c.

 {
     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->StartLOsPtr = _StartLOs;
     AH->StartLOPtr = _StartLO;
     AH->EndLOPtr = _EndLO;
     AH->EndLOsPtr = _EndLOs;
  
     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);
  
     /*
      * 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)
                 pg_fatal("could not open output file \"%s\": %m", AH->fSpec);
         }
         else
         {
             AH->FH = stdout;
             if (!AH->FH)
                 pg_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)
                 pg_fatal("could not open input file \"%s\": %m", AH->fSpec);
         }
         else
         {
             AH->FH = stdin;
             if (!AH->FH)
                 pg_fatal("could not open input file: %m");
         }
  
         ctx->hasSeek = checkSeek(AH->FH);
  
         ReadHead(AH);
         ReadToc(AH);
  
         /*
          * Remember location of first data block (i.e., the point after TOC)
          * in case we have to search for desired data blocks.
          */
         ctx->lastFilePos = _getFilePos(AH, ctx);
     }
 }

Referenced by _allocAH().

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle * AH )

Definition at line 107 of file pg_backup_directory.c.

 {
     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->StartLOsPtr = _StartLOs;
     AH->StartLOPtr = _StartLO;
     AH->EndLOPtr = _EndLO;
     AH->EndLOsPtr = _EndLOs;
  
     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->LOsTocFH = 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)
         pg_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)
                     pg_fatal("could not read directory \"%s\": %m",
                              ctx->directory);
  
                 if (closedir(dir))
                     pg_fatal("could not close directory \"%s\": %m",
                              ctx->directory);
             }
         }
  
         if (!is_empty && mkdir(ctx->directory, 0700) < 0)
             pg_fatal("could not create directory \"%s\": %m",
                      ctx->directory);
     }
     else
     {                           /* Read Mode */
         char        fname[MAXPGPATH];
         CompressFileHandle *tocFH;
  
         setFilePath(AH, fname, "toc.dat");
  
         tocFH = InitDiscoverCompressFileHandle(fname, PG_BINARY_R);
         if (tocFH == NULL)
             pg_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 (!EndCompressFileHandle(tocFH))
             pg_fatal("could not close TOC file: %m");
         ctx->dataFH = NULL;
     }
 }

Referenced by _allocAH().

◆ InitArchiveFmt_Null()

void InitArchiveFmt_Null ( ArchiveHandle * AH )

Definition at line 48 of file pg_backup_null.c.

 {
     /* 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->StartLOsPtr = _StartLOs;
     AH->StartLOPtr = _StartLO;
     AH->EndLOPtr = _EndLO;
     AH->EndLOsPtr = _EndLOs;
     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)
         pg_fatal("this format cannot be read");
 }

Referenced by _allocAH().

◆ InitArchiveFmt_Tar()

void InitArchiveFmt_Tar ( ArchiveHandle * AH )

Definition at line 121 of file pg_backup_tar.c.

 {
     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->StartLOsPtr = _StartLOs;
     AH->StartLOPtr = _StartLO;
     AH->EndLOPtr = _EndLO;
     AH->EndLOsPtr = _EndLOs;
     AH->ClonePtr = NULL;
     AH->DeClonePtr = NULL;
  
     AH->WorkerJobDumpPtr = NULL;
     AH->WorkerJobRestorePtr = NULL;
  
     /*
      * Set up some special context used in compressing data.
      */
     ctx = pg_malloc0_object(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)
                 pg_fatal("could not open TOC file \"%s\" for output: %m",
                          AH->fSpec);
         }
         else
         {
             ctx->tarFH = stdout;
             if (ctx->tarFH == NULL)
                 pg_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_spec.algorithm != PG_COMPRESSION_NONE)
             pg_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)
                 pg_fatal("could not open TOC file \"%s\" for input: %m",
                          AH->fSpec);
         }
         else
         {
             ctx->tarFH = stdin;
             if (ctx->tarFH == NULL)
                 pg_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);
  
         ctx->FH = (void *) tarOpen(AH, "toc.dat", 'r');
         ReadHead(AH);
         ReadToc(AH);
         tarClose(AH, ctx->FH);  /* Nothing else in the file... */
     }
 }

References _ArchiveEntry(), _CloseArchive(), _EndData(), _EndLO(), _EndLOs(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _StartData(), _StartLO(), _StartLOs(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), archModeWrite, checkSeek(), lclContext::FH, lclContext::filePos, lclContext::hasSeek, lclContext::isSpecialScript, LOBBUFSIZE, PG_BINARY_R, PG_BINARY_W, PG_COMPRESSION_NONE, pg_fatal, pg_malloc(), pg_malloc0_object, ReadHead(), ReadToc(), generate_unaccent_rules::stdout, tarClose(), lclContext::tarFH, lclContext::tarFHpos, and tarOpen().

Referenced by _allocAH().

◆ isValidTarHeader()

bool isValidTarHeader ( char * header )

Definition at line 973 of file pg_backup_tar.c.

 {
     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;
 }

References read_tar_number(), and tarChecksum().

Referenced by _discoverArchiveFormat().

◆ on_exit_close_archive()

void on_exit_close_archive ( Archive * AHX )

Definition at line 328 of file parallel.c.

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

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

Referenced by main().

◆ parallel_restore()

int parallel_restore	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 4418 of file pg_backup_archiver.c.

 {
     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;
 }

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

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

◆ ReadHead()

void ReadHead ( ArchiveHandle * AH )

Definition at line 3731 of file pg_backup_archiver.c.

 {
     char       *errmsg;
     char        vmaj,
                 vmin,
                 vrev;
     int         fmt;
  
     /*
      * 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        tmpMag[7];
  
         AH->ReadBufPtr(AH, tmpMag, 5);
  
         if (strncmp(tmpMag, "PGDMP", 5) != 0)
             pg_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)
         pg_fatal("unsupported version (%d.%d) in file header",
                  vmaj, vmin);
  
     AH->intSize = AH->ReadBytePtr(AH);
     if (AH->intSize > 32)
         pg_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)
         pg_fatal("expected format (%d) differs from format found in file (%d)",
                  AH->format, fmt);
  
     if (AH->version >= K_VERS_1_15)
         AH->compression_spec.algorithm = AH->ReadBytePtr(AH);
     else if (AH->version >= K_VERS_1_2)
     {
         /* Guess the compression method based on the level */
         if (AH->version < K_VERS_1_4)
             AH->compression_spec.level = AH->ReadBytePtr(AH);
         else
             AH->compression_spec.level = ReadInt(AH);
  
         if (AH->compression_spec.level != 0)
             AH->compression_spec.algorithm = PG_COMPRESSION_GZIP;
     }
     else
         AH->compression_spec.algorithm = PG_COMPRESSION_GZIP;
  
     errmsg = supports_compression(AH->compression_spec);
     if (errmsg)
     {
         pg_log_warning("archive is compressed, but this installation does not support compression (%s) -- no data will be available",
                        errmsg);
         pg_free(errmsg);
     }
  
     if (AH->version >= K_VERS_1_4)
     {
         struct tm   crtm;
  
         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);
  
         /*
          * Newer versions of glibc have mktime() report failure if tm_isdst is
          * inconsistent with the prevailing timezone, e.g. tm_isdst = 1 when
          * TZ=UTC.  This is problematic when restoring an archive under a
          * different timezone setting.  If we get a failure, try again with
          * tm_isdst set to -1 ("don't know").
          *
          * XXX with or without this hack, we reconstruct createDate
          * incorrectly when the prevailing timezone is different from
          * pg_dump's.  Next time we bump the archive version, we should flush
          * this representation and store a plain seconds-since-the-Epoch
          * timestamp instead.
          */
         AH->createDate = mktime(&crtm);
         if (AH->createDate == (time_t) -1)
         {
             crtm.tm_isdst = -1;
             AH->createDate = mktime(&crtm);
             if (AH->createDate == (time_t) -1)
                 pg_log_warning("invalid creation date in header");
         }
     }
  
     if (AH->version >= K_VERS_1_4)
     {
         AH->archdbname = ReadStr(AH);
     }
  
     if (AH->version >= K_VERS_1_10)
     {
         AH->archiveRemoteVersion = ReadStr(AH);
         AH->archiveDumpVersion = ReadStr(AH);
     }
 }

References pg_compress_specification::algorithm, _archiveHandle::archdbname, _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, _archiveHandle::compression_spec, _archiveHandle::createDate, errmsg(), fmt, _archiveHandle::format, _archiveHandle::intSize, K_VERS_1_0, K_VERS_1_10, K_VERS_1_15, K_VERS_1_2, K_VERS_1_4, K_VERS_1_7, K_VERS_MAX, pg_compress_specification::level, MAKE_ARCHIVE_VERSION, _archiveHandle::offSize, PG_COMPRESSION_GZIP, pg_fatal, pg_free(), pg_log_warning, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::readHeader, ReadInt(), ReadStr(), supports_compression(), tm, pg_tm::tm_sec, and _archiveHandle::version.

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

◆ ReadInt()

int ReadInt ( ArchiveHandle * AH )

Definition at line 2021 of file pg_backup_archiver.c.

 {
     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;
 }

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

Referenced by _CustomReadFunc(), _LoadLOs(), _readBlockHeader(), _ReadExtraToc(), _skipData(), _skipLOs(), ReadHead(), ReadOffset(), ReadStr(), and ReadToc().

◆ ReadOffset()

int ReadOffset	(	ArchiveHandle *	AH,
		pgoff_t *	o
	)

Definition at line 1926 of file pg_backup_archiver.c.

 {
     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:
             pg_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)
                 pg_fatal("file offset in dump file is too large");
         }
     }
  
     return offsetFlg;
 }

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

Referenced by _ReadExtraToc().

◆ ReadStr()

char* ReadStr ( ArchiveHandle * AH )

Definition at line 2067 of file pg_backup_archiver.c.

 {
     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;
 }

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

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

◆ ReadToc()

void ReadToc ( ArchiveHandle * AH )

Definition at line 2525 of file pg_backup_archiver.c.

 {
     int         i;
     char       *tmp;
     DumpId     *deps;
     int         depIdx;
     int         depSize;
     TocEntry   *te;
     bool        is_supported;
  
     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)
             pg_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);
         is_supported = true;
         if (AH->version < K_VERS_1_9)
             is_supported = false;
         else
         {
             tmp = ReadStr(AH);
  
             if (strcmp(tmp, "true") == 0)
                 is_supported = false;
  
             free(tmp);
         }
  
         if (!is_supported)
             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);
     }
 }

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, 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_fatal, 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().

◆ ReconnectToServer()

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

Definition at line 74 of file pg_backup_db.c.

 {
     PGconn     *oldConn = AH->connection;
     RestoreOptions *ropt = AH->public.ropt;
  
     /*
      * Save the dbname, if given, in override_dbname so that it will also
      * affect any later reconnection attempt.
      */
     if (dbname)
         ropt->cparams.override_dbname = pg_strdup(dbname);
  
     /*
      * Note: we want to establish the new connection, and in particular update
      * ArchiveHandle's connCancel, before closing old connection.  Otherwise
      * an ill-timed SIGINT could try to access a dead connection.
      */
     AH->connection = NULL;      /* dodge error check in ConnectDatabase */
  
     ConnectDatabase((Archive *) AH, &ropt->cparams, true);
  
     PQfinish(oldConn);
 }

References ConnectDatabase(), _archiveHandle::connection, _restoreOptions::cparams, dbname, _connParams::override_dbname, pg_strdup(), PQfinish(), _archiveHandle::public, and Archive::ropt.

Referenced by _reconnectToDB().

◆ StartRestoreLO()

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

Definition at line 1356 of file pg_backup_archiver.c.

 {
     bool        old_lo_style = (AH->version < K_VERS_1_12);
     Oid         loOid;
  
     AH->loCount++;
  
     /* 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_lo_style && drop)
         DropLOIfExists(AH, oid);
  
     if (AH->connection)
     {
         if (old_lo_style)
         {
             loOid = lo_create(AH->connection, oid);
             if (loOid == 0 || loOid != oid)
                 pg_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)
             pg_fatal("could not open large object %u: %s",
                      oid, PQerrorMessage(AH->connection));
     }
     else
     {
         if (old_lo_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->writingLO = true;
 }

References ahprintf(), _archiveHandle::connection, DropLOIfExists(), INV_WRITE, K_VERS_1_12, _archiveHandle::lo_buf_used, lo_create(), lo_open(), _archiveHandle::loCount, _archiveHandle::loFd, pg_fatal, pg_log_info, PQerrorMessage(), _archiveHandle::version, and _archiveHandle::writingLO.

Referenced by _LoadLOs().

◆ StartRestoreLOs()

void StartRestoreLOs ( ArchiveHandle * AH )

Definition at line 1314 of file pg_backup_archiver.c.

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

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

Referenced by _LoadLOs().

◆ TocIDRequired()

int TocIDRequired	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1898 of file pg_backup_archiver.c.

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

References getTocEntryByDumpId(), and _tocEntry::reqs.

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

◆ 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 2352 of file pg_backup_archiver.c.

 {
     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(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);
         }
     }
 }

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().

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 2433 of file pg_backup_archiver.c.

 {
     StartDataPtrType startPtr;
     EndDataPtrType endPtr;
  
     AH->currToc = te;
  
     if (strcmp(te->desc, "BLOBS") == 0)
     {
         startPtr = AH->StartLOsPtr;
         endPtr = AH->EndLOsPtr;
     }
     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;
 }

References _archiveHandle::currToc, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::desc, _archiveHandle::EndDataPtr, _archiveHandle::EndLOsPtr, _archiveHandle::StartDataPtr, and _archiveHandle::StartLOsPtr.

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

◆ WriteHead()

void WriteHead ( ArchiveHandle * AH )

Definition at line 3705 of file pg_backup_archiver.c.

 {
     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);
     AH->WriteBytePtr(AH, AH->compression_spec.algorithm);
     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);
 }

References pg_compress_specification::algorithm, ARCHIVE_MAJOR, ARCHIVE_MINOR, ARCHIVE_REV, _archiveHandle::compression_spec, _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().

◆ WriteInt()

size_t WriteInt	(	ArchiveHandle *	AH,
		int	i
	)

Definition at line 1990 of file pg_backup_archiver.c.

 {
     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;
 }

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

Referenced by _CustomWriteFunc(), _EndData(), _EndLO(), _EndLOs(), _StartData(), _StartLO(), _StartLOs(), WriteHead(), WriteStr(), and WriteToc().

◆ WriteOffset()

size_t WriteOffset	(	ArchiveHandle *	AH,
		pgoff_t	o,
		int	wasSet
	)

Definition at line 1909 of file pg_backup_archiver.c.

 {
     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;
 }

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

◆ WriteStr()

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

Definition at line 2048 of file pg_backup_archiver.c.

 {
     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;
 }

References len, res, _archiveHandle::WriteBufPtr, and WriteInt().

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

◆ WriteToc()

void WriteToc ( ArchiveHandle * AH )

Definition at line 2466 of file pg_backup_archiver.c.

 {
     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);
     }
 }

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().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ appendByteaLiteralAHX

◆ appendStringLiteralAHX

◆ ARCHIVE_MAJOR

◆ ARCHIVE_MINOR

◆ ARCHIVE_OPTS

◆ ARCHIVE_REV

◆ BLK_BLOBS

◆ BLK_DATA

◆ 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_15

◆ 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

◆ REQ_DATA

◆ REQ_SCHEMA

◆ REQ_SPECIAL

◆ RESTORE_PASS_LAST

◆ WORKER_CREATE_DONE

◆ WORKER_IGNORED_ERRORS

◆ WORKER_INHIBIT_DATA

◆ WORKER_OK

◆ WRITE_ERROR_EXIT

Typedef Documentation

◆ ArchiveEntryPtrType

◆ ArchiveHandle

◆ ArchiveOpts

◆ ClonePtrType

◆ ClosePtrType

◆ CustomOutPtrType

◆ DeClonePtrType

◆ EndDataPtrType

◆ EndLOPtrType

◆ EndLOsPtrType

◆ PrepParallelRestorePtrType

◆ PrintExtraTocPtrType

◆ PrintTocDataPtrType

◆ ReadBufPtrType

◆ ReadBytePtrType

◆ ReadExtraTocPtrType

◆ ReopenPtrType

◆ StartDataPtrType

◆ StartLOPtrType

◆ StartLOsPtrType

◆ T_Action

◆ TocEntry

◆ WorkerJobDumpPtrType

◆ WorkerJobRestorePtrType

◆ WriteBufPtrType

◆ WriteBytePtrType

◆ WriteDataPtrType

◆ WriteExtraTocPtrType

Enumeration Type Documentation

◆ ArchiverOutput