PostgreSQL Source Code  git master
pg_backup_archiver.h File Reference
#include <time.h>
#include "libpq-fe.h"
#include "pg_backup.h"
#include "pqexpbuffer.h"
Include dependency graph for pg_backup_archiver.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  sqlparseInfo
 
struct  _archiveHandle
 
struct  _tocEntry
 
struct  _archiveOpts
 

Macros

#define LOBBUFSIZE   16384
 
#define BLK_DATA   1
 
#define BLK_BLOBS   3
 
#define MAKE_ARCHIVE_VERSION(major, minor, rev)   (((major) * 256 + (minor)) * 256 + (rev))
 
#define ARCHIVE_MAJOR(version)   (((version) >> 16) & 255)
 
#define ARCHIVE_MINOR(version)   (((version) >> 8) & 255)
 
#define ARCHIVE_REV(version)   (((version) ) & 255)
 
#define K_VERS_1_0   MAKE_ARCHIVE_VERSION(1, 0, 0)
 
#define K_VERS_1_2   MAKE_ARCHIVE_VERSION(1, 2, 0) /* Allow No ZLIB */
 
#define K_VERS_1_3   MAKE_ARCHIVE_VERSION(1, 3, 0) /* BLOBS */
 
#define K_VERS_1_4   MAKE_ARCHIVE_VERSION(1, 4, 0) /* Date & name in header */
 
#define K_VERS_1_5   MAKE_ARCHIVE_VERSION(1, 5, 0) /* Handle dependencies */
 
#define K_VERS_1_6   MAKE_ARCHIVE_VERSION(1, 6, 0) /* Schema field in TOCs */
 
#define K_VERS_1_7
 
#define K_VERS_1_8
 
#define K_VERS_1_9
 
#define K_VERS_1_10   MAKE_ARCHIVE_VERSION(1, 10, 0) /* add tablespace */
 
#define K_VERS_1_11
 
#define K_VERS_1_12
 
#define K_VERS_1_13
 
#define K_VERS_1_14   MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */
 
#define K_VERS_1_15
 
#define K_VERS_MAJOR   1
 
#define K_VERS_MINOR   15
 
#define K_VERS_REV   0
 
#define K_VERS_SELF   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV)
 
#define K_VERS_MAX   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)
 
#define K_OFFSET_POS_NOT_SET   1
 
#define K_OFFSET_POS_SET   2
 
#define K_OFFSET_NO_DATA   3
 
#define WORKER_OK   0
 
#define WORKER_CREATE_DONE   10
 
#define WORKER_INHIBIT_DATA   11
 
#define WORKER_IGNORED_ERRORS   12
 
#define READ_ERROR_EXIT(fd)
 
#define WRITE_ERROR_EXIT
 
#define RESTORE_PASS_LAST   RESTORE_PASS_POST_ACL
 
#define REQ_SCHEMA   0x01 /* want schema */
 
#define REQ_DATA   0x02 /* want data */
 
#define REQ_SPECIAL   0x04 /* for special TOC entries */
 
#define ARCHIVE_OPTS(...)   &(ArchiveOpts){__VA_ARGS__}
 
#define appendStringLiteralAHX(buf, str, AH)    appendStringLiteral(buf, str, (AH)->public.encoding, (AH)->public.std_strings)
 
#define appendByteaLiteralAHX(buf, str, len, AH)    appendByteaLiteral(buf, str, len, (AH)->public.std_strings)
 

Typedefs

typedef struct _archiveHandle ArchiveHandle
 
typedef struct _tocEntry TocEntry
 
typedef enum T_Action T_Action
 
typedef void(* ClosePtrType) (ArchiveHandle *AH)
 
typedef void(* ReopenPtrType) (ArchiveHandle *AH)
 
typedef void(* ArchiveEntryPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* WriteDataPtrType) (ArchiveHandle *AH, const void *data, size_t dLen)
 
typedef void(* EndDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartLOsPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartLOPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)
 
typedef void(* EndLOPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)
 
typedef void(* EndLOsPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef int(* WriteBytePtrType) (ArchiveHandle *AH, const int i)
 
typedef int(* ReadBytePtrType) (ArchiveHandle *AH)
 
typedef void(* WriteBufPtrType) (ArchiveHandle *AH, const void *c, size_t len)
 
typedef void(* ReadBufPtrType) (ArchiveHandle *AH, void *buf, size_t len)
 
typedef void(* WriteExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* ReadExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* PrintExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* PrintTocDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)
 
typedef void(* ClonePtrType) (ArchiveHandle *AH)
 
typedef void(* DeClonePtrType) (ArchiveHandle *AH)
 
typedef int(* WorkerJobDumpPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef int(* WorkerJobRestorePtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef size_t(* CustomOutPtrType) (ArchiveHandle *AH, const void *buf, size_t len)
 
typedef void struct _archiveOpts ArchiveOpts
 

Enumerations

enum  T_Action { ACT_DUMP , ACT_RESTORE }
 
enum  sqlparseState { SQL_SCAN = 0 , SQL_IN_SINGLE_QUOTE , SQL_IN_DOUBLE_QUOTE }
 
enum  ArchiverStage { STAGE_NONE = 0 , STAGE_INITIALIZING , STAGE_PROCESSING , STAGE_FINALIZING }
 
enum  ArchiverOutput { OUTPUT_SQLCMDS = 0 , OUTPUT_COPYDATA , OUTPUT_OTHERDATA }
 
enum  RestorePass { RESTORE_PASS_MAIN = 0 , RESTORE_PASS_ACL , RESTORE_PASS_POST_ACL }
 

Functions

int parallel_restore (ArchiveHandle *AH, TocEntry *te)
 
void on_exit_close_archive (Archive *AHX)
 
void warn_or_exit_horribly (ArchiveHandle *AH, const char *fmt,...) pg_attribute_printf(2
 
TocEntryArchiveEntry (Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts *opts)
 
void WriteHead (ArchiveHandle *AH)
 
void ReadHead (ArchiveHandle *AH)
 
void WriteToc (ArchiveHandle *AH)
 
void ReadToc (ArchiveHandle *AH)
 
void WriteDataChunks (ArchiveHandle *AH, struct ParallelState *pstate)
 
void WriteDataChunksForTocEntry (ArchiveHandle *AH, TocEntry *te)
 
ArchiveHandleCloneArchive (ArchiveHandle *AH)
 
void DeCloneArchive (ArchiveHandle *AH)
 
int 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 *c)
 
int ReadOffset (ArchiveHandle *, pgoff_t *)
 
size_t WriteOffset (ArchiveHandle *, pgoff_t, int)
 
void StartRestoreLOs (ArchiveHandle *AH)
 
void StartRestoreLO (ArchiveHandle *AH, Oid oid, bool drop)
 
void EndRestoreLO (ArchiveHandle *AH, Oid oid)
 
void EndRestoreLOs (ArchiveHandle *AH)
 
void InitArchiveFmt_Custom (ArchiveHandle *AH)
 
void InitArchiveFmt_Null (ArchiveHandle *AH)
 
void InitArchiveFmt_Directory (ArchiveHandle *AH)
 
void InitArchiveFmt_Tar (ArchiveHandle *AH)
 
bool isValidTarHeader (char *header)
 
void ReconnectToServer (ArchiveHandle *AH, const char *dbname)
 
void DropLOIfExists (ArchiveHandle *AH, Oid oid)
 
void ahwrite (const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)
 
int ahprintf (ArchiveHandle *AH, const char *fmt,...) pg_attribute_printf(2
 

Macro Definition Documentation

◆ appendByteaLiteralAHX

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

Definition at line 414 of file pg_backup_archiver.h.

◆ appendStringLiteralAHX

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

Definition at line 411 of file pg_backup_archiver.h.

◆ ARCHIVE_MAJOR

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

Definition at line 42 of file pg_backup_archiver.h.

◆ ARCHIVE_MINOR

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

Definition at line 43 of file pg_backup_archiver.h.

◆ ARCHIVE_OPTS

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

Definition at line 393 of file pg_backup_archiver.h.

◆ ARCHIVE_REV

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

Definition at line 44 of file pg_backup_archiver.h.

◆ BLK_BLOBS

#define BLK_BLOBS   3

Definition at line 37 of file pg_backup_archiver.h.

◆ BLK_DATA

#define BLK_DATA   1

Definition at line 36 of file pg_backup_archiver.h.

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA   3

Definition at line 76 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET   1

Definition at line 74 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET   2

Definition at line 75 of file pg_backup_archiver.h.

◆ K_VERS_1_0

#define K_VERS_1_0   MAKE_ARCHIVE_VERSION(1, 0, 0)

Definition at line 47 of file pg_backup_archiver.h.

◆ K_VERS_1_10

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

Definition at line 56 of file pg_backup_archiver.h.

◆ K_VERS_1_11

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

Definition at line 57 of file pg_backup_archiver.h.

◆ K_VERS_1_12

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

Definition at line 58 of file pg_backup_archiver.h.

◆ K_VERS_1_13

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

Definition at line 59 of file pg_backup_archiver.h.

◆ K_VERS_1_14

#define K_VERS_1_14   MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */

Definition at line 60 of file pg_backup_archiver.h.

◆ K_VERS_1_15

#define K_VERS_1_15
Value:
MAKE_ARCHIVE_VERSION(1, 15, 0) /* add
* compression_algorithm
* in header */

Definition at line 61 of file pg_backup_archiver.h.

◆ K_VERS_1_2

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

Definition at line 48 of file pg_backup_archiver.h.

◆ K_VERS_1_3

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

Definition at line 49 of file pg_backup_archiver.h.

◆ K_VERS_1_4

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

Definition at line 50 of file pg_backup_archiver.h.

◆ K_VERS_1_5

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

Definition at line 51 of file pg_backup_archiver.h.

◆ K_VERS_1_6

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

Definition at line 52 of file pg_backup_archiver.h.

◆ K_VERS_1_7

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

Definition at line 53 of file pg_backup_archiver.h.

◆ K_VERS_1_8

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

Definition at line 54 of file pg_backup_archiver.h.

◆ K_VERS_1_9

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

Definition at line 55 of file pg_backup_archiver.h.

◆ K_VERS_MAJOR

#define K_VERS_MAJOR   1

Definition at line 64 of file pg_backup_archiver.h.

◆ K_VERS_MAX

#define K_VERS_MAX   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)

Definition at line 70 of file pg_backup_archiver.h.

◆ K_VERS_MINOR

#define K_VERS_MINOR   15

Definition at line 65 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV   0

Definition at line 66 of file pg_backup_archiver.h.

◆ K_VERS_SELF

Definition at line 67 of file pg_backup_archiver.h.

◆ LOBBUFSIZE

#define LOBBUFSIZE   16384

Definition at line 33 of file pg_backup_archiver.h.

◆ MAKE_ARCHIVE_VERSION

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

Definition at line 40 of file pg_backup_archiver.h.

◆ READ_ERROR_EXIT

#define READ_ERROR_EXIT (   fd)
Value:
do { \
if (feof(fd)) \
pg_fatal("could not read from input file: end of file"); \
pg_fatal("could not read from input file: %m"); \
} while (0)
#define pg_fatal(...)
static int fd(const char *x, int i)
Definition: preproc-init.c:105

Definition at line 91 of file pg_backup_archiver.h.

◆ REQ_DATA

#define REQ_DATA   0x02 /* want data */

Definition at line 199 of file pg_backup_archiver.h.

◆ REQ_SCHEMA

#define REQ_SCHEMA   0x01 /* want schema */

Definition at line 198 of file pg_backup_archiver.h.

◆ REQ_SPECIAL

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

Definition at line 200 of file pg_backup_archiver.h.

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST   RESTORE_PASS_POST_ACL

Definition at line 195 of file pg_backup_archiver.h.

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE   10

Definition at line 83 of file pg_backup_archiver.h.

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS   12

Definition at line 85 of file pg_backup_archiver.h.

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA   11

Definition at line 84 of file pg_backup_archiver.h.

◆ WORKER_OK

#define WORKER_OK   0

Definition at line 82 of file pg_backup_archiver.h.

◆ WRITE_ERROR_EXIT

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

Definition at line 99 of file pg_backup_archiver.h.

Typedef Documentation

◆ ArchiveEntryPtrType

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

Definition at line 112 of file pg_backup_archiver.h.

◆ ArchiveHandle

typedef struct _archiveHandle ArchiveHandle

Definition at line 1 of file pg_backup_archiver.h.

◆ ArchiveOpts

typedef void struct _archiveOpts ArchiveOpts

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 133 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 110 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 139 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 134 of file pg_backup_archiver.h.

◆ EndDataPtrType

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

Definition at line 116 of file pg_backup_archiver.h.

◆ EndLOPtrType

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

Definition at line 120 of file pg_backup_archiver.h.

◆ EndLOsPtrType

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

Definition at line 121 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 132 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

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

Definition at line 129 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

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

Definition at line 130 of file pg_backup_archiver.h.

◆ ReadBufPtrType

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

Definition at line 126 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 124 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

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

Definition at line 128 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 111 of file pg_backup_archiver.h.

◆ StartDataPtrType

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

Definition at line 114 of file pg_backup_archiver.h.

◆ StartLOPtrType

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

Definition at line 119 of file pg_backup_archiver.h.

◆ StartLOsPtrType

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

Definition at line 118 of file pg_backup_archiver.h.

◆ T_Action

typedef enum T_Action T_Action

◆ TocEntry

typedef struct _tocEntry TocEntry

Definition at line 1 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

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

Definition at line 136 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

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

Definition at line 137 of file pg_backup_archiver.h.

◆ WriteBufPtrType

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

Definition at line 125 of file pg_backup_archiver.h.

◆ WriteBytePtrType

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

Definition at line 123 of file pg_backup_archiver.h.

◆ WriteDataPtrType

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

Definition at line 115 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

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

Definition at line 127 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

Enumerator
OUTPUT_SQLCMDS 
OUTPUT_COPYDATA 
OUTPUT_OTHERDATA 

Definition at line 163 of file pg_backup_archiver.h.

165 {
166  STAGE_NONE = 0,
@ STAGE_INITIALIZING
@ STAGE_PROCESSING
@ STAGE_NONE

◆ ArchiverStage

Enumerator
STAGE_NONE 
STAGE_INITIALIZING 
STAGE_PROCESSING 
STAGE_FINALIZING 

Definition at line 155 of file pg_backup_archiver.h.

158 {
159  sqlparseState state; /* see above */
160  bool backSlash; /* next char is backslash quoted? */
161  PQExpBuffer curCmd; /* incomplete line (NULL if not created) */
sqlparseState
Definition: regguts.h:323

◆ RestorePass

Enumerator
RESTORE_PASS_MAIN 
RESTORE_PASS_ACL 
RESTORE_PASS_POST_ACL 

Definition at line 189 of file pg_backup_archiver.h.

199 {

◆ sqlparseState

Enumerator
SQL_SCAN 
SQL_IN_SINGLE_QUOTE 
SQL_IN_DOUBLE_QUOTE 

Definition at line 141 of file pg_backup_archiver.h.

151 {

◆ T_Action

enum T_Action
Enumerator
ACT_DUMP 
ACT_RESTORE 

Definition at line 104 of file pg_backup_archiver.h.

105  : %m"); \
106  } while (0)
107 
108 #define WRITE_ERROR_EXIT \

Function Documentation

◆ ahprintf()

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

◆ ahwrite()

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

Definition at line 1687 of file pg_backup_archiver.c.

1688 {
1689  int bytes_written = 0;
1690 
1691  if (AH->writingLO)
1692  {
1693  size_t remaining = size * nmemb;
1694 
1695  while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1696  {
1697  size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1698 
1699  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1700  ptr = (const void *) ((const char *) ptr + avail);
1701  remaining -= avail;
1702  AH->lo_buf_used += avail;
1703  dump_lo_buf(AH);
1704  }
1705 
1706  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1707  AH->lo_buf_used += remaining;
1708 
1709  bytes_written = size * nmemb;
1710  }
1711  else if (AH->CustomOutPtr)
1712  bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1713 
1714  /*
1715  * If we're doing a restore, and it's direct to DB, and we're connected
1716  * then send it to the DB.
1717  */
1718  else if (RestoringToDB(AH))
1719  bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1720  else
1721  {
1722  CompressFileHandle *CFH = (CompressFileHandle *) AH->OF;
1723 
1724  if (CFH->write_func(ptr, size * nmemb, CFH))
1725  bytes_written = size * nmemb;
1726  }
1727 
1728  if (bytes_written != size * nmemb)
1730 }
int remaining
Definition: informix.c:667
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
static int RestoringToDB(ArchiveHandle *AH)
static void dump_lo_buf(ArchiveHandle *AH)
#define WRITE_ERROR_EXIT
int ExecuteSqlCommandBuf(Archive *AHX, const char *buf, size_t bufLen)
Definition: pg_backup_db.c:445
bool(* write_func)(const void *ptr, size_t size, struct CompressFileHandle *CFH)
Definition: compress_io.h:139
CustomOutPtrType CustomOutPtr

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

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

◆ ArchiveEntry()

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

Definition at line 1097 of file pg_backup_archiver.c.

1099 {
1100  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1101  TocEntry *newToc;
1102 
1103  newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
1104 
1105  AH->tocCount++;
1106  if (dumpId > AH->maxDumpId)
1107  AH->maxDumpId = dumpId;
1108 
1109  newToc->prev = AH->toc->prev;
1110  newToc->next = AH->toc;
1111  AH->toc->prev->next = newToc;
1112  AH->toc->prev = newToc;
1113 
1114  newToc->catalogId = catalogId;
1115  newToc->dumpId = dumpId;
1116  newToc->section = opts->section;
1117 
1118  newToc->tag = pg_strdup(opts->tag);
1119  newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
1120  newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
1121  newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
1122  newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
1123  newToc->desc = pg_strdup(opts->description);
1124  newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
1125  newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
1126  newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
1127 
1128  if (opts->nDeps > 0)
1129  {
1130  newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
1131  memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
1132  newToc->nDeps = opts->nDeps;
1133  }
1134  else
1135  {
1136  newToc->dependencies = NULL;
1137  newToc->nDeps = 0;
1138  }
1139 
1140  newToc->dataDumper = opts->dumpFn;
1141  newToc->dataDumperArg = opts->dumpArg;
1142  newToc->hadDumper = opts->dumpFn ? true : false;
1143 
1144  newToc->formatData = NULL;
1145  newToc->dataLength = 0;
1146 
1147  if (AH->ArchiveEntryPtr != NULL)
1148  AH->ArchiveEntryPtr(AH, newToc);
1149 
1150  return newToc;
1151 }
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
return true
Definition: isn.c:126
static AmcheckOptions opts
Definition: pg_amcheck.c:111
int DumpId
Definition: pg_backup.h:268
struct _tocEntry * toc
ArchiveEntryPtrType ArchiveEntryPtr
struct _tocEntry * prev
teSection section
DataDumperPtr dataDumper
pgoff_t dataLength
CatalogId catalogId
struct _tocEntry * next
const void * dataDumperArg
DumpId * dependencies

References _archiveHandle::ArchiveEntryPtr, _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, _tocEntry::formatData, _tocEntry::hadDumper, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, opts, _tocEntry::owner, pg_malloc(), pg_malloc0(), pg_strdup(), _tocEntry::prev, _tocEntry::section, _tocEntry::tableam, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and true.

Referenced by dumpAccessMethod(), dumpACL(), dumpAgg(), dumpAttrDef(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCommentExtended(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpLO(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationNamespace(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpSubscriptionTable(), dumpTableAttach(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

◆ checkSeek()

bool checkSeek ( FILE *  fp)

Definition at line 3867 of file pg_backup_archiver.c.

3868 {
3869  pgoff_t tpos;
3870 
3871  /* Check that ftello works on this file */
3872  tpos = ftello(fp);
3873  if (tpos < 0)
3874  return false;
3875 
3876  /*
3877  * Check that fseeko(SEEK_SET) works, too. NB: we used to try to test
3878  * this with fseeko(fp, 0, SEEK_CUR). But some platforms treat that as a
3879  * successful no-op even on files that are otherwise unseekable.
3880  */
3881  if (fseeko(fp, tpos, SEEK_SET) != 0)
3882  return false;
3883 
3884  return true;
3885 }
#define ftello(stream)
Definition: win32_port.h:219
#define fseeko(stream, offset, origin)
Definition: win32_port.h:216
#define pgoff_t
Definition: win32_port.h:207

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle AH)

Definition at line 4726 of file pg_backup_archiver.c.

4727 {
4728  ArchiveHandle *clone;
4729 
4730  /* Make a "flat" copy */
4731  clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
4732  memcpy(clone, AH, sizeof(ArchiveHandle));
4733 
4734  /* Handle format-independent fields */
4735  memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
4736 
4737  /* The clone will have its own connection, so disregard connection state */
4738  clone->connection = NULL;
4739  clone->connCancel = NULL;
4740  clone->currUser = NULL;
4741  clone->currSchema = NULL;
4742  clone->currTableAm = NULL;
4743  clone->currTablespace = NULL;
4744 
4745  /* savedPassword must be local in case we change it while connecting */
4746  if (clone->savedPassword)
4747  clone->savedPassword = pg_strdup(clone->savedPassword);
4748 
4749  /* clone has its own error count, too */
4750  clone->public.n_errors = 0;
4751 
4752  /*
4753  * Connect our new clone object to the database, using the same connection
4754  * parameters used for the original connection.
4755  */
4756  ConnectDatabase((Archive *) clone, &clone->public.ropt->cparams, true);
4757 
4758  /* re-establish fixed state */
4759  if (AH->mode == archModeRead)
4760  _doSetFixedOutputState(clone);
4761  /* in write case, setupDumpWorker will fix up connection state */
4762 
4763  /* Let the format-specific code have a chance too */
4764  clone->ClonePtr(clone);
4765 
4766  Assert(clone->connection != NULL);
4767  return clone;
4768 }
Assert(fmt[strlen(fmt) - 1] !='\n')
void ConnectDatabase(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition: pg_backup_db.c:110
@ archModeRead
Definition: pg_backup.h:52
static void _doSetFixedOutputState(ArchiveHandle *AH)
int n_errors
Definition: pg_backup.h:236
RestoreOptions * ropt
Definition: pg_backup.h:213
PGcancel *volatile connCancel
ClonePtrType ClonePtr
sqlparseInfo sqlparse
ConnParams cparams
Definition: pg_backup.h:144

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

Referenced by RunWorker().

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle AH)

Definition at line 4776 of file pg_backup_archiver.c.

4777 {
4778  /* Should not have an open database connection */
4779  Assert(AH->connection == NULL);
4780 
4781  /* Clear format-specific state */
4782  AH->DeClonePtr(AH);
4783 
4784  /* Clear state allocated by CloneArchive */
4785  if (AH->sqlparse.curCmd)
4787 
4788  /* Clear any connection-local state */
4789  free(AH->currUser);
4790  free(AH->currSchema);
4791  free(AH->currTablespace);
4792  free(AH->currTableAm);
4793  free(AH->savedPassword);
4794 
4795  free(AH);
4796 }
#define free(a)
Definition: header.h:65
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:114
DeClonePtrType DeClonePtr
PQExpBuffer curCmd

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

Referenced by RunWorker().

◆ DropLOIfExists()

void DropLOIfExists ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 545 of file pg_backup_db.c.

546 {
547  /*
548  * If we are not restoring to a direct database connection, we have to
549  * guess about how to detect whether the LO exists. Assume new-style.
550  */
551  if (AH->connection == NULL ||
552  PQserverVersion(AH->connection) >= 90000)
553  {
554  ahprintf(AH,
555  "SELECT pg_catalog.lo_unlink(oid) "
556  "FROM pg_catalog.pg_largeobject_metadata "
557  "WHERE oid = '%u';\n",
558  oid);
559  }
560  else
561  {
562  /* Restoring to pre-9.0 server, so do it the old way */
563  ahprintf(AH,
564  "SELECT CASE WHEN EXISTS("
565  "SELECT 1 FROM pg_catalog.pg_largeobject WHERE loid = '%u'"
566  ") THEN pg_catalog.lo_unlink('%u') END;\n",
567  oid, oid);
568  }
569 }
int PQserverVersion(const PGconn *conn)
Definition: fe-connect.c:6831
int ahprintf(ArchiveHandle *AH, const char *fmt,...)

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

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

◆ EndRestoreLO()

void EndRestoreLO ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 1382 of file pg_backup_archiver.c.

1383 {
1384  if (AH->lo_buf_used > 0)
1385  {
1386  /* Write remaining bytes from the LO buffer */
1387  dump_lo_buf(AH);
1388  }
1389 
1390  AH->writingLO = false;
1391 
1392  if (AH->connection)
1393  {
1394  lo_close(AH->connection, AH->loFd);
1395  AH->loFd = -1;
1396  }
1397  else
1398  {
1399  ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
1400  }
1401 }
int lo_close(PGconn *conn, int fd)
Definition: fe-lobj.c:96

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

Referenced by _LoadLOs().

◆ EndRestoreLOs()

void EndRestoreLOs ( ArchiveHandle AH)

Definition at line 1315 of file pg_backup_archiver.c.

1316 {
1317  RestoreOptions *ropt = AH->public.ropt;
1318 
1319  if (!ropt->single_txn)
1320  {
1321  if (AH->connection)
1322  CommitTransaction(&AH->public);
1323  else
1324  ahprintf(AH, "COMMIT;\n\n");
1325  }
1326 
1327  pg_log_info(ngettext("restored %d large object",
1328  "restored %d large objects",
1329  AH->loCount),
1330  AH->loCount);
1331 }
#define ngettext(s, p, n)
Definition: c.h:1170
#define pg_log_info(...)
Definition: logging.h:124
static void CommitTransaction(void)
Definition: xact.c:2156

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

Referenced by _LoadLOs().

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1867 of file pg_backup_archiver.c.

1868 {
1869  /* build index arrays if we didn't already */
1870  if (AH->tocsByDumpId == NULL)
1871  buildTocEntryArrays(AH);
1872 
1873  if (id > 0 && id <= AH->maxDumpId)
1874  return AH->tocsByDumpId[id];
1875 
1876  return NULL;
1877 }
static void buildTocEntryArrays(ArchiveHandle *AH)
struct _tocEntry ** tocsByDumpId

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

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

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle AH)

Definition at line 106 of file pg_backup_custom.c.

107 {
108  lclContext *ctx;
109 
110  /* Assuming static functions, this can be copied for each format. */
112  AH->StartDataPtr = _StartData;
113  AH->WriteDataPtr = _WriteData;
114  AH->EndDataPtr = _EndData;
115  AH->WriteBytePtr = _WriteByte;
116  AH->ReadBytePtr = _ReadByte;
117  AH->WriteBufPtr = _WriteBuf;
118  AH->ReadBufPtr = _ReadBuf;
119  AH->ClosePtr = _CloseArchive;
125 
126  AH->StartLOsPtr = _StartLOs;
127  AH->StartLOPtr = _StartLO;
128  AH->EndLOPtr = _EndLO;
129  AH->EndLOsPtr = _EndLOs;
130 
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  /*
148  * Now open the file
149  */
150  if (AH->mode == archModeWrite)
151  {
152  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
153  {
154  AH->FH = fopen(AH->fSpec, PG_BINARY_W);
155  if (!AH->FH)
156  pg_fatal("could not open output file \"%s\": %m", AH->fSpec);
157  }
158  else
159  {
160  AH->FH = stdout;
161  if (!AH->FH)
162  pg_fatal("could not open output file: %m");
163  }
164 
165  ctx->hasSeek = checkSeek(AH->FH);
166  }
167  else
168  {
169  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
170  {
171  AH->FH = fopen(AH->fSpec, PG_BINARY_R);
172  if (!AH->FH)
173  pg_fatal("could not open input file \"%s\": %m", AH->fSpec);
174  }
175  else
176  {
177  AH->FH = stdin;
178  if (!AH->FH)
179  pg_fatal("could not open input file: %m");
180  }
181 
182  ctx->hasSeek = checkSeek(AH->FH);
183 
184  ReadHead(AH);
185  ReadToc(AH);
186 
187  /*
188  * Remember location of first data block (i.e., the point after TOC)
189  * in case we have to search for desired data blocks.
190  */
191  ctx->lastFilePos = _getFilePos(AH, ctx);
192  }
193 }
#define PG_BINARY_R
Definition: c.h:1264
#define PG_BINARY_W
Definition: c.h:1265
@ archModeWrite
Definition: pg_backup.h:51
bool checkSeek(FILE *fp)
void ReadHead(ArchiveHandle *AH)
void ReadToc(ArchiveHandle *AH)
#define LOBBUFSIZE
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
static pgoff_t _getFilePos(ArchiveHandle *AH, lclContext *ctx)
static void _DeClone(ArchiveHandle *AH)
static void _ReopenArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _PrepParallelRestore(ArchiveHandle *AH)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static int _ReadByte(ArchiveHandle *AH)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static int _WorkerJobRestoreCustom(ArchiveHandle *AH, TocEntry *te)
static void _Clone(ArchiveHandle *AH)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
EndLOsPtrType EndLOsPtr
ReadExtraTocPtrType ReadExtraTocPtr
WorkerJobDumpPtrType WorkerJobDumpPtr
StartLOsPtrType StartLOsPtr
WriteDataPtrType WriteDataPtr
StartLOPtrType StartLOPtr
WriteBufPtrType WriteBufPtr
PrepParallelRestorePtrType PrepParallelRestorePtr
EndLOPtrType EndLOPtr
WriteExtraTocPtrType WriteExtraTocPtr
ReadBytePtrType ReadBytePtr
WorkerJobRestorePtrType WorkerJobRestorePtr
PrintTocDataPtrType PrintTocDataPtr
WriteBytePtrType WriteBytePtr
ReadBufPtrType ReadBufPtr
PrintExtraTocPtrType PrintExtraTocPtr
StartDataPtrType StartDataPtr
ReopenPtrType ReopenPtr
EndDataPtrType EndDataPtr
ClosePtrType ClosePtr
pgoff_t lastFilePos

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

Referenced by _allocAH().

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle AH)

Definition at line 107 of file pg_backup_directory.c.

108 {
109  lclContext *ctx;
110 
111  /* Assuming static functions, this can be copied for each format. */
113  AH->StartDataPtr = _StartData;
114  AH->WriteDataPtr = _WriteData;
115  AH->EndDataPtr = _EndData;
116  AH->WriteBytePtr = _WriteByte;
117  AH->ReadBytePtr = _ReadByte;
118  AH->WriteBufPtr = _WriteBuf;
119  AH->ReadBufPtr = _ReadBuf;
120  AH->ClosePtr = _CloseArchive;
126 
127  AH->StartLOsPtr = _StartLOs;
128  AH->StartLOPtr = _StartLO;
129  AH->EndLOPtr = _EndLO;
130  AH->EndLOsPtr = _EndLOs;
131 
133  AH->ClonePtr = _Clone;
134  AH->DeClonePtr = _DeClone;
135 
138 
139  /* Set up our private context */
140  ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
141  AH->formatData = (void *) ctx;
142 
143  ctx->dataFH = NULL;
144  ctx->LOsTocFH = NULL;
145 
146  /* Initialize LO buffering */
147  AH->lo_buf_size = LOBBUFSIZE;
148  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
149 
150  /*
151  * Now open the TOC file
152  */
153 
154  if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
155  pg_fatal("no output directory specified");
156 
157  ctx->directory = AH->fSpec;
158 
159  if (AH->mode == archModeWrite)
160  {
161  struct stat st;
162  bool is_empty = false;
163 
164  /* we accept an empty existing directory */
165  if (stat(ctx->directory, &st) == 0 && S_ISDIR(st.st_mode))
166  {
167  DIR *dir = opendir(ctx->directory);
168 
169  if (dir)
170  {
171  struct dirent *d;
172 
173  is_empty = true;
174  while (errno = 0, (d = readdir(dir)))
175  {
176  if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0)
177  {
178  is_empty = false;
179  break;
180  }
181  }
182 
183  if (errno)
184  pg_fatal("could not read directory \"%s\": %m",
185  ctx->directory);
186 
187  if (closedir(dir))
188  pg_fatal("could not close directory \"%s\": %m",
189  ctx->directory);
190  }
191  }
192 
193  if (!is_empty && mkdir(ctx->directory, 0700) < 0)
194  pg_fatal("could not create directory \"%s\": %m",
195  ctx->directory);
196  }
197  else
198  { /* Read Mode */
199  char fname[MAXPGPATH];
200  CompressFileHandle *tocFH;
201 
202  setFilePath(AH, fname, "toc.dat");
203 
205  if (tocFH == NULL)
206  pg_fatal("could not open input file \"%s\": %m", fname);
207 
208  ctx->dataFH = tocFH;
209 
210  /*
211  * The TOC of a directory format dump shares the format code of the
212  * tar format.
213  */
214  AH->format = archTar;
215  ReadHead(AH);
216  AH->format = archDirectory;
217  ReadToc(AH);
218 
219  /* Nothing else in the file, so close it again... */
220  if (!EndCompressFileHandle(tocFH))
221  pg_fatal("could not close TOC file: %m");
222  ctx->dataFH = NULL;
223  }
224 }
bool EndCompressFileHandle(CompressFileHandle *CFH)
Definition: compress_io.c:289
CompressFileHandle * InitDiscoverCompressFileHandle(const char *path, const char *mode)
Definition: compress_io.c:241
int closedir(DIR *)
Definition: dirent.c:127
struct dirent * readdir(DIR *)
Definition: dirent.c:78
DIR * opendir(const char *)
Definition: dirent.c:33
@ archTar
Definition: pg_backup.h:43
@ archDirectory
Definition: pg_backup.h:45
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
static void _DeClone(ArchiveHandle *AH)
static void _ReopenArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _PrepParallelRestore(ArchiveHandle *AH)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static int _ReadByte(ArchiveHandle *AH)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _Clone(ArchiveHandle *AH)
static int _WorkerJobRestoreDirectory(ArchiveHandle *AH, TocEntry *te)
static void setFilePath(ArchiveHandle *AH, char *buf, const char *relativeFilename)
static int _WorkerJobDumpDirectory(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
#define MAXPGPATH
Definition: dirent.c:26
ArchiveFormat format
Definition: dirent.h:10
char d_name[MAX_PATH]
Definition: dirent.h:15
CompressFileHandle * LOsTocFH
CompressFileHandle * dataFH
#define stat
Definition: win32_port.h:284
#define S_ISDIR(m)
Definition: win32_port.h:325
#define mkdir(a, b)
Definition: win32_port.h:80

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

Referenced by _allocAH().

◆ InitArchiveFmt_Null()

void InitArchiveFmt_Null ( ArchiveHandle AH)

Definition at line 48 of file pg_backup_null.c.

49 {
50  /* Assuming static functions, this can be copied for each format. */
52  AH->EndDataPtr = _EndData;
54  AH->WriteBufPtr = _WriteBuf;
55  AH->ClosePtr = _CloseArchive;
56  AH->ReopenPtr = NULL;
58 
59  AH->StartLOsPtr = _StartLOs;
60  AH->StartLOPtr = _StartLO;
61  AH->EndLOPtr = _EndLO;
62  AH->EndLOsPtr = _EndLOs;
63  AH->ClonePtr = NULL;
64  AH->DeClonePtr = NULL;
65 
66  /* Initialize LO buffering */
67  AH->lo_buf_size = LOBBUFSIZE;
68  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
69 
70  /*
71  * Now prevent reading...
72  */
73  if (AH->mode == archModeRead)
74  pg_fatal("this format cannot be read");
75 }
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _CloseArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)

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

Referenced by _allocAH().

◆ InitArchiveFmt_Tar()

void InitArchiveFmt_Tar ( ArchiveHandle AH)

Definition at line 121 of file pg_backup_tar.c.

122 {
123  lclContext *ctx;
124 
125  /* Assuming static functions, this can be copied for each format. */
127  AH->StartDataPtr = _StartData;
128  AH->WriteDataPtr = _WriteData;
129  AH->EndDataPtr = _EndData;
130  AH->WriteBytePtr = _WriteByte;
131  AH->ReadBytePtr = _ReadByte;
132  AH->WriteBufPtr = _WriteBuf;
133  AH->ReadBufPtr = _ReadBuf;
134  AH->ClosePtr = _CloseArchive;
135  AH->ReopenPtr = NULL;
140 
141  AH->StartLOsPtr = _StartLOs;
142  AH->StartLOPtr = _StartLO;
143  AH->EndLOPtr = _EndLO;
144  AH->EndLOsPtr = _EndLOs;
145  AH->ClonePtr = NULL;
146  AH->DeClonePtr = NULL;
147 
148  AH->WorkerJobDumpPtr = NULL;
149  AH->WorkerJobRestorePtr = NULL;
150 
151  /*
152  * Set up some special context used in compressing data.
153  */
155  AH->formatData = (void *) ctx;
156  ctx->filePos = 0;
157  ctx->isSpecialScript = 0;
158 
159  /* Initialize LO buffering */
160  AH->lo_buf_size = LOBBUFSIZE;
161  AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
162 
163  /*
164  * Now open the tar file, and load the TOC if we're in read mode.
165  */
166  if (AH->mode == archModeWrite)
167  {
168  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
169  {
170  ctx->tarFH = fopen(AH->fSpec, PG_BINARY_W);
171  if (ctx->tarFH == NULL)
172  pg_fatal("could not open TOC file \"%s\" for output: %m",
173  AH->fSpec);
174  }
175  else
176  {
177  ctx->tarFH = stdout;
178  if (ctx->tarFH == NULL)
179  pg_fatal("could not open TOC file for output: %m");
180  }
181 
182  ctx->tarFHpos = 0;
183 
184  /*
185  * Make unbuffered since we will dup() it, and the buffers screw each
186  * other
187  */
188  /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
189 
190  ctx->hasSeek = checkSeek(ctx->tarFH);
191 
192  /*
193  * We don't support compression because reading the files back is not
194  * possible since gzdopen uses buffered IO which totally screws file
195  * positioning.
196  */
198  pg_fatal("compression is not supported by tar archive format");
199  }
200  else
201  { /* Read Mode */
202  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
203  {
204  ctx->tarFH = fopen(AH->fSpec, PG_BINARY_R);
205  if (ctx->tarFH == NULL)
206  pg_fatal("could not open TOC file \"%s\" for input: %m",
207  AH->fSpec);
208  }
209  else
210  {
211  ctx->tarFH = stdin;
212  if (ctx->tarFH == NULL)
213  pg_fatal("could not open TOC file for input: %m");
214  }
215 
216  /*
217  * Make unbuffered since we will dup() it, and the buffers screw each
218  * other
219  */
220  /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
221 
222  ctx->tarFHpos = 0;
223 
224  ctx->hasSeek = checkSeek(ctx->tarFH);
225 
226  ctx->FH = (void *) tarOpen(AH, "toc.dat", 'r');
227  ReadHead(AH);
228  ReadToc(AH);
229  tarClose(AH, ctx->FH); /* Nothing else in the file... */
230  }
231 }
@ PG_COMPRESSION_NONE
Definition: compression.h:23
#define pg_malloc0_object(type)
Definition: fe_memutils.h:39
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static int _ReadByte(ArchiveHandle *AH)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static TAR_MEMBER * tarOpen(ArchiveHandle *AH, const char *filename, char mode)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
static void tarClose(ArchiveHandle *AH, TAR_MEMBER *th)
pg_compress_specification compression_spec
FILE * tarFH
Definition: pg_backup_tar.c:83
pgoff_t filePos
Definition: pg_backup_tar.c:81
pgoff_t tarFHpos
Definition: pg_backup_tar.c:84
TAR_MEMBER * FH
Definition: pg_backup_tar.c:86
int isSpecialScript
Definition: pg_backup_tar.c:87
pg_compress_algorithm algorithm
Definition: compression.h:34

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

Referenced by _allocAH().

◆ isValidTarHeader()

bool isValidTarHeader ( char *  header)

Definition at line 973 of file pg_backup_tar.c.

974 {
975  int sum;
976  int chk = tarChecksum(header);
977 
978  sum = read_tar_number(&header[TAR_OFFSET_CHECKSUM], 8);
979 
980  if (sum != chk)
981  return false;
982 
983  /* POSIX tar format */
984  if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar\0", 6) == 0 &&
985  memcmp(&header[TAR_OFFSET_VERSION], "00", 2) == 0)
986  return true;
987  /* GNU tar format */
988  if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar \0", 8) == 0)
989  return true;
990  /* not-quite-POSIX format written by pre-9.3 pg_dump */
991  if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar00\0", 8) == 0)
992  return true;
993 
994  return false;
995 }
uint64 read_tar_number(const char *s, int len)
Definition: tar.c:58
int tarChecksum(char *header)
Definition: tar.c:90
@ TAR_OFFSET_VERSION
Definition: pgtar.h:49
@ TAR_OFFSET_CHECKSUM
Definition: pgtar.h:45
@ TAR_OFFSET_MAGIC
Definition: pgtar.h:48

References read_tar_number(), TAR_OFFSET_CHECKSUM, TAR_OFFSET_MAGIC, TAR_OFFSET_VERSION, and tarChecksum().

Referenced by _discoverArchiveFormat().

◆ on_exit_close_archive()

void on_exit_close_archive ( Archive AHX)

Definition at line 328 of file parallel.c.

329 {
330  shutdown_info.AHX = AHX;
332 }
static void archive_close_connection(int code, void *arg)
Definition: parallel.c:339
static ShutdownInformation shutdown_info
Definition: parallel.c:152
void on_exit_nicely(on_exit_nicely_callback function, void *arg)

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

Referenced by main().

◆ parallel_restore()

int parallel_restore ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 4359 of file pg_backup_archiver.c.

4360 {
4361  int status;
4362 
4363  Assert(AH->connection != NULL);
4364 
4365  /* Count only errors associated with this TOC entry */
4366  AH->public.n_errors = 0;
4367 
4368  /* Restore the TOC item */
4369  status = restore_toc_entry(AH, te, true);
4370 
4371  return status;
4372 }
static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel)

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

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

◆ ReadHead()

void ReadHead ( ArchiveHandle AH)

Definition at line 3733 of file pg_backup_archiver.c.

3734 {
3735  char *errmsg;
3736  char vmaj,
3737  vmin,
3738  vrev;
3739  int fmt;
3740 
3741  /*
3742  * If we haven't already read the header, do so.
3743  *
3744  * NB: this code must agree with _discoverArchiveFormat(). Maybe find a
3745  * way to unify the cases?
3746  */
3747  if (!AH->readHeader)
3748  {
3749  char tmpMag[7];
3750 
3751  AH->ReadBufPtr(AH, tmpMag, 5);
3752 
3753  if (strncmp(tmpMag, "PGDMP", 5) != 0)
3754  pg_fatal("did not find magic string in file header");
3755  }
3756 
3757  vmaj = AH->ReadBytePtr(AH);
3758  vmin = AH->ReadBytePtr(AH);
3759 
3760  if (vmaj > 1 || (vmaj == 1 && vmin > 0)) /* Version > 1.0 */
3761  vrev = AH->ReadBytePtr(AH);
3762  else
3763  vrev = 0;
3764 
3765  AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
3766 
3767  if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
3768  pg_fatal("unsupported version (%d.%d) in file header",
3769  vmaj, vmin);
3770 
3771  AH->intSize = AH->ReadBytePtr(AH);
3772  if (AH->intSize > 32)
3773  pg_fatal("sanity check on integer size (%lu) failed",
3774  (unsigned long) AH->intSize);
3775 
3776  if (AH->intSize > sizeof(int))
3777  pg_log_warning("archive was made on a machine with larger integers, some operations might fail");
3778 
3779  if (AH->version >= K_VERS_1_7)
3780  AH->offSize = AH->ReadBytePtr(AH);
3781  else
3782  AH->offSize = AH->intSize;
3783 
3784  fmt = AH->ReadBytePtr(AH);
3785 
3786  if (AH->format != fmt)
3787  pg_fatal("expected format (%d) differs from format found in file (%d)",
3788  AH->format, fmt);
3789 
3790  if (AH->version >= K_VERS_1_15)
3791  AH->compression_spec.algorithm = AH->ReadBytePtr(AH);
3792  else if (AH->version >= K_VERS_1_2)
3793  {
3794  /* Guess the compression method based on the level */
3795  if (AH->version < K_VERS_1_4)
3796  AH->compression_spec.level = AH->ReadBytePtr(AH);
3797  else
3798  AH->compression_spec.level = ReadInt(AH);
3799 
3800  if (AH->compression_spec.level != 0)
3802  }
3803  else
3805 
3807  if (errmsg)
3808  {
3809  pg_log_warning("archive is compressed, but this installation does not support compression (%s) -- no data will be available",
3810  errmsg);
3811  pg_free(errmsg);
3812  }
3813 
3814  if (AH->version >= K_VERS_1_4)
3815  {
3816  struct tm crtm;
3817 
3818  crtm.tm_sec = ReadInt(AH);
3819  crtm.tm_min = ReadInt(AH);
3820  crtm.tm_hour = ReadInt(AH);
3821  crtm.tm_mday = ReadInt(AH);
3822  crtm.tm_mon = ReadInt(AH);
3823  crtm.tm_year = ReadInt(AH);
3824  crtm.tm_isdst = ReadInt(AH);
3825 
3826  /*
3827  * Newer versions of glibc have mktime() report failure if tm_isdst is
3828  * inconsistent with the prevailing timezone, e.g. tm_isdst = 1 when
3829  * TZ=UTC. This is problematic when restoring an archive under a
3830  * different timezone setting. If we get a failure, try again with
3831  * tm_isdst set to -1 ("don't know").
3832  *
3833  * XXX with or without this hack, we reconstruct createDate
3834  * incorrectly when the prevailing timezone is different from
3835  * pg_dump's. Next time we bump the archive version, we should flush
3836  * this representation and store a plain seconds-since-the-Epoch
3837  * timestamp instead.
3838  */
3839  AH->createDate = mktime(&crtm);
3840  if (AH->createDate == (time_t) -1)
3841  {
3842  crtm.tm_isdst = -1;
3843  AH->createDate = mktime(&crtm);
3844  if (AH->createDate == (time_t) -1)
3845  pg_log_warning("invalid creation date in header");
3846  }
3847  }
3848 
3849  if (AH->version >= K_VERS_1_4)
3850  {
3851  AH->archdbname = ReadStr(AH);
3852  }
3853 
3854  if (AH->version >= K_VERS_1_10)
3855  {
3856  AH->archiveRemoteVersion = ReadStr(AH);
3857  AH->archiveDumpVersion = ReadStr(AH);
3858  }
3859 }
char * supports_compression(const pg_compress_specification compression_spec)
Definition: compress_io.c:88
@ PG_COMPRESSION_GZIP
Definition: compression.h:24
int errmsg(const char *fmt,...)
Definition: elog.c:1075
void pg_free(void *ptr)
Definition: fe_memutils.c:105
static void const char * fmt
static struct pg_tm tm
Definition: localtime.c:104
char * ReadStr(ArchiveHandle *AH)
int ReadInt(ArchiveHandle *AH)
#define K_VERS_1_15
#define K_VERS_1_10
#define K_VERS_1_2
#define K_VERS_1_4
#define K_VERS_1_0
#define K_VERS_MAX
#define K_VERS_1_7
#define pg_log_warning(...)
Definition: pgfnames.c:24
int tm_sec
Definition: pgtime.h:36

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

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

◆ ReadInt()

int ReadInt ( ArchiveHandle AH)

Definition at line 2003 of file pg_backup_archiver.c.

2004 {
2005  int res = 0;
2006  int bv,
2007  b;
2008  int sign = 0; /* Default positive */
2009  int bitShift = 0;
2010 
2011  if (AH->version > K_VERS_1_0)
2012  /* Read a sign byte */
2013  sign = AH->ReadBytePtr(AH);
2014 
2015  for (b = 0; b < AH->intSize; b++)
2016  {
2017  bv = AH->ReadBytePtr(AH) & 0xFF;
2018  if (bv != 0)
2019  res = res + (bv << bitShift);
2020  bitShift += 8;
2021  }
2022 
2023  if (sign)
2024  res = -res;
2025 
2026  return res;
2027 }
char sign
Definition: informix.c:668
int b
Definition: isn.c:70

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

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

◆ ReadOffset()

int ReadOffset ( ArchiveHandle AH,
pgoff_t o 
)

Definition at line 1908 of file pg_backup_archiver.c.

1909 {
1910  int i;
1911  int off;
1912  int offsetFlg;
1913 
1914  /* Initialize to zero */
1915  *o = 0;
1916 
1917  /* Check for old version */
1918  if (AH->version < K_VERS_1_7)
1919  {
1920  /* Prior versions wrote offsets using WriteInt */
1921  i = ReadInt(AH);
1922  /* -1 means not set */
1923  if (i < 0)
1924  return K_OFFSET_POS_NOT_SET;
1925  else if (i == 0)
1926  return K_OFFSET_NO_DATA;
1927 
1928  /* Cast to pgoff_t because it was written as an int. */
1929  *o = (pgoff_t) i;
1930  return K_OFFSET_POS_SET;
1931  }
1932 
1933  /*
1934  * Read the flag indicating the state of the data pointer. Check if valid
1935  * and die if not.
1936  *
1937  * This used to be handled by a negative or zero pointer, now we use an
1938  * extra byte specifically for the state.
1939  */
1940  offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
1941 
1942  switch (offsetFlg)
1943  {
1944  case K_OFFSET_POS_NOT_SET:
1945  case K_OFFSET_NO_DATA:
1946  case K_OFFSET_POS_SET:
1947 
1948  break;
1949 
1950  default:
1951  pg_fatal("unexpected data offset flag %d", offsetFlg);
1952  }
1953 
1954  /*
1955  * Read the bytes
1956  */
1957  for (off = 0; off < AH->offSize; off++)
1958  {
1959  if (off < sizeof(pgoff_t))
1960  *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
1961  else
1962  {
1963  if (AH->ReadBytePtr(AH) != 0)
1964  pg_fatal("file offset in dump file is too large");
1965  }
1966  }
1967 
1968  return offsetFlg;
1969 }
int i
Definition: isn.c:73
#define K_OFFSET_NO_DATA
#define K_OFFSET_POS_NOT_SET
#define K_OFFSET_POS_SET

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

Referenced by _ReadExtraToc().

◆ ReadStr()

char* ReadStr ( ArchiveHandle AH)

Definition at line 2049 of file pg_backup_archiver.c.

2050 {
2051  char *buf;
2052  int l;
2053 
2054  l = ReadInt(AH);
2055  if (l < 0)
2056  buf = NULL;
2057  else
2058  {
2059  buf = (char *) pg_malloc(l + 1);
2060  AH->ReadBufPtr(AH, (void *) buf, l);
2061 
2062  buf[l] = '\0';
2063  }
2064 
2065  return buf;
2066 }
static char * buf
Definition: pg_test_fsync.c:73

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

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

◆ ReadToc()

void ReadToc ( ArchiveHandle AH)

Definition at line 2508 of file pg_backup_archiver.c.

2509 {
2510  int i;
2511  char *tmp;
2512  DumpId *deps;
2513  int depIdx;
2514  int depSize;
2515  TocEntry *te;
2516  bool is_supported;
2517 
2518  AH->tocCount = ReadInt(AH);
2519  AH->maxDumpId = 0;
2520 
2521  for (i = 0; i < AH->tocCount; i++)
2522  {
2523  te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
2524  te->dumpId = ReadInt(AH);
2525 
2526  if (te->dumpId > AH->maxDumpId)
2527  AH->maxDumpId = te->dumpId;
2528 
2529  /* Sanity check */
2530  if (te->dumpId <= 0)
2531  pg_fatal("entry ID %d out of range -- perhaps a corrupt TOC",
2532  te->dumpId);
2533 
2534  te->hadDumper = ReadInt(AH);
2535 
2536  if (AH->version >= K_VERS_1_8)
2537  {
2538  tmp = ReadStr(AH);
2539  sscanf(tmp, "%u", &te->catalogId.tableoid);
2540  free(tmp);
2541  }
2542  else
2544  tmp = ReadStr(AH);
2545  sscanf(tmp, "%u", &te->catalogId.oid);
2546  free(tmp);
2547 
2548  te->tag = ReadStr(AH);
2549  te->desc = ReadStr(AH);
2550 
2551  if (AH->version >= K_VERS_1_11)
2552  {
2553  te->section = ReadInt(AH);
2554  }
2555  else
2556  {
2557  /*
2558  * Rules for pre-8.4 archives wherein pg_dump hasn't classified
2559  * the entries into sections. This list need not cover entry
2560  * types added later than 8.4.
2561  */
2562  if (strcmp(te->desc, "COMMENT") == 0 ||
2563  strcmp(te->desc, "ACL") == 0 ||
2564  strcmp(te->desc, "ACL LANGUAGE") == 0)
2565  te->section = SECTION_NONE;
2566  else if (strcmp(te->desc, "TABLE DATA") == 0 ||
2567  strcmp(te->desc, "BLOBS") == 0 ||
2568  strcmp(te->desc, "BLOB COMMENTS") == 0)
2569  te->section = SECTION_DATA;
2570  else if (strcmp(te->desc, "CONSTRAINT") == 0 ||
2571  strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
2572  strcmp(te->desc, "FK CONSTRAINT") == 0 ||
2573  strcmp(te->desc, "INDEX") == 0 ||
2574  strcmp(te->desc, "RULE") == 0 ||
2575  strcmp(te->desc, "TRIGGER") == 0)
2576  te->section = SECTION_POST_DATA;
2577  else
2578  te->section = SECTION_PRE_DATA;
2579  }
2580 
2581  te->defn = ReadStr(AH);
2582  te->dropStmt = ReadStr(AH);
2583 
2584  if (AH->version >= K_VERS_1_3)
2585  te->copyStmt = ReadStr(AH);
2586 
2587  if (AH->version >= K_VERS_1_6)
2588  te->namespace = ReadStr(AH);
2589 
2590  if (AH->version >= K_VERS_1_10)
2591  te->tablespace = ReadStr(AH);
2592 
2593  if (AH->version >= K_VERS_1_14)
2594  te->tableam = ReadStr(AH);
2595 
2596  te->owner = ReadStr(AH);
2597  is_supported = true;
2598  if (AH->version < K_VERS_1_9)
2599  is_supported = false;
2600  else
2601  {
2602  tmp = ReadStr(AH);
2603 
2604  if (strcmp(tmp, "true") == 0)
2605  is_supported = false;
2606 
2607  free(tmp);
2608  }
2609 
2610  if (!is_supported)
2611  pg_log_warning("restoring tables WITH OIDS is not supported anymore");
2612 
2613  /* Read TOC entry dependencies */
2614  if (AH->version >= K_VERS_1_5)
2615  {
2616  depSize = 100;
2617  deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
2618  depIdx = 0;
2619  for (;;)
2620  {
2621  tmp = ReadStr(AH);
2622  if (!tmp)
2623  break; /* end of list */
2624  if (depIdx >= depSize)
2625  {
2626  depSize *= 2;
2627  deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depSize);
2628  }
2629  sscanf(tmp, "%d", &deps[depIdx]);
2630  free(tmp);
2631  depIdx++;
2632  }
2633 
2634  if (depIdx > 0) /* We have a non-null entry */
2635  {
2636  deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depIdx);
2637  te->dependencies = deps;
2638  te->nDeps = depIdx;
2639  }
2640  else
2641  {
2642  free(deps);
2643  te->dependencies = NULL;
2644  te->nDeps = 0;
2645  }
2646  }
2647  else
2648  {
2649  te->dependencies = NULL;
2650  te->nDeps = 0;
2651  }
2652  te->dataLength = 0;
2653 
2654  if (AH->ReadExtraTocPtr)
2655  AH->ReadExtraTocPtr(AH, te);
2656 
2657  pg_log_debug("read TOC entry %d (ID %d) for %s %s",
2658  i, te->dumpId, te->desc, te->tag);
2659 
2660  /* link completed entry into TOC circular list */
2661  te->prev = AH->toc->prev;
2662  AH->toc->prev->next = te;
2663  AH->toc->prev = te;
2664  te->next = AH->toc;
2665 
2666  /* special processing immediately upon read for some items */
2667  if (strcmp(te->desc, "ENCODING") == 0)
2668  processEncodingEntry(AH, te);
2669  else if (strcmp(te->desc, "STDSTRINGS") == 0)
2670  processStdStringsEntry(AH, te);
2671  else if (strcmp(te->desc, "SEARCHPATH") == 0)
2672  processSearchPathEntry(AH, te);
2673  }
2674 }
void * pg_realloc(void *ptr, size_t size)
Definition: fe_memutils.c:65
#define pg_log_debug(...)
Definition: logging.h:133
@ SECTION_NONE
Definition: pg_backup.h:57
@ SECTION_POST_DATA
Definition: pg_backup.h:60
@ SECTION_PRE_DATA
Definition: pg_backup.h:58
@ SECTION_DATA
Definition: pg_backup.h:59
static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te)
static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te)
#define K_VERS_1_14
#define K_VERS_1_5
#define K_VERS_1_6
#define K_VERS_1_8
#define K_VERS_1_11
#define K_VERS_1_9
#define K_VERS_1_3
#define InvalidOid
Definition: postgres_ext.h:36
Oid tableoid
Definition: pg_backup.h:264

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

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

◆ ReconnectToServer()

void ReconnectToServer ( ArchiveHandle AH,
const char *  dbname 
)

Definition at line 74 of file pg_backup_db.c.

75 {
76  PGconn *oldConn = AH->connection;
77  RestoreOptions *ropt = AH->public.ropt;
78 
79  /*
80  * Save the dbname, if given, in override_dbname so that it will also
81  * affect any later reconnection attempt.
82  */
83  if (dbname)
85 
86  /*
87  * Note: we want to establish the new connection, and in particular update
88  * ArchiveHandle's connCancel, before closing old connection. Otherwise
89  * an ill-timed SIGINT could try to access a dead connection.
90  */
91  AH->connection = NULL; /* dodge error check in ConnectDatabase */
92 
93  ConnectDatabase((Archive *) AH, &ropt->cparams, true);
94 
95  PQfinish(oldConn);
96 }
void PQfinish(PGconn *conn)
Definition: fe-connect.c:4562
void ConnectDatabase(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition: pg_backup_db.c:110
char * dbname
Definition: streamutil.c:51
char * override_dbname
Definition: pg_backup.h:91

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

Referenced by _reconnectToDB().

◆ StartRestoreLO()

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

Definition at line 1338 of file pg_backup_archiver.c.

1339 {
1340  bool old_lo_style = (AH->version < K_VERS_1_12);
1341  Oid loOid;
1342 
1343  AH->loCount++;
1344 
1345  /* Initialize the LO Buffer */
1346  AH->lo_buf_used = 0;
1347 
1348  pg_log_info("restoring large object with OID %u", oid);
1349 
1350  /* With an old archive we must do drop and create logic here */
1351  if (old_lo_style && drop)
1352  DropLOIfExists(AH, oid);
1353 
1354  if (AH->connection)
1355  {
1356  if (old_lo_style)
1357  {
1358  loOid = lo_create(AH->connection, oid);
1359  if (loOid == 0 || loOid != oid)
1360  pg_fatal("could not create large object %u: %s",
1361  oid, PQerrorMessage(AH->connection));
1362  }
1363  AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
1364  if (AH->loFd == -1)
1365  pg_fatal("could not open large object %u: %s",
1366  oid, PQerrorMessage(AH->connection));
1367  }
1368  else
1369  {
1370  if (old_lo_style)
1371  ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
1372  oid, INV_WRITE);
1373  else
1374  ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
1375  oid, INV_WRITE);
1376  }
1377 
1378  AH->writingLO = true;
1379 }
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:6841
int lo_open(PGconn *conn, Oid lobjId, int mode)
Definition: fe-lobj.c:57
Oid lo_create(PGconn *conn, Oid lobjId)
Definition: fe-lobj.c:474
#define INV_WRITE
Definition: libpq-fs.h:21
void DropLOIfExists(ArchiveHandle *AH, Oid oid)
Definition: pg_backup_db.c:545
#define K_VERS_1_12
unsigned int Oid
Definition: postgres_ext.h:31

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

Referenced by _LoadLOs().

◆ StartRestoreLOs()

void StartRestoreLOs ( ArchiveHandle AH)

Definition at line 1296 of file pg_backup_archiver.c.

1297 {
1298  RestoreOptions *ropt = AH->public.ropt;
1299 
1300  if (!ropt->single_txn)
1301  {
1302  if (AH->connection)
1303  StartTransaction(&AH->public);
1304  else
1305  ahprintf(AH, "BEGIN;\n\n");
1306  }
1307 
1308  AH->loCount = 0;
1309 }
static void StartTransaction(void)
Definition: xact.c:1993

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

Referenced by _LoadLOs().

◆ TocIDRequired()

int TocIDRequired ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1880 of file pg_backup_archiver.c.

1881 {
1882  TocEntry *te = getTocEntryByDumpId(AH, id);
1883 
1884  if (!te)
1885  return 0;
1886 
1887  return te->reqs;
1888 }
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)

References getTocEntryByDumpId(), and _tocEntry::reqs.

Referenced by _tarPositionTo(), and findDumpableDependencies().

◆ warn_or_exit_horribly()

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

◆ WriteDataChunks()

void WriteDataChunks ( ArchiveHandle AH,
struct ParallelState pstate 
)

Definition at line 2335 of file pg_backup_archiver.c.

2336 {
2337  TocEntry *te;
2338 
2339  if (pstate && pstate->numWorkers > 1)
2340  {
2341  /*
2342  * In parallel mode, this code runs in the leader process. We
2343  * construct an array of candidate TEs, then sort it into decreasing
2344  * size order, then dispatch each TE to a data-transfer worker. By
2345  * dumping larger tables first, we avoid getting into a situation
2346  * where we're down to one job and it's big, losing parallelism.
2347  */
2348  TocEntry **tes;
2349  int ntes;
2350 
2351  tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
2352  ntes = 0;
2353  for (te = AH->toc->next; te != AH->toc; te = te->next)
2354  {
2355  /* Consider only TEs with dataDumper functions ... */
2356  if (!te->dataDumper)
2357  continue;
2358  /* ... and ignore ones not enabled for dump */
2359  if ((te->reqs & REQ_DATA) == 0)
2360  continue;
2361 
2362  tes[ntes++] = te;
2363  }
2364 
2365  if (ntes > 1)
2366  qsort(tes, ntes, sizeof(TocEntry *), TocEntrySizeCompareQsort);
2367 
2368  for (int i = 0; i < ntes; i++)
2369  DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
2370  mark_dump_job_done, NULL);
2371 
2372  pg_free(tes);
2373 
2374  /* Now wait for workers to finish. */
2375  WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2376  }
2377  else
2378  {
2379  /* Non-parallel mode: just dump all candidate TEs sequentially. */
2380  for (te = AH->toc->next; te != AH->toc; te = te->next)
2381  {
2382  /* Must have same filter conditions as above */
2383  if (!te->dataDumper)
2384  continue;
2385  if ((te->reqs & REQ_DATA) == 0)
2386  continue;
2387 
2389  }
2390  }
2391 }
void WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
Definition: parallel.c:1451
void DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te, T_Action act, ParallelCompletionPtr callback, void *callback_data)
Definition: parallel.c:1205
@ WFW_ALL_IDLE
Definition: parallel.h:35
void WriteDataChunksForTocEntry(ArchiveHandle *AH, TocEntry *te)
static int TocEntrySizeCompareQsort(const void *p1, const void *p2)
static void mark_dump_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
@ ACT_DUMP
#define REQ_DATA
#define qsort(a, b, c, d)
Definition: port.h:449
int numWorkers
Definition: parallel.h:57

References ACT_DUMP, _tocEntry::dataDumper, DispatchJobForTocEntry(), i, mark_dump_job_done(), _tocEntry::next, ParallelState::numWorkers, pg_free(), pg_malloc(), qsort, REQ_DATA, _tocEntry::reqs, _archiveHandle::toc, _archiveHandle::tocCount, TocEntrySizeCompareQsort(), WaitForWorkers(), WFW_ALL_IDLE, and WriteDataChunksForTocEntry().

Referenced by _CloseArchive().

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 2416 of file pg_backup_archiver.c.

2417 {
2418  StartDataPtrType startPtr;
2419  EndDataPtrType endPtr;
2420 
2421  AH->currToc = te;
2422 
2423  if (strcmp(te->desc, "BLOBS") == 0)
2424  {
2425  startPtr = AH->StartLOsPtr;
2426  endPtr = AH->EndLOsPtr;
2427  }
2428  else
2429  {
2430  startPtr = AH->StartDataPtr;
2431  endPtr = AH->EndDataPtr;
2432  }
2433 
2434  if (startPtr != NULL)
2435  (*startPtr) (AH, te);
2436 
2437  /*
2438  * The user-provided DataDumper routine needs to call AH->WriteData
2439  */
2440  te->dataDumper((Archive *) AH, te->dataDumperArg);
2441 
2442  if (endPtr != NULL)
2443  (*endPtr) (AH, te);
2444 
2445  AH->currToc = NULL;
2446 }
void(* EndDataPtrType)(ArchiveHandle *AH, TocEntry *te)
void(* StartDataPtrType)(ArchiveHandle *AH, TocEntry *te)
struct _tocEntry * currToc

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

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

◆ WriteHead()

void WriteHead ( ArchiveHandle AH)

Definition at line 3707 of file pg_backup_archiver.c.

3708 {
3709  struct tm crtm;
3710 
3711  AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
3712  AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
3713  AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
3714  AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
3715  AH->WriteBytePtr(AH, AH->intSize);
3716  AH->WriteBytePtr(AH, AH->offSize);
3717  AH->WriteBytePtr(AH, AH->format);
3719  crtm = *localtime(&AH->createDate);
3720  WriteInt(AH, crtm.tm_sec);
3721  WriteInt(AH, crtm.tm_min);
3722  WriteInt(AH, crtm.tm_hour);
3723  WriteInt(AH, crtm.tm_mday);
3724  WriteInt(AH, crtm.tm_mon);
3725  WriteInt(AH, crtm.tm_year);
3726  WriteInt(AH, crtm.tm_isdst);
3727  WriteStr(AH, PQdb(AH->connection));
3728  WriteStr(AH, AH->public.remoteVersionStr);
3729  WriteStr(AH, PG_VERSION);
3730 }
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:6687
size_t WriteInt(ArchiveHandle *AH, int i)
size_t WriteStr(ArchiveHandle *AH, const char *c)
#define ARCHIVE_MAJOR(version)
#define ARCHIVE_MINOR(version)
#define ARCHIVE_REV(version)
char * remoteVersionStr
Definition: pg_backup.h:216

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

Referenced by _CloseArchive().

◆ WriteInt()

size_t WriteInt ( ArchiveHandle AH,
int  i 
)

Definition at line 1972 of file pg_backup_archiver.c.

1973 {
1974  int b;
1975 
1976  /*
1977  * This is a bit yucky, but I don't want to make the binary format very
1978  * dependent on representation, and not knowing much about it, I write out
1979  * a sign byte. If you change this, don't forget to change the file
1980  * version #, and modify ReadInt to read the new format AS WELL AS the old
1981  * formats.
1982  */
1983 
1984  /* SIGN byte */
1985  if (i < 0)
1986  {
1987  AH->WriteBytePtr(AH, 1);
1988  i = -i;
1989  }
1990  else
1991  AH->WriteBytePtr(AH, 0);
1992 
1993  for (b = 0; b < AH->intSize; b++)
1994  {
1995  AH->WriteBytePtr(AH, i & 0xFF);
1996  i >>= 8;
1997  }
1998 
1999  return AH->intSize + 1;
2000 }

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

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

◆ WriteOffset()

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

Definition at line 1891 of file pg_backup_archiver.c.

1892 {
1893  int off;
1894 
1895  /* Save the flag */
1896  AH->WriteBytePtr(AH, wasSet);
1897 
1898  /* Write out pgoff_t smallest byte first, prevents endian mismatch */
1899  for (off = 0; off < sizeof(pgoff_t); off++)
1900  {
1901  AH->WriteBytePtr(AH, o & 0xFF);
1902  o >>= 8;
1903  }
1904  return sizeof(pgoff_t) + 1;
1905 }

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

◆ WriteStr()

size_t WriteStr ( ArchiveHandle AH,
const char *  c 
)

Definition at line 2030 of file pg_backup_archiver.c.

2031 {
2032  size_t res;
2033 
2034  if (c)
2035  {
2036  int len = strlen(c);
2037 
2038  res = WriteInt(AH, len);
2039  AH->WriteBufPtr(AH, c, len);
2040  res += len;
2041  }
2042  else
2043  res = WriteInt(AH, -1);
2044 
2045  return res;
2046 }
const void size_t len
char * c

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

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

◆ WriteToc()

void WriteToc ( ArchiveHandle AH)

Definition at line 2449 of file pg_backup_archiver.c.

2450 {
2451  TocEntry *te;
2452  char workbuf[32];
2453  int tocCount;
2454  int i;
2455 
2456  /* count entries that will actually be dumped */
2457  tocCount = 0;
2458  for (te = AH->toc->next; te != AH->toc; te = te->next)
2459  {
2460  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
2461  tocCount++;
2462  }
2463 
2464  /* printf("%d TOC Entries to save\n", tocCount); */
2465 
2466  WriteInt(AH, tocCount);
2467 
2468  for (te = AH->toc->next; te != AH->toc; te = te->next)
2469  {
2470  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) == 0)
2471  continue;
2472 
2473  WriteInt(AH, te->dumpId);
2474  WriteInt(AH, te->dataDumper ? 1 : 0);
2475 
2476  /* OID is recorded as a string for historical reasons */
2477  sprintf(workbuf, "%u", te->catalogId.tableoid);
2478  WriteStr(AH, workbuf);
2479  sprintf(workbuf, "%u", te->catalogId.oid);
2480  WriteStr(AH, workbuf);
2481 
2482  WriteStr(AH, te->tag);
2483  WriteStr(AH, te->desc);
2484  WriteInt(AH, te->section);
2485  WriteStr(AH, te->defn);
2486  WriteStr(AH, te->dropStmt);
2487  WriteStr(AH, te->copyStmt);
2488  WriteStr(AH, te->namespace);
2489  WriteStr(AH, te->tablespace);
2490  WriteStr(AH, te->tableam);
2491  WriteStr(AH, te->owner);
2492  WriteStr(AH, "false");
2493 
2494  /* Dump list of dependencies */
2495  for (i = 0; i < te->nDeps; i++)
2496  {
2497  sprintf(workbuf, "%d", te->dependencies[i]);
2498  WriteStr(AH, workbuf);
2499  }
2500  WriteStr(AH, NULL); /* Terminate List */
2501 
2502  if (AH->WriteExtraTocPtr)
2503  AH->WriteExtraTocPtr(AH, te);
2504  }
2505 }
#define REQ_SCHEMA
#define REQ_SPECIAL
#define sprintf
Definition: port.h:240

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

Referenced by _CloseArchive().