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

Go to the source code of this file.

Data Structures

struct  _z_stream
 
struct  sqlparseInfo
 
struct  _archiveHandle
 
struct  _tocEntry
 
struct  _archiveOpts
 

Macros

#define LOBBUFSIZE   16384
 
#define GZCLOSE(fh)   fclose(fh)
 
#define GZWRITE(p, s, n, fh)   (fwrite(p, s, n, fh) * (s))
 
#define GZREAD(p, s, n, fh)   fread(p, s, n, fh)
 
#define GZEOF(fh)   feof(fh)
 
#define Z_DEFAULT_COMPRESSION   (-1)
 
#define BLK_DATA   1
 
#define BLK_BLOBS   3
 
#define MAKE_ARCHIVE_VERSION(major, minor, rev)   (((major) * 256 + (minor)) * 256 + (rev))
 
#define ARCHIVE_MAJOR(version)   (((version) >> 16) & 255)
 
#define ARCHIVE_MINOR(version)   (((version) >> 8) & 255)
 
#define ARCHIVE_REV(version)   (((version) ) & 255)
 
#define K_VERS_1_0   MAKE_ARCHIVE_VERSION(1, 0, 0)
 
#define K_VERS_1_2   MAKE_ARCHIVE_VERSION(1, 2, 0) /* Allow No ZLIB */
 
#define K_VERS_1_3   MAKE_ARCHIVE_VERSION(1, 3, 0) /* BLOBs */
 
#define K_VERS_1_4   MAKE_ARCHIVE_VERSION(1, 4, 0) /* Date & name in header */
 
#define K_VERS_1_5   MAKE_ARCHIVE_VERSION(1, 5, 0) /* Handle dependencies */
 
#define K_VERS_1_6   MAKE_ARCHIVE_VERSION(1, 6, 0) /* Schema field in TOCs */
 
#define K_VERS_1_7
 
#define K_VERS_1_8
 
#define K_VERS_1_9
 
#define K_VERS_1_10   MAKE_ARCHIVE_VERSION(1, 10, 0) /* add tablespace */
 
#define K_VERS_1_11
 
#define K_VERS_1_12
 
#define K_VERS_1_13
 
#define K_VERS_1_14   MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */
 
#define K_VERS_MAJOR   1
 
#define K_VERS_MINOR   14
 
#define K_VERS_REV   0
 
#define K_VERS_SELF   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV);
 
#define K_VERS_MAX   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)
 
#define K_OFFSET_POS_NOT_SET   1
 
#define K_OFFSET_POS_SET   2
 
#define K_OFFSET_NO_DATA   3
 
#define WORKER_OK   0
 
#define WORKER_CREATE_DONE   10
 
#define WORKER_INHIBIT_DATA   11
 
#define WORKER_IGNORED_ERRORS   12
 
#define READ_ERROR_EXIT(fd)
 
#define WRITE_ERROR_EXIT
 
#define RESTORE_PASS_LAST   RESTORE_PASS_REFRESH
 
#define 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 _z_stream z_stream
 
typedef z_streamz_streamp
 
typedef struct _archiveHandle ArchiveHandle
 
typedef struct _tocEntry TocEntry
 
typedef enum T_Action T_Action
 
typedef void(* ClosePtrType) (ArchiveHandle *AH)
 
typedef void(* ReopenPtrType) (ArchiveHandle *AH)
 
typedef void(* ArchiveEntryPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* WriteDataPtrType) (ArchiveHandle *AH, const void *data, size_t dLen)
 
typedef void(* EndDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartBlobsPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartBlobPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)
 
typedef void(* EndBlobPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)
 
