#include "postgres_fe.h"
#include <dirent.h>
#include <sys/stat.h>
#include "common/file_utils.h"
#include "compress_io.h"
#include "parallel.h"
#include "pg_backup_utils.h"

Include dependency graph for pg_backup_directory.c:

Data Structures
struct	lclContext

struct	lclTocEntry

Functions
static void	_ArchiveEntry (ArchiveHandle AH, TocEntry te)

static void	_StartData (ArchiveHandle AH, TocEntry te)

static void	_EndData (ArchiveHandle AH, TocEntry te)

static void	_WriteData (ArchiveHandle AH, const void data, size_t dLen)

static int	_WriteByte (ArchiveHandle *AH, const int i)

static int	_ReadByte (ArchiveHandle *)

static void	_WriteBuf (ArchiveHandle AH, const void buf, size_t len)

static void	_ReadBuf (ArchiveHandle AH, void buf, size_t len)

static void	_CloseArchive (ArchiveHandle *AH)

static void	_ReopenArchive (ArchiveHandle *AH)

static void	_PrintTocData (ArchiveHandle AH, TocEntry te)

static void	_WriteExtraToc (ArchiveHandle AH, TocEntry te)

static void	_ReadExtraToc (ArchiveHandle AH, TocEntry te)

static void	_PrintExtraToc (ArchiveHandle AH, TocEntry te)

static void	_StartBlobs (ArchiveHandle AH, TocEntry te)

static void	_StartBlob (ArchiveHandle AH, TocEntry te, Oid oid)

static void	_EndBlob (ArchiveHandle AH, TocEntry te, Oid oid)

static void	_EndBlobs (ArchiveHandle AH, TocEntry te)

static void	_LoadBlobs (ArchiveHandle *AH)

static void	_PrepParallelRestore (ArchiveHandle *AH)

static void	_Clone (ArchiveHandle *AH)

static void	_DeClone (ArchiveHandle *AH)

static int	_WorkerJobRestoreDirectory (ArchiveHandle AH, TocEntry te)

static int	_WorkerJobDumpDirectory (ArchiveHandle AH, TocEntry te)

static void	setFilePath (ArchiveHandle AH, char buf, const char *relativeFilename)

void	InitArchiveFmt_Directory (ArchiveHandle *AH)

static void	_PrintFileData (ArchiveHandle AH, char filename)

Function Documentation

◆ _ArchiveEntry()

static void _ArchiveEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 233 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx;
     char        fn[MAXPGPATH];
  
     tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
     if (strcmp(te->desc, "BLOBS") == 0)
         tctx->filename = pg_strdup("blobs.toc");
     else if (te->dataDumper)
     {
         snprintf(fn, MAXPGPATH, "%d.dat", te->dumpId);
         tctx->filename = pg_strdup(fn);
     }
     else
         tctx->filename = NULL;
  
     te->formatData = (void *) tctx;
 }

References _tocEntry::dataDumper, _tocEntry::desc, _tocEntry::dumpId, lclTocEntry::filename, fn(), _tocEntry::formatData, MAXPGPATH, pg_malloc0(), pg_strdup(), and snprintf.

Referenced by InitArchiveFmt_Directory().

◆ _Clone()

static void _Clone ( ArchiveHandle * AH )

static

Definition at line 797 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     AH->formatData = (lclContext *) pg_malloc(sizeof(lclContext));
     memcpy(AH->formatData, ctx, sizeof(lclContext));
     ctx = (lclContext *) AH->formatData;
  
     /*
      * Note: we do not make a local lo_buf because we expect at most one BLOBS
      * entry per archive, so no parallelism is possible.  Likewise,
      * TOC-entry-local state isn't an issue because any one TOC entry is
      * touched by just one worker child.
      */
  
     /*
      * We also don't copy the ParallelState pointer (pstate), only the leader
      * process ever writes to it.
      */
 }

References _archiveHandle::formatData, and pg_malloc().

Referenced by InitArchiveFmt_Directory().

◆ _CloseArchive()

static void _CloseArchive ( ArchiveHandle * AH )

static

Definition at line 569 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     if (AH->mode == archModeWrite)
     {
         cfp        *tocFH;
         char        fname[MAXPGPATH];
  
         setFilePath(AH, fname, "toc.dat");
  
         /* this will actually fork the processes for a parallel backup */
         ctx->pstate = ParallelBackupStart(AH);
  
         /* The TOC is always created uncompressed */
         tocFH = cfopen_write(fname, PG_BINARY_W, 0);
         if (tocFH == NULL)
             pg_fatal("could not open output file \"%s\": %m", fname);
         ctx->dataFH = tocFH;
  
         /*
          * Write 'tar' in the format field of the toc.dat file. The directory
          * is compatible with 'tar', so there's no point having a different
          * format code for it.
          */
         AH->format = archTar;
         WriteHead(AH);
         AH->format = archDirectory;
         WriteToc(AH);
         if (cfclose(tocFH) != 0)
             pg_fatal("could not close TOC file: %m");
         WriteDataChunks(AH, ctx->pstate);
  
         ParallelBackupEnd(AH, ctx->pstate);
  
         /*
          * In directory mode, there is no need to sync all the entries
          * individually. Just recurse once through all the files generated.
          */
         if (AH->dosync)
             fsync_dir_recurse(ctx->directory);
     }
     AH->FH = NULL;
 }

References archDirectory, archModeWrite, archTar, cfclose(), cfopen_write(), lclContext::dataFH, lclContext::directory, _archiveHandle::dosync, _archiveHandle::FH, _archiveHandle::format, _archiveHandle::formatData, if(), MAXPGPATH, _archiveHandle::mode, ParallelBackupEnd(), ParallelBackupStart(), PG_BINARY_W, pg_fatal, lclContext::pstate, setFilePath(), WriteDataChunks(), WriteHead(), and WriteToc().

Referenced by InitArchiveFmt_Directory().

◆ _DeClone()

static void _DeClone ( ArchiveHandle * AH )

static

Definition at line 819 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     free(ctx);
 }

References _archiveHandle::formatData, and free.

Referenced by InitArchiveFmt_Directory().

◆ _EndBlob()

static void _EndBlob	(	ArchiveHandle *	AH,
		TocEntry *	te,
		Oid	oid
	)

static

Definition at line 677 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char        buf[50];
     int         len;
  
     /* Close the BLOB data file itself */
     if (cfclose(ctx->dataFH) != 0)
         pg_fatal("could not close blob data file: %m");
     ctx->dataFH = NULL;
  
     /* register the blob in blobs.toc */
     len = snprintf(buf, sizeof(buf), "%u blob_%u.dat\n", oid, oid);
     if (cfwrite(buf, len, ctx->blobsTocFH) != len)
         pg_fatal("could not write to blobs TOC file");
 }

References lclContext::blobsTocFH, buf, cfclose(), cfwrite(), lclContext::dataFH, _archiveHandle::formatData, if(), len, pg_fatal, and snprintf.

Referenced by InitArchiveFmt_Directory().

◆ _EndBlobs()

static void _EndBlobs	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 700 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     if (cfclose(ctx->blobsTocFH) != 0)
         pg_fatal("could not close blobs TOC file: %m");
     ctx->blobsTocFH = NULL;
 }

References lclContext::blobsTocFH, cfclose(), _archiveHandle::formatData, if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _EndData()

static void _EndData	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 367 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     /* Close the file */
     if (cfclose(ctx->dataFH) != 0)
         pg_fatal("could not close data file: %m");
  
     ctx->dataFH = NULL;
 }

References cfclose(), lclContext::dataFH, _archiveHandle::formatData, if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _LoadBlobs()

static void _LoadBlobs ( ArchiveHandle * AH )

static

Definition at line 433 of file pg_backup_directory.c.

 {
     Oid         oid;
     lclContext *ctx = (lclContext *) AH->formatData;
     char        tocfname[MAXPGPATH];
     char        line[MAXPGPATH];
  
     StartRestoreBlobs(AH);
  
     setFilePath(AH, tocfname, "blobs.toc");
  
     ctx->blobsTocFH = cfopen_read(tocfname, PG_BINARY_R);
  
     if (ctx->blobsTocFH == NULL)
         pg_fatal("could not open large object TOC file \"%s\" for input: %m",
                  tocfname);
  
     /* Read the blobs TOC file line-by-line, and process each blob */
     while ((cfgets(ctx->blobsTocFH, line, MAXPGPATH)) != NULL)
     {
         char        blobfname[MAXPGPATH + 1];
         char        path[MAXPGPATH];
  
         /* Can't overflow because line and blobfname are the same length */
         if (sscanf(line, "%u %" CppAsString2(MAXPGPATH) "s\n", &oid, blobfname) != 2)
             pg_fatal("invalid line in large object TOC file \"%s\": \"%s\"",
                      tocfname, line);
  
         StartRestoreBlob(AH, oid, AH->public.ropt->dropSchema);
         snprintf(path, MAXPGPATH, "%s/%s", ctx->directory, blobfname);
         _PrintFileData(AH, path);
         EndRestoreBlob(AH, oid);
     }
     if (!cfeof(ctx->blobsTocFH))
         pg_fatal("error reading large object TOC file \"%s\"",
                  tocfname);
  
     if (cfclose(ctx->blobsTocFH) != 0)
         pg_fatal("could not close large object TOC file \"%s\": %m",
                  tocfname);
  
     ctx->blobsTocFH = NULL;
  
     EndRestoreBlobs(AH);
 }

References _PrintFileData(), lclContext::blobsTocFH, cfclose(), cfeof(), cfgets(), cfopen_read(), CppAsString2, lclContext::directory, _restoreOptions::dropSchema, EndRestoreBlob(), EndRestoreBlobs(), _archiveHandle::formatData, MAXPGPATH, PG_BINARY_R, pg_fatal, _archiveHandle::public, Archive::ropt, setFilePath(), snprintf, StartRestoreBlob(), and StartRestoreBlobs().

Referenced by _PrintTocData().

◆ _PrepParallelRestore()

static void _PrepParallelRestore ( ArchiveHandle * AH )

static

Definition at line 742 of file pg_backup_directory.c.

 {
     TocEntry   *te;
  
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         lclTocEntry *tctx = (lclTocEntry *) te->formatData;
         char        fname[MAXPGPATH];
         struct stat st;
  
         /*
          * A dumpable object has set tctx->filename, any other object has not.
          * (see _ArchiveEntry).
          */
         if (tctx->filename == NULL)
             continue;
  
         /* We may ignore items not due to be restored */
         if ((te->reqs & REQ_DATA) == 0)
             continue;
  
         /*
          * Stat the file and, if successful, put its size in dataLength.  When
          * using compression, the physical file size might not be a very good
          * guide to the amount of work involved in restoring the file, but we
          * only need an approximate indicator of that.
          */
         setFilePath(AH, fname, tctx->filename);
  
         if (stat(fname, &st) == 0)
             te->dataLength = st.st_size;
         else
         {
             /* It might be compressed */
             strlcat(fname, ".gz", sizeof(fname));
             if (stat(fname, &st) == 0)
                 te->dataLength = st.st_size;
         }
  
         /*
          * If this is the BLOBS entry, what we stat'd was blobs.toc, which
          * most likely is a lot smaller than the actual blob data.  We don't
          * have a cheap way to estimate how much smaller, but fortunately it
          * doesn't matter too much as long as we get the blobs processed
          * reasonably early.  Arbitrarily scale up by a factor of 1K.
          */
         if (strcmp(te->desc, "BLOBS") == 0)
             te->dataLength *= 1024;
     }
 }

References _tocEntry::dataLength, _tocEntry::desc, lclTocEntry::filename, _tocEntry::formatData, if(), MAXPGPATH, _tocEntry::next, REQ_DATA, _tocEntry::reqs, setFilePath(), stat, strlcat(), and _archiveHandle::toc.

Referenced by InitArchiveFmt_Directory().

◆ _PrintExtraToc()

static void _PrintExtraToc	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 304 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     if (AH->public.verbose && tctx->filename)
         ahprintf(AH, "-- File: %s\n", tctx->filename);
 }

References ahprintf(), lclTocEntry::filename, _tocEntry::formatData, if(), _archiveHandle::public, and Archive::verbose.

Referenced by InitArchiveFmt_Directory().

◆ _PrintFileData()

static void _PrintFileData	(	ArchiveHandle *	AH,
		char *	filename
	)

static

Definition at line 382 of file pg_backup_directory.c.

 {
     size_t      cnt;
     char       *buf;
     size_t      buflen;
     cfp        *cfp;
  
     if (!filename)
         return;
  
     cfp = cfopen_read(filename, PG_BINARY_R);
  
     if (!cfp)
         pg_fatal("could not open input file \"%s\": %m", filename);
  
     buf = pg_malloc(ZLIB_OUT_SIZE);
     buflen = ZLIB_OUT_SIZE;
  
     while ((cnt = cfread(buf, buflen, cfp)))
     {
         ahwrite(buf, 1, cnt, AH);
     }
  
     free(buf);
     if (cfclose(cfp) != 0)
         pg_fatal("could not close data file \"%s\": %m", filename);
 }

References ahwrite(), buf, cfclose(), cfopen_read(), cfread(), filename, free, PG_BINARY_R, pg_fatal, pg_malloc(), and ZLIB_OUT_SIZE.

Referenced by _LoadBlobs(), and _PrintTocData().

◆ _PrintTocData()

static void _PrintTocData	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 414 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     if (!tctx->filename)
         return;
  
     if (strcmp(te->desc, "BLOBS") == 0)
         _LoadBlobs(AH);
     else
     {
         char        fname[MAXPGPATH];
  
         setFilePath(AH, fname, tctx->filename);
         _PrintFileData(AH, fname);
     }
 }

References _LoadBlobs(), _PrintFileData(), _tocEntry::desc, lclTocEntry::filename, _tocEntry::formatData, if(), MAXPGPATH, and setFilePath().

Referenced by InitArchiveFmt_Directory().

◆ _ReadBuf()

static void _ReadBuf	(	ArchiveHandle *	AH,
		void *	buf,
		size_t	len
	)

static

Definition at line 544 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     /*
      * If there was an I/O error, we already exited in cfread(), so here we
      * exit on short reads.
      */
     if (cfread(buf, len, ctx->dataFH) != len)
         pg_fatal("could not read from input file: end of file");
 }

References buf, cfread(), lclContext::dataFH, _archiveHandle::formatData, if(), len, and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _ReadByte()

static int _ReadByte ( ArchiveHandle * AH )

static

Definition at line 511 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     return cfgetc(ctx->dataFH);
 }

References cfgetc(), lclContext::dataFH, and _archiveHandle::formatData.

Referenced by InitArchiveFmt_Directory().

◆ _ReadExtraToc()

static void _ReadExtraToc	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 281 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     if (tctx == NULL)
     {
         tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
         te->formatData = (void *) tctx;
     }
  
     tctx->filename = ReadStr(AH);
     if (strlen(tctx->filename) == 0)
     {
         free(tctx->filename);
         tctx->filename = NULL;
     }
 }

References lclTocEntry::filename, _tocEntry::formatData, free, if(), pg_malloc0(), and ReadStr().

Referenced by InitArchiveFmt_Directory().

◆ _ReopenArchive()

static void _ReopenArchive ( ArchiveHandle * AH )

static

Definition at line 618 of file pg_backup_directory.c.

 {
     /*
      * Our TOC is in memory, our data files are opened by each child anyway as
      * they are separate. We support reopening the archive by just doing
      * nothing.
      */
 }

Referenced by InitArchiveFmt_Directory().

◆ _StartBlob()

static void _StartBlob	(	ArchiveHandle *	AH,
		TocEntry *	te,
		Oid	oid
	)

static

Definition at line 658 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char        fname[MAXPGPATH];
  
     snprintf(fname, MAXPGPATH, "%s/blob_%u.dat", ctx->directory, oid);
  
     ctx->dataFH = cfopen_write(fname, PG_BINARY_W, AH->compression);
  
     if (ctx->dataFH == NULL)
         pg_fatal("could not open output file \"%s\": %m", fname);
 }

References cfopen_write(), _archiveHandle::compression, lclContext::dataFH, lclContext::directory, _archiveHandle::formatData, MAXPGPATH, PG_BINARY_W, pg_fatal, and snprintf.

Referenced by InitArchiveFmt_Directory().

◆ _StartBlobs()

static void _StartBlobs	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 639 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char        fname[MAXPGPATH];
  
     setFilePath(AH, fname, "blobs.toc");
  
     /* The blob TOC file is never compressed */
     ctx->blobsTocFH = cfopen_write(fname, "ab", 0);
     if (ctx->blobsTocFH == NULL)
         pg_fatal("could not open output file \"%s\": %m", fname);
 }

References lclContext::blobsTocFH, cfopen_write(), _archiveHandle::formatData, MAXPGPATH, pg_fatal, and setFilePath().

Referenced by InitArchiveFmt_Directory().

◆ _StartData()

static void _StartData	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 322 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
     lclContext *ctx = (lclContext *) AH->formatData;
     char        fname[MAXPGPATH];
  
     setFilePath(AH, fname, tctx->filename);
  
     ctx->dataFH = cfopen_write(fname, PG_BINARY_W, AH->compression);
     if (ctx->dataFH == NULL)
         pg_fatal("could not open output file \"%s\": %m", fname);
 }

References cfopen_write(), _archiveHandle::compression, lclTocEntry::filename, _archiveHandle::formatData, _tocEntry::formatData, MAXPGPATH, PG_BINARY_W, pg_fatal, and setFilePath().

Referenced by InitArchiveFmt_Directory().

◆ _WorkerJobDumpDirectory()

static int _WorkerJobDumpDirectory	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 831 of file pg_backup_directory.c.

 {
     /*
      * This function returns void. We either fail and die horribly or
      * succeed... A failure will be detected by the parent when the child dies
      * unexpectedly.
      */
     WriteDataChunksForTocEntry(AH, te);
  
     return 0;
 }

References WriteDataChunksForTocEntry().

Referenced by InitArchiveFmt_Directory().

◆ _WorkerJobRestoreDirectory()

static int _WorkerJobRestoreDirectory	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 848 of file pg_backup_directory.c.

 {
     return parallel_restore(AH, te);
 }

References parallel_restore().

Referenced by InitArchiveFmt_Directory().

◆ _WriteBuf()

static void _WriteBuf	(	ArchiveHandle *	AH,
		const void *	buf,
		size_t	len
	)

static

Definition at line 523 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     errno = 0;
     if (cfwrite(buf, len, ctx->dataFH) != len)
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to output file: %s",
                  get_cfp_error(ctx->dataFH));
     }
 }

References buf, cfwrite(), lclContext::dataFH, _archiveHandle::formatData, get_cfp_error(), if(), len, and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _WriteByte()

static int _WriteByte	(	ArchiveHandle *	AH,
		const int	i
	)

static

Definition at line 486 of file pg_backup_directory.c.

 {
     unsigned char c = (unsigned char) i;
     lclContext *ctx = (lclContext *) AH->formatData;
  
     errno = 0;
     if (cfwrite(&c, 1, ctx->dataFH) != 1)
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to output file: %s",
                  get_cfp_error(ctx->dataFH));
     }
  
     return 1;
 }

References cfwrite(), lclContext::dataFH, _archiveHandle::formatData, get_cfp_error(), i, if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _WriteData()

static void _WriteData	(	ArchiveHandle *	AH,
		const void *	data,
		size_t	dLen
	)

static

Definition at line 345 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     errno = 0;
     if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen)
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to output file: %s",
                  get_cfp_error(ctx->dataFH));
     }
 }

References cfwrite(), data, lclContext::dataFH, _archiveHandle::formatData, get_cfp_error(), if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _WriteExtraToc()

static void _WriteExtraToc	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 260 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     /*
      * A dumpable object has set tctx->filename, any other object has not.
      * (see _ArchiveEntry).
      */
     if (tctx->filename)
         WriteStr(AH, tctx->filename);
     else
         WriteStr(AH, "");
 }

References lclTocEntry::filename, _tocEntry::formatData, if(), and WriteStr().

Referenced by InitArchiveFmt_Directory().

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle * AH )

Definition at line 108 of file pg_backup_directory.c.

 {
     lclContext *ctx;
  
     /* Assuming static functions, this can be copied for each format. */
     AH->ArchiveEntryPtr = _ArchiveEntry;
     AH->StartDataPtr = _StartData;
     AH->WriteDataPtr = _WriteData;
     AH->EndDataPtr = _EndData;
     AH->WriteBytePtr = _WriteByte;
     AH->ReadBytePtr = _ReadByte;
     AH->WriteBufPtr = _WriteBuf;
     AH->ReadBufPtr = _ReadBuf;
     AH->ClosePtr = _CloseArchive;
     AH->ReopenPtr = _ReopenArchive;
     AH->PrintTocDataPtr = _PrintTocData;
     AH->ReadExtraTocPtr = _ReadExtraToc;
     AH->WriteExtraTocPtr = _WriteExtraToc;
     AH->PrintExtraTocPtr = _PrintExtraToc;
  
     AH->StartBlobsPtr = _StartBlobs;
     AH->StartBlobPtr = _StartBlob;
     AH->EndBlobPtr = _EndBlob;
     AH->EndBlobsPtr = _EndBlobs;
  
     AH->PrepParallelRestorePtr = _PrepParallelRestore;
     AH->ClonePtr = _Clone;
     AH->DeClonePtr = _DeClone;
  
     AH->WorkerJobRestorePtr = _WorkerJobRestoreDirectory;
     AH->WorkerJobDumpPtr = _WorkerJobDumpDirectory;
  
     /* Set up our private context */
     ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
     AH->formatData = (void *) ctx;
  
     ctx->dataFH = NULL;
     ctx->blobsTocFH = NULL;
  
     /* Initialize LO buffering */
     AH->lo_buf_size = LOBBUFSIZE;
     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
  
     /*
      * Now open the TOC file
      */
  
     if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
         pg_fatal("no output directory specified");
  
     ctx->directory = AH->fSpec;
  
     if (AH->mode == archModeWrite)
     {
         struct stat st;
         bool        is_empty = false;
  
         /* we accept an empty existing directory */
         if (stat(ctx->directory, &st) == 0 && S_ISDIR(st.st_mode))
         {
             DIR        *dir = opendir(ctx->directory);
  
             if (dir)
             {
                 struct dirent *d;
  
                 is_empty = true;
                 while (errno = 0, (d = readdir(dir)))
                 {
                     if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0)
                     {
                         is_empty = false;
                         break;
                     }
                 }
  
                 if (errno)
                     pg_fatal("could not read directory \"%s\": %m",
                              ctx->directory);
  
                 if (closedir(dir))
                     pg_fatal("could not close directory \"%s\": %m",
                              ctx->directory);
             }
         }
  
         if (!is_empty && mkdir(ctx->directory, 0700) < 0)
             pg_fatal("could not create directory \"%s\": %m",
                      ctx->directory);
     }
     else
     {                           /* Read Mode */
         char        fname[MAXPGPATH];
         cfp        *tocFH;
  
         setFilePath(AH, fname, "toc.dat");
  
         tocFH = cfopen_read(fname, PG_BINARY_R);
         if (tocFH == NULL)
             pg_fatal("could not open input file \"%s\": %m", fname);
  
         ctx->dataFH = tocFH;
  
         /*
          * The TOC of a directory format dump shares the format code of the
          * tar format.
          */
         AH->format = archTar;
         ReadHead(AH);
         AH->format = archDirectory;
         ReadToc(AH);
  
         /* Nothing else in the file, so close it again... */
         if (cfclose(tocFH) != 0)
             pg_fatal("could not close TOC file: %m");
         ctx->dataFH = NULL;
     }
 }

Referenced by _allocAH().

◆ setFilePath()

static void setFilePath	(	ArchiveHandle *	AH,
		char *	buf,
		const char *	relativeFilename
	)

static

Definition at line 716 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char       *dname;
  
     dname = ctx->directory;
  
     if (strlen(dname) + 1 + strlen(relativeFilename) + 1 > MAXPGPATH)
         pg_fatal("file name too long: \"%s\"", dname);
  
     strcpy(buf, dname);
     strcat(buf, "/");
     strcat(buf, relativeFilename);
 }

References buf, lclContext::directory, _archiveHandle::formatData, if(), MAXPGPATH, and pg_fatal.

Referenced by _CloseArchive(), _LoadBlobs(), _PrepParallelRestore(), _PrintTocData(), _StartBlobs(), _StartData(), and InitArchiveFmt_Directory().

Data Structures

Functions

Function Documentation

◆ _ArchiveEntry()

◆ _Clone()

◆ _CloseArchive()

◆ _DeClone()

◆ _EndBlob()

◆ _EndBlobs()

◆ _EndData()

◆ _LoadBlobs()

◆ _PrepParallelRestore()

◆ _PrintExtraToc()

◆ _PrintFileData()

◆ _PrintTocData()

◆ _ReadBuf()

◆ _ReadByte()

◆ _ReadExtraToc()

◆ _ReopenArchive()

◆ _StartBlob()

◆ _StartBlobs()

◆ _StartData()

◆ _WorkerJobDumpDirectory()

◆ _WorkerJobRestoreDirectory()

◆ _WriteBuf()

◆ _WriteByte()

◆ _WriteData()

◆ _WriteExtraToc()

◆ InitArchiveFmt_Directory()

◆ setFilePath()