#include "postgres_fe.h"
#include "compress_io.h"
#include "parallel.h"
#include "pg_backup_utils.h"
#include "common/file_utils.h"
#include <dirent.h>
#include <sys/stat.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	_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)

Variables
static const char *	modulename = gettext_noop("directory archiver")

Function Documentation

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

static

Definition at line 237 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

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

static void _Clone ( ArchiveHandle * AH )

static

Definition at line 733 of file pg_backup_directory.c.

References _archiveHandle::formatData, and pg_malloc().

Referenced by InitArchiveFmt_Directory().

 {
     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 master
      * process ever writes to it.
      */
 }

static void _CloseArchive ( ArchiveHandle * AH )

static

Definition at line 565 of file pg_backup_directory.c.

References archDirectory, archModeWrite, archTar, cfclose(), cfopen_write(), lclContext::dataFH, lclContext::directory, _archiveHandle::dosync, exit_horribly(), _archiveHandle::FH, _archiveHandle::format, _archiveHandle::formatData, fsync_dir_recurse(), MAXPGPATH, _archiveHandle::mode, modulename, NULL, ParallelBackupEnd(), ParallelBackupStart(), PG_BINARY_W, progname, lclContext::pstate, setFilePath(), strerror(), WriteDataChunks(), WriteHead(), and WriteToc().

Referenced by InitArchiveFmt_Directory().

 {
     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)
             exit_horribly(modulename, "could not open output file \"%s\": %s\n",
                           fname, strerror(errno));
         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)
             exit_horribly(modulename, "could not close TOC file: %s\n",
                           strerror(errno));
         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, progname);
     }
     AH->FH = NULL;
 }

static void _DeClone ( ArchiveHandle * AH )

static

Definition at line 755 of file pg_backup_directory.c.

References _archiveHandle::formatData, and free.

Referenced by InitArchiveFmt_Directory().

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

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

static

Definition at line 677 of file pg_backup_directory.c.

References lclContext::blobsTocFH, buf, cfclose(), cfwrite(), lclContext::dataFH, exit_horribly(), _archiveHandle::formatData, modulename, NULL, and snprintf().

Referenced by InitArchiveFmt_Directory().

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char        buf[50];
     int         len;
 
     /* Close the BLOB data file itself */
     cfclose(ctx->dataFH);
     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)
         exit_horribly(modulename, "could not write to blobs TOC file\n");
 }

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

static

Definition at line 699 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

 {
     lclContext *ctx = (lclContext *) AH->formatData;
 
     cfclose(ctx->blobsTocFH);
     ctx->blobsTocFH = NULL;
 }

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

static

Definition at line 369 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

 {
     lclContext *ctx = (lclContext *) AH->formatData;
 
     /* Close the file */
     cfclose(ctx->dataFH);
 
     ctx->dataFH = NULL;
 }

static void _LoadBlobs ( ArchiveHandle * AH )

static

Definition at line 436 of file pg_backup_directory.c.

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

Referenced by _PrintTocData().

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

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

static

Definition at line 308 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

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

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

static

Definition at line 383 of file pg_backup_directory.c.

References ahwrite(), buf, cfclose(), cfopen_read(), cfread(), exit_horribly(), free, modulename, PG_BINARY_R, pg_malloc(), strerror(), and ZLIB_OUT_SIZE.

Referenced by _LoadBlobs(), and _PrintTocData().

 {
     size_t      cnt;
     char       *buf;
     size_t      buflen;
     cfp        *cfp;
 
     if (!filename)
         return;
 
     cfp = cfopen_read(filename, PG_BINARY_R);
 
     if (!cfp)
         exit_horribly(modulename, "could not open input file \"%s\": %s\n",
                       filename, strerror(errno));
 
     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)
         exit_horribly(modulename, "could not close data file: %s\n",
                       strerror(errno));
 }

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

static

Definition at line 417 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

 {
     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);
     }
 }

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

static

Definition at line 537 of file pg_backup_directory.c.

References cfread(), lclContext::dataFH, exit_horribly(), _archiveHandle::formatData, and modulename.

Referenced by InitArchiveFmt_Directory().

 {
     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)
         exit_horribly(modulename,
                       "could not read from input file: end of file\n");
 
     return;
 }

static int _ReadByte ( ArchiveHandle * AH )

static

Definition at line 508 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

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

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

static

Definition at line 285 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

 {
     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;
     }
 }

static void _ReopenArchive ( ArchiveHandle * AH )

static

Definition at line 616 of file pg_backup_directory.c.

Referenced by InitArchiveFmt_Directory().

 {
     /*
      * 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.
      */
 }

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

static

Definition at line 657 of file pg_backup_directory.c.

References cfopen_write(), _archiveHandle::compression, lclContext::dataFH, lclContext::directory, exit_horribly(), _archiveHandle::formatData, MAXPGPATH, modulename, NULL, PG_BINARY_W, snprintf(), and strerror().

Referenced by InitArchiveFmt_Directory().

 {
     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)
         exit_horribly(modulename, "could not open output file \"%s\": %s\n",
                       fname, strerror(errno));
 }

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

static

Definition at line 637 of file pg_backup_directory.c.

References lclContext::blobsTocFH, cfopen_write(), exit_horribly(), _archiveHandle::formatData, MAXPGPATH, modulename, NULL, setFilePath(), and strerror().

Referenced by InitArchiveFmt_Directory().

 {
     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)
         exit_horribly(modulename, "could not open output file \"%s\": %s\n",
                       fname, strerror(errno));
 }

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

static

Definition at line 326 of file pg_backup_directory.c.

References cfopen_write(), _archiveHandle::compression, exit_horribly(), lclTocEntry::filename, _archiveHandle::formatData, _tocEntry::formatData, MAXPGPATH, modulename, NULL, PG_BINARY_W, setFilePath(), and strerror().

Referenced by InitArchiveFmt_Directory().

 {
     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)
         exit_horribly(modulename, "could not open output file \"%s\": %s\n",
                       fname, strerror(errno));
 }

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

static

Definition at line 767 of file pg_backup_directory.c.

References WriteDataChunksForTocEntry().

Referenced by InitArchiveFmt_Directory().

 {
     /*
      * 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;
 }

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

static

Definition at line 784 of file pg_backup_directory.c.

References parallel_restore().

Referenced by InitArchiveFmt_Directory().

 {
     return parallel_restore(AH, te);
 }

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

static

Definition at line 520 of file pg_backup_directory.c.

References cfwrite(), lclContext::dataFH, exit_horribly(), _archiveHandle::formatData, get_cfp_error(), and modulename.

Referenced by InitArchiveFmt_Directory().

 {
     lclContext *ctx = (lclContext *) AH->formatData;
 
     if (cfwrite(buf, len, ctx->dataFH) != len)
         exit_horribly(modulename, "could not write to output file: %s\n",
                       get_cfp_error(ctx->dataFH));
 
     return;
 }

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

static

Definition at line 489 of file pg_backup_directory.c.

References cfwrite(), lclContext::dataFH, exit_horribly(), _archiveHandle::formatData, get_cfp_error(), and modulename.

Referenced by InitArchiveFmt_Directory().

 {
     unsigned char c = (unsigned char) i;
     lclContext *ctx = (lclContext *) AH->formatData;
 
     if (cfwrite(&c, 1, ctx->dataFH) != 1)
         exit_horribly(modulename, "could not write to output file: %s\n",
                       get_cfp_error(ctx->dataFH));
 
     return 1;
 }

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

static

Definition at line 350 of file pg_backup_directory.c.

References cfwrite(), lclContext::dataFH, exit_horribly(), _archiveHandle::formatData, get_cfp_error(), and modulename.

Referenced by InitArchiveFmt_Directory().

 {
     lclContext *ctx = (lclContext *) AH->formatData;
 
     if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen)
         exit_horribly(modulename, "could not write to output file: %s\n",
                       get_cfp_error(ctx->dataFH));
 
 
     return;
 }

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

static

Definition at line 264 of file pg_backup_directory.c.

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

Referenced by InitArchiveFmt_Directory().

 {
     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, "");
 }

void InitArchiveFmt_Directory ( ArchiveHandle * AH )

Definition at line 110 of file pg_backup_directory.c.

Referenced by _allocAH().

 {
     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->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)
         exit_horribly(modulename, "no output directory specified\n");
 
     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)
                     exit_horribly(modulename, "could not read directory \"%s\": %s\n",
                                   ctx->directory, strerror(errno));
 
                 if (closedir(dir))
                     exit_horribly(modulename, "could not close directory \"%s\": %s\n",
                                   ctx->directory, strerror(errno));
             }
         }
 
         if (!is_empty && mkdir(ctx->directory, 0700) < 0)
             exit_horribly(modulename, "could not create directory \"%s\": %s\n",
                           ctx->directory, strerror(errno));
     }
     else
     {                           /* Read Mode */
         char        fname[MAXPGPATH];
         cfp        *tocFH;
 
         setFilePath(AH, fname, "toc.dat");
 
         tocFH = cfopen_read(fname, PG_BINARY_R);
         if (tocFH == NULL)
             exit_horribly(modulename,
                           "could not open input file \"%s\": %s\n",
                           fname, strerror(errno));
 
         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)
             exit_horribly(modulename, "could not close TOC file: %s\n",
                           strerror(errno));
         ctx->dataFH = NULL;
     }
 }

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

static

Definition at line 714 of file pg_backup_directory.c.

References lclContext::directory, exit_horribly(), _archiveHandle::formatData, MAXPGPATH, and modulename.

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

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

Variable Documentation

const char* modulename = gettext_noop("directory archiver")

static

Definition at line 65 of file pg_backup_directory.c.

Referenced by _CloseArchive(), _EndBlob(), _LoadBlobs(), _PrintFileData(), _ReadBuf(), _StartBlob(), _StartBlobs(), _StartData(), _WriteBuf(), _WriteByte(), _WriteData(), InitArchiveFmt_Directory(), and setFilePath().

Data Structures

Functions

Variables

Function Documentation

Variable Documentation