typedef void(* EndBlobsPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef int(* WriteBytePtrType) (ArchiveHandle *AH, const int i)
 
typedef int(* ReadBytePtrType) (ArchiveHandle *AH)
 
typedef void(* WriteBufPtrType) (ArchiveHandle *AH, const void *c, size_t len)
 
typedef void(* ReadBufPtrType) (ArchiveHandle *AH, void *buf, size_t len)
 
typedef void(* 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 }
 
enum  teReqs { REQ_SCHEMA = 0x01, REQ_DATA = 0x02, REQ_SPECIAL = 0x04 }
 

Functions

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

Macro Definition Documentation

◆ appendByteaLiteralAHX

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

Definition at line 445 of file pg_backup_archiver.h.

Referenced by _WriteBlobData(), and dump_lo_buf().

◆ appendStringLiteralAHX

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

Definition at line 442 of file pg_backup_archiver.h.

Referenced by _doSetSessionAuth().

◆ ARCHIVE_MAJOR

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

Definition at line 72 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_MINOR

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

Definition at line 73 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_OPTS

◆ ARCHIVE_REV

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

Definition at line 74 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ BLK_BLOBS

#define BLK_BLOBS   3

Definition at line 67 of file pg_backup_archiver.h.

Referenced by _PrintTocData(), and _StartBlobs().

◆ BLK_DATA

#define BLK_DATA   1

Definition at line 66 of file pg_backup_archiver.h.

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

◆ GZCLOSE

#define GZCLOSE (   fh)    fclose(fh)

Definition at line 48 of file pg_backup_archiver.h.

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

◆ GZEOF

#define GZEOF (   fh)    feof(fh)

Definition at line 51 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZREAD

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

Definition at line 50 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZWRITE

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

Definition at line 49 of file pg_backup_archiver.h.

Referenced by ahwrite(), and tarWrite().

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA   3

Definition at line 112 of file pg_backup_archiver.h.

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

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET   1

Definition at line 110 of file pg_backup_archiver.h.

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

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET   2

Definition at line 111 of file pg_backup_archiver.h.

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

◆ K_VERS_1_0

#define K_VERS_1_0   MAKE_ARCHIVE_VERSION(1, 0, 0)

Definition at line 77 of file pg_backup_archiver.h.

Referenced by ReadHead(), and ReadInt().

◆ K_VERS_1_10

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

Definition at line 90 of file pg_backup_archiver.h.

Referenced by ReadHead(), and ReadToc().

◆ K_VERS_1_11

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

Definition at line 91 of file pg_backup_archiver.h.

Referenced by fix_dependencies(), and ReadToc().

◆ K_VERS_1_12

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

Definition at line 93 of file pg_backup_archiver.h.

Referenced by _StartBlob(), and StartRestoreBlob().

◆ K_VERS_1_13

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

Definition at line 95 of file pg_backup_archiver.h.

◆ K_VERS_1_14

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

Definition at line 97 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_2

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

Definition at line 78 of file pg_backup_archiver.h.

Referenced by ReadHead().

◆ K_VERS_1_3

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

Definition at line 79 of file pg_backup_archiver.h.

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

◆ K_VERS_1_4

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

Definition at line 80 of file pg_backup_archiver.h.

Referenced by ReadHead().

◆ K_VERS_1_5

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

Definition at line 81 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_6

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

Definition at line 82 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_1_7

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

Definition at line 83 of file pg_backup_archiver.h.

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

◆ K_VERS_1_8

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

Definition at line 85 of file pg_backup_archiver.h.

Referenced by ReadToc(), and RestoreArchive().

◆ K_VERS_1_9

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

Definition at line 88 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_MAJOR

#define K_VERS_MAJOR   1

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

Referenced by ReadHead().

◆ K_VERS_MINOR

#define K_VERS_MINOR   14

Definition at line 101 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV   0

Definition at line 102 of file pg_backup_archiver.h.

◆ K_VERS_SELF

Definition at line 103 of file pg_backup_archiver.h.

Referenced by _allocAH().

◆ LOBBUFSIZE

#define LOBBUFSIZE   16384

◆ MAKE_ARCHIVE_VERSION

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

Definition at line 70 of file pg_backup_archiver.h.

Referenced by _discoverArchiveFormat(), and ReadHead().

◆ READ_ERROR_EXIT

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

Definition at line 127 of file pg_backup_archiver.h.

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

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST   RESTORE_PASS_REFRESH

Definition at line 227 of file pg_backup_archiver.h.

Referenced by restore_toc_entries_parallel().

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE   10

Definition at line 119 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS   12

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA   11

Definition at line 120 of file pg_backup_archiver.h.

Referenced by mark_restore_job_done(), and restore_toc_entry().

◆ WORKER_OK

#define WORKER_OK   0

Definition at line 118 of file pg_backup_archiver.h.

Referenced by restore_toc_entry().

◆ WRITE_ERROR_EXIT

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

Definition at line 135 of file pg_backup_archiver.h.

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

◆ Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION   (-1)

Definition at line 53 of file pg_backup_archiver.h.

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

Typedef Documentation

◆ ArchiveEntryPtrType

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

Definition at line 148 of file pg_backup_archiver.h.

◆ ArchiveHandle

typedef struct _archiveHandle ArchiveHandle

Definition at line 123 of file pg_backup_archiver.h.

◆ ArchiveOpts

typedef void struct _archiveOpts ArchiveOpts

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 169 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 146 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 175 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 170 of file pg_backup_archiver.h.

◆ EndBlobPtrType

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

Definition at line 156 of file pg_backup_archiver.h.

◆ EndBlobsPtrType

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

Definition at line 157 of file pg_backup_archiver.h.

◆ EndDataPtrType

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

Definition at line 152 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 168 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

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

Definition at line 165 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

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

Definition at line 166 of file pg_backup_archiver.h.

◆ ReadBufPtrType

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

Definition at line 162 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 160 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

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

Definition at line 164 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 147 of file pg_backup_archiver.h.

◆ StartBlobPtrType

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

Definition at line 155 of file pg_backup_archiver.h.

◆ StartBlobsPtrType

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

Definition at line 154 of file pg_backup_archiver.h.

◆ StartDataPtrType

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

Definition at line 150 of file pg_backup_archiver.h.

◆ T_Action

typedef enum T_Action T_Action

◆ TocEntry

typedef struct _tocEntry TocEntry

Definition at line 124 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

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

Definition at line 172 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

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

Definition at line 173 of file pg_backup_archiver.h.

◆ WriteBufPtrType

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

Definition at line 161 of file pg_backup_archiver.h.

◆ WriteBytePtrType

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

Definition at line 159 of file pg_backup_archiver.h.

◆ WriteDataPtrType

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

Definition at line 151 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

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

Definition at line 163 of file pg_backup_archiver.h.

◆ z_stream

typedef struct _z_stream z_stream

◆ z_streamp

typedef z_stream* z_streamp

Definition at line 62 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

Enumerator
OUTPUT_SQLCMDS 
OUTPUT_COPYDATA 
OUTPUT_OTHERDATA 

Definition at line 199 of file pg_backup_archiver.h.

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

◆ ArchiverStage

Enumerator
STAGE_NONE 
STAGE_INITIALIZING 
STAGE_PROCESSING 
STAGE_FINALIZING 

Definition at line 191 of file pg_backup_archiver.h.

◆ RestorePass

Enumerator
RESTORE_PASS_MAIN 
RESTORE_PASS_ACL 

Definition at line 221 of file pg_backup_archiver.h.

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

◆ sqlparseState

Enumerator
SQL_SCAN 
SQL_IN_SINGLE_QUOTE 
SQL_IN_DOUBLE_QUOTE 

Definition at line 177 of file pg_backup_archiver.h.

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

◆ T_Action

enum T_Action
Enumerator
ACT_DUMP 
ACT_RESTORE 

Definition at line 140 of file pg_backup_archiver.h.

◆ teReqs

enum teReqs
Enumerator
REQ_SCHEMA 
REQ_DATA 
REQ_SPECIAL 

Definition at line 230 of file pg_backup_archiver.h.

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

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

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

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

1697 {
1698  int bytes_written = 0;
1699 
1700  if (AH->writingBlob)
1701  {
1702  size_t remaining = size * nmemb;
1703 
1704  while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1705  {
1706  size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1707 
1708  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1709  ptr = (const void *) ((const char *) ptr + avail);
1710  remaining -= avail;
1711  AH->lo_buf_used += avail;
1712  dump_lo_buf(AH);
1713  }
1714 
1715  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1716  AH->lo_buf_used += remaining;
1717 
1718  bytes_written = size * nmemb;
1719  }
1720  else if (AH->gzOut)
1721  bytes_written = GZWRITE(ptr, size, nmemb, AH->OF);
1722  else if (AH->CustomOutPtr)
1723  bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1724 
1725  else
1726  {
1727  /*
1728  * If we're doing a restore, and it's direct to DB, and we're
1729  * connected then send it to the DB.
1730  */
1731  if (RestoringToDB(AH))
1732  bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1733  else
1734  bytes_written = fwrite(ptr, size, nmemb, AH->OF) * size;
1735  }
1736 
1737  if (bytes_written != size * nmemb)
1739 
1740  return;
1741 }
int remaining
Definition: informix.c:687
static int RestoringToDB(ArchiveHandle *AH)
int ExecuteSqlCommandBuf(Archive *AHX, const char *buf, size_t bufLen)
Definition: pg_backup_db.c:556
static void dump_lo_buf(ArchiveHandle *AH)
#define GZWRITE(p, s, n, fh)
CustomOutPtrType CustomOutPtr
#define WRITE_ERROR_EXIT

◆ ArchiveEntry()

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

Definition at line 1063 of file pg_backup_archiver.c.

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, _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(), dumpBlob(), dumpCast(), dumpCollation(), dumpComment(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

1065 {
1066  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1067  TocEntry *newToc;
1068 
1069  newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
1070 
1071  AH->tocCount++;
1072  if (dumpId > AH->maxDumpId)
1073  AH->maxDumpId = dumpId;
1074 
1075  newToc->prev = AH->toc->prev;
1076  newToc->next = AH->toc;
1077  AH->toc->prev->next = newToc;
1078  AH->toc->prev = newToc;
1079 
1080  newToc->catalogId = catalogId;
1081  newToc->dumpId = dumpId;
1082  newToc->section = opts->section;
1083 
1084  newToc->tag = pg_strdup(opts->tag);
1085  newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
1086  newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
1087  newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
1088  newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
1089  newToc->desc = pg_strdup(opts->description);
1090  newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
1091  newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
1092  newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
1093 
1094  if (opts->nDeps > 0)
1095  {
1096  newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
1097  memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
1098  newToc->nDeps = opts->nDeps;
1099  }
1100  else
1101  {
1102  newToc->dependencies = NULL;
1103  newToc->nDeps = 0;
1104  }
1105 
1106  newToc->dataDumper = opts->dumpFn;
1107  newToc->dataDumperArg = opts->dumpArg;
1108  newToc->hadDumper = opts->dumpFn ? true : false;
1109 
1110  newToc->formatData = NULL;
1111  newToc->dataLength = 0;
1112 
1113  if (AH->ArchiveEntryPtr != NULL)
1114  AH->ArchiveEntryPtr(AH, newToc);
1115 
1116  return newToc;
1117 }
struct _tocEntry * next
int DumpId
Definition: pg_backup.h:234
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
CatalogId catalogId
void * dataDumperArg
DataDumperPtr dataDumper
teSection section
#define true
Definition: c.h:313
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
struct _tocEntry * toc
DumpId * dependencies
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
pgoff_t dataLength
struct _tocEntry * prev
ArchiveEntryPtrType ArchiveEntryPtr

◆ checkSeek()

bool checkSeek ( FILE *  fp)

Definition at line 3876 of file pg_backup_archiver.c.

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

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

◆ CloneArchive()

ArchiveHandle* CloneArchive ( ArchiveHandle AH)

Definition at line 4811 of file pg_backup_archiver.c.

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

Referenced by RunWorker().

4812 {
4813  ArchiveHandle *clone;
4814 
4815  /* Make a "flat" copy */
4816  clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
4817  memcpy(clone, AH, sizeof(ArchiveHandle));
4818 
4819  /* Handle format-independent fields */
4820  memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
4821 
4822  /* The clone will have its own connection, so disregard connection state */
4823  clone->connection = NULL;
4824  clone->connCancel = NULL;
4825  clone->currUser = NULL;
4826  clone->currSchema = NULL;
4827  clone->currTablespace = NULL;
4828 
4829  /* savedPassword must be local in case we change it while connecting */
4830  if (clone->savedPassword)
4831  clone->savedPassword = pg_strdup(clone->savedPassword);
4832 
4833  /* clone has its own error count, too */
4834  clone->public.n_errors = 0;
4835 
4836  /*
4837  * Connect our new clone object to the database: In parallel restore the
4838  * parent is already disconnected, because we can connect the worker
4839  * processes independently to the database (no snapshot sync required). In
4840  * parallel backup we clone the parent's existing connection.
4841  */
4842  if (AH->mode == archModeRead)
4843  {
4844  RestoreOptions *ropt = AH->public.ropt;
4845 
4846  Assert(AH->connection == NULL);
4847 
4848  /* this also sets clone->connection */
4849  ConnectDatabase((Archive *) clone, ropt->dbname,
4850  ropt->pghost, ropt->pgport, ropt->username,
4851  ropt->promptPassword);
4852 
4853  /* re-establish fixed state */
4854  _doSetFixedOutputState(clone);
4855  }
4856  else
4857  {
4859  char *pghost;
4860  char *pgport;
4861  char *username;
4862 
4863  Assert(AH->connection != NULL);
4864 
4865  /*
4866  * Even though we are technically accessing the parent's database
4867  * object here, these functions are fine to be called like that
4868  * because all just return a pointer and do not actually send/receive
4869  * any data to/from the database.
4870  */
4871  initPQExpBuffer(&connstr);
4872  appendPQExpBufferStr(&connstr, "dbname=");
4873  appendConnStrVal(&connstr, PQdb(AH->connection));
4874  pghost = PQhost(AH->connection);
4875  pgport = PQport(AH->connection);
4876  username = PQuser(AH->connection);
4877 
4878  /* this also sets clone->connection */
4879  ConnectDatabase((Archive *) clone, connstr.data,
4880  pghost, pgport, username, TRI_NO);
4881 
4882  termPQExpBuffer(&connstr);
4883  /* setupDumpWorker will fix up connection state */
4884  }
4885 
4886  /* Let the format-specific code have a chance too */
4887  clone->ClonePtr(clone);
4888 
4889  Assert(clone->connection != NULL);
4890  return clone;
4891 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
RestoreOptions * ropt
Definition: pg_backup.h:183
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:131
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:369
char * username
Definition: pg_backup.h:113
void appendConnStrVal(PQExpBuffer buf, const char *str)
Definition: string_utils.c:545
char * PQport(const PGconn *conn)
Definition: fe-connect.c:6536
int n_errors
Definition: pg_backup.h:206
PGcancel *volatile connCancel
char * PQuser(const PGconn *conn)
Definition: fe-connect.c:6475
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static void _doSetFixedOutputState(ArchiveHandle *AH)
sqlparseInfo sqlparse
char * pghost
Definition: pgbench.c:242
static char * username
Definition: initdb.c:133
char * PQhost(const PGconn *conn)
Definition: fe-connect.c:6500
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:6467
#define Assert(condition)
Definition: c.h:733
ClonePtrType ClonePtr
char * pgport
Definition: pgbench.c:243
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:92
void ConnectDatabase(Archive *AH, const char *dbname, const char *pghost, const char *pgport, const char *username, trivalue prompt_password)
Definition: pg_backup_db.c:236
static char * connstr
Definition: pg_dumpall.c:61
trivalue promptPassword
Definition: pg_backup.h:115

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle AH)

Definition at line 4899 of file pg_backup_archiver.c.

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

4900 {
4901  /* Should not have an open database connection */
4902  Assert(AH->connection == NULL);
4903 
4904  /* Clear format-specific state */
4905  AH->DeClonePtr(AH);
4906 
4907  /* Clear state allocated by CloneArchive */
4908  if (AH->sqlparse.curCmd)
4910 
4911  /* Clear any connection-local state */
4912  if (AH->currUser)
4913  free(AH->currUser);
4914  if (AH->currSchema)
4915  free(AH->currSchema);
4916  if (AH->currTablespace)
4917  free(AH->currTablespace);
4918  if (AH->currTableAm)
4919  free(AH->currTableAm);
4920  if (AH->savedPassword)
4921  free(AH->savedPassword);
4922 
4923  free(AH);
4924 }
PQExpBuffer curCmd
DeClonePtrType DeClonePtr
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:116
sqlparseInfo sqlparse
#define free(a)
Definition: header.h:65
#define Assert(condition)
Definition: c.h:733

◆ DropBlobIfExists()

void DropBlobIfExists ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 656 of file pg_backup_db.c.

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

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

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

◆ EndRestoreBlob()

void EndRestoreBlob ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 1343 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

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

◆ EndRestoreBlobs()

void EndRestoreBlobs ( ArchiveHandle AH)

Definition at line 1276 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

1277 {
1278  RestoreOptions *ropt = AH->public.ropt;
1279 
1280  if (!ropt->single_txn)
1281  {
1282  if (AH->connection)
1283  CommitTransaction(&AH->public);
1284  else
1285  ahprintf(AH, "COMMIT;\n\n");
1286  }
1287 
1288  pg_log_info(ngettext("restored %d large object",
1289  "restored %d large objects",
1290  AH->blobCount),
1291  AH->blobCount);
1292 }
RestoreOptions * ropt
Definition: pg_backup.h:183
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
#define ngettext(s, p, n)
Definition: c.h:1128
static void CommitTransaction(void)
Definition: xact.c:2045
#define pg_log_info(...)
Definition: logging.h:87

◆ getTocEntryByDumpId()

TocEntry* getTocEntryByDumpId ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1878 of file pg_backup_archiver.c.

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

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

1879 {
1880  /* build index arrays if we didn't already */
1881  if (AH->tocsByDumpId == NULL)
1882  buildTocEntryArrays(AH);
1883 
1884  if (id > 0 && id <= AH->maxDumpId)
1885  return AH->tocsByDumpId[id];
1886 
1887  return NULL;
1888 }
static void buildTocEntryArrays(ArchiveHandle *AH)
struct _tocEntry ** tocsByDumpId

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle AH)

Definition at line 106 of file pg_backup_custom.c.

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

Referenced by _allocAH().

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 
127  AH->StartBlobPtr = _StartBlob;
128  AH->EndBlobPtr = _EndBlob;
129  AH->EndBlobsPtr = _EndBlobs;
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  ctx->filePos = 0;
148 
149  /*
150  * Now open the file
151  */
152  if (AH->mode == archModeWrite)
153  {
154  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
155  {
156  AH->FH = fopen(AH->fSpec, PG_BINARY_W);
157  if (!AH->FH)
158  fatal("could not open output file \"%s\": %m", AH->fSpec);
159  }
160  else
161  {
162  AH->FH = stdout;
163  if (!AH->FH)
164  fatal("could not open output file: %m");
165  }
166 
167  ctx->hasSeek = checkSeek(AH->FH);
168  }
169  else
170  {
171  if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
172  {
173  AH->FH = fopen(AH->fSpec, PG_BINARY_R);
174  if (!AH->FH)
175  fatal("could not open input file \"%s\": %m", AH->fSpec);
176  }
177  else
178  {
179  AH->FH = stdin;
180  if (!AH->FH)
181  fatal("could not open input file: %m");
182  }
183 
184  ctx->hasSeek = checkSeek(AH->FH);
185 
186  ReadHead(AH);
187  ReadToc(AH);
188  ctx->dataStart = _getFilePos(AH, ctx);
189  }
190 
191 }
static void _ReopenArchive(ArchiveHandle *AH)
ReopenPtrType ReopenPtr
ReadBufPtrType ReadBufPtr
void ReadToc(ArchiveHandle *AH)
void ReadHead(ArchiveHandle *AH)
DeClonePtrType DeClonePtr
static void _Clone(ArchiveHandle *AH)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
WriteBufPtrType WriteBufPtr
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
StartBlobPtrType StartBlobPtr
static int _WorkerJobRestoreCustom(ArchiveHandle *AH, TocEntry *te)
EndDataPtrType EndDataPtr
#define PG_BINARY_W
Definition: c.h:1219
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
StartBlobsPtrType StartBlobsPtr
#define PG_BINARY_R
Definition: c.h:1218
ReadBytePtrType ReadBytePtr
EndBlobPtrType EndBlobPtr
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
static void _StartBlobs(ArchiveHandle *AH, TocEntry *te)
StartDataPtrType StartDataPtr
WriteBytePtrType WriteBytePtr
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _PrepParallelRestore(ArchiveHandle *AH)
static int _ReadByte(ArchiveHandle *)
PrintTocDataPtrType PrintTocDataPtr
WriteDataPtrType WriteDataPtr
static pgoff_t _getFilePos(ArchiveHandle *AH, lclContext *ctx)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _EndBlobs(ArchiveHandle *AH, TocEntry *te)
PrepParallelRestorePtrType PrepParallelRestorePtr
EndBlobsPtrType EndBlobsPtr
ArchiveEntryPtrType ArchiveEntryPtr
#define fatal(...)
pgoff_t dataStart
ClonePtrType ClonePtr
WorkerJobRestorePtrType WorkerJobRestorePtr
static void _DeClone(ArchiveHandle *AH)
bool checkSeek(FILE *fp)
ClosePtrType ClosePtr
PrintExtraTocPtrType PrintExtraTocPtr
pgoff_t filePos
static int _WriteByte(ArchiveHandle *AH, const int i)
WriteExtraTocPtrType WriteExtraTocPtr
#define LOBBUFSIZE
ReadExtraTocPtrType ReadExtraTocPtr
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _StartBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
WorkerJobDumpPtrType WorkerJobDumpPtr

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle AH)

