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

#define	K_VERS_MAJOR 1

#define	K_VERS_MINOR 16

#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 , RESTORE_PASS_POST_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	IssueCommandPerBlob (ArchiveHandle AH, TocEntry te, const char cmdBegin, const char cmdEnd)

void	IssueACLPerBlob (ArchiveHandle AH, TocEntry te)

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 420 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 417 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 399 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 77 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET 1

Definition at line 75 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET 2

Definition at line 76 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_16

#define K_VERS_1_16

Value:

                                                     MAKE_ARCHIVE_VERSION(1, 16, 0) /* BLOB METADATA entries
                                                     * and multiple BLOBS,
                                                     * relkind */

Definition at line 62 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 65 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 71 of file pg_backup_archiver.h.

◆ K_VERS_MINOR

#define K_VERS_MINOR 16

Definition at line 66 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV 0

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

◆ REQ_DATA

#define REQ_DATA 0x02 /* want data */

Definition at line 200 of file pg_backup_archiver.h.

◆ REQ_SCHEMA

#define REQ_SCHEMA 0x01 /* want schema */

Definition at line 199 of file pg_backup_archiver.h.

◆ REQ_SPECIAL

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

Definition at line 201 of file pg_backup_archiver.h.

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST RESTORE_PASS_POST_ACL

Definition at line 196 of file pg_backup_archiver.h.

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE 10

Definition at line 84 of file pg_backup_archiver.h.

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS 12

Definition at line 86 of file pg_backup_archiver.h.

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA 11

Definition at line 85 of file pg_backup_archiver.h.

◆ WORKER_OK

#define WORKER_OK 0

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

Typedef Documentation

◆ ArchiveEntryPtrType

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

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

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 111 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 140 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 135 of file pg_backup_archiver.h.

◆ EndDataPtrType

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

Definition at line 117 of file pg_backup_archiver.h.

◆ EndLOPtrType

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

Definition at line 121 of file pg_backup_archiver.h.

◆ EndLOsPtrType

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

Definition at line 122 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 133 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

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

Definition at line 130 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

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

Definition at line 131 of file pg_backup_archiver.h.

◆ ReadBufPtrType

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

Definition at line 127 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 125 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

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

Definition at line 129 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 112 of file pg_backup_archiver.h.

◆ StartDataPtrType

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

Definition at line 115 of file pg_backup_archiver.h.

◆ StartLOPtrType

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

Definition at line 120 of file pg_backup_archiver.h.

◆ StartLOsPtrType

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

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

◆ WorkerJobRestorePtrType

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

Definition at line 138 of file pg_backup_archiver.h.

◆ WriteBufPtrType

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

Definition at line 126 of file pg_backup_archiver.h.

◆ WriteBytePtrType

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

Definition at line 124 of file pg_backup_archiver.h.

◆ WriteDataPtrType

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

Definition at line 116 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

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

Definition at line 128 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

enum ArchiverOutput

Enumerator
OUTPUT_SQLCMDS
OUTPUT_COPYDATA
OUTPUT_OTHERDATA

Definition at line 164 of file pg_backup_archiver.h.

