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

Include dependency graph for pg_backup_archiver.h:

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

Data Structures
struct	_z_stream

struct	sqlparseInfo

struct	_archiveHandle

struct	_tocEntry

Macros
#define	LOBBUFSIZE 16384

#define	GZCLOSE(fh) fclose(fh)

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

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

#define	GZEOF(fh) feof(fh)

#define	Z_DEFAULT_COMPRESSION (-1)

#define	BLK_DATA 1

#define	BLK_BLOBS 3

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

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

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

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

#define	K_VERS_1_0 MAKE_ARCHIVE_VERSION(1, 0, 0)

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

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

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

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

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

#define	K_VERS_1_7

#define	K_VERS_1_8

#define	K_VERS_1_9

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

#define	K_VERS_1_11

#define	K_VERS_1_12

#define	K_VERS_MAJOR 1

#define	K_VERS_MINOR 12

#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	appendStringLiteralAHX(buf, str, AH) appendStringLiteral(buf, str, (AH)->public.encoding, (AH)->public.std_strings)

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

Typedefs
typedef struct _z_stream	z_stream

typedef z_stream *	z_streamp

typedef struct _archiveHandle	ArchiveHandle

typedef struct _tocEntry	TocEntry

typedef enum T_Action	T_Action

typedef void(*	ClosePtrType )(ArchiveHandle *AH)

typedef void(*	ReopenPtrType )(ArchiveHandle *AH)

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

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

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

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

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

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

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

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

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

typedef int(*	ReadBytePtrType )(ArchiveHandle *AH)

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

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

typedef void(*	SaveArchivePtrType )(ArchiveHandle *AH)

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

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	teReqs { REQ_SCHEMA = 0x01, REQ_DATA = 0x02, REQ_SPECIAL = 0x04 }

Functions
int	parallel_restore (ArchiveHandle AH, TocEntry te)

void	on_exit_close_archive (Archive *AHX)

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

void void	WriteTOC (ArchiveHandle *AH)

void	ReadTOC (ArchiveHandle *AH)

void	WriteHead (ArchiveHandle *AH)

void	ReadHead (ArchiveHandle *AH)

void	WriteToc (ArchiveHandle *AH)

void	ReadToc (ArchiveHandle *AH)

void	WriteDataChunks (ArchiveHandle AH, struct ParallelState pstate)

void	WriteDataChunksForTocEntry (ArchiveHandle AH, TocEntry te)

ArchiveHandle *	CloneArchive (ArchiveHandle *AH)

void	DeCloneArchive (ArchiveHandle *AH)

teReqs	TocIDRequired (ArchiveHandle *AH, DumpId id)

TocEntry *	getTocEntryByDumpId (ArchiveHandle *AH, DumpId id)

bool	checkSeek (FILE *fp)

size_t	WriteInt (ArchiveHandle *AH, int i)

int	ReadInt (ArchiveHandle *AH)

char *	ReadStr (ArchiveHandle *AH)

size_t	WriteStr (ArchiveHandle AH, const char s)

int	ReadOffset (ArchiveHandle , pgoff_t )

size_t	WriteOffset (ArchiveHandle *, pgoff_t, int)

void	StartRestoreBlobs (ArchiveHandle *AH)

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

void	EndRestoreBlob (ArchiveHandle *AH, Oid oid)

void	EndRestoreBlobs (ArchiveHandle *AH)

void	InitArchiveFmt_Custom (ArchiveHandle *AH)

void	InitArchiveFmt_Null (ArchiveHandle *AH)

void	InitArchiveFmt_Directory (ArchiveHandle *AH)

void	InitArchiveFmt_Tar (ArchiveHandle *AH)

bool	isValidTarHeader (char *header)

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

void	DropBlobIfExists (ArchiveHandle *AH, Oid oid)

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

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