Definition at line 108 of file pg_backup_directory.c.

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

Referenced by _allocAH().

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

◆ InitArchiveFmt_Null()

void InitArchiveFmt_Null ( ArchiveHandle AH)

Definition at line 48 of file pg_backup_null.c.

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

Referenced by _allocAH().

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 
61  AH->EndBlobPtr = _EndBlob;
62  AH->EndBlobsPtr = _EndBlobs;
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  fatal("this format cannot be read");
75 }
ReopenPtrType ReopenPtr
DeClonePtrType DeClonePtr
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
WriteBufPtrType WriteBufPtr
StartBlobPtrType StartBlobPtr
EndDataPtrType EndDataPtr
StartBlobsPtrType StartBlobsPtr
EndBlobPtrType EndBlobPtr
static void _CloseArchive(ArchiveHandle *AH)
static void _EndBlobs(ArchiveHandle *AH, TocEntry *te)
WriteBytePtrType WriteBytePtr
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartBlobs(ArchiveHandle *AH, TocEntry *te)
PrintTocDataPtrType PrintTocDataPtr
WriteDataPtrType WriteDataPtr
static void _EndData(ArchiveHandle *AH, TocEntry *te)
EndBlobsPtrType EndBlobsPtr
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
#define fatal(...)
ClonePtrType ClonePtr
ClosePtrType ClosePtr
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
#define LOBBUFSIZE
static void _StartBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)

◆ InitArchiveFmt_Tar()

void InitArchiveFmt_Tar ( ArchiveHandle AH)

Definition at line 126 of file pg_backup_tar.c.

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

Referenced by _allocAH().

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

◆ isValidTarHeader()

bool isValidTarHeader ( char *  header)

Definition at line 1048 of file pg_backup_tar.c.

References read_tar_number(), and tarChecksum().

Referenced by _discoverArchiveFormat().

1049 {
1050  int sum;
1051  int chk = tarChecksum(header);
1052 
1053  sum = read_tar_number(&header[148], 8);
1054 
1055  if (sum != chk)
1056  return false;
1057 
1058  /* POSIX tar format */
1059  if (memcmp(&header[257], "ustar\0", 6) == 0 &&
1060  memcmp(&header[263], "00", 2) == 0)
1061  return true;
1062  /* GNU tar format */
1063  if (memcmp(&header[257], "ustar \0", 8) == 0)
1064  return true;
1065  /* not-quite-POSIX format written by pre-9.3 pg_dump */
1066  if (memcmp(&header[257], "ustar00\0", 8) == 0)
1067  return true;
1068 
1069  return false;
1070 }
uint64 read_tar_number(const char *s, int len)
Definition: tar.c:58
int tarChecksum(char *header)
Definition: tar.c:90
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:209

