PostgreSQL Source Code  git master
pg_backup_archiver.h File Reference
#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:

Go to the source code of 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_1_13
 
#define K_VERS_MAJOR   1
 
#define K_VERS_MINOR   13
 
#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_REFRESH
 
#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_streamz_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  RestorePass { RESTORE_PASS_MAIN = 0, RESTORE_PASS_ACL }
 
enum  teReqs { REQ_SCHEMA = 0x01, REQ_DATA = 0x02, REQ_SPECIAL = 0x04 }
 

Functions

int parallel_restore (ArchiveHandle *AH, TocEntry *te)
 
void on_exit_close_archive (Archive *AHX)
 
void warn_or_exit_horribly (ArchiveHandle *AH, const char *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)
 
ArchiveHandleCloneArchive (ArchiveHandle *AH)
 
void DeCloneArchive (ArchiveHandle *AH)
 
teReqs TocIDRequired (ArchiveHandle *AH, DumpId id)
 
TocEntrygetTocEntryByDumpId (ArchiveHandle *AH, DumpId id)
 
bool checkSeek (FILE *fp)
 
size_t WriteInt (ArchiveHandle *AH, int i)
 
int ReadInt (ArchiveHandle *AH)
 
char * ReadStr (ArchiveHandle *AH)
 
size_t WriteStr (ArchiveHandle *AH, const char *s)
 
int ReadOffset (ArchiveHandle *, pgoff_t *)
 
size_t WriteOffset (ArchiveHandle *, pgoff_t, int)
 
void StartRestoreBlobs (ArchiveHandle *AH)
 
void StartRestoreBlob (ArchiveHandle *AH, Oid oid, bool drop)
 
void EndRestoreBlob (ArchiveHandle *AH, Oid oid)
 
void EndRestoreBlobs (ArchiveHandle *AH)
 
void InitArchiveFmt_Custom (ArchiveHandle *AH)
 
void InitArchiveFmt_Null (ArchiveHandle *AH)
 
void InitArchiveFmt_Directory (ArchiveHandle *AH)
 
void InitArchiveFmt_Tar (ArchiveHandle *AH)
 
bool isValidTarHeader (char *header)
 
void ReconnectToServer (ArchiveHandle *AH, const char *dbname, const char *newUser)
 
void DropBlobIfExists (ArchiveHandle *AH, Oid oid)
 
void ahwrite (const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)
 
int ahprintf (ArchiveHandle *AH, const char *fmt,...) pg_attribute_printf(2
 
int void ahlog (ArchiveHandle *AH, int level, const char *fmt,...) pg_attribute_printf(3
 

Macro Definition Documentation

◆ appendByteaLiteralAHX

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

Definition at line 426 of file pg_backup_archiver.h.

Referenced by _WriteBlobData(), and dump_lo_buf().

◆ appendStringLiteralAHX

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

Definition at line 423 of file pg_backup_archiver.h.

Referenced by _doSetSessionAuth().

◆ ARCHIVE_MAJOR

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

Definition at line 72 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_MINOR

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

Definition at line 73 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_REV

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

Definition at line 74 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ BLK_BLOBS

#define BLK_BLOBS   3

Definition at line 67 of file pg_backup_archiver.h.

Referenced by _PrintTocData(), and _StartBlobs().

◆ BLK_DATA

#define BLK_DATA   1

Definition at line 66 of file pg_backup_archiver.h.

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

◆ GZCLOSE

#define GZCLOSE (   fh)    fclose(fh)

Definition at line 48 of file pg_backup_archiver.h.

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

◆ GZEOF

#define GZEOF (   fh)    feof(fh)

Definition at line 51 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZREAD

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

Definition at line 50 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZWRITE

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

Definition at line 49 of file pg_backup_archiver.h.

Referenced by ahwrite(), and tarWrite().

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA   3

Definition at line 111 of file pg_backup_archiver.h.

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

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET   1

Definition at line 109 of file pg_backup_archiver.h.

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

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET   2

Definition at line 110 of file pg_backup_archiver.h.

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

◆ K_VERS_1_0

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

◆ K_VERS_1_10

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

◆ K_VERS_1_11

#define K_VERS_1_11
Value:
MAKE_ARCHIVE_VERSION(1, 11, 0) /* add toc section
* indicator */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition at line 91 of file pg_backup_archiver.h.

Referenced by fix_dependencies(), and ReadToc().

◆ K_VERS_1_12

#define K_VERS_1_12
Value:
MAKE_ARCHIVE_VERSION(1, 12, 0) /* add separate BLOB
* entries */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition at line 93 of file pg_backup_archiver.h.

Referenced by _StartBlob(), and StartRestoreBlob().

◆ K_VERS_1_13

#define K_VERS_1_13
Value:
MAKE_ARCHIVE_VERSION(1, 13, 0) /* change search_path
* behavior */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

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

Referenced by ReadHead().

◆ K_VERS_1_3

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

Definition at line 79 of file pg_backup_archiver.h.

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

◆ K_VERS_1_4

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

Definition at line 80 of file pg_backup_archiver.h.

Referenced by ReadHead().

◆ K_VERS_1_5

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

Definition at line 81 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_6

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

Definition at line 82 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_7

#define K_VERS_1_7
Value:
MAKE_ARCHIVE_VERSION(1, 7, 0) /* File Offset size in
* header */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition at line 83 of file pg_backup_archiver.h.

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

◆ K_VERS_1_8

#define K_VERS_1_8
Value:
MAKE_ARCHIVE_VERSION(1, 8, 0) /* change interpretation
* of ID numbers and
* dependencies */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition at line 85 of file pg_backup_archiver.h.

Referenced by ReadToc(), and RestoreArchive().

◆ K_VERS_1_9

#define K_VERS_1_9
Value:
MAKE_ARCHIVE_VERSION(1, 9, 0) /* add default_with_oids
* tracking */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition at line 88 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_MAJOR

#define K_VERS_MAJOR   1

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

Referenced by ReadHead().

◆ K_VERS_MINOR

#define K_VERS_MINOR   13

Definition at line 100 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV   0

Definition at line 101 of file pg_backup_archiver.h.

◆ K_VERS_SELF

Definition at line 102 of file pg_backup_archiver.h.

Referenced by _allocAH().

◆ LOBBUFSIZE

#define LOBBUFSIZE   16384

◆ MAKE_ARCHIVE_VERSION

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

◆ READ_ERROR_EXIT

#define READ_ERROR_EXIT (   fd)
Value:
do { \
if (feof(fd)) \
exit_horribly(modulename, \
"could not read from input file: end of file\n"); \
"could not read from input file: %s\n", strerror(errno)); \
} while (0)
static const char * modulename
Definition: compress_io.c:78
static int fd(const char *x, int i)
Definition: preproc-init.c:105
void exit_horribly(const char *modulename, const char *fmt,...)
const char * strerror(int errnum)
Definition: strerror.c:19

Definition at line 126 of file pg_backup_archiver.h.

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

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST   RESTORE_PASS_REFRESH

Definition at line 229 of file pg_backup_archiver.h.

Referenced by restore_toc_entries_parallel().

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE   10

Definition at line 118 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS   12

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA   11

Definition at line 119 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_OK

#define WORKER_OK   0

Definition at line 117 of file pg_backup_archiver.h.

Referenced by restore_toc_entry().

◆ WRITE_ERROR_EXIT

#define WRITE_ERROR_EXIT
Value:
do { \
exit_horribly(modulename, "could not write to output file: %s\n", \
strerror(errno)); \
} while (0)
static const char * modulename
Definition: compress_io.c:78
const char * strerror(int errnum)
Definition: strerror.c:19

Definition at line 136 of file pg_backup_archiver.h.

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

◆ Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION   (-1)

Definition at line 53 of file pg_backup_archiver.h.

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

Typedef Documentation

◆ ArchiveEntryPtrType

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

Definition at line 150 of file pg_backup_archiver.h.

◆ ArchiveHandle

Definition at line 122 of file pg_backup_archiver.h.

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 171 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 148 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 177 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 172 of file pg_backup_archiver.h.

◆ EndBlobPtrType

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

Definition at line 158 of file pg_backup_archiver.h.

◆ EndBlobsPtrType

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

Definition at line 159 of file pg_backup_archiver.h.

◆ EndDataPtrType

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

Definition at line 154 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

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

Definition at line 168 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

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

Definition at line 169 of file pg_backup_archiver.h.

◆ ReadBufPtrType

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

Definition at line 164 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 162 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

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

Definition at line 167 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 149 of file pg_backup_archiver.h.

◆ SaveArchivePtrType

typedef void(* SaveArchivePtrType) (ArchiveHandle *AH)

Definition at line 165 of file pg_backup_archiver.h.

◆ StartBlobPtrType

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

Definition at line 157 of file pg_backup_archiver.h.

◆ StartBlobsPtrType

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

Definition at line 156 of file pg_backup_archiver.h.

◆ StartDataPtrType

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

Definition at line 152 of file pg_backup_archiver.h.

◆ T_Action

◆ TocEntry

Definition at line 123 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

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

Definition at line 174 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

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

Definition at line 175 of file pg_backup_archiver.h.

◆ WriteBufPtrType

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

Definition at line 163 of file pg_backup_archiver.h.

◆ WriteBytePtrType

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

Definition at line 161 of file pg_backup_archiver.h.

◆ WriteDataPtrType

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

Definition at line 153 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

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

Definition at line 166 of file pg_backup_archiver.h.

◆ z_stream

◆ z_streamp

Definition at line 62 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

Enumerator
OUTPUT_SQLCMDS 
OUTPUT_COPYDATA 
OUTPUT_OTHERDATA 

Definition at line 201 of file pg_backup_archiver.h.

202 {
203  OUTPUT_SQLCMDS = 0, /* emitting general SQL commands */
204  OUTPUT_COPYDATA, /* writing COPY data */
205  OUTPUT_OTHERDATA /* writing data as INSERT commands */
ArchiverOutput

◆ ArchiverStage

Enumerator
STAGE_NONE 
STAGE_INITIALIZING 
STAGE_PROCESSING 
STAGE_FINALIZING 

Definition at line 193 of file pg_backup_archiver.h.

◆ RestorePass

Enumerator
RESTORE_PASS_MAIN 
RESTORE_PASS_ACL 

Definition at line 223 of file pg_backup_archiver.h.

224 {
225  RESTORE_PASS_MAIN = 0, /* Main pass (most TOC item types) */
226  RESTORE_PASS_ACL, /* ACL item types */
227  RESTORE_PASS_REFRESH /* Matview REFRESH items */
228 
229 #define RESTORE_PASS_LAST RESTORE_PASS_REFRESH
230 } RestorePass;

◆ sqlparseState

Enumerator
SQL_SCAN 
SQL_IN_SINGLE_QUOTE 
SQL_IN_DOUBLE_QUOTE 

Definition at line 179 of file pg_backup_archiver.h.

180 {
181  SQL_SCAN = 0, /* normal */
182  SQL_IN_SINGLE_QUOTE, /* '...' literal */
183  SQL_IN_DOUBLE_QUOTE /* "..." identifier */
184 } sqlparseState;
sqlparseState

◆ T_Action

enum T_Action
Enumerator
ACT_DUMP 
ACT_RESTORE 

Definition at line 142 of file pg_backup_archiver.h.

◆ teReqs

enum teReqs
Enumerator
REQ_SCHEMA 
REQ_DATA 
REQ_SPECIAL 

Definition at line 232 of file pg_backup_archiver.h.

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

Function Documentation

◆ ahlog()

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

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

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

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

1714 {
1715  int bytes_written = 0;
1716 
1717  if (AH->writingBlob)
1718  {
1719  size_t remaining = size * nmemb;
1720 
1721  while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1722  {
1723  size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1724 
1725  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1726  ptr = (const void *) ((const char *) ptr + avail);
1727  remaining -= avail;
1728  AH->lo_buf_used += avail;
1729  dump_lo_buf(AH);
1730  }
1731 
1732  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1733  AH->lo_buf_used += remaining;
1734 
1735  bytes_written = size * nmemb;
1736  }
1737  else if (AH->gzOut)
1738  bytes_written = GZWRITE(ptr, size, nmemb, AH->OF);
1739  else if (AH->CustomOutPtr)
1740  bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1741 
1742  else
1743  {
1744  /*
1745  * If we're doing a restore, and it's direct to DB, and we're
1746  * connected then send it to the DB.
1747  */
1748  if (RestoringToDB(AH))
1749  bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1750  else
1751  bytes_written = fwrite(ptr, size, nmemb, AH->OF) * size;
1752  }
1753 
1754  if (bytes_written != size * nmemb)
1756 
1757  return;
1758 }
int remaining
Definition: informix.c:692
static int RestoringToDB(ArchiveHandle *AH)
int ExecuteSqlCommandBuf(Archive *AHX, const char *buf, size_t bufLen)
Definition: pg_backup_db.c:561
static void dump_lo_buf(ArchiveHandle *AH)
#define GZWRITE(p, s, n, fh)
CustomOutPtrType CustomOutPtr
#define WRITE_ERROR_EXIT

◆ checkSeek()

bool checkSeek ( FILE *  fp)

Definition at line 3872 of file pg_backup_archiver.c.

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

3873 {
3874  pgoff_t tpos;
3875 
3876  /*
3877  * If pgoff_t is wider than long, we must have "real" fseeko and not an
3878  * emulation using fseek. Otherwise report no seek capability.
3879  */
3880 #ifndef HAVE_FSEEKO
3881  if (sizeof(pgoff_t) > sizeof(long))
3882  return false;
3883 #endif
3884 
3885  /* Check that ftello works on this file */
3886  tpos = ftello(fp);
3887  if (tpos < 0)
3888  return false;
3889 
3890  /*
3891  * Check that fseeko(SEEK_SET) works, too. NB: we used to try to test
3892  * this with fseeko(fp, 0, SEEK_CUR). But some platforms treat that as a
3893  * successful no-op even on files that are otherwise unseekable.
3894  */
3895  if (fseeko(fp, tpos, SEEK_SET) != 0)
3896  return false;
3897 
3898  return true;
3899 }
#define pgoff_t
Definition: win32_port.h:206
#define ftello(stream)
Definition: win32_port.h:215
#define fseeko(stream, offset, origin)
Definition: win32_port.h:212

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle AH)

Definition at line 4722 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, 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().

4723 {
4724  ArchiveHandle *clone;
4725 
4726  /* Make a "flat" copy */
4727  clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
4728  memcpy(clone, AH, sizeof(ArchiveHandle));
4729 
4730  /* Handle format-independent fields */
4731  memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
4732 
4733  /* The clone will have its own connection, so disregard connection state */
4734  clone->connection = NULL;
4735  clone->connCancel = NULL;
4736  clone->currUser = NULL;
4737  clone->currSchema = NULL;
4738  clone->currTablespace = NULL;
4739  clone->currWithOids = -1;
4740 
4741  /* savedPassword must be local in case we change it while connecting */
4742  if (clone->savedPassword)
4743  clone->savedPassword = pg_strdup(clone->savedPassword);
4744 
4745  /* clone has its own error count, too */
4746  clone->public.n_errors = 0;
4747 
4748  /*
4749  * Connect our new clone object to the database: In parallel restore the
4750  * parent is already disconnected, because we can connect the worker
4751  * processes independently to the database (no snapshot sync required). In
4752  * parallel backup we clone the parent's existing connection.
4753  */
4754  if (AH->mode == archModeRead)
4755  {
4756  RestoreOptions *ropt = AH->public.ropt;
4757 
4758  Assert(AH->connection == NULL);
4759 
4760  /* this also sets clone->connection */
4761  ConnectDatabase((Archive *) clone, ropt->dbname,
4762  ropt->pghost, ropt->pgport, ropt->username,
4763  ropt->promptPassword);
4764 
4765  /* re-establish fixed state */
4766  _doSetFixedOutputState(clone);
4767  }
4768  else
4769  {
4771  char *pghost;
4772  char *pgport;
4773  char *username;
4774 
4775  Assert(AH->connection != NULL);
4776 
4777  /*
4778  * Even though we are technically accessing the parent's database
4779  * object here, these functions are fine to be called like that
4780  * because all just return a pointer and do not actually send/receive
4781  * any data to/from the database.
4782  */
4783  initPQExpBuffer(&connstr);
4784  appendPQExpBuffer(&connstr, "dbname=");
4785  appendConnStrVal(&connstr, PQdb(AH->connection));
4786  pghost = PQhost(AH->connection);
4787  pgport = PQport(AH->connection);
4788  username = PQuser(AH->connection);
4789 
4790  /* this also sets clone->connection */
4791  ConnectDatabase((Archive *) clone, connstr.data,
4792  pghost, pgport, username, TRI_NO);
4793 
4794  termPQExpBuffer(&connstr);
4795  /* setupDumpWorker will fix up connection state */
4796  }
4797 
4798  /* Let the format-specific code have a chance too */
4799  clone->ClonePtr(clone);
4800 
4801  Assert(clone->connection != NULL);
4802  return clone;
4803 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
RestoreOptions * ropt
Definition: pg_backup.h:184
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:128
char * username
Definition: pg_backup.h:113
void appendConnStrVal(PQExpBuffer buf, const char *str)
Definition: string_utils.c:551
char * PQport(const PGconn *conn)
Definition: fe-connect.c:6035
int n_errors
Definition: pg_backup.h:207
PGcancel *volatile connCancel
char * PQuser(const PGconn *conn)
Definition: fe-connect.c:5991
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:262
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static void _doSetFixedOutputState(ArchiveHandle *AH)
sqlparseInfo sqlparse
char * pghost
Definition: pgbench.c:192
static char * username
Definition: initdb.c:132
char * PQhost(const PGconn *conn)
Definition: fe-connect.c:6016
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:5983
#define Assert(condition)
Definition: c.h:699
ClonePtrType ClonePtr
char * pgport
Definition: pgbench.c:193
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:89
void ConnectDatabase(Archive *AH, const char *dbname, const char *pghost, const char *pgport, const char *username, trivalue prompt_password)
Definition: pg_backup_db.c:240
static char * connstr
Definition: pg_dumpall.c:59
trivalue promptPassword
Definition: pg_backup.h:115

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle AH)

Definition at line 4811 of file pg_backup_archiver.c.

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

Referenced by RunWorker().

4812 {
4813  /* Should not have an open database connection */
4814  Assert(AH->connection == NULL);
4815 
4816  /* Clear format-specific state */
4817  AH->DeClonePtr(AH);
4818 
4819  /* Clear state allocated by CloneArchive */
4820  if (AH->sqlparse.curCmd)
4822 
4823  /* Clear any connection-local state */
4824  if (AH->currUser)
4825  free(AH->currUser);
4826  if (AH->currSchema)
4827  free(AH->currSchema);
4828  if (AH->currTablespace)
4829  free(AH->currTablespace);
4830  if (AH->savedPassword)
4831  free(AH->savedPassword);
4832 
4833  free(AH);
4834 }
PQExpBuffer curCmd
DeClonePtrType DeClonePtr
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:113
sqlparseInfo sqlparse
#define free(a)
Definition: header.h:65
#define Assert(condition)
Definition: c.h:699

◆ DropBlobIfExists()

void DropBlobIfExists ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 661 of file pg_backup_db.c.

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

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

662 {
663  /*
664  * If we are not restoring to a direct database connection, we have to
665  * guess about how to detect whether the blob exists. Assume new-style.
666  */
667  if (AH->connection == NULL ||
668  PQserverVersion(AH->connection) >= 90000)
669  {
670  ahprintf(AH,
671  "SELECT pg_catalog.lo_unlink(oid) "
672  "FROM pg_catalog.pg_largeobject_metadata "
673  "WHERE oid = '%u';\n",
674  oid);
675  }
676  else
677  {
678  /* Restoring to pre-9.0 server, so do it the old way */
679  ahprintf(AH,
680  "SELECT CASE WHEN EXISTS("
681  "SELECT 1 FROM pg_catalog.pg_largeobject WHERE loid = '%u'"
682  ") THEN pg_catalog.lo_unlink('%u') END;\n",
683  oid, oid);
684  }
685 }
int PQserverVersion(const PGconn *conn)
Definition: fe-connect.c:6106
int ahprintf(ArchiveHandle *AH, const char *fmt,...)

◆ EndRestoreBlob()

void EndRestoreBlob ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 1349 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().

1350 {
1351  if (AH->lo_buf_used > 0)
1352  {
1353  /* Write remaining bytes from the LO buffer */
1354  dump_lo_buf(AH);
1355  }
1356 
1357  AH->writingBlob = 0;
1358 
1359  if (AH->connection)
1360  {
1361  lo_close(AH->connection, AH->loFd);
1362  AH->loFd = -1;
1363  }
1364  else
1365  {
1366  ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
1367  }
1368 }
int lo_close(PGconn *conn, int fd)
Definition: fe-lobj.c:99
static void dump_lo_buf(ArchiveHandle *AH)
int ahprintf(ArchiveHandle *AH, const char *fmt,...)

◆ EndRestoreBlobs()

void EndRestoreBlobs ( ArchiveHandle AH)

Definition at line 1282 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().

1283 {
1284  RestoreOptions *ropt = AH->public.ropt;
1285 
1286  if (!ropt->single_txn)
1287  {
1288  if (AH->connection)
1289  CommitTransaction(&AH->public);
1290  else
1291  ahprintf(AH, "COMMIT;\n\n");
1292  }
1293 
1294  ahlog(AH, 1, ngettext("restored %d large object\n",
1295  "restored %d large objects\n",
1296  AH->blobCount),
1297  AH->blobCount);
1298 }
RestoreOptions * ropt
Definition: pg_backup.h:184
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
#define ngettext(s, p, n)
Definition: c.h:1022
void ahlog(ArchiveHandle *AH, int level, const char *fmt,...)
static void CommitTransaction(void)
Definition: xact.c:1933

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1893 of file pg_backup_archiver.c.

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

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

1894 {
1895  /* build index arrays if we didn't already */
1896  if (AH->tocsByDumpId == NULL)
1897  buildTocEntryArrays(AH);
1898 
1899  if (id > 0 && id <= AH->maxDumpId)
1900  return AH->tocsByDumpId[id];
1901 
1902  return NULL;
1903 }
static void buildTocEntryArrays(ArchiveHandle *AH)
struct _tocEntry ** tocsByDumpId

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle AH)

Definition at line 108 of file pg_backup_custom.c.

References _ArchiveEntry(), _Clone(), _CloseArchive(), _DeClone(), _EndBlob(), _EndBlobs(), _EndData(), _getFilePos(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _ReopenArchive(), _StartBlob(), _StartBlobs(), _StartData(), _WorkerJobRestoreCustom(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), _archiveHandle::ArchiveEntryPtr, archModeWrite, checkSeek(), _archiveHandle::ClonePtr, _archiveHandle::ClosePtr, lclContext::dataStart, _archiveHandle::DeClonePtr, _archiveHandle::EndBlobPtr, _archiveHandle::EndBlobsPtr, _archiveHandle::EndDataPtr, exit_horribly(), _archiveHandle::FH, lclContext::filePos, _archiveHandle::formatData, _archiveHandle::fSpec, lclContext::hasSeek, _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, LOBBUFSIZE, _archiveHandle::mode, modulename, PG_BINARY_R, PG_BINARY_W, pg_malloc(), pg_malloc0(), _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, _archiveHandle::StartBlobPtr, _archiveHandle::StartBlobsPtr, _archiveHandle::StartDataPtr, strerror(), _archiveHandle::WorkerJobDumpPtr, _archiveHandle::WorkerJobRestorePtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, _archiveHandle::WriteDataPtr, and _archiveHandle::WriteExtraTocPtr.

Referenced by _allocAH().

109 {
110  lclContext *ctx;
111 
112  /* Assuming static functions, this can be copied for each format. */
114  AH->StartDataPtr = _StartData;
115  AH->WriteDataPtr = _WriteData;
116  AH->EndDataPtr = _EndData;
117  AH->WriteBytePtr = _WriteByte;
118  AH->ReadBytePtr = _ReadByte;
119  AH->WriteBufPtr = _WriteBuf;
120  AH->ReadBufPtr = _ReadBuf;
121  AH->ClosePtr = _CloseArchive;
127 
129  AH->StartBlobPtr = _StartBlob;
130  AH->EndBlobPtr = _EndBlob;
131  AH->EndBlobsPtr = _EndBlobs;
132  AH->ClonePtr = _Clone;
133  AH->DeClonePtr = _DeClone;
134 
135  /* no parallel dump in the custom archive, only parallel restore */
136  AH->WorkerJobDumpPtr = NULL;
138 
139  /* Set up a private area. */
140  ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
141  AH->formatData = (void *) ctx;
142 
143  /* Initialize LO buffering */
144  AH->lo_buf_size = LOBBUFSIZE;
145  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
146 
147  ctx->filePos = 0;
148 
149  /*
150  * Now open the file
151  */
152  if (AH->mode == archModeWrite)
153  {
154  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
155  {
156  AH->FH = fopen(AH->fSpec, PG_BINARY_W);
157  if (!AH->FH)
158  exit_horribly(modulename, "could not open output file \"%s\": %s\n",
159  AH->fSpec, strerror(errno));
160  }
161  else
162  {
163  AH->FH = stdout;
164  if (!AH->FH)
165  exit_horribly(modulename, "could not open output file: %s\n",
166  strerror(errno));
167  }
168 
169  ctx->hasSeek = checkSeek(AH->FH);
170  }
171  else
172  {
173  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
174  {
175  AH->FH = fopen(AH->fSpec, PG_BINARY_R);
176  if (!AH->FH)
177  exit_horribly(modulename, "could not open input file \"%s\": %s\n",
178  AH->fSpec, strerror(errno));
179  }
180  else
181  {
182  AH->FH = stdin;
183  if (!AH->FH)
184  exit_horribly(modulename, "could not open input file: %s\n",
185  strerror(errno));
186  }
187 
188  ctx->hasSeek = checkSeek(AH->FH);
189 
190  ReadHead(AH);
191  ReadToc(AH);
192  ctx->dataStart = _getFilePos(AH, ctx);
193  }
194 
195 }
static void _ReopenArchive(ArchiveHandle *AH)
ReopenPtrType ReopenPtr
ReadBufPtrType ReadBufPtr
void ReadToc(ArchiveHandle *AH)
void ReadHead(ArchiveHandle *AH)
DeClonePtrType DeClonePtr
static void _Clone(ArchiveHandle *AH)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
WriteBufPtrType WriteBufPtr
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
StartBlobPtrType StartBlobPtr
static int _WorkerJobRestoreCustom(ArchiveHandle *AH, TocEntry *te)
EndDataPtrType EndDataPtr
#define PG_BINARY_W
Definition: c.h:1083
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
StartBlobsPtrType StartBlobsPtr
#define PG_BINARY_R
Definition: c.h:1082
ReadBytePtrType ReadBytePtr
EndBlobPtrType EndBlobPtr
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
static void _StartBlobs(ArchiveHandle *AH, TocEntry *te)
StartDataPtrType StartDataPtr
WriteBytePtrType WriteBytePtr
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static int _ReadByte(ArchiveHandle *)
PrintTocDataPtrType PrintTocDataPtr
static const char * modulename
WriteDataPtrType WriteDataPtr
static pgoff_t _getFilePos(ArchiveHandle *AH, lclContext *ctx)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _EndBlobs(ArchiveHandle *AH, TocEntry *te)
EndBlobsPtrType EndBlobsPtr
ArchiveEntryPtrType ArchiveEntryPtr
void exit_horribly(const char *modulename, const char *fmt,...)
pgoff_t dataStart
ClonePtrType ClonePtr
const char * strerror(int errnum)
Definition: strerror.c:19
WorkerJobRestorePtrType WorkerJobRestorePtr
static void _DeClone(ArchiveHandle *AH)
bool checkSeek(FILE *fp)
ClosePtrType ClosePtr
PrintExtraTocPtrType PrintExtraTocPtr
pgoff_t filePos
static int _WriteByte(ArchiveHandle *AH, const int i)
WriteExtraTocPtrType WriteExtraTocPtr
#define LOBBUFSIZE
ReadExtraTocPtrType ReadExtraTocPtr
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _StartBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
WorkerJobDumpPtrType WorkerJobDumpPtr

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle AH)

Definition at line 110 of file pg_backup_directory.c.

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

Referenced by _allocAH().

111 {
112  lclContext *ctx;
113 
114  /* Assuming static functions, this can be copied for each format. */
116  AH->StartDataPtr = _StartData;
117  AH->WriteDataPtr = _WriteData;
118  AH->EndDataPtr = _EndData;
119  AH->WriteBytePtr = _WriteByte;
120  AH->ReadBytePtr = _ReadByte;
121  AH->WriteBufPtr = _WriteBuf;
122  AH->ReadBufPtr = _ReadBuf;
123  AH->ClosePtr = _CloseArchive;
129 
131  AH->StartBlobPtr = _StartBlob;
132  AH->EndBlobPtr = _EndBlob;
133  AH->EndBlobsPtr = _EndBlobs;
134 
135  AH->ClonePtr = _Clone;
136  AH->DeClonePtr = _DeClone;
137 
140 
141  /* Set up our private context */
142  ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
143  AH->formatData = (void *) ctx;
144 
145  ctx->dataFH = NULL;
146  ctx->blobsTocFH = NULL;
147 
148  /* Initialize LO buffering */
149  AH->lo_buf_size = LOBBUFSIZE;
150  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
151 
152  /*
153  * Now open the TOC file
154  */
155 
156  if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
157  exit_horribly(modulename, "no output directory specified\n");
158 
159  ctx->directory = AH->fSpec;
160 
161  if (AH->mode == archModeWrite)
162  {
163  struct stat st;
164  bool is_empty = false;
165 
166  /* we accept an empty existing directory */
167  if (stat(ctx->directory, &st) == 0 && S_ISDIR(st.st_mode))
168  {
169  DIR *dir = opendir(ctx->directory);
170 
171  if (dir)
172  {
173  struct dirent *d;
174 
175  is_empty = true;
176  while (errno = 0, (d = readdir(dir)))
177  {
178  if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0)
179  {
180  is_empty = false;
181  break;
182  }
183  }
184 
185  if (errno)
186  exit_horribly(modulename, "could not read directory \"%s\": %s\n",
187  ctx->directory, strerror(errno));
188 
189  if (closedir(dir))
190  exit_horribly(modulename, "could not close directory \"%s\": %s\n",
191  ctx->directory, strerror(errno));
192  }
193  }
194 
195  if (!is_empty && mkdir(ctx->directory, 0700) < 0)
196  exit_horribly(modulename, "could not create directory \"%s\": %s\n",
197  ctx->directory, strerror(errno));
198  }
199  else
200  { /* Read Mode */
201  char fname[MAXPGPATH];
202  cfp *tocFH;
203 
204  setFilePath(AH, fname, "toc.dat");
205 
206  tocFH = cfopen_read(fname, PG_BINARY_R);
207  if (tocFH == NULL)
209  "could not open input file \"%s\": %s\n",
210  fname, strerror(errno));
211 
212  ctx->dataFH = tocFH;
213 
214  /*
215  * The TOC of a directory format dump shares the format code of the
216  * tar format.
217  */
218  AH->format = archTar;
219  ReadHead(AH);
220  AH->format = archDirectory;
221  ReadToc(AH);
222 
223  /* Nothing else in the file, so close it again... */
224  if (cfclose(tocFH) != 0)
225  exit_horribly(modulename, "could not close TOC file: %s\n",
226  strerror(errno));
227  ctx->dataFH = NULL;
228  }
229 }
ReopenPtrType ReopenPtr
static void _StartData(ArchiveHandle *AH, TocEntry *te)
ReadBufPtrType ReadBufPtr
void ReadToc(ArchiveHandle *AH)
void ReadHead(ArchiveHandle *AH)
DeClonePtrType DeClonePtr
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
WriteBufPtrType WriteBufPtr
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static int _WorkerJobRestoreDirectory(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void setFilePath(ArchiveHandle *AH, char *buf, const char *relativeFilename)
StartBlobPtrType StartBlobPtr
EndDataPtrType EndDataPtr
int closedir(DIR *)
Definition: dirent.c:111
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _StartBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
static const char * modulename
StartBlobsPtrType StartBlobsPtr
int cfclose(cfp *fp)
Definition: compress_io.c:667
Definition: dirent.h:9
#define PG_BINARY_R
Definition: c.h:1082
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
ReadBytePtrType ReadBytePtr
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
EndBlobPtrType EndBlobPtr
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
Definition: dirent.c:25
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
#define MAXPGPATH
DIR * opendir(const char *)
Definition: dirent.c:33
static void _Clone(ArchiveHandle *AH)
StartDataPtrType StartDataPtr
WriteBytePtrType WriteBytePtr
#define stat(a, b)
Definition: win32_port.h:266
ArchiveFormat format
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
PrintTocDataPtrType PrintTocDataPtr
WriteDataPtrType WriteDataPtr
static void _DeClone(ArchiveHandle *AH)
static int _ReadByte(ArchiveHandle *)
EndBlobsPtrType EndBlobsPtr
static void _StartBlobs(ArchiveHandle *AH, TocEntry *te)
ArchiveEntryPtrType ArchiveEntryPtr
struct dirent * readdir(DIR *)
Definition: dirent.c:77
#define S_ISDIR(m)
Definition: win32_port.h:307
void exit_horribly(const char *modulename, const char *fmt,...)
static void _CloseArchive(ArchiveHandle *AH)
ClonePtrType ClonePtr
cfp * cfopen_read(const char *path, const char *mode)
Definition: compress_io.c:467
const char * strerror(int errnum)
Definition: strerror.c:19
WorkerJobRestorePtrType WorkerJobRestorePtr
static int _WorkerJobDumpDirectory(ArchiveHandle *AH, TocEntry *te)
static void _ReopenArchive(ArchiveHandle *AH)
ClosePtrType ClosePtr
char d_name[MAX_PATH]
Definition: dirent.h:14
PrintExtraTocPtrType PrintExtraTocPtr
#define mkdir(a, b)
Definition: win32_port.h:58
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
WriteExtraTocPtrType WriteExtraTocPtr
static void _EndBlobs(ArchiveHandle *AH, TocEntry *te)
#define LOBBUFSIZE
ReadExtraTocPtrType ReadExtraTocPtr
WorkerJobDumpPtrType WorkerJobDumpPtr

◆ InitArchiveFmt_Null()

void InitArchiveFmt_Null ( ArchiveHandle AH)

Definition at line 49 of file pg_backup_null.c.

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

Referenced by _allocAH().

50 {
51  /* Assuming static functions, this can be copied for each format. */
53  AH->EndDataPtr = _EndData;
55  AH->WriteBufPtr = _WriteBuf;
56  AH->ClosePtr = _CloseArchive;
57  AH->ReopenPtr = NULL;
59 
62  AH->EndBlobPtr = _EndBlob;
63  AH->EndBlobsPtr = _EndBlobs;
64  AH->ClonePtr = NULL;
65  AH->DeClonePtr = NULL;
66 
67  /* Initialize LO buffering */
68  AH->lo_buf_size = LOBBUFSIZE;
69  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
70 
71  /*
72  * Now prevent reading...
73  */
74  if (AH->mode == archModeRead)
75  exit_horribly(NULL, "this format cannot be read\n");
76 }
ReopenPtrType ReopenPtr
DeClonePtrType DeClonePtr
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
WriteBufPtrType WriteBufPtr
StartBlobPtrType StartBlobPtr
EndDataPtrType EndDataPtr
StartBlobsPtrType StartBlobsPtr
EndBlobPtrType EndBlobPtr
static void _CloseArchive(ArchiveHandle *AH)
static void _EndBlobs(ArchiveHandle *AH, TocEntry *te)
WriteBytePtrType WriteBytePtr
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartBlobs(ArchiveHandle *AH, TocEntry *te)
PrintTocDataPtrType PrintTocDataPtr
WriteDataPtrType WriteDataPtr
static void _EndData(ArchiveHandle *AH, TocEntry *te)
EndBlobsPtrType EndBlobsPtr
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
void exit_horribly(const char *modulename, const char *fmt,...)
ClonePtrType ClonePtr
ClosePtrType ClosePtr
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
#define LOBBUFSIZE
static void _StartBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)

◆ InitArchiveFmt_Tar()

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, PG_BINARY_R, PG_BINARY_W, pg_malloc(), pg_malloc0(), ReadHead(), ReadToc(), strerror(), tarClose(), lclContext::tarFH, lclContext::tarFHpos, and tarOpen().

Referenced by _allocAH().

130 {
131  lclContext *ctx;
132 
133  /* Assuming static functions, this can be copied for each format. */
135  AH->StartDataPtr = _StartData;
136  AH->WriteDataPtr = _WriteData;
137  AH->EndDataPtr = _EndData;
138  AH->WriteBytePtr = _WriteByte;
139  AH->ReadBytePtr = _ReadByte;
140  AH->WriteBufPtr = _WriteBuf;
141  AH->ReadBufPtr = _ReadBuf;
142  AH->ClosePtr = _CloseArchive;
143  AH->ReopenPtr = NULL;
148 
150  AH->StartBlobPtr = _StartBlob;
151  AH->EndBlobPtr = _EndBlob;
152  AH->EndBlobsPtr = _EndBlobs;
153  AH->ClonePtr = NULL;
154  AH->DeClonePtr = NULL;
155 
156  AH->WorkerJobDumpPtr = NULL;
157  AH->WorkerJobRestorePtr = NULL;
158 
159  /*
160  * Set up some special context used in compressing data.
161  */
162  ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
163  AH->formatData = (void *) ctx;
164  ctx->filePos = 0;
165  ctx->isSpecialScript = 0;
166 
167  /* Initialize LO buffering */
168  AH->lo_buf_size = LOBBUFSIZE;
169  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
170 
171  /*
172  * Now open the tar file, and load the TOC if we're in read mode.
173  */
174  if (AH->mode == archModeWrite)
175  {
176  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
177  {
178  ctx->tarFH = fopen(AH->fSpec, PG_BINARY_W);
179  if (ctx->tarFH == NULL)
181  "could not open TOC file \"%s\" for output: %s\n",
182  AH->fSpec, strerror(errno));
183  }
184  else
185  {
186  ctx->tarFH = stdout;
187  if (ctx->tarFH == NULL)
189  "could not open TOC file for output: %s\n",
190  strerror(errno));
191  }
192 
193  ctx->tarFHpos = 0;
194 
195  /*
196  * Make unbuffered since we will dup() it, and the buffers screw each
197  * other
198  */
199  /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
200 
201  ctx->hasSeek = checkSeek(ctx->tarFH);
202 
203  /*
204  * We don't support compression because reading the files back is not
205  * possible since gzdopen uses buffered IO which totally screws file
206  * positioning.
207  */
208  if (AH->compression != 0)
210  "compression is not supported by tar archive format\n");
211  }
212  else
213  { /* Read Mode */
214  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
215  {
216  ctx->tarFH = fopen(AH->fSpec, PG_BINARY_R);
217  if (ctx->tarFH == NULL)
218  exit_horribly(modulename, "could not open TOC file \"%s\" for input: %s\n",
219  AH->fSpec, strerror(errno));
220  }
221  else
222  {
223  ctx->tarFH = stdin;
224  if (ctx->tarFH == NULL)
225  exit_horribly(modulename, "could not open TOC file for input: %s\n",
226  strerror(errno));
227  }
228 
229  /*
230  * Make unbuffered since we will dup() it, and the buffers screw each
231  * other
232  */
233  /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
234 
235  ctx->tarFHpos = 0;
236 
237  ctx->hasSeek = checkSeek(ctx->tarFH);
238 
239  /*
240  * Forcibly unmark the header as read since we use the lookahead
241  * buffer
242  */
243  AH->readHeader = 0;
244 
245  ctx->FH = (void *) tarOpen(AH, "toc.dat", 'r');
246  ReadHead(AH);
247  ReadToc(AH);
248  tarClose(AH, ctx->FH); /* Nothing else in the file... */
249  }
250 }
TAR_MEMBER * FH
Definition: pg_backup_tar.c:91
ReopenPtrType ReopenPtr
ReadBufPtrType ReadBufPtr
void ReadToc(ArchiveHandle *AH)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
void ReadHead(ArchiveHandle *AH)
DeClonePtrType DeClonePtr
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
WriteBufPtrType WriteBufPtr
static TAR_MEMBER * tarOpen(ArchiveHandle *AH, const char *filename, char mode)
pgoff_t tarFHpos
Definition: pg_backup_tar.c:89
StartBlobPtrType StartBlobPtr
EndDataPtrType EndDataPtr
#define PG_BINARY_W
Definition: c.h:1083
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
StartBlobsPtrType StartBlobsPtr
#define PG_BINARY_R
Definition: c.h:1082
ReadBytePtrType ReadBytePtr
EndBlobPtrType EndBlobPtr
int isSpecialScript
Definition: pg_backup_tar.c:92
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
FILE * tarFH
Definition: pg_backup_tar.c:88
static void _StartBlobs(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
StartDataPtrType StartDataPtr
static void tarClose(ArchiveHandle *AH, TAR_MEMBER *TH)
WriteBytePtrType WriteBytePtr
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndBlobs(ArchiveHandle *AH, TocEntry *te)
static const char * modulename
PrintTocDataPtrType PrintTocDataPtr
WriteDataPtrType WriteDataPtr
static void _EndData(ArchiveHandle *AH, TocEntry *te)
EndBlobsPtrType EndBlobsPtr
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
ArchiveEntryPtrType ArchiveEntryPtr
static void _StartBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
void exit_horribly(const char *modulename, const char *fmt,...)
ClonePtrType ClonePtr
static void _CloseArchive(ArchiveHandle *AH)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
const char * strerror(int errnum)
Definition: strerror.c:19
WorkerJobRestorePtrType WorkerJobRestorePtr
bool checkSeek(FILE *fp)
ClosePtrType ClosePtr
PrintExtraTocPtrType PrintExtraTocPtr
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
pgoff_t filePos
static int _ReadByte(ArchiveHandle *)
WriteExtraTocPtrType WriteExtraTocPtr
#define LOBBUFSIZE
static int _WriteByte(ArchiveHandle *AH, const int i)
ReadExtraTocPtrType ReadExtraTocPtr
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
WorkerJobDumpPtrType WorkerJobDumpPtr

◆ isValidTarHeader()

bool isValidTarHeader ( char *  header)

Definition at line 1059 of file pg_backup_tar.c.

References read_tar_number(), and tarChecksum().

Referenced by _discoverArchiveFormat().

1060 {
1061  int sum;
1062  int chk = tarChecksum(header);
1063 
1064  sum = read_tar_number(&header[148], 8);
1065 
1066  if (sum != chk)
1067  return false;
1068 
1069  /* POSIX tar format */
1070  if (memcmp(&header[257], "ustar\0", 6) == 0 &&
1071  memcmp(&header[263], "00", 2) == 0)
1072  return true;
1073  /* GNU tar format */
1074  if (memcmp(&header[257], "ustar \0", 8) == 0)
1075  return true;
1076  /* not-quite-POSIX format written by pre-9.3 pg_dump */
1077  if (memcmp(&header[257], "ustar00\0", 8) == 0)
1078  return true;
1079 
1080  return false;
1081 }
uint64 read_tar_number(const char *s, int len)
Definition: tar.c:56
int tarChecksum(char *header)
Definition: tar.c:88
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:208

◆ on_exit_close_archive()

void on_exit_close_archive ( Archive AHX)

Definition at line 347 of file parallel.c.

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

Referenced by main().

348 {
349  shutdown_info.AHX = AHX;
351 }
void on_exit_nicely(on_exit_nicely_callback function, void *arg)
static ShutdownInformation shutdown_info
Definition: parallel.c:150
static void archive_close_connection(int code, void *arg)
Definition: parallel.c:358

◆ parallel_restore()

int parallel_restore ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 4374 of file pg_backup_archiver.c.

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

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

4375 {
4376  int status;
4377 
4378  Assert(AH->connection != NULL);
4379 
4380  /* Count only errors associated with this TOC entry */
4381  AH->public.n_errors = 0;
4382 
4383  /* Restore the TOC item */
4384  status = restore_toc_entry(AH, te, true);
4385 
4386  return status;
4387 }
int n_errors
Definition: pg_backup.h:207
static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel)
#define Assert(condition)
Definition: c.h:699
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:225

◆ ReadHead()

void ReadHead ( ArchiveHandle AH)

Definition at line 3769 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().

3770 {
3771  char tmpMag[7];
3772  int fmt;
3773  struct tm crtm;
3774 
3775  /*
3776  * If we haven't already read the header, do so.
3777  *
3778  * NB: this code must agree with _discoverArchiveFormat(). Maybe find a
3779  * way to unify the cases?
3780  */
3781  if (!AH->readHeader)
3782  {
3783  char vmaj,
3784  vmin,
3785  vrev;
3786 
3787  AH->ReadBufPtr(AH, tmpMag, 5);
3788 
3789  if (strncmp(tmpMag, "PGDMP", 5) != 0)
3790  exit_horribly(modulename, "did not find magic string in file header\n");
3791 
3792  vmaj = AH->ReadBytePtr(AH);
3793  vmin = AH->ReadBytePtr(AH);
3794 
3795  if (vmaj > 1 || (vmaj == 1 && vmin > 0)) /* Version > 1.0 */
3796  vrev = AH->ReadBytePtr(AH);
3797  else
3798  vrev = 0;
3799 
3800  AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
3801 
3802  if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
3803  exit_horribly(modulename, "unsupported version (%d.%d) in file header\n",
3804  vmaj, vmin);
3805 
3806  AH->intSize = AH->ReadBytePtr(AH);
3807  if (AH->intSize > 32)
3808  exit_horribly(modulename, "sanity check on integer size (%lu) failed\n",
3809  (unsigned long) AH->intSize);
3810 
3811  if (AH->intSize > sizeof(int))
3812  write_msg(modulename, "WARNING: archive was made on a machine with larger integers, some operations might fail\n");
3813 
3814  if (AH->version >= K_VERS_1_7)
3815  AH->offSize = AH->ReadBytePtr(AH);
3816  else
3817  AH->offSize = AH->intSize;
3818 
3819  fmt = AH->ReadBytePtr(AH);
3820 
3821  if (AH->format != fmt)
3822  exit_horribly(modulename, "expected format (%d) differs from format found in file (%d)\n",
3823  AH->format, fmt);
3824  }
3825 
3826  if (AH->version >= K_VERS_1_2)
3827  {
3828  if (AH->version < K_VERS_1_4)
3829  AH->compression = AH->ReadBytePtr(AH);
3830  else
3831  AH->compression = ReadInt(AH);
3832  }
3833  else
3835 
3836 #ifndef HAVE_LIBZ
3837  if (AH->compression != 0)
3838  write_msg(modulename, "WARNING: archive is compressed, but this installation does not support compression -- no data will be available\n");
3839 #endif
3840 
3841  if (AH->version >= K_VERS_1_4)
3842  {
3843  crtm.tm_sec = ReadInt(AH);
3844  crtm.tm_min = ReadInt(AH);
3845  crtm.tm_hour = ReadInt(AH);
3846  crtm.tm_mday = ReadInt(AH);
3847  crtm.tm_mon = ReadInt(AH);
3848  crtm.tm_year = ReadInt(AH);
3849  crtm.tm_isdst = ReadInt(AH);
3850 
3851  AH->archdbname = ReadStr(AH);
3852 
3853  AH->createDate = mktime(&crtm);
3854 
3855  if (AH->createDate == (time_t) -1)
3856  write_msg(modulename, "WARNING: invalid creation date in header\n");
3857  }
3858 
3859  if (AH->version >= K_VERS_1_10)
3860  {
3861  AH->archiveRemoteVersion = ReadStr(AH);
3862  AH->archiveDumpVersion = ReadStr(AH);
3863  }
3864 }
ReadBufPtrType ReadBufPtr
#define Z_DEFAULT_COMPRESSION
#define K_VERS_1_0
int ReadInt(ArchiveHandle *AH)
#define K_VERS_1_4
ReadBytePtrType ReadBytePtr
static struct pg_tm tm
Definition: localtime.c:107
#define K_VERS_1_7
#define MAKE_ARCHIVE_VERSION(major, minor, rev)
#define K_VERS_1_2
#define K_VERS_1_10
ArchiveFormat format
#define K_VERS_MAX
void write_msg(const char *modulename, const char *fmt,...)
char * ReadStr(ArchiveHandle *AH)
void exit_horribly(const char *modulename, const char *fmt,...)
static const char * modulename

◆ ReadInt()

int ReadInt ( ArchiveHandle AH)

Definition at line 2029 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().

2030 {
2031  int res = 0;
2032  int bv,
2033  b;
2034  int sign = 0; /* Default positive */
2035  int bitShift = 0;
2036 
2037  if (AH->version > K_VERS_1_0)
2038  /* Read a sign byte */
2039  sign = AH->ReadBytePtr(AH);
2040 
2041  for (b = 0; b < AH->intSize; b++)
2042  {
2043  bv = AH->ReadBytePtr(AH) & 0xFF;
2044  if (bv != 0)
2045  res = res + (bv << bitShift);
2046  bitShift += 8;
2047  }
2048 
2049  if (sign)
2050  res = -res;
2051 
2052  return res;
2053 }
#define K_VERS_1_0
ReadBytePtrType ReadBytePtr
char sign
Definition: informix.c:693

◆ ReadOffset()

int ReadOffset ( ArchiveHandle ,
pgoff_t  
)

Definition at line 1934 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().

1935 {
1936  int i;
1937  int off;
1938  int offsetFlg;
1939 
1940  /* Initialize to zero */
1941  *o = 0;
1942 
1943  /* Check for old version */
1944  if (AH->version < K_VERS_1_7)
1945  {
1946  /* Prior versions wrote offsets using WriteInt */
1947  i = ReadInt(AH);
1948  /* -1 means not set */
1949  if (i < 0)
1950  return K_OFFSET_POS_NOT_SET;
1951  else if (i == 0)
1952  return K_OFFSET_NO_DATA;
1953 
1954  /* Cast to pgoff_t because it was written as an int. */
1955  *o = (pgoff_t) i;
1956  return K_OFFSET_POS_SET;
1957  }
1958 
1959  /*
1960  * Read the flag indicating the state of the data pointer. Check if valid
1961  * and die if not.
1962  *
1963  * This used to be handled by a negative or zero pointer, now we use an
1964  * extra byte specifically for the state.
1965  */
1966  offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
1967 
1968  switch (offsetFlg)
1969  {
1970  case K_OFFSET_POS_NOT_SET:
1971  case K_OFFSET_NO_DATA:
1972  case K_OFFSET_POS_SET:
1973 
1974  break;
1975 
1976  default:
1977  exit_horribly(modulename, "unexpected data offset flag %d\n", offsetFlg);
1978  }
1979 
1980  /*
1981  * Read the bytes
1982  */
1983  for (off = 0; off < AH->offSize; off++)
1984  {
1985  if (off < sizeof(pgoff_t))
1986  *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
1987  else
1988  {
1989  if (AH->ReadBytePtr(AH) != 0)
1990  exit_horribly(modulename, "file offset in dump file is too large\n");
1991  }
1992  }
1993 
1994  return offsetFlg;
1995 }
int ReadInt(ArchiveHandle *AH)
#define K_VERS_1_7
#define pgoff_t
Definition: win32_port.h:206
#define K_OFFSET_NO_DATA
void exit_horribly(const char *modulename, const char *fmt,...)
#define K_OFFSET_POS_SET
int i
static const char * modulename
#define K_OFFSET_POS_NOT_SET

◆ ReadStr()

char* ReadStr ( ArchiveHandle AH)

Definition at line 2075 of file pg_backup_archiver.c.

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

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

2076 {
2077  char *buf;
2078  int l;
2079 
2080  l = ReadInt(AH);
2081  if (l < 0)
2082  buf = NULL;
2083  else
2084  {
2085  buf = (char *) pg_malloc(l + 1);
2086  AH->ReadBufPtr(AH, (void *) buf, l);
2087 
2088  buf[l] = '\0';
2089  }
2090 
2091  return buf;
2092 }
ReadBufPtrType ReadBufPtr
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
int ReadInt(ArchiveHandle *AH)
static char * buf
Definition: pg_test_fsync.c:67

◆ ReadTOC()

void ReadTOC ( ArchiveHandle AH)

◆ ReadToc()

void ReadToc ( ArchiveHandle AH)

Definition at line 2564 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, CatalogId::oid, _tocEntry::owner, pg_malloc(), pg_malloc0(), pg_realloc(), _tocEntry::prev, processEncodingEntry(), processSearchPathEntry(), processStdStringsEntry(), _archiveHandle::ReadExtraTocPtr, ReadInt(), ReadStr(), _tocEntry::section, SECTION_DATA, SECTION_NONE, SECTION_POST_DATA, SECTION_PRE_DATA, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, _archiveHandle::version, and _tocEntry::withOids.

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

2565 {
2566  int i;
2567  char *tmp;
2568  DumpId *deps;
2569  int depIdx;
2570  int depSize;
2571  TocEntry *te;
2572 
2573  AH->tocCount = ReadInt(AH);
2574  AH->maxDumpId = 0;
2575 
2576  for (i = 0; i < AH->tocCount; i++)
2577  {
2578  te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
2579  te->dumpId = ReadInt(AH);
2580 
2581  if (te->dumpId > AH->maxDumpId)
2582  AH->maxDumpId = te->dumpId;
2583 
2584  /* Sanity check */
2585  if (te->dumpId <= 0)
2587  "entry ID %d out of range -- perhaps a corrupt TOC\n",
2588  te->dumpId);
2589 
2590  te->hadDumper = ReadInt(AH);
2591 
2592  if (AH->version >= K_VERS_1_8)
2593  {
2594  tmp = ReadStr(AH);
2595  sscanf(tmp, "%u", &te->catalogId.tableoid);
2596  free(tmp);
2597  }
2598  else
2600  tmp = ReadStr(AH);
2601  sscanf(tmp, "%u", &te->catalogId.oid);
2602  free(tmp);
2603 
2604  te->tag = ReadStr(AH);
2605  te->desc = ReadStr(AH);
2606 
2607  if (AH->version >= K_VERS_1_11)
2608  {
2609  te->section = ReadInt(AH);
2610  }
2611  else
2612  {
2613  /*
2614  * Rules for pre-8.4 archives wherein pg_dump hasn't classified
2615  * the entries into sections. This list need not cover entry
2616  * types added later than 8.4.
2617  */
2618  if (strcmp(te->desc, "COMMENT") == 0 ||
2619  strcmp(te->desc, "ACL") == 0 ||
2620  strcmp(te->desc, "ACL LANGUAGE") == 0)
2621  te->section = SECTION_NONE;
2622  else if (strcmp(te->desc, "TABLE DATA") == 0 ||
2623  strcmp(te->desc, "BLOBS") == 0 ||
2624  strcmp(te->desc, "BLOB COMMENTS") == 0)
2625  te->section = SECTION_DATA;
2626  else if (strcmp(te->desc, "CONSTRAINT") == 0 ||
2627  strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
2628  strcmp(te->desc, "FK CONSTRAINT") == 0 ||
2629  strcmp(te->desc, "INDEX") == 0 ||
2630  strcmp(te->desc, "RULE") == 0 ||
2631  strcmp(te->desc, "TRIGGER") == 0)
2632  te->section = SECTION_POST_DATA;
2633  else
2634  te->section = SECTION_PRE_DATA;
2635  }
2636 
2637  te->defn = ReadStr(AH);
2638  te->dropStmt = ReadStr(AH);
2639 
2640  if (AH->version >= K_VERS_1_3)
2641  te->copyStmt = ReadStr(AH);
2642 
2643  if (AH->version >= K_VERS_1_6)
2644  te->namespace = ReadStr(AH);
2645 
2646  if (AH->version >= K_VERS_1_10)
2647  te->tablespace = ReadStr(AH);
2648 
2649  te->owner = ReadStr(AH);
2650  if (AH->version >= K_VERS_1_9)
2651  {
2652  if (strcmp(ReadStr(AH), "true") == 0)
2653  te->withOids = true;
2654  else
2655  te->withOids = false;
2656  }
2657  else
2658  te->withOids = true;
2659 
2660  /* Read TOC entry dependencies */
2661  if (AH->version >= K_VERS_1_5)
2662  {
2663  depSize = 100;
2664  deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
2665  depIdx = 0;
2666  for (;;)
2667  {
2668  tmp = ReadStr(AH);
2669  if (!tmp)
2670  break; /* end of list */
2671  if (depIdx >= depSize)
2672  {
2673  depSize *= 2;
2674  deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depSize);
2675  }
2676  sscanf(tmp, "%d", &deps[depIdx]);
2677  free(tmp);
2678  depIdx++;
2679  }
2680 
2681  if (depIdx > 0) /* We have a non-null entry */
2682  {
2683  deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depIdx);
2684  te->dependencies = deps;
2685  te->nDeps = depIdx;
2686  }
2687  else
2688  {
2689  free(deps);
2690  te->dependencies = NULL;
2691  te->nDeps = 0;
2692  }
2693  }
2694  else
2695  {
2696  te->dependencies = NULL;
2697  te->nDeps = 0;
2698  }
2699 
2700  if (AH->ReadExtraTocPtr)
2701  AH->ReadExtraTocPtr(AH, te);
2702 
2703  ahlog(AH, 3, "read TOC entry %d (ID %d) for %s %s\n",
2704  i, te->dumpId, te->desc, te->tag);
2705 
2706  /* link completed entry into TOC circular list */
2707  te->prev = AH->toc->prev;
2708  AH->toc->prev->next = te;
2709  AH->toc->prev = te;
2710  te->next = AH->toc;
2711 
2712  /* special processing immediately upon read for some items */
2713  if (strcmp(te->desc, "ENCODING") == 0)
2714  processEncodingEntry(AH, te);
2715  else if (strcmp(te->desc, "STDSTRINGS") == 0)
2716  processStdStringsEntry(AH, te);
2717  else if (strcmp(te->desc, "SEARCHPATH") == 0)
2718  processSearchPathEntry(AH, te);
2719  }
2720 }
struct _tocEntry * next
static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
int DumpId
Definition: pg_backup.h:235
Oid tableoid
Definition: pg_backup.h:231
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
CatalogId catalogId
#define K_VERS_1_9
int ReadInt(ArchiveHandle *AH)
static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te)
teSection section
#define K_VERS_1_5
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
struct _tocEntry * toc
DumpId * dependencies
#define K_VERS_1_8
static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te)
#define K_VERS_1_10
void * pg_realloc(void *ptr, size_t size)
Definition: fe_memutils.c:65
#define K_VERS_1_3
struct _tocEntry * prev
#define InvalidOid
Definition: postgres_ext.h:36
#define free(a)
Definition: header.h:65
char * ReadStr(ArchiveHandle *AH)
void exit_horribly(const char *modulename, const char *fmt,...)
#define K_VERS_1_6
void ahlog(ArchiveHandle *AH, int level, const char *fmt,...)
int i
#define K_VERS_1_11
static const char * modulename
ReadExtraTocPtrType ReadExtraTocPtr

◆ ReconnectToServer()

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

Definition at line 83 of file pg_backup_db.c.

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

Referenced by _reconnectToDB().

84 {
85  PGconn *newConn;
86  const char *newdbname;
87  const char *newusername;
88 
89  if (!dbname)
90  newdbname = PQdb(AH->connection);
91  else
92  newdbname = dbname;
93 
94  if (!username)
95  newusername = PQuser(AH->connection);
96  else
97  newusername = username;
98 
99  newConn = _connectDB(AH, newdbname, newusername);
100 
101  /* Update ArchiveHandle's connCancel before closing old connection */
102  set_archive_cancel_info(AH, newConn);
103 
104  PQfinish(AH->connection);
105  AH->connection = newConn;
106 
107  /* Start strict; later phases may override this. */
110 }
static PGconn * _connectDB(ArchiveHandle *AH, const char *newdbname, const char *newUser)
Definition: pg_backup_db.c:122
void PQfinish(PGconn *conn)
Definition: fe-connect.c:3638
char * PQuser(const PGconn *conn)
Definition: fe-connect.c:5991
PGresult * ExecuteSqlQueryForSingleRow(Archive *fout, const char *query)
Definition: pg_backup_db.c:420
static char * username
Definition: initdb.c:132
void PQclear(PGresult *res)
Definition: fe-exec.c:671
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:5983
char * dbname
Definition: streamutil.c:51
#define ALWAYS_SECURE_SEARCH_PATH_SQL
Definition: connect.h:25
void set_archive_cancel_info(ArchiveHandle *AH, PGconn *conn)
Definition: parallel.c:744

◆ StartRestoreBlob()

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

Definition at line 1305 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().

1306 {
1307  bool old_blob_style = (AH->version < K_VERS_1_12);
1308  Oid loOid;
1309 
1310  AH->blobCount++;
1311 
1312  /* Initialize the LO Buffer */
1313  AH->lo_buf_used = 0;
1314 
1315  ahlog(AH, 1, "restoring large object with OID %u\n", oid);
1316 
1317  /* With an old archive we must do drop and create logic here */
1318  if (old_blob_style && drop)
1319  DropBlobIfExists(AH, oid);
1320 
1321  if (AH->connection)
1322  {
1323  if (old_blob_style)
1324  {
1325  loOid = lo_create(AH->connection, oid);
1326  if (loOid == 0 || loOid != oid)
1327  exit_horribly(modulename, "could not create large object %u: %s",
1328  oid, PQerrorMessage(AH->connection));
1329  }
1330  AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
1331  if (AH->loFd == -1)
1332  exit_horribly(modulename, "could not open large object %u: %s",
1333  oid, PQerrorMessage(AH->connection));
1334  }
1335  else
1336  {
1337  if (old_blob_style)
1338  ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
1339  oid, INV_WRITE);
1340  else
1341  ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
1342  oid, INV_WRITE);
1343  }
1344 
1345  AH->writingBlob = 1;
1346 }
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:6116
void DropBlobIfExists(ArchiveHandle *AH, Oid oid)
Definition: pg_backup_db.c:661
unsigned int Oid
Definition: postgres_ext.h:31
#define K_VERS_1_12
int lo_open(PGconn *conn, Oid lobjId, int mode)
Definition: fe-lobj.c:57
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
Oid lo_create(PGconn *conn, Oid lobjId)
Definition: fe-lobj.c:504
#define INV_WRITE
Definition: libpq-fs.h:21
void exit_horribly(const char *modulename, const char *fmt,...)
void ahlog(ArchiveHandle *AH, int level, const char *fmt,...)
static const char * modulename

◆ StartRestoreBlobs()

void StartRestoreBlobs ( ArchiveHandle AH)

Definition at line 1263 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

1264 {
1265  RestoreOptions *ropt = AH->public.ropt;
1266 
1267  if (!ropt->single_txn)
1268  {
1269  if (AH->connection)
1270  StartTransaction(&AH->public);
1271  else
1272  ahprintf(AH, "BEGIN;\n\n");
1273  }
1274 
1275  AH->blobCount = 0;
1276 }
RestoreOptions * ropt
Definition: pg_backup.h:184
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
static void StartTransaction(void)
Definition: xact.c:1795

◆ TocIDRequired()

teReqs TocIDRequired ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1906 of file pg_backup_archiver.c.

References getTocEntryByDumpId(), and _tocEntry::reqs.

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

1907 {
1908  TocEntry *te = getTocEntryByDumpId(AH, id);
1909 
1910  if (!te)
1911  return 0;
1912 
1913  return te->reqs;
1914 }
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)

◆ warn_or_exit_horribly()

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

◆ WriteDataChunks()

void WriteDataChunks ( ArchiveHandle AH,
struct ParallelState pstate 
)

Definition at line 2418 of file pg_backup_archiver.c.

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

Referenced by _CloseArchive().

2419 {
2420  TocEntry *te;
2421 
2422  for (te = AH->toc->next; te != AH->toc; te = te->next)
2423  {
2424  if (!te->dataDumper)
2425  continue;
2426 
2427  if ((te->reqs & REQ_DATA) == 0)
2428  continue;
2429 
2430  if (pstate && pstate->numWorkers > 1)
2431  {
2432  /*
2433  * If we are in a parallel backup, then we are always the master
2434  * process. Dispatch each data-transfer job to a worker.
2435  */
2436  DispatchJobForTocEntry(AH, pstate, te, ACT_DUMP,
2437  mark_dump_job_done, NULL);
2438  }
2439  else
2441  }
2442 
2443  /*
2444  * If parallel, wait for workers to finish.
2445  */
2446  if (pstate && pstate->numWorkers > 1)
2447  WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2448 }
struct _tocEntry * next
void DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te, T_Action act, ParallelCompletionPtr callback, void *callback_data)
Definition: parallel.c:1229
DataDumperPtr dataDumper
struct _tocEntry * toc
void WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
Definition: parallel.c:1477
void WriteDataChunksForTocEntry(ArchiveHandle *AH, TocEntry *te)
static void mark_dump_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
int numWorkers
Definition: parallel.h:42

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 2473 of file pg_backup_archiver.c.

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

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

2474 {
2475  StartDataPtrType startPtr;
2476  EndDataPtrType endPtr;
2477 
2478  AH->currToc = te;
2479 
2480  if (strcmp(te->desc, "BLOBS") == 0)
2481  {
2482  startPtr = AH->StartBlobsPtr;
2483  endPtr = AH->EndBlobsPtr;
2484  }
2485  else
2486  {
2487  startPtr = AH->StartDataPtr;
2488  endPtr = AH->EndDataPtr;
2489  }
2490 
2491  if (startPtr != NULL)
2492  (*startPtr) (AH, te);
2493 
2494  /*
2495  * The user-provided DataDumper routine needs to call AH->WriteData
2496  */
2497  te->dataDumper((Archive *) AH, te->dataDumperArg);
2498 
2499  if (endPtr != NULL)
2500  (*endPtr) (AH, te);
2501 
2502  AH->currToc = NULL;
2503 }
void * dataDumperArg
EndDataPtrType EndDataPtr
DataDumperPtr dataDumper
StartBlobsPtrType StartBlobsPtr
struct _tocEntry * currToc
StartDataPtrType StartDataPtr
void(* StartDataPtrType)(ArchiveHandle *AH, TocEntry *te)
void(* EndDataPtrType)(ArchiveHandle *AH, TocEntry *te)
EndBlobsPtrType EndBlobsPtr

◆ WriteHead()

void WriteHead ( ArchiveHandle AH)

Definition at line 3743 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().

3744 {
3745  struct tm crtm;
3746 
3747  AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
3748  AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
3749  AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
3750  AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
3751  AH->WriteBytePtr(AH, AH->intSize);
3752  AH->WriteBytePtr(AH, AH->offSize);
3753  AH->WriteBytePtr(AH, AH->format);
3754  WriteInt(AH, AH->compression);
3755  crtm = *localtime(&AH->createDate);
3756  WriteInt(AH, crtm.tm_sec);
3757  WriteInt(AH, crtm.tm_min);
3758  WriteInt(AH, crtm.tm_hour);
3759  WriteInt(AH, crtm.tm_mday);
3760  WriteInt(AH, crtm.tm_mon);
3761  WriteInt(AH, crtm.tm_year);
3762  WriteInt(AH, crtm.tm_isdst);
3763  WriteStr(AH, PQdb(AH->connection));
3764  WriteStr(AH, AH->public.remoteVersionStr);
3765  WriteStr(AH, PG_VERSION);
3766 }
WriteBufPtrType WriteBufPtr
static struct pg_tm tm
Definition: localtime.c:107
#define ARCHIVE_REV(version)
WriteBytePtrType WriteBytePtr
#define ARCHIVE_MINOR(version)
ArchiveFormat format
#define ARCHIVE_MAJOR(version)
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:5983
size_t WriteInt(ArchiveHandle *AH, int i)
char * remoteVersionStr
Definition: pg_backup.h:187
size_t WriteStr(ArchiveHandle *AH, const char *c)

◆ WriteInt()

size_t WriteInt ( ArchiveHandle AH,
int  i 
)

Definition at line 1998 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().

1999 {
2000  int b;
2001 
2002  /*
2003  * This is a bit yucky, but I don't want to make the binary format very
2004  * dependent on representation, and not knowing much about it, I write out
2005  * a sign byte. If you change this, don't forget to change the file
2006  * version #, and modify readInt to read the new format AS WELL AS the old
2007  * formats.
2008  */
2009 
2010  /* SIGN byte */
2011  if (i < 0)
2012  {
2013  AH->WriteBytePtr(AH, 1);
2014  i = -i;
2015  }
2016  else
2017  AH->WriteBytePtr(AH, 0);
2018 
2019  for (b = 0; b < AH->intSize; b++)
2020  {
2021  AH->WriteBytePtr(AH, i & 0xFF);
2022  i >>= 8;
2023  }
2024 
2025  return AH->intSize + 1;
2026 }
WriteBytePtrType WriteBytePtr
int i

◆ WriteOffset()

size_t WriteOffset ( ArchiveHandle ,
pgoff_t  ,
int   
)

Definition at line 1917 of file pg_backup_archiver.c.

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

1918 {
1919  int off;
1920 
1921  /* Save the flag */
1922  AH->WriteBytePtr(AH, wasSet);
1923 
1924  /* Write out pgoff_t smallest byte first, prevents endian mismatch */
1925  for (off = 0; off < sizeof(pgoff_t); off++)
1926  {
1927  AH->WriteBytePtr(AH, o & 0xFF);
1928  o >>= 8;
1929  }
1930  return sizeof(pgoff_t) + 1;
1931 }
#define pgoff_t
Definition: win32_port.h:206

◆ WriteStr()

size_t WriteStr ( ArchiveHandle AH,
const char *  s 
)

Definition at line 2056 of file pg_backup_archiver.c.

References _archiveHandle::WriteBufPtr, and WriteInt().

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

2057 {
2058  size_t res;
2059 
2060  if (c)
2061  {
2062  int len = strlen(c);
2063 
2064  res = WriteInt(AH, len);
2065  AH->WriteBufPtr(AH, c, len);
2066  res += len;
2067  }
2068  else
2069  res = WriteInt(AH, -1);
2070 
2071  return res;
2072 }
WriteBufPtrType WriteBufPtr
char * c
size_t WriteInt(ArchiveHandle *AH, int i)

◆ WriteTOC()

void void WriteTOC ( ArchiveHandle AH)

◆ WriteToc()

void WriteToc ( ArchiveHandle AH)

Definition at line 2506 of file pg_backup_archiver.c.

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

Referenced by _CloseArchive().

2507 {
2508  TocEntry *te;
2509  char workbuf[32];
2510  int tocCount;
2511  int i;
2512 
2513  /* count entries that will actually be dumped */
2514  tocCount = 0;
2515  for (te = AH->toc->next; te != AH->toc; te = te->next)
2516  {
2517  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
2518  tocCount++;
2519  }
2520 
2521  /* printf("%d TOC Entries to save\n", tocCount); */
2522 
2523  WriteInt(AH, tocCount);
2524 
2525  for (te = AH->toc->next; te != AH->toc; te = te->next)
2526  {
2527  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) == 0)
2528  continue;
2529 
2530  WriteInt(AH, te->dumpId);
2531  WriteInt(AH, te->dataDumper ? 1 : 0);
2532 
2533  /* OID is recorded as a string for historical reasons */
2534  sprintf(workbuf, "%u", te->catalogId.tableoid);
2535  WriteStr(AH, workbuf);
2536  sprintf(workbuf, "%u", te->catalogId.oid);
2537  WriteStr(AH, workbuf);
2538 
2539  WriteStr(AH, te->tag);
2540  WriteStr(AH, te->desc);
2541  WriteInt(AH, te->section);
2542  WriteStr(AH, te->defn);
2543  WriteStr(AH, te->dropStmt);
2544  WriteStr(AH, te->copyStmt);
2545  WriteStr(AH, te->namespace);
2546  WriteStr(AH, te->tablespace);
2547  WriteStr(AH, te->owner);
2548  WriteStr(AH, te->withOids ? "true" : "false");
2549 
2550  /* Dump list of dependencies */
2551  for (i = 0; i < te->nDeps; i++)
2552  {
2553  sprintf(workbuf, "%d", te->dependencies[i]);
2554  WriteStr(AH, workbuf);
2555  }
2556  WriteStr(AH, NULL); /* Terminate List */
2557 
2558  if (AH->WriteExtraTocPtr)
2559  AH->WriteExtraTocPtr(AH, te);
2560  }
2561 }
struct _tocEntry * next
Oid tableoid
Definition: pg_backup.h:231
CatalogId catalogId
DataDumperPtr dataDumper
teSection section
struct _tocEntry * toc
DumpId * dependencies
size_t WriteInt(ArchiveHandle *AH, int i)
int i
size_t WriteStr(ArchiveHandle *AH, const char *c)
WriteExtraTocPtrType WriteExtraTocPtr