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  _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 443 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 440 of file pg_backup_archiver.h.

Referenced by _doSetSessionAuth().

◆ ARCHIVE_MAJOR

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

Definition at line 70 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_MINOR

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

Definition at line 71 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ ARCHIVE_OPTS

◆ ARCHIVE_REV

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

Definition at line 72 of file pg_backup_archiver.h.

Referenced by PrintTOCSummary(), and WriteHead().

◆ BLK_BLOBS

#define BLK_BLOBS   3

Definition at line 65 of file pg_backup_archiver.h.

Referenced by _PrintTocData(), and _StartBlobs().

◆ BLK_DATA

#define BLK_DATA   1

Definition at line 64 of file pg_backup_archiver.h.

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

◆ GZCLOSE

#define GZCLOSE (   fh)    fclose(fh)

Definition at line 46 of file pg_backup_archiver.h.

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

◆ GZEOF

#define GZEOF (   fh)    feof(fh)

Definition at line 49 of file pg_backup_archiver.h.

Referenced by _tarReadRaw().

◆ GZREAD

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

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

Referenced by ahwrite(), and tarWrite().

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA   3

Definition at line 110 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 108 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 109 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 75 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 88 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 89 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 91 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 93 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 95 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 76 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 77 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 78 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 79 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 80 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 81 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 83 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 86 of file pg_backup_archiver.h.

Referenced by ReadToc().

◆ K_VERS_MAJOR

#define K_VERS_MAJOR   1

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

Referenced by ReadHead().

◆ K_VERS_MINOR

#define K_VERS_MINOR   14

Definition at line 99 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV   0

Definition at line 100 of file pg_backup_archiver.h.

◆ K_VERS_SELF

Definition at line 101 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 68 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 125 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 225 of file pg_backup_archiver.h.

Referenced by restore_toc_entries_parallel().

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE   10

Definition at line 117 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 118 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 116 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 133 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 51 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 146 of file pg_backup_archiver.h.

◆ ArchiveHandle

typedef struct _archiveHandle ArchiveHandle

Definition at line 121 of file pg_backup_archiver.h.

◆ ArchiveOpts

typedef void struct _archiveOpts ArchiveOpts

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 167 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 144 of file pg_backup_archiver.h.

◆ CustomOutPtrType

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

Definition at line 173 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 168 of file pg_backup_archiver.h.

◆ EndBlobPtrType

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

Definition at line 154 of file pg_backup_archiver.h.

◆ EndBlobsPtrType

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

Definition at line 155 of file pg_backup_archiver.h.

◆ EndDataPtrType

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

Definition at line 150 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 166 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

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

Definition at line 163 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

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

Definition at line 164 of file pg_backup_archiver.h.

◆ ReadBufPtrType

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

Definition at line 160 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 158 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

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

Definition at line 162 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 145 of file pg_backup_archiver.h.

◆ StartBlobPtrType

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

Definition at line 153 of file pg_backup_archiver.h.

◆ StartBlobsPtrType

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

Definition at line 152 of file pg_backup_archiver.h.

◆ StartDataPtrType

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

Definition at line 148 of file pg_backup_archiver.h.

◆ T_Action

typedef enum T_Action T_Action

◆ TocEntry

typedef struct _tocEntry TocEntry

Definition at line 122 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

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

Definition at line 170 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

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

Definition at line 171 of file pg_backup_archiver.h.

◆ WriteBufPtrType

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

Definition at line 159 of file pg_backup_archiver.h.

◆ WriteBytePtrType

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

Definition at line 157 of file pg_backup_archiver.h.

◆ WriteDataPtrType

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

Definition at line 149 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

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

Definition at line 161 of file pg_backup_archiver.h.

◆ z_stream

typedef struct _z_stream z_stream

◆ z_streamp

typedef z_stream* z_streamp

Definition at line 60 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

Enumerator
OUTPUT_SQLCMDS 
OUTPUT_COPYDATA 
OUTPUT_OTHERDATA 

Definition at line 197 of file pg_backup_archiver.h.

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

◆ ArchiverStage

Enumerator
STAGE_NONE 
STAGE_INITIALIZING 
STAGE_PROCESSING 
STAGE_FINALIZING 

Definition at line 189 of file pg_backup_archiver.h.

◆ RestorePass

Enumerator
RESTORE_PASS_MAIN 
RESTORE_PASS_ACL 

Definition at line 219 of file pg_backup_archiver.h.

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

◆ sqlparseState

Enumerator
SQL_SCAN 
SQL_IN_SINGLE_QUOTE 
SQL_IN_DOUBLE_QUOTE 

Definition at line 175 of file pg_backup_archiver.h.

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

◆ T_Action

enum T_Action
Enumerator
ACT_DUMP 
ACT_RESTORE 

Definition at line 138 of file pg_backup_archiver.h.

◆ teReqs

enum teReqs
Enumerator
REQ_SCHEMA 
REQ_DATA 
REQ_SPECIAL 

Definition at line 228 of file pg_backup_archiver.h.

229 {
230  REQ_SCHEMA = 0x01, /* want schema */
231  REQ_DATA = 0x02, /* want data */
232  REQ_SPECIAL = 0x04 /* for special TOC entries */
233 } 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 1693 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().

1694 {
1695  int bytes_written = 0;
1696 
1697  if (AH->writingBlob)
1698  {
1699  size_t remaining = size * nmemb;
1700 
1701  while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1702  {
1703  size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1704 
1705  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1706  ptr = (const void *) ((const char *) ptr + avail);
1707  remaining -= avail;
1708  AH->lo_buf_used += avail;
1709  dump_lo_buf(AH);
1710  }
1711 
1712  memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1713  AH->lo_buf_used += remaining;
1714 
1715  bytes_written = size * nmemb;
1716  }
1717  else if (AH->gzOut)
1718  bytes_written = GZWRITE(ptr, size, nmemb, AH->OF);
1719  else if (AH->CustomOutPtr)
1720  bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1721 
1722  else
1723  {
1724  /*
1725  * If we're doing a restore, and it's direct to DB, and we're
1726  * connected then send it to the DB.
1727  */
1728  if (RestoringToDB(AH))
1729  bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1730  else
1731  bytes_written = fwrite(ptr, size, nmemb, AH->OF) * size;
1732  }
1733 
1734  if (bytes_written != size * nmemb)
1736 }
int remaining
Definition: informix.c:667
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 1061 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().

1063 {
1064  ArchiveHandle *AH = (ArchiveHandle *) AHX;
1065  TocEntry *newToc;
1066 
1067  newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
1068 
1069  AH->tocCount++;
1070  if (dumpId > AH->maxDumpId)
1071  AH->maxDumpId = dumpId;
1072 
1073  newToc->prev = AH->toc->prev;
1074  newToc->next = AH->toc;
1075  AH->toc->prev->next = newToc;
1076  AH->toc->prev = newToc;
1077 
1078  newToc->catalogId = catalogId;
1079  newToc->dumpId = dumpId;
1080  newToc->section = opts->section;
1081 
1082  newToc->tag = pg_strdup(opts->tag);
1083  newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
1084  newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
1085  newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
1086  newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
1087  newToc->desc = pg_strdup(opts->description);
1088  newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
1089  newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
1090  newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
1091 
1092  if (opts->nDeps > 0)
1093  {
1094  newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
1095  memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
1096  newToc->nDeps = opts->nDeps;
1097  }
1098  else
1099  {
1100  newToc->dependencies = NULL;
1101  newToc->nDeps = 0;
1102  }
1103 
1104  newToc->dataDumper = opts->dumpFn;
1105  newToc->dataDumperArg = opts->dumpArg;
1106  newToc->hadDumper = opts->dumpFn ? true : false;
1107 
1108  newToc->formatData = NULL;
1109  newToc->dataLength = 0;
1110 
1111  if (AH->ArchiveEntryPtr != NULL)
1112  AH->ArchiveEntryPtr(AH, newToc);
1113 
1114  return newToc;
1115 }
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 3871 of file pg_backup_archiver.c.

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

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

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

4895 {
4896  /* Should not have an open database connection */
4897  Assert(AH->connection == NULL);
4898 
4899  /* Clear format-specific state */
4900  AH->DeClonePtr(AH);
4901 
4902  /* Clear state allocated by CloneArchive */
4903  if (AH->sqlparse.curCmd)
4905 
4906  /* Clear any connection-local state */
4907  if (AH->currUser)
4908  free(AH->currUser);
4909  if (AH->currSchema)
4910  free(AH->currSchema);
4911  if (AH->currTablespace)
4912  free(AH->currTablespace);
4913  if (AH->currTableAm)
4914  free(AH->currTableAm);
4915  if (AH->savedPassword)
4916  free(AH->savedPassword);
4917 
4918  free(AH);
4919 }
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:739

◆ 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:6621
int ahprintf(ArchiveHandle *AH, const char *fmt,...)

◆ EndRestoreBlob()

void EndRestoreBlob ( ArchiveHandle AH,
Oid  oid 
)

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

1342 {
1343  if (AH->lo_buf_used > 0)
1344  {
1345  /* Write remaining bytes from the LO buffer */
1346  dump_lo_buf(AH);
1347  }
1348 
1349  AH->writingBlob = 0;
1350 
1351  if (AH->connection)
1352  {
1353  lo_close(AH->connection, AH->loFd);
1354  AH->loFd = -1;
1355  }
1356  else
1357  {
1358  ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
1359  }
1360 }
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 1274 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().

1275 {
1276  RestoreOptions *ropt = AH->public.ropt;
1277 
1278  if (!ropt->single_txn)
1279  {
1280  if (AH->connection)
1281  CommitTransaction(&AH->public);
1282  else
1283  ahprintf(AH, "COMMIT;\n\n");
1284  }
1285 
1286  pg_log_info(ngettext("restored %d large object",
1287  "restored %d large objects",
1288  AH->blobCount),
1289  AH->blobCount);
1290 }
RestoreOptions * ropt
Definition: pg_backup.h:183
int ahprintf(ArchiveHandle *AH, const char *fmt,...)
#define ngettext(s, p, n)
Definition: c.h:1133
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 1873 of file pg_backup_archiver.c.

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

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

1874 {
1875  /* build index arrays if we didn't already */
1876  if (AH->tocsByDumpId == NULL)
1877  buildTocEntryArrays(AH);
1878 
1879  if (id > 0 && id <= AH->maxDumpId)
1880  return AH->tocsByDumpId[id];
1881 
1882  return NULL;
1883 }
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:1224
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
StartBlobsPtrType StartBlobsPtr
#define PG_BINARY_R
Definition: c.h:1223
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:649
Definition: dirent.h:9
#define PG_BINARY_R
Definition: c.h:1223
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:452
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:1224
static void _EndBlob(ArchiveHandle *AH, TocEntry *te, Oid oid)
StartBlobsPtrType StartBlobsPtr
#define PG_BINARY_R
Definition: c.h:1223
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 1045 of file pg_backup_tar.c.

References read_tar_number(), and tarChecksum().

Referenced by _discoverArchiveFormat().

1046 {
1047  int sum;
1048  int chk = tarChecksum(header);
1049 
1050  sum = read_tar_number(&header[148], 8);
1051 
1052  if (sum != chk)
1053  return false;
1054 
1055  /* POSIX tar format */
1056  if (memcmp(&header[257], "ustar\0", 6) == 0 &&
1057  memcmp(&header[263], "00", 2) == 0)
1058  return true;
1059  /* GNU tar format */
1060  if (memcmp(&header[257], "ustar \0", 8) == 0)
1061  return true;
1062  /* not-quite-POSIX format written by pre-9.3 pg_dump */
1063  if (memcmp(&header[257], "ustar00\0", 8) == 0)
1064  return true;
1065 
1066  return false;
1067 }
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 4439 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().

4440 {
4441  int status;
4442 
4443  Assert(AH->connection != NULL);
4444 
4445  /* Count only errors associated with this TOC entry */
4446  AH->public.n_errors = 0;
4447 
4448  /* Restore the TOC item */
4449  status = restore_toc_entry(AH, te, true);
4450 
4451  return status;
4452 }
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:739
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 3768 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().

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

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

◆ ReadOffset()

int ReadOffset ( ArchiveHandle ,
pgoff_t  
)

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

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

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

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

2056 {
2057  char *buf;
2058  int l;
2059 
2060  l = ReadInt(AH);
2061  if (l < 0)
2062  buf = NULL;
2063  else
2064  {
2065  buf = (char *) pg_malloc(l + 1);
2066  AH->ReadBufPtr(AH, (void *) buf, l);
2067 
2068  buf[l] = '\0';
2069  }
2070 
2071  return buf;
2072 }
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 2563 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().

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

◆ StartRestoreBlob()

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

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

1298 {
1299  bool old_blob_style = (AH->version < K_VERS_1_12);
1300  Oid loOid;
1301 
1302  AH->blobCount++;
1303 
1304  /* Initialize the LO Buffer */
1305  AH->lo_buf_used = 0;
1306 
1307  pg_log_info("restoring large object with OID %u", oid);
1308 
1309  /* With an old archive we must do drop and create logic here */
1310  if (old_blob_style && drop)
1311  DropBlobIfExists(AH, oid);
1312 
1313  if (AH->connection)
1314  {
1315  if (old_blob_style)
1316  {
1317  loOid = lo_create(AH->connection, oid);
1318  if (loOid == 0 || loOid != oid)
1319  fatal("could not create large object %u: %s",
1320  oid, PQerrorMessage(AH->connection));
1321  }
1322  AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
1323  if (AH->loFd == -1)
1324  fatal("could not open large object %u: %s",
1325  oid, PQerrorMessage(AH->connection));
1326  }
1327  else
1328  {
1329  if (old_blob_style)
1330  ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
1331  oid, INV_WRITE);
1332  else
1333  ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
1334  oid, INV_WRITE);
1335  }
1336 
1337  AH->writingBlob = 1;
1338 }
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:6631
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 1255 of file pg_backup_archiver.c.

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

Referenced by _LoadBlobs().

1256 {
1257  RestoreOptions *ropt = AH->public.ropt;
1258 
1259  if (!ropt->single_txn)
1260  {
1261  if (AH->connection)
1262  StartTransaction(&AH->public);
1263  else
1264  ahprintf(AH, "BEGIN;\n\n");
1265  }
1266 
1267  AH->blobCount = 0;
1268 }
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 1886 of file pg_backup_archiver.c.

References getTocEntryByDumpId(), and _tocEntry::reqs.

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

1887 {
1888  TocEntry *te = getTocEntryByDumpId(AH, id);
1889 
1890  if (!te)
1891  return 0;
1892 
1893  return te->reqs;
1894 }
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 2389 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().

2390 {
2391  TocEntry *te;
2392 
2393  if (pstate && pstate->numWorkers > 1)
2394  {
2395  /*
2396  * In parallel mode, this code runs in the master process. We
2397  * construct an array of candidate TEs, then sort it into decreasing
2398  * size order, then dispatch each TE to a data-transfer worker. By
2399  * dumping larger tables first, we avoid getting into a situation
2400  * where we're down to one job and it's big, losing parallelism.
2401  */
2402  TocEntry **tes;
2403  int ntes;
2404 
2405  tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
2406  ntes = 0;
2407  for (te = AH->toc->next; te != AH->toc; te = te->next)
2408  {
2409  /* Consider only TEs with dataDumper functions ... */
2410  if (!te->dataDumper)
2411  continue;
2412  /* ... and ignore ones not enabled for dump */
2413  if ((te->reqs & REQ_DATA) == 0)
2414  continue;
2415 
2416  tes[ntes++] = te;
2417  }
2418 
2419  if (ntes > 1)
2420  qsort((void *) tes, ntes, sizeof(TocEntry *),
2422 
2423  for (int i = 0; i < ntes; i++)
2424  DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
2425  mark_dump_job_done, NULL);
2426 
2427  pg_free(tes);
2428 
2429  /* Now wait for workers to finish. */
2430  WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2431  }
2432  else
2433  {
2434  /* Non-parallel mode: just dump all candidate TEs sequentially. */
2435  for (te = AH->toc->next; te != AH->toc; te = te->next)
2436  {
2437  /* Must have same filter conditions as above */
2438  if (!te->dataDumper)
2439  continue;
2440  if ((te->reqs & REQ_DATA) == 0)
2441  continue;
2442 
2444  }
2445  }
2446 }
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:1221
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:1467
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:491
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 2471 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().

2472 {
2473  StartDataPtrType startPtr;
2474  EndDataPtrType endPtr;
2475 
2476  AH->currToc = te;
2477 
2478  if (strcmp(te->desc, "BLOBS") == 0)
2479  {
2480  startPtr = AH->StartBlobsPtr;
2481  endPtr = AH->EndBlobsPtr;
2482  }
2483  else
2484  {
2485  startPtr = AH->StartDataPtr;
2486  endPtr = AH->EndDataPtr;
2487  }
2488 
2489  if (startPtr != NULL)
2490  (*startPtr) (AH, te);
2491 
2492  /*
2493  * The user-provided DataDumper routine needs to call AH->WriteData
2494  */
2495  te->dataDumper((Archive *) AH, te->dataDumperArg);
2496 
2497  if (endPtr != NULL)
2498  (*endPtr) (AH, te);
2499 
2500  AH->currToc = NULL;
2501 }
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 3742 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().

3743 {
3744  struct tm crtm;
3745 
3746  AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
3747  AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
3748  AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
3749  AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
3750  AH->WriteBytePtr(AH, AH->intSize);
3751  AH->WriteBytePtr(AH, AH->offSize);
3752  AH->WriteBytePtr(AH, AH->format);
3753  WriteInt(AH, AH->compression);
3754  crtm = *localtime(&AH->createDate);
3755  WriteInt(AH, crtm.tm_sec);
3756  WriteInt(AH, crtm.tm_min);
3757  WriteInt(AH, crtm.tm_hour);
3758  WriteInt(AH, crtm.tm_mday);
3759  WriteInt(AH, crtm.tm_mon);
3760  WriteInt(AH, crtm.tm_year);
3761  WriteInt(AH, crtm.tm_isdst);
3762  WriteStr(AH, PQdb(AH->connection));
3763  WriteStr(AH, AH->public.remoteVersionStr);
3764  WriteStr(AH, PG_VERSION);
3765 }
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:6481
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 1978 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().

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

◆ WriteOffset()

size_t WriteOffset ( ArchiveHandle ,
pgoff_t  ,
int   
)

Definition at line 1897 of file pg_backup_archiver.c.

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

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

◆ WriteStr()

size_t WriteStr ( ArchiveHandle AH,
const char *  s 
)

Definition at line 2036 of file pg_backup_archiver.c.

References _archiveHandle::WriteBufPtr, and WriteInt().

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

2037 {
2038  size_t res;
2039 
2040  if (c)
2041  {
2042  int len = strlen(c);
2043 
2044  res = WriteInt(AH, len);
2045  AH->WriteBufPtr(AH, c, len);
2046  res += len;
2047  }
2048  else
2049  res = WriteInt(AH, -1);
2050 
2051  return res;
2052 }
WriteBufPtrType WriteBufPtr
char * c
size_t WriteInt(ArchiveHandle *AH, int i)

◆ WriteToc()

void WriteToc ( ArchiveHandle AH)

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

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