pg_backup_archiver.h File Reference

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

Go to the source code of 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_STATS   0x04
#define	REQ_SPECIAL   0x08 /* 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 char *(*	DefnDumperPtr) (Archive *AH, const void *userArg, const TocEntry *te)
typedef int(*	DataDumperPtr) (Archive *AH, const void *userArg)
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	replace_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 432 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 429 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 411 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 */

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   0x08 /* for special TOC entries */

Definition at line 202 of file pg_backup_archiver.h.

REQ_STATS

#define REQ_STATS   0x04

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 88 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.

DataDumperPtr

typedef int(* DataDumperPtr) (Archive *AH, const void *userArg)

Definition at line 335 of file pg_backup_archiver.h.

DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 135 of file pg_backup_archiver.h.

DefnDumperPtr

typedef char *(* DefnDumperPtr) (Archive *AH, const void *userArg, const TocEntry *te)

Definition at line 334 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 89 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.

{
    STAGE_NONE = 0,

ArchiverStage

enum ArchiverStage

Enumerator
STAGE_NONE
STAGE_INITIALIZING
STAGE_PROCESSING
STAGE_FINALIZING

Definition at line 156 of file pg_backup_archiver.h.

{
    sqlparseState state;        /* see above */

RestorePass

enum RestorePass

Enumerator
RESTORE_PASS_MAIN
RESTORE_PASS_ACL
RESTORE_PASS_POST_ACL

Definition at line 190 of file pg_backup_archiver.h.

{

sqlparseState

enum sqlparseState

Enumerator
SQL_SCAN
SQL_IN_SINGLE_QUOTE
SQL_IN_DOUBLE_QUOTE

Definition at line 142 of file pg_backup_archiver.h.

{

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 1834 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 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 1225 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->defnDumper = opts->defnFn;
    newToc->defnDumperArg = opts->defnArg;
 
    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::defnDumper, _tocEntry::defnDumperArg, _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(), dumpRelationStats(), 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 4244 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 5111 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.
     */
    ConnectDatabaseAhx((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, ConnectDatabaseAhx(), _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 5175 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 612 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 1528 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 1455 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 2014 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 105 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 = 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);
    }
}

References _ArchiveEntry(), _Clone(), _CloseArchive(), _DeClone(), _EndData(), _EndLO(), _EndLOs(), _getFilePos(), _PrepParallelRestore(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _ReopenArchive(), _StartData(), _StartLO(), _StartLOs(), _WorkerJobRestoreCustom(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), _archiveHandle::ArchiveEntryPtr, archModeWrite, checkSeek(), _archiveHandle::ClonePtr, _archiveHandle::ClosePtr, _archiveHandle::DeClonePtr, _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::FH, _archiveHandle::formatData, _archiveHandle::fSpec, lclContext::hasSeek, lclContext::lastFilePos, _archiveHandle::mode, PG_BINARY_R, PG_BINARY_W, pg_fatal, pg_malloc0(), _archiveHandle::PrepParallelRestorePtr, _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, _archiveHandle::StartDataPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, generate_unaccent_rules::stdout, _archiveHandle::WorkerJobDumpPtr, _archiveHandle::WorkerJobRestorePtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, _archiveHandle::WriteDataPtr, and _archiveHandle::WriteExtraTocPtr.

Referenced by _allocAH().

InitArchiveFmt_Directory()

void InitArchiveFmt_Directory

(

ArchiveHandle *

AH

)

Definition at line 110 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 = 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)
    {
        /* we accept an empty existing directory */
        create_or_open_dir(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, _archiveHandle::ClosePtr, create_or_open_dir(), lclContext::dataFH, _archiveHandle::DeClonePtr, lclContext::directory, EndCompressFileHandle(), _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::format, _archiveHandle::formatData, _archiveHandle::fSpec, InitDiscoverCompressFileHandle(), lclContext::LOsTocFH, MAXPGPATH, _archiveHandle::mode, PG_BINARY_R, pg_fatal, pg_malloc0(), _archiveHandle::PrepParallelRestorePtr, _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, setFilePath(), _archiveHandle::StartDataPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, _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");
}

References _CloseArchive(), _EndData(), _EndLO(), _EndLOs(), _PrintTocData(), _StartLO(), _StartLOs(), _WriteBuf(), _WriteByte(), _WriteData(), archModeRead, _archiveHandle::ClonePtr, _archiveHandle::ClosePtr, _archiveHandle::DeClonePtr, _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::mode, pg_fatal, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReopenPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, and _archiveHandle::WriteDataPtr.

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 = 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 = 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 538 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 491 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 330 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(), and restore_one_database().

parallel_restore()

int parallel_restore	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 4744 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 4110 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(), _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 2150 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, 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 2055 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 2196 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, 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 2694 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 73 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 ConnectDatabaseAhx */
 
    ConnectDatabaseAhx((Archive *) AH, &ropt->cparams, true);
 
    PQfinish(oldConn);
}

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

Referenced by _reconnectToDB().

replace_on_exit_close_archive()

void replace_on_exit_close_archive

(

Archive *

AHX

)

Definition at line 341 of file parallel.c.

{
    shutdown_info.AHX = AHX;
}

References ShutdownInformation::AHX, and shutdown_info.

Referenced by restore_one_database().

StartRestoreLO()

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

Definition at line 1478 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 = 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 1431 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 2027 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 2482 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 2563 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 4084 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 2119 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 2038 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 2177 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, _archiveHandle::WriteBufPtr, and WriteInt().

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

WriteToc()

void WriteToc

(

ArchiveHandle *

AH

)

Definition at line 2596 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_STATS | 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_STATS | 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);
 
        if (te->defnLen)
        {
            /*
             * defnLen should only be set for custom format's second call to
             * WriteToc(), which rewrites the TOC in place to update data
             * offsets.  Instead of calling the defnDumper a second time
             * (which could involve re-executing queries), just skip writing
             * the entry.  While regenerating the definition should
             * theoretically produce the same result as before, it's expensive
             * and feels risky.
             *
             * The custom format only calls WriteToc() a second time if
             * fseeko() is usable (see _CloseArchive() in pg_backup_custom.c),
             * so we can safely use it without checking.  For other formats,
             * we fail because one of our assumptions must no longer hold
             * true.
             *
             * XXX This is a layering violation, but the alternative is an
             * awkward and complicated callback infrastructure for this
             * special case.  This might be worth revisiting in the future.
             */
            if (AH->format != archCustom)
                pg_fatal("unexpected TOC entry in WriteToc(): %d %s %s",
                         te->dumpId, te->desc, te->tag);
 
            if (fseeko(AH->FH, te->defnLen, SEEK_CUR != 0))
                pg_fatal("error during file seek: %m");
        }
        else if (te->defnDumper)
        {
            char       *defn = te->defnDumper((Archive *) AH, te->defnDumperArg, te);
 
            te->defnLen = WriteStr(AH, defn);
            pg_free(defn);
        }
        else
            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 archCustom, _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::defn, _tocEntry::defnDumper, _tocEntry::defnDumperArg, _tocEntry::defnLen, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, _archiveHandle::FH, _archiveHandle::format, fseeko, i, _tocEntry::nDeps, _tocEntry::next, CatalogId::oid, _tocEntry::owner, pg_fatal, pg_free(), _tocEntry::relkind, REQ_DATA, REQ_SCHEMA, REQ_SPECIAL, REQ_STATS, _tocEntry::reqs, _tocEntry::section, sprintf, _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::WriteExtraTocPtr, WriteInt(), and WriteStr().

Referenced by _CloseArchive().