int void	ahlog (ArchiveHandle AH, int level, const char fmt,...) pg_attribute_printf(3

Macro Definition Documentation

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

Definition at line 399 of file pg_backup_archiver.h.

Referenced by _WriteBlobData(), and dump_lo_buf().

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

Definition at line 396 of file pg_backup_archiver.h.

Referenced by _doSetSessionAuth().

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

Definition at line 72 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

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

Definition at line 73 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

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

Definition at line 74 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

#define BLK_BLOBS 3

Definition at line 67 of file pg_backup_archiver.h.

Referenced by _PrintTocData(), and _StartBlobs().

#define BLK_DATA 1

Definition at line 66 of file pg_backup_archiver.h.

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

#define GZCLOSE ( fh ) fclose(fh)

Definition at line 48 of file pg_backup_archiver.h.

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

#define GZEOF ( fh ) feof(fh)

Definition at line 51 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

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

Definition at line 50 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

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

Definition at line 49 of file pg_backup_archiver.h.

Referenced by ahwrite(), and tarWrite().

#define K_OFFSET_NO_DATA 3

Definition at line 109 of file pg_backup_archiver.h.

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

#define K_OFFSET_POS_NOT_SET 1

Definition at line 107 of file pg_backup_archiver.h.

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

#define K_OFFSET_POS_SET 2

Definition at line 108 of file pg_backup_archiver.h.

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

#define K_VERS_1_0 MAKE_ARCHIVE_VERSION(1, 0, 0)

Definition at line 77 of file pg_backup_archiver.h.

Referenced by ReadHead(), and ReadInt().

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

Definition at line 90 of file pg_backup_archiver.h.

Referenced by ReadHead(), and ReadToc().

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

Definition at line 91 of file pg_backup_archiver.h.

Referenced by fix_dependencies(), and ReadToc().

#define K_VERS_1_12

Value:

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

* entries */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:70

Definition at line 93 of file pg_backup_archiver.h.

Referenced by _StartBlob(), and StartRestoreBlob().

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

Definition at line 78 of file pg_backup_archiver.h.

Referenced by ReadHead().

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

Definition at line 79 of file pg_backup_archiver.h.

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

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

Definition at line 80 of file pg_backup_archiver.h.

Referenced by ReadHead().

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

Definition at line 81 of file pg_backup_archiver.h.

Referenced by ReadToc().

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

Definition at line 82 of file pg_backup_archiver.h.

Referenced by ReadToc().

#define K_VERS_1_7

Value:

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

* header */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:70

Definition at line 83 of file pg_backup_archiver.h.

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

#define K_VERS_1_8

Value:

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

Definition at line 85 of file pg_backup_archiver.h.

Referenced by ReadToc(), and RestoreArchive().

#define K_VERS_1_9

Value:

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

* tracking */

MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition: pg_backup_archiver.h:70

Definition at line 88 of file pg_backup_archiver.h.

Referenced by ReadToc().

#define K_VERS_MAJOR 1

Definition at line 97 of file pg_backup_archiver.h.

#define K_VERS_MAX MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)

Definition at line 103 of file pg_backup_archiver.h.

Referenced by ReadHead().

#define K_VERS_MINOR 12

Definition at line 98 of file pg_backup_archiver.h.

#define K_VERS_REV 0

Definition at line 99 of file pg_backup_archiver.h.

#define K_VERS_SELF MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV);

Definition at line 100 of file pg_backup_archiver.h.

Referenced by _allocAH().

#define LOBBUFSIZE 16384

Definition at line 35 of file pg_backup_archiver.h.

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

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

Definition at line 70 of file pg_backup_archiver.h.

Referenced by _discoverArchiveFormat(), and ReadHead().

#define READ_ERROR_EXIT ( fd )

Value:

do { \
        if (feof(fd)) \
			exit_horribly(modulename, \
                          "could not read from input file: end of file\n"); \
		else \
			exit_horribly(modulename, \
                    "could not read from input file: %s\n", strerror(errno)); \
    } while (0)

Definition at line 124 of file pg_backup_archiver.h.

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

#define WORKER_CREATE_DONE 10

Definition at line 116 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

#define WORKER_IGNORED_ERRORS 12

Definition at line 118 of file pg_backup_archiver.h.

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

#define WORKER_INHIBIT_DATA 11

Definition at line 117 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

#define WORKER_OK 0

Definition at line 115 of file pg_backup_archiver.h.

Referenced by restore_toc_entry().

#define WRITE_ERROR_EXIT

Value:

do { \
		exit_horribly(modulename, "could not write to output file: %s\n", \
                      strerror(errno)); \
    } while (0)

Definition at line 134 of file pg_backup_archiver.h.

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

#define Z_DEFAULT_COMPRESSION (-1)

Definition at line 53 of file pg_backup_archiver.h.

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

Typedef Documentation

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

Definition at line 148 of file pg_backup_archiver.h.

typedef struct _archiveHandle ArchiveHandle

Definition at line 120 of file pg_backup_archiver.h.

typedef void(* ClonePtrType)(ArchiveHandle *AH)

Definition at line 169 of file pg_backup_archiver.h.

typedef void(* ClosePtrType)(ArchiveHandle *AH)

Definition at line 146 of file pg_backup_archiver.h.

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

Definition at line 175 of file pg_backup_archiver.h.

typedef void(* DeClonePtrType)(ArchiveHandle *AH)

Definition at line 170 of file pg_backup_archiver.h.

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

Definition at line 156 of file pg_backup_archiver.h.

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

Definition at line 157 of file pg_backup_archiver.h.

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

Definition at line 152 of file pg_backup_archiver.h.

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

Definition at line 166 of file pg_backup_archiver.h.

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

Definition at line 167 of file pg_backup_archiver.h.

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

Definition at line 162 of file pg_backup_archiver.h.

typedef int(* ReadBytePtrType)(ArchiveHandle *AH)

Definition at line 160 of file pg_backup_archiver.h.

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

Definition at line 165 of file pg_backup_archiver.h.

typedef void(* ReopenPtrType)(ArchiveHandle *AH)

Definition at line 147 of file pg_backup_archiver.h.

typedef void(* SaveArchivePtrType)(ArchiveHandle *AH)

Definition at line 163 of file pg_backup_archiver.h.

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

Definition at line 155 of file pg_backup_archiver.h.

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

Definition at line 154 of file pg_backup_archiver.h.

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

Definition at line 150 of file pg_backup_archiver.h.

typedef enum T_Action T_Action

typedef struct _tocEntry TocEntry

Definition at line 121 of file pg_backup_archiver.h.

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

Definition at line 172 of file pg_backup_archiver.h.

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

Definition at line 173 of file pg_backup_archiver.h.

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

Definition at line 161 of file pg_backup_archiver.h.

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

Definition at line 159 of file pg_backup_archiver.h.

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

Definition at line 151 of file pg_backup_archiver.h.

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

Definition at line 164 of file pg_backup_archiver.h.

typedef struct _z_stream z_stream

typedef z_stream* z_streamp

Definition at line 62 of file pg_backup_archiver.h.

Enumeration Type Documentation

enum ArchiverOutput

Enumerator
OUTPUT_SQLCMDS
OUTPUT_COPYDATA
OUTPUT_OTHERDATA

Definition at line 199 of file pg_backup_archiver.h.

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

enum ArchiverStage

Enumerator
STAGE_NONE
STAGE_INITIALIZING
STAGE_PROCESSING
STAGE_FINALIZING

Definition at line 191 of file pg_backup_archiver.h.

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

enum sqlparseState

Enumerator
SQL_SCAN
SQL_IN_SINGLE_QUOTE
SQL_IN_DOUBLE_QUOTE

Definition at line 177 of file pg_backup_archiver.h.

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

enum T_Action

Enumerator
ACT_DUMP
ACT_RESTORE

Definition at line 140 of file pg_backup_archiver.h.

 {
     ACT_DUMP,
     ACT_RESTORE
 } T_Action;

enum teReqs

Enumerator
REQ_SCHEMA
REQ_DATA
REQ_SPECIAL

Definition at line 206 of file pg_backup_archiver.h.

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

Function Documentation

int void ahlog	(	ArchiveHandle *	AH,
		int	level,
		const char *	fmt,
			...
	)

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

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

Definition at line 1688 of file pg_backup_archiver.c.

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

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

 {
     int         bytes_written = 0;
 
     if (AH->writingBlob)
     {
         size_t      remaining = size * nmemb;
 
         while (AH->lo_buf_used + remaining > AH->lo_buf_size)
         {
             size_t      avail = AH->lo_buf_size - AH->lo_buf_used;
 
             memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
             ptr = (const void *) ((const char *) ptr + avail);
             remaining -= avail;
             AH->lo_buf_used += avail;
             dump_lo_buf(AH);
         }
 
         memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
         AH->lo_buf_used += remaining;
 
         bytes_written = size * nmemb;
     }
     else if (AH->gzOut)
         bytes_written = GZWRITE(ptr, size, nmemb, AH->OF);
     else if (AH->CustomOutPtr)
         bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
 
     else
     {
         /*
          * If we're doing a restore, and it's direct to DB, and we're
          * connected then send it to the DB.
          */
         if (RestoringToDB(AH))
             bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
         else
             bytes_written = fwrite(ptr, size, nmemb, AH->OF) * size;
     }
 
     if (bytes_written != size * nmemb)
         WRITE_ERROR_EXIT;
 
     return;
 }

bool checkSeek ( FILE * fp )

Definition at line 3728 of file pg_backup_archiver.c.

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

 {
     pgoff_t     tpos;
 
     /*
      * If pgoff_t is wider than long, we must have "real" fseeko and not an
      * emulation using fseek.  Otherwise report no seek capability.
      */
 #ifndef HAVE_FSEEKO
     if (sizeof(pgoff_t) > sizeof(long))
         return false;
 #endif
 
     /* 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;
 }

ArchiveHandle* CloneArchive ( ArchiveHandle * AH )

Definition at line 4509 of file pg_backup_archiver.c.

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

Referenced by RunWorker().

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

void DeCloneArchive ( ArchiveHandle * AH )

Definition at line 4598 of file pg_backup_archiver.c.

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

Referenced by RunWorker().

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

void DropBlobIfExists	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 663 of file pg_backup_db.c.

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

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

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

void EndRestoreBlob	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 1324 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

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

void EndRestoreBlobs ( ArchiveHandle * AH )

Definition at line 1257 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

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

TocEntry* getTocEntryByDumpId	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1868 of file pg_backup_archiver.c.

References buildTocEntryArrays(), NULL, and _archiveHandle::tocsByDumpId.

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

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

void InitArchiveFmt_Custom ( ArchiveHandle * AH )

Definition at line 108 of file pg_backup_custom.c.

Referenced by _allocAH().

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

void InitArchiveFmt_Directory ( ArchiveHandle * AH )

Definition at line 110 of file pg_backup_directory.c.

Referenced by _allocAH().

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

void InitArchiveFmt_Null ( ArchiveHandle * AH )

Definition at line 49 of file pg_backup_null.c.

Referenced by _allocAH().

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

void InitArchiveFmt_Tar ( ArchiveHandle * AH )

Definition at line 129 of file pg_backup_tar.c.

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

Referenced by _allocAH().

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

bool isValidTarHeader ( char * header )

Definition at line 1047 of file pg_backup_tar.c.

References read_tar_number(), and tarChecksum().

Referenced by _discoverArchiveFormat().

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

void on_exit_close_archive ( Archive * AHX )

Definition at line 345 of file parallel.c.

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

Referenced by main().

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

int parallel_restore	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 4174 of file pg_backup_archiver.c.

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

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

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

void ReadHead ( ArchiveHandle * AH )

Definition at line 3625 of file pg_backup_archiver.c.

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

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

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

int ReadInt ( ArchiveHandle * AH )

Definition at line 2004 of file pg_backup_archiver.c.

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

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

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

int ReadOffset	(	ArchiveHandle *	,
		pgoff_t *
	)

Definition at line 1909 of file pg_backup_archiver.c.

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

Referenced by _ReadExtraToc().

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

char* ReadStr ( ArchiveHandle * AH )

Definition at line 2050 of file pg_backup_archiver.c.

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

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

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

void ReadTOC ( ArchiveHandle * AH )

void ReadToc ( ArchiveHandle * AH )

Definition at line 2539 of file pg_backup_archiver.c.

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

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

 {
     int         i;
     char       *tmp;
     DumpId     *deps;
     int         depIdx;
     int         depSize;
     TocEntry   *te;
 
     AH->tocCount = ReadInt(AH);
     AH->maxDumpId = 0;
 
     for (i = 0; i < AH->tocCount; i++)
     {
         te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
         te->dumpId = ReadInt(AH);
 
         if (te->dumpId > AH->maxDumpId)
             AH->maxDumpId = te->dumpId;
 
         /* Sanity check */
         if (te->dumpId <= 0)
             exit_horribly(modulename,
                           "entry ID %d out of range -- perhaps a corrupt TOC\n",
                           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);
 
         te->owner = ReadStr(AH);
         if (AH->version >= K_VERS_1_9)
         {
             if (strcmp(ReadStr(AH), "true") == 0)
                 te->withOids = true;
             else
                 te->withOids = false;
         }
         else
             te->withOids = true;
 
         /* 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;
         }
 
         if (AH->ReadExtraTocPtr)
             (*AH->ReadExtraTocPtr) (AH, te);
 
         ahlog(AH, 3, "read TOC entry %d (ID %d) for %s %s\n",
               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);
     }
 }

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

Definition at line 86 of file pg_backup_db.c.

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

Referenced by _reconnectToDB().

 {
     PGconn     *newConn;
     const char *newdbname;
     const char *newusername;
 
     if (!dbname)
         newdbname = PQdb(AH->connection);
     else
         newdbname = dbname;
 
     if (!username)
         newusername = PQuser(AH->connection);
     else
         newusername = username;
 
     /* Let's see if the request is already satisfied */
     if (strcmp(newdbname, PQdb(AH->connection)) == 0 &&
         strcmp(newusername, PQuser(AH->connection)) == 0)
         return 1;
 
     newConn = _connectDB(AH, newdbname, newusername);
 
     /* Update ArchiveHandle's connCancel before closing old connection */
     set_archive_cancel_info(AH, newConn);
 
     PQfinish(AH->connection);
     AH->connection = newConn;
 
     return 1;
 }

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

Definition at line 1280 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

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

void StartRestoreBlobs ( ArchiveHandle * AH )

Definition at line 1238 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

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

teReqs TocIDRequired	(	ArchiveHandle *	AH,
		DumpId	id
	)

Definition at line 1881 of file pg_backup_archiver.c.

References getTocEntryByDumpId(), and _tocEntry::reqs.

Referenced by _tarPositionTo(), and findDumpableDependencies().

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

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

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

Definition at line 2393 of file pg_backup_archiver.c.

References ACT_DUMP, _tocEntry::dataDumper, DispatchJobForTocEntry(), mark_dump_job_done(), _tocEntry::next, NULL, ParallelState::numWorkers, REQ_DATA, _tocEntry::reqs, _archiveHandle::toc, WaitForWorkers(), WFW_ALL_IDLE, and WriteDataChunksForTocEntry().

Referenced by _CloseArchive().

 {
     TocEntry   *te;
 
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         if (!te->dataDumper)
             continue;
 
         if ((te->reqs & REQ_DATA) == 0)
             continue;
 
         if (pstate && pstate->numWorkers > 1)
         {
             /*
              * If we are in a parallel backup, then we are always the master
              * process.  Dispatch each data-transfer job to a worker.
              */
             DispatchJobForTocEntry(AH, pstate, te, ACT_DUMP,
                                    mark_dump_job_done, NULL);
         }
         else
             WriteDataChunksForTocEntry(AH, te);
     }
 
     /*
      * If parallel, wait for workers to finish.
      */
     if (pstate && pstate->numWorkers > 1)
         WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
 }

void WriteDataChunksForTocEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 2448 of file pg_backup_archiver.c.

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

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

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

void WriteHead ( ArchiveHandle * AH )

Definition at line 3599 of file pg_backup_archiver.c.

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

Referenced by _CloseArchive().

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

size_t WriteInt	(	ArchiveHandle *	AH,
		int	i
	)

Definition at line 1973 of file pg_backup_archiver.c.

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

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

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

size_t WriteOffset	(	ArchiveHandle *	,
		pgoff_t	,
		int
	)

Definition at line 1892 of file pg_backup_archiver.c.

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

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

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

Definition at line 2031 of file pg_backup_archiver.c.

References _archiveHandle::WriteBufPtr, and WriteInt().

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

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

void void WriteTOC ( ArchiveHandle * AH )

void WriteToc ( ArchiveHandle * AH )

Definition at line 2481 of file pg_backup_archiver.c.

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

Referenced by _CloseArchive().

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

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation