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 }
 

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 413 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 410 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 392 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 

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

1706 {
1707  int bytes_written = 0;
1708 
1709  if (AH->writingLO)
1710  {
1711  size_t remaining = size * nmemb;
1712 
1713  while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1714  {
1715  size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1716 
1717  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1718  ptr = (const void *) ((const char *) ptr + avail);
1719  remaining -= avail;
1720  AH->lo_buf_used += avail;
1721  dump_lo_buf(AH);
1722  }
1723 
1724  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1725  AH->lo_buf_used += remaining;
1726 
1727  bytes_written = size * nmemb;
1728  }
1729  else if (AH->CustomOutPtr)
1730  bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1731 
1732  /*
1733  * If we're doing a restore, and it's direct to DB, and we're connected
1734  * then send it to the DB.
1735  */
1736  else if (RestoringToDB(AH))
1737  bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1738  else
1739  {
1740  CompressFileHandle *CFH = (CompressFileHandle *) AH->OF;
1741 
1742  if (CFH->write_func(ptr, size * nmemb, CFH))
1743  bytes_written = size * nmemb;
1744  }
1745 
1746  if (bytes_written != size * nmemb)
1748 }
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 1115 of file pg_backup_archiver.c.

1117 {
1118  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1119  TocEntry *newToc;
1120 
1121  newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
1122 
1123  AH->tocCount++;
1124  if (dumpId > AH->maxDumpId)
1125  AH->maxDumpId = dumpId;
1126 
1127  newToc->prev = AH->toc->prev;
1128  newToc->next = AH->toc;
1129  AH->toc->prev->next = newToc;
1130  AH->toc->prev = newToc;
1131 
1132  newToc->catalogId = catalogId;
1133  newToc->dumpId = dumpId;
1134  newToc->section = opts->section;
1135 
1136  newToc->tag = pg_strdup(opts->tag);
1137  newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
1138  newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
1139  newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
1140  newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
1141  newToc->desc = pg_strdup(opts->description);
1142  newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
1143  newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
1144  newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
1145 
1146  if (opts->nDeps > 0)
1147  {
1148  newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
1149  memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
1150  newToc->nDeps = opts->nDeps;
1151  }
1152  else
1153  {
1154  newToc->dependencies = NULL;
1155  newToc->nDeps = 0;
1156  }
1157 
1158  newToc->dataDumper = opts->dumpFn;
1159  newToc->dataDumperArg = opts->dumpArg;
1160  newToc->hadDumper = opts->dumpFn ? true : false;
1161 
1162  newToc->formatData = NULL;
1163  newToc->dataLength = 0;
1164 
1165  if (AH->ArchiveEntryPtr != NULL)
1166  AH->ArchiveEntryPtr(AH, newToc);
1167 
1168  return newToc;
1169 }
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:110
int DumpId
Definition: pg_backup.h:267
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(), dumpTableAttach(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

◆ checkSeek()

bool checkSeek ( FILE *  fp)

Definition at line 3865 of file pg_backup_archiver.c.

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

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle AH)

Definition at line 4785 of file pg_backup_archiver.c.

4786 {
4787  ArchiveHandle *clone;
4788 
4789  /* Make a "flat" copy */
4790  clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
4791  memcpy(clone, AH, sizeof(ArchiveHandle));
4792 
4793  /* Handle format-independent fields */
4794  memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
4795 
4796  /* The clone will have its own connection, so disregard connection state */
4797  clone->connection = NULL;
4798  clone->connCancel = NULL;
4799  clone->currUser = NULL;
4800  clone->currSchema = NULL;
4801  clone->currTableAm = NULL;
4802  clone->currTablespace = NULL;
4803 
4804  /* savedPassword must be local in case we change it while connecting */
4805  if (clone->savedPassword)
4806  clone->savedPassword = pg_strdup(clone->savedPassword);
4807 
4808  /* clone has its own error count, too */
4809  clone->public.n_errors = 0;
4810 
4811  /*
4812  * Connect our new clone object to the database, using the same connection
4813  * parameters used for the original connection.
4814  */
4815  ConnectDatabase((Archive *) clone, &clone->public.ropt->cparams, true);
4816 
4817  /* re-establish fixed state */
4818  if (AH->mode == archModeRead)
4819  _doSetFixedOutputState(clone);
4820  /* in write case, setupDumpWorker will fix up connection state */
4821 
4822  /* Let the format-specific code have a chance too */
4823  clone->ClonePtr(clone);
4824 
4825  Assert(clone->connection != NULL);
4826  return clone;
4827 }
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:51
static void _doSetFixedOutputState(ArchiveHandle *AH)
int n_errors
Definition: pg_backup.h:235
RestoreOptions * ropt
Definition: pg_backup.h:212
PGcancel *volatile connCancel
ClonePtrType ClonePtr
sqlparseInfo sqlparse
ConnParams cparams
Definition: pg_backup.h:143

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

4836 {
4837  /* Should not have an open database connection */
4838  Assert(AH->connection == NULL);
4839 
4840  /* Clear format-specific state */
4841  AH->DeClonePtr(AH);
4842 
4843  /* Clear state allocated by CloneArchive */
4844  if (AH->sqlparse.curCmd)
4846 
4847  /* Clear any connection-local state */
4848  free(AH->currUser);
4849  free(AH->currSchema);
4850  free(AH->currTablespace);
4851  free(AH->currTableAm);
4852  free(AH->savedPassword);
4853 
4854  free(AH);
4855 }
#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:7235
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 1400 of file pg_backup_archiver.c.

1401 {
1402  if (AH->lo_buf_used > 0)
1403  {
1404  /* Write remaining bytes from the LO buffer */
1405  dump_lo_buf(AH);
1406  }
1407 
1408  AH->writingLO = false;
1409 
1410  if (AH->connection)
1411  {
1412  lo_close(AH->connection, AH->loFd);
1413  AH->loFd = -1;
1414  }
1415  else
1416  {
1417  ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
1418  }
1419 }
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 1333 of file pg_backup_archiver.c.

1334 {
1335  RestoreOptions *ropt = AH->public.ropt;
1336 
1337  if (!ropt->single_txn)
1338  {
1339  if (AH->connection)
1340  CommitTransaction(&AH->public);
1341  else
1342  ahprintf(AH, "COMMIT;\n\n");
1343  }
1344 
1345  pg_log_info(ngettext("restored %d large object",
1346  "restored %d large objects",
1347  AH->loCount),
1348  AH->loCount);
1349 }
#define ngettext(s, p, n)
Definition: c.h:1189
#define pg_log_info(...)
Definition: logging.h:124
static void CommitTransaction(void)
Definition: xact.c:2152

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

1886 {
1887  /* build index arrays if we didn't already */
1888  if (AH->tocsByDumpId == NULL)
1889  buildTocEntryArrays(AH);
1890 
1891  if (id > 0 && id <= AH->maxDumpId)
1892  return AH->tocsByDumpId[id];
1893 
1894  return NULL;
1895 }
static void buildTocEntryArrays(ArchiveHandle *AH)
struct _tocEntry ** tocsByDumpId

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

Referenced by _PrintTocData(), 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:1280
#define PG_BINARY_W
Definition: c.h:1281
@ archModeWrite
Definition: pg_backup.h:50
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:42
@ archDirectory
Definition: pg_backup.h:44
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:292
#define S_ISDIR(m)
Definition: win32_port.h:333
#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[148], 8);
979 
980  if (sum != chk)
981  return false;
982 
983  /* POSIX tar format */
984  if (memcmp(&header[257], "ustar\0", 6) == 0 &&
985  memcmp(&header[263], "00", 2) == 0)
986  return true;
987  /* GNU tar format */
988  if (memcmp(&header[257], "ustar \0", 8) == 0)
989  return true;
990  /* not-quite-POSIX format written by pre-9.3 pg_dump */
991  if (memcmp(&header[257], "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

References read_tar_number(), 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 4418 of file pg_backup_archiver.c.

4419 {
4420  int status;
4421 
4422  Assert(AH->connection != NULL);
4423 
4424  /* Count only errors associated with this TOC entry */
4425  AH->public.n_errors = 0;
4426 
4427  /* Restore the TOC item */
4428  status = restore_toc_entry(AH, te, true);
4429 
4430  return status;
4431 }
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 3731 of file pg_backup_archiver.c.

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

2022 {
2023  int res = 0;
2024  int bv,
2025  b;
2026  int sign = 0; /* Default positive */
2027  int bitShift = 0;
2028 
2029  if (AH->version > K_VERS_1_0)
2030  /* Read a sign byte */
2031  sign = AH->ReadBytePtr(AH);
2032 
2033  for (b = 0; b < AH->intSize; b++)
2034  {
2035  bv = AH->ReadBytePtr(AH) & 0xFF;
2036  if (bv != 0)
2037  res = res + (bv << bitShift);
2038  bitShift += 8;
2039  }
2040 
2041  if (sign)
2042  res = -res;
2043 
2044  return res;
2045 }
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 1926 of file pg_backup_archiver.c.

1927 {
1928  int i;
1929  int off;
1930  int offsetFlg;
1931 
1932  /* Initialize to zero */
1933  *o = 0;
1934 
1935  /* Check for old version */
1936  if (AH->version < K_VERS_1_7)
1937  {
1938  /* Prior versions wrote offsets using WriteInt */
1939  i = ReadInt(AH);
1940  /* -1 means not set */
1941  if (i < 0)
1942  return K_OFFSET_POS_NOT_SET;
1943  else if (i == 0)
1944  return K_OFFSET_NO_DATA;
1945 
1946  /* Cast to pgoff_t because it was written as an int. */
1947  *o = (pgoff_t) i;
1948  return K_OFFSET_POS_SET;
1949  }
1950 
1951  /*
1952  * Read the flag indicating the state of the data pointer. Check if valid
1953  * and die if not.
1954  *
1955  * This used to be handled by a negative or zero pointer, now we use an
1956  * extra byte specifically for the state.
1957  */
1958  offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
1959 
1960  switch (offsetFlg)
1961  {
1962  case K_OFFSET_POS_NOT_SET:
1963  case K_OFFSET_NO_DATA:
1964  case K_OFFSET_POS_SET:
1965 
1966  break;
1967 
1968  default:
1969  pg_fatal("unexpected data offset flag %d", offsetFlg);
1970  }
1971 
1972  /*
1973  * Read the bytes
1974  */
1975  for (off = 0; off < AH->offSize; off++)
1976  {
1977  if (off < sizeof(pgoff_t))
1978  *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
1979  else
1980  {
1981  if (AH->ReadBytePtr(AH) != 0)
1982  pg_fatal("file offset in dump file is too large");
1983  }
1984  }
1985 
1986  return offsetFlg;
1987 }
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 2067 of file pg_backup_archiver.c.

2068 {
2069  char *buf;
2070  int l;
2071 
2072  l = ReadInt(AH);
2073  if (l < 0)
2074  buf = NULL;
2075  else
2076  {
2077  buf = (char *) pg_malloc(l + 1);
2078  AH->ReadBufPtr(AH, (void *) buf, l);
2079 
2080  buf[l] = '\0';
2081  }
2082 
2083  return buf;
2084 }
static char * buf
Definition: pg_test_fsync.c:67

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

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

◆ ReadToc()

void ReadToc ( ArchiveHandle AH)

Definition at line 2525 of file pg_backup_archiver.c.

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

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:4599
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:90

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

1357 {
1358  bool old_lo_style = (AH->version < K_VERS_1_12);
1359  Oid loOid;
1360 
1361  AH->loCount++;
1362 
1363  /* Initialize the LO Buffer */
1364  AH->lo_buf_used = 0;
1365 
1366  pg_log_info("restoring large object with OID %u", oid);
1367 
1368  /* With an old archive we must do drop and create logic here */
1369  if (old_lo_style && drop)
1370  DropLOIfExists(AH, oid);
1371 
1372  if (AH->connection)
1373  {
1374  if (old_lo_style)
1375  {
1376  loOid = lo_create(AH->connection, oid);
1377  if (loOid == 0 || loOid != oid)
1378  pg_fatal("could not create large object %u: %s",
1379  oid, PQerrorMessage(AH->connection));
1380  }
1381  AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
1382  if (AH->loFd == -1)
1383  pg_fatal("could not open large object %u: %s",
1384  oid, PQerrorMessage(AH->connection));
1385  }
1386  else
1387  {
1388  if (old_lo_style)
1389  ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
1390  oid, INV_WRITE);
1391  else
1392  ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
1393  oid, INV_WRITE);
1394  }
1395 
1396  AH->writingLO = true;
1397 }
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:7245
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 1314 of file pg_backup_archiver.c.

1315 {
1316  RestoreOptions *ropt = AH->public.ropt;
1317 
1318  if (!ropt->single_txn)
1319  {
1320  if (AH->connection)
1321  StartTransaction(&AH->public);
1322  else
1323  ahprintf(AH, "BEGIN;\n\n");
1324  }
1325 
1326  AH->loCount = 0;
1327 }
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 1898 of file pg_backup_archiver.c.

1899 {
1900  TocEntry *te = getTocEntryByDumpId(AH, id);
1901 
1902  if (!te)
1903  return 0;
1904 
1905  return te->reqs;
1906 }
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)

References getTocEntryByDumpId(), and _tocEntry::reqs.

Referenced by _tarPositionTo(), _tocEntryRequired(), 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 2352 of file pg_backup_archiver.c.

2353 {
2354  TocEntry *te;
2355 
2356  if (pstate && pstate->numWorkers > 1)
2357  {
2358  /*
2359  * In parallel mode, this code runs in the leader process. We
2360  * construct an array of candidate TEs, then sort it into decreasing
2361  * size order, then dispatch each TE to a data-transfer worker. By
2362  * dumping larger tables first, we avoid getting into a situation
2363  * where we're down to one job and it's big, losing parallelism.
2364  */
2365  TocEntry **tes;
2366  int ntes;
2367 
2368  tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
2369  ntes = 0;
2370  for (te = AH->toc->next; te != AH->toc; te = te->next)
2371  {
2372  /* Consider only TEs with dataDumper functions ... */
2373  if (!te->dataDumper)
2374  continue;
2375  /* ... and ignore ones not enabled for dump */
2376  if ((te->reqs & REQ_DATA) == 0)
2377  continue;
2378 
2379  tes[ntes++] = te;
2380  }
2381 
2382  if (ntes > 1)
2383  qsort(tes, ntes, sizeof(TocEntry *), TocEntrySizeCompare);
2384 
2385  for (int i = 0; i < ntes; i++)
2386  DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
2387  mark_dump_job_done, NULL);
2388 
2389  pg_free(tes);
2390 
2391  /* Now wait for workers to finish. */
2392  WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2393  }
2394  else
2395  {
2396  /* Non-parallel mode: just dump all candidate TEs sequentially. */
2397  for (te = AH->toc->next; te != AH->toc; te = te->next)
2398  {
2399  /* Must have same filter conditions as above */
2400  if (!te->dataDumper)
2401  continue;
2402  if ((te->reqs & REQ_DATA) == 0)
2403  continue;
2404 
2406  }
2407  }
2408 }
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 void mark_dump_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
static int TocEntrySizeCompare(const void *p1, const void *p2)
@ ACT_DUMP
#define REQ_DATA
#define qsort(a, b, c, d)
Definition: port.h:445
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, TocEntrySizeCompare(), WaitForWorkers(), WFW_ALL_IDLE, and WriteDataChunksForTocEntry().

Referenced by _CloseArchive().

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 2433 of file pg_backup_archiver.c.

2434 {
2435  StartDataPtrType startPtr;
2436  EndDataPtrType endPtr;
2437 
2438  AH->currToc = te;
2439 
2440  if (strcmp(te->desc, "BLOBS") == 0)
2441  {
2442  startPtr = AH->StartLOsPtr;
2443  endPtr = AH->EndLOsPtr;
2444  }
2445  else
2446  {
2447  startPtr = AH->StartDataPtr;
2448  endPtr = AH->EndDataPtr;
2449  }
2450 
2451  if (startPtr != NULL)
2452  (*startPtr) (AH, te);
2453 
2454  /*
2455  * The user-provided DataDumper routine needs to call AH->WriteData
2456  */
2457  te->dataDumper((Archive *) AH, te->dataDumperArg);
2458 
2459  if (endPtr != NULL)
2460  (*endPtr) (AH, te);
2461 
2462  AH->currToc = NULL;
2463 }
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 3705 of file pg_backup_archiver.c.

3706 {
3707  struct tm crtm;
3708 
3709  AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
3710  AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
3711  AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
3712  AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
3713  AH->WriteBytePtr(AH, AH->intSize);
3714  AH->WriteBytePtr(AH, AH->offSize);
3715  AH->WriteBytePtr(AH, AH->format);
3717  crtm = *localtime(&AH->createDate);
3718  WriteInt(AH, crtm.tm_sec);
3719  WriteInt(AH, crtm.tm_min);
3720  WriteInt(AH, crtm.tm_hour);
3721  WriteInt(AH, crtm.tm_mday);
3722  WriteInt(AH, crtm.tm_mon);
3723  WriteInt(AH, crtm.tm_year);
3724  WriteInt(AH, crtm.tm_isdst);
3725  WriteStr(AH, PQdb(AH->connection));
3726  WriteStr(AH, AH->public.remoteVersionStr);
3727  WriteStr(AH, PG_VERSION);
3728 }
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:7091
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:215

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

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

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

1910 {
1911  int off;
1912 
1913  /* Save the flag */
1914  AH->WriteBytePtr(AH, wasSet);
1915 
1916  /* Write out pgoff_t smallest byte first, prevents endian mismatch */
1917  for (off = 0; off < sizeof(pgoff_t); off++)
1918  {
1919  AH->WriteBytePtr(AH, o & 0xFF);
1920  o >>= 8;
1921  }
1922  return sizeof(pgoff_t) + 1;
1923 }

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

◆ WriteStr()

size_t WriteStr ( ArchiveHandle AH,
const char *  c 
)

Definition at line 2048 of file pg_backup_archiver.c.

2049 {
2050  size_t res;
2051 
2052  if (c)
2053  {
2054  int len = strlen(c);
2055 
2056  res = WriteInt(AH, len);
2057  AH->WriteBufPtr(AH, c, len);
2058  res += len;
2059  }
2060  else
2061  res = WriteInt(AH, -1);
2062 
2063  return res;
2064 }
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 2466 of file pg_backup_archiver.c.

2467 {
2468  TocEntry *te;
2469  char workbuf[32];
2470  int tocCount;
2471  int i;
2472 
2473  /* count entries that will actually be dumped */
2474  tocCount = 0;
2475  for (te = AH->toc->next; te != AH->toc; te = te->next)
2476  {
2477  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
2478  tocCount++;
2479  }
2480 
2481  /* printf("%d TOC Entries to save\n", tocCount); */
2482 
2483  WriteInt(AH, tocCount);
2484 
2485  for (te = AH->toc->next; te != AH->toc; te = te->next)
2486  {
2487  if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) == 0)
2488  continue;
2489 
2490  WriteInt(AH, te->dumpId);
2491  WriteInt(AH, te->dataDumper ? 1 : 0);
2492 
2493  /* OID is recorded as a string for historical reasons */
2494  sprintf(workbuf, "%u", te->catalogId.tableoid);
2495  WriteStr(AH, workbuf);
2496  sprintf(workbuf, "%u", te->catalogId.oid);
2497  WriteStr(AH, workbuf);
2498 
2499  WriteStr(AH, te->tag);
2500  WriteStr(AH, te->desc);
2501  WriteInt(AH, te->section);
2502  WriteStr(AH, te->defn);
2503  WriteStr(AH, te->dropStmt);
2504  WriteStr(AH, te->copyStmt);
2505  WriteStr(AH, te->namespace);
2506  WriteStr(AH, te->tablespace);
2507  WriteStr(AH, te->tableam);
2508  WriteStr(AH, te->owner);
2509  WriteStr(AH, "false");
2510 
2511  /* Dump list of dependencies */
2512  for (i = 0; i < te->nDeps; i++)
2513  {
2514  sprintf(workbuf, "%d", te->dependencies[i]);
2515  WriteStr(AH, workbuf);
2516  }
2517  WriteStr(AH, NULL); /* Terminate List */
2518 
2519  if (AH->WriteExtraTocPtr)
2520  AH->WriteExtraTocPtr(AH, te);
2521  }
2522 }
#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().