168 {

169 STAGE_NONE = 0,

STAGE_NONE

@ STAGE_NONE

Definition: pg_backup_archiver.h:158

◆ ArchiverStage

enum ArchiverStage

Enumerator
STAGE_NONE
STAGE_INITIALIZING
STAGE_PROCESSING
STAGE_FINALIZING

Definition at line 156 of file pg_backup_archiver.h.

161 {

162 sqlparseState state; /* see above */

sqlparseState

Definition: pg_backup_archiver.h:143

state

Definition: regguts.h:323

◆ RestorePass

enum RestorePass

Enumerator
RESTORE_PASS_MAIN
RESTORE_PASS_ACL
RESTORE_PASS_POST_ACL

Definition at line 190 of file pg_backup_archiver.h.

202 {

◆ sqlparseState

enum sqlparseState

Enumerator
SQL_SCAN
SQL_IN_SINGLE_QUOTE
SQL_IN_DOUBLE_QUOTE

Definition at line 142 of file pg_backup_archiver.h.

154 {

◆ T_Action

enum T_Action

Enumerator
ACT_DUMP
ACT_RESTORE

Definition at line 105 of file pg_backup_archiver.h.

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

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 1805 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(), size, 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 1203 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->relkind = opts->relkind;
     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::relkind, _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(), dumpSubscriptionTable(), dumpTableAttach(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

◆ checkSeek()

bool checkSeek ( FILE * fp )

Definition at line 4092 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 4959 of file pg_backup_archiver.c.

 {
     ArchiveHandle *clone;
  
     /* Make a "flat" copy */
     clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
     memcpy(clone, AH, sizeof(ArchiveHandle));
  
     /* Likewise flat-copy the RestoreOptions, so we can alter them locally */
     clone->public.ropt = (RestoreOptions *) pg_malloc(sizeof(RestoreOptions));
     memcpy(clone->public.ropt, AH->public.ropt, sizeof(RestoreOptions));
  
     /* 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;
  
     /* clones should not share lo_buf */
     clone->lo_buf = NULL;
  
     /*
      * Clone connections disregard --transaction-size; they must commit after
      * each command so that the results are immediately visible to other
      * workers.
      */
     clone->public.ropt->txn_size = 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::lo_buf, _archiveHandle::mode, Archive::n_errors, pg_malloc(), pg_strdup(), _archiveHandle::public, Archive::ropt, _archiveHandle::savedPassword, _archiveHandle::sqlparse, and _restoreOptions::txn_size.

Referenced by RunWorker().

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle * AH )

Definition at line 5023 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 673 of file pg_backup_db.c.

 {
     ahprintf(AH,
              "SELECT pg_catalog.lo_unlink(oid) "
              "FROM pg_catalog.pg_largeobject_metadata "
              "WHERE oid = '%u';\n",
              oid);
 }

References ahprintf().

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

◆ EndRestoreLO()

void EndRestoreLO	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 1500 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 1427 of file pg_backup_archiver.c.

 {
     RestoreOptions *ropt = AH->public.ropt;
  
     if (!(ropt->single_txn || ropt->txn_size > 0))
     {
         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, _restoreOptions::single_txn, and _restoreOptions::txn_size.

Referenced by _LoadLOs().

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1985 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(), _tocEntryRequired(), IssueACLPerBlob(), 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;
  
     /*
      * 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 109 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;
  
     /*
      * 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;
     }
 }

References _ArchiveEntry(), _Clone(), _CloseArchive(), _DeClone(), _EndData(), _EndLO(), _EndLOs(), _PrepParallelRestore(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _ReopenArchive(), _StartData(), _StartLO(), _StartLOs(), _WorkerJobDumpDirectory(), _WorkerJobRestoreDirectory(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), archDirectory, _archiveHandle::ArchiveEntryPtr, archModeWrite, archTar, _archiveHandle::ClonePtr, closedir(), _archiveHandle::ClosePtr, dirent::d_name, lclContext::dataFH, _archiveHandle::DeClonePtr, lclContext::directory, EndCompressFileHandle(), _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::format, _archiveHandle::formatData, _archiveHandle::fSpec, InitDiscoverCompressFileHandle(), lclContext::LOsTocFH, MAXPGPATH, mkdir, _archiveHandle::mode, opendir(), PG_BINARY_R, pg_fatal, pg_malloc0(), _archiveHandle::PrepParallelRestorePtr, _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, readdir(), _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, S_ISDIR, setFilePath(), stat::st_mode, _archiveHandle::StartDataPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, stat, _archiveHandle::WorkerJobDumpPtr, _archiveHandle::WorkerJobRestorePtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, _archiveHandle::WriteDataPtr, and _archiveHandle::WriteExtraTocPtr.

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;
  
     /*
      * 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;
  
     /*
      * 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, PG_BINARY_R, PG_BINARY_W, PG_COMPRESSION_NONE, pg_fatal, pg_malloc0_object, ReadHead(), ReadToc(), generate_unaccent_rules::stdout, tarClose(), lclContext::tarFH, lclContext::tarFHpos, and tarOpen().

Referenced by _allocAH().

◆ IssueACLPerBlob()

void IssueACLPerBlob	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 599 of file pg_backup_db.c.

 {
     TocEntry   *blobte = getTocEntryByDumpId(AH, te->dependencies[0]);
     char       *buf;
     char       *st;
     char       *st2;
     char       *en;
     bool        inquotes;
  
     if (!blobte)
         pg_fatal("could not find entry for ID %d", te->dependencies[0]);
     Assert(strcmp(blobte->desc, "BLOB METADATA") == 0);
  
     /* Make a writable copy of the ACL commands string */
     buf = pg_strdup(te->defn);
  
     /*
      * We have to parse out the commands sufficiently to locate the blob OIDs
      * and find the command-ending semicolons.  The commands should not
      * contain anything hard to parse except for double-quoted role names,
      * which are easy to ignore.  Once we've split apart the first and second
      * halves of a command, apply IssueCommandPerBlob.  (This means the
      * updates on the blobs are interleaved if there's multiple commands, but
      * that should cause no trouble.)
      */
     inquotes = false;
     st = en = buf;
     st2 = NULL;
     while (*en)
     {
         /* Ignore double-quoted material */
         if (*en == '"')
             inquotes = !inquotes;
         if (inquotes)
         {
             en++;
             continue;
         }
         /* If we found "LARGE OBJECT", that's the end of the first half */
         if (strncmp(en, "LARGE OBJECT ", 13) == 0)
         {
             /* Terminate the first-half string */
             en += 13;
             Assert(isdigit((unsigned char) *en));
             *en++ = '\0';
             /* Skip the rest of the blob OID */
             while (isdigit((unsigned char) *en))
                 en++;
             /* Second half starts here */
             Assert(st2 == NULL);
             st2 = en;
         }
         /* If we found semicolon, that's the end of the second half */
         else if (*en == ';')
         {
             /* Terminate the second-half string */
             *en++ = '\0';
             Assert(st2 != NULL);
             /* Issue this command for each blob */
             IssueCommandPerBlob(AH, blobte, st, st2);
             /* For neatness, skip whitespace before the next command */
             while (isspace((unsigned char) *en))
                 en++;
             /* Reset for new command */
             st = en;
             st2 = NULL;
         }
         else
             en++;
     }
     pg_free(buf);
 }

References Assert, buf, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, getTocEntryByDumpId(), IssueCommandPerBlob(), pg_fatal, pg_free(), and pg_strdup().

Referenced by _printTocEntry().

◆ IssueCommandPerBlob()

void IssueCommandPerBlob	(	ArchiveHandle *	AH,
		TocEntry *	te,
		const char *	cmdBegin,
		const char *	cmdEnd
	)

Definition at line 552 of file pg_backup_db.c.

 {
     /* Make a writable copy of the command string */
     char       *buf = pg_strdup(te->defn);
     RestoreOptions *ropt = AH->public.ropt;
     char       *st;
     char       *en;
  
     st = buf;
     while ((en = strchr(st, '\n')) != NULL)
     {
         *en++ = '\0';
         ahprintf(AH, "%s%s%s;\n", cmdBegin, st, cmdEnd);
  
         /* In --transaction-size mode, count each command as an action */
         if (ropt && ropt->txn_size > 0)
         {
             if (++AH->txnCount >= ropt->txn_size)
             {
                 if (AH->connection)
                 {
                     CommitTransaction(&AH->public);
                     StartTransaction(&AH->public);
                 }
                 else
                     ahprintf(AH, "COMMIT;\nBEGIN;\n\n");
                 AH->txnCount = 0;
             }
         }
  
         st = en;
     }
     ahprintf(AH, "\n");
     pg_free(buf);
 }

References ahprintf(), buf, CommitTransaction(), _archiveHandle::connection, _tocEntry::defn, pg_free(), pg_strdup(), _archiveHandle::public, Archive::ropt, StartTransaction(), _restoreOptions::txn_size, and _archiveHandle::txnCount.

Referenced by _printTocEntry(), IssueACLPerBlob(), and RestoreArchive().

◆ isValidTarHeader()

bool isValidTarHeader ( char * header )

Definition at line 988 of file pg_backup_tar.c.

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

References read_tar_number(), TAR_OFFSET_CHECKSUM, TAR_OFFSET_MAGIC, TAR_OFFSET_VERSION, 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 4592 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 3958 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 2121 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 2026 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 2167 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 2627 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);
  
         if (AH->version >= K_VERS_1_16)
             te->relkind = ReadInt(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_16, 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::relkind, _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 1450 of file pg_backup_archiver.c.

 {
     bool        old_lo_style = (AH->version < K_VERS_1_12);
     Oid         loOid;
  
     AH->loCount++;
  
     /* Initialize the LO Buffer */
     if (AH->lo_buf == NULL)
     {
         /* First time through (in this process) so allocate the buffer */
         AH->lo_buf_size = LOBBUFSIZE;
         AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
     }
     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, _archiveHandle::lo_buf_size, _archiveHandle::lo_buf_used, lo_create(), lo_open(), LOBBUFSIZE, _archiveHandle::loCount, _archiveHandle::loFd, pg_fatal, pg_log_info, pg_malloc(), PQerrorMessage(), _archiveHandle::version, and _archiveHandle::writingLO.

Referenced by _LoadLOs().

◆ StartRestoreLOs()

void StartRestoreLOs ( ArchiveHandle * AH )

Definition at line 1403 of file pg_backup_archiver.c.

 {
     RestoreOptions *ropt = AH->public.ropt;
  
     /*
      * LOs must be restored within a transaction block, since we need the LO
      * handle to stay open while we write it.  Establish a transaction unless
      * there's one being used globally.
      */
     if (!(ropt->single_txn || ropt->txn_size > 0))
     {
         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, StartTransaction(), and _restoreOptions::txn_size.

Referenced by _LoadLOs().

◆ TocIDRequired()

int TocIDRequired	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1998 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(), 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 2453 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 *), TocEntrySizeCompareQsort);
  
         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, TocEntrySizeCompareQsort(), WaitForWorkers(), WFW_ALL_IDLE, and WriteDataChunksForTocEntry().

Referenced by _CloseArchive().

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 2534 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 3932 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 2090 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 2009 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 2148 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 2567 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);
         WriteInt(AH, te->relkind);
         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, _tocEntry::relkind, 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_16

◆ 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