◆ on_exit_close_archive()

void on_exit_close_archive ( Archive AHX)

Definition at line 342 of file parallel.c.

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

Referenced by main().

343 {
344  shutdown_info.AHX = AHX;
346 }
void on_exit_nicely(on_exit_nicely_callback function, void *arg)
static ShutdownInformation shutdown_info
Definition: parallel.c:149
static void archive_close_connection(int code, void *arg)
Definition: parallel.c:353

◆ parallel_restore()

int parallel_restore ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 4444 of file pg_backup_archiver.c.

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

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

4445 {
4446  int status;
4447 
4448  Assert(AH->connection != NULL);
4449 
4450  /* Count only errors associated with this TOC entry */
4451  AH->public.n_errors = 0;
4452 
4453  /* Restore the TOC item */
4454  status = restore_toc_entry(AH, te, true);
4455 
4456  return status;
4457 }
int n_errors
Definition: pg_backup.h:206
static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel)
#define Assert(condition)
Definition: c.h:733
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:226

◆ ReadHead()

void ReadHead ( ArchiveHandle AH)

Definition at line 3773 of file pg_backup_archiver.c.

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

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

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

◆ ReadInt()

int ReadInt ( ArchiveHandle AH)

Definition at line 2014 of file pg_backup_archiver.c.

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

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

2015 {
2016  int res = 0;
2017  int bv,
2018  b;
2019  int sign = 0; /* Default positive */
2020  int bitShift = 0;
2021 
2022  if (AH->version > K_VERS_1_0)
2023  /* Read a sign byte */
2024  sign = AH->ReadBytePtr(AH);
2025 
2026  for (b = 0; b < AH->intSize; b++)
2027  {
2028  bv = AH->ReadBytePtr(AH) & 0xFF;
2029  if (bv != 0)
2030  res = res + (bv << bitShift);
2031  bitShift += 8;
2032  }
2033 
2034  if (sign)
2035  res = -res;
2036 
2037  return res;
2038 }
#define K_VERS_1_0
ReadBytePtrType ReadBytePtr
char sign
Definition: informix.c:688

◆ ReadOffset()

int ReadOffset ( ArchiveHandle ,
pgoff_t  
)

Definition at line 1919 of file pg_backup_archiver.c.

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

Referenced by _ReadExtraToc().

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

◆ ReadStr()

char* ReadStr ( ArchiveHandle AH)

Definition at line 2060 of file pg_backup_archiver.c.

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

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

2061 {
2062  char *buf;
2063  int l;
2064 
2065  l = ReadInt(AH);
2066  if (l < 0)
2067  buf = NULL;
2068  else
2069  {
2070  buf = (char *) pg_malloc(l + 1);
2071  AH->ReadBufPtr(AH, (void *) buf, l);
2072 
2073  buf[l] = '\0';
2074  }
2075 
2076  return buf;
2077 }
ReadBufPtrType ReadBufPtr
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
int ReadInt(ArchiveHandle *AH)
static char * buf
Definition: pg_test_fsync.c:67

◆ ReadToc()

void ReadToc ( ArchiveHandle AH)

Definition at line 2568 of file pg_backup_archiver.c.

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, fatal, 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_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().

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

◆ ReconnectToServer()

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

Definition at line 79 of file pg_backup_db.c.

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

Referenced by _reconnectToDB().

80 {
81  PGconn *newConn;
82  const char *newdbname;
83  const char *newusername;
84 
85  if (!dbname)
86  newdbname = PQdb(AH->connection);
87  else
88  newdbname = dbname;
89 
90  if (!username)
91  newusername = PQuser(AH->connection);
92  else
93  newusername = username;
94 
95  newConn = _connectDB(AH, newdbname, newusername);
96 
97  /* Update ArchiveHandle's connCancel before closing old connection */
98  set_archive_cancel_info(AH, newConn);
99 
100  PQfinish(AH->connection);
101  AH->connection = newConn;
102 
103  /* Start strict; later phases may override this. */
106 }
static PGconn * _connectDB(ArchiveHandle *AH, const char *newdbname, const char *newUser)
Definition: pg_backup_db.c:118
void PQfinish(PGconn *conn)
Definition: fe-connect.c:4119
char * PQuser(const PGconn *conn)
Definition: fe-connect.c:6475
PGresult * ExecuteSqlQueryForSingleRow(Archive *fout, const char *query)
Definition: pg_backup_db.c:416
static char * username
Definition: initdb.c:133
void PQclear(PGresult *res)
Definition: fe-exec.c:694
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:6467
char * dbname
Definition: streamutil.c:50
#define ALWAYS_SECURE_SEARCH_PATH_SQL
Definition: connect.h:25
void set_archive_cancel_info(ArchiveHandle *AH, PGconn *conn)
Definition: parallel.c:739

◆ StartRestoreBlob()

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

Definition at line 1299 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

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

◆ StartRestoreBlobs()

void StartRestoreBlobs ( ArchiveHandle AH)

Definition at line 1257 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

1258 {
1259  RestoreOptions *ropt = AH->public.ropt;
1260 
1261  if (!ropt->single_txn)
1262  {
1263  if (AH->connection)
1264  StartTransaction(&AH->public);
1265  else
1266  ahprintf(AH, "BEGIN;\n\n");
1267  }
1268 
1269  AH->blobCount = 0;
1270 }
RestoreOptions * ropt
Definition: pg_backup.h:183
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
static void StartTransaction(void)
Definition: xact.c:1886

◆ TocIDRequired()

teReqs TocIDRequired ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1891 of file pg_backup_archiver.c.

References getTocEntryByDumpId(), and _tocEntry::reqs.

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

1892 {
1893  TocEntry *te = getTocEntryByDumpId(AH, id);
1894 
1895  if (!te)
1896  return 0;
1897 
1898  return te->reqs;
1899 }
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)

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

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

2395 {
2396  TocEntry *te;
2397 
2398  if (pstate && pstate->numWorkers > 1)
2399  {
2400  /*
2401  * In parallel mode, this code runs in the master process. We
2402  * construct an array of candidate TEs, then sort it into decreasing
2403  * size order, then dispatch each TE to a data-transfer worker. By
2404  * dumping larger tables first, we avoid getting into a situation
2405  * where we're down to one job and it's big, losing parallelism.
2406  */
2407  TocEntry **tes;
2408  int ntes;
2409 
2410  tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
2411  ntes = 0;
2412  for (te = AH->toc->next; te != AH->toc; te = te->next)
2413  {
2414  /* Consider only TEs with dataDumper functions ... */
2415  if (!te->dataDumper)
2416  continue;
2417  /* ... and ignore ones not enabled for dump */
2418  if ((te->reqs & REQ_DATA) == 0)
2419  continue;
2420 
2421  tes[ntes++] = te;
2422  }
2423 
2424  if (ntes > 1)
2425  qsort((void *) tes, ntes, sizeof(TocEntry *),
2427 
2428  for (int i = 0; i < ntes; i++)
2429  DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
2430  mark_dump_job_done, NULL);
2431 
2432  pg_free(tes);
2433 
2434  /* Now wait for workers to finish. */
2435  WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2436  }
2437  else
2438  {
2439  /* Non-parallel mode: just dump all candidate TEs sequentially. */
2440  for (te = AH->toc->next; te != AH->toc; te = te->next)
2441  {
2442  /* Must have same filter conditions as above */
2443  if (!te->dataDumper)
2444  continue;
2445  if ((te->reqs & REQ_DATA) == 0)
2446  continue;
2447 
2449  }
2450  }
2451 }
struct _tocEntry * next
static int TocEntrySizeCompare(const void *p1, const void *p2)
void DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te, T_Action act, ParallelCompletionPtr callback, void *callback_data)
Definition: parallel.c:1218
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
DataDumperPtr dataDumper
struct _tocEntry * toc
void WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
Definition: parallel.c:1464
void pg_free(void *ptr)
Definition: fe_memutils.c:105
void WriteDataChunksForTocEntry(ArchiveHandle *AH, TocEntry *te)
int i
#define qsort(a, b, c, d)
Definition: port.h:492
static void mark_dump_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
int numWorkers
Definition: parallel.h:42

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 2476 of file pg_backup_archiver.c.

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

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

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

◆ WriteHead()

void WriteHead ( ArchiveHandle AH)

Definition at line 3747 of file pg_backup_archiver.c.

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

Referenced by _CloseArchive().

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

◆ WriteInt()

size_t WriteInt ( ArchiveHandle AH,
int  i 
)

Definition at line 1983 of file pg_backup_archiver.c.

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

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

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

◆ WriteOffset()

size_t WriteOffset ( ArchiveHandle ,
pgoff_t  ,
int   
)

Definition at line 1902 of file pg_backup_archiver.c.

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

1903 {
1904  int off;
1905 
1906  /* Save the flag */
1907  AH->WriteBytePtr(AH, wasSet);
1908 
1909  /* Write out pgoff_t smallest byte first, prevents endian mismatch */
1910  for (off = 0; off < sizeof(pgoff_t); off++)
1911  {
1912  AH->WriteBytePtr(AH, o & 0xFF);
1913  o >>= 8;
1914  }
1915  return sizeof(pgoff_t) + 1;
1916 }
#define pgoff_t
Definition: win32_port.h:195

◆ WriteStr()

size_t WriteStr ( ArchiveHandle AH,
const char *  s 
)

Definition at line 2041 of file pg_backup_archiver.c.

References _archiveHandle::WriteBufPtr, and WriteInt().

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

2042 {
2043  size_t res;
2044 
2045  if (c)
2046  {
2047  int len = strlen(c);
2048 
2049  res = WriteInt(AH, len);
2050  AH->WriteBufPtr(AH, c, len);
2051  res += len;
2052  }
2053  else
2054  res = WriteInt(AH, -1);
2055 
2056  return res;
2057 }
WriteBufPtrType WriteBufPtr
char * c
size_t WriteInt(ArchiveHandle *AH, int i)

◆ WriteToc()

void WriteToc ( ArchiveHandle AH)

Definition at line 2509 of file pg_backup_archiver.c.

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

Referenced by _CloseArchive().

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