bbstreamer_tar.c File Reference

#include "postgres_fe.h"
#include <time.h>
#include "bbstreamer.h"
#include "common/logging.h"
#include "pgtar.h"

Include dependency graph for bbstreamer_tar.c:

Go to the source code of this file.

Data Structures
struct	bbstreamer_tar_parser
struct	bbstreamer_tar_archiver

Typedefs
typedef struct bbstreamer_tar_parser	bbstreamer_tar_parser
typedef struct bbstreamer_tar_archiver	bbstreamer_tar_archiver

Functions
static void	bbstreamer_tar_parser_content (bbstreamer *streamer, bbstreamer_member *member, const char *data, int len, bbstreamer_archive_context context)
static void	bbstreamer_tar_parser_finalize (bbstreamer *streamer)
static void	bbstreamer_tar_parser_free (bbstreamer *streamer)
static bool	bbstreamer_tar_header (bbstreamer_tar_parser *mystreamer)
static void	bbstreamer_tar_archiver_content (bbstreamer *streamer, bbstreamer_member *member, const char *data, int len, bbstreamer_archive_context context)
static void	bbstreamer_tar_archiver_finalize (bbstreamer *streamer)
static void	bbstreamer_tar_archiver_free (bbstreamer *streamer)
static void	bbstreamer_tar_terminator_content (bbstreamer *streamer, bbstreamer_member *member, const char *data, int len, bbstreamer_archive_context context)
static void	bbstreamer_tar_terminator_finalize (bbstreamer *streamer)
static void	bbstreamer_tar_terminator_free (bbstreamer *streamer)
bbstreamer *	bbstreamer_tar_parser_new (bbstreamer *next)
bbstreamer *	bbstreamer_tar_archiver_new (bbstreamer *next)
bbstreamer *	bbstreamer_tar_terminator_new (bbstreamer *next)

Variables
const bbstreamer_ops	bbstreamer_tar_parser_ops
const bbstreamer_ops	bbstreamer_tar_archiver_ops
const bbstreamer_ops	bbstreamer_tar_terminator_ops

Typedef Documentation

bbstreamer_tar_archiver

typedef struct bbstreamer_tar_archiver bbstreamer_tar_archiver

bbstreamer_tar_parser

typedef struct bbstreamer_tar_parser bbstreamer_tar_parser

Function Documentation

bbstreamer_tar_archiver_content()

static void bbstreamer_tar_archiver_content ( bbstreamer *  streamer, bbstreamer_member *  member, const char *  data, int  len, bbstreamer_archive_context  context  )

static

Definition at line 392 of file bbstreamer_tar.c.

{
    bbstreamer_tar_archiver *mystreamer = (bbstreamer_tar_archiver *) streamer;
    char        buffer[2 * TAR_BLOCK_SIZE];
 
    Assert(context != BBSTREAMER_UNKNOWN);
 
    if (context == BBSTREAMER_MEMBER_HEADER && len != TAR_BLOCK_SIZE)
    {
        Assert(len == 0);
 
        /* Replace zero-length tar header with a newly constructed one. */
        tarCreateHeader(buffer, member->pathname, NULL,
                        member->size, member->mode, member->uid, member->gid,
                        time(NULL));
        data = buffer;
        len = TAR_BLOCK_SIZE;
 
        /* Also make a note to replace padding, in case size changed. */
        mystreamer->rearchive_member = true;
    }
    else if (context == BBSTREAMER_MEMBER_TRAILER &&
             mystreamer->rearchive_member)
    {
        int         pad_bytes = tarPaddingBytesRequired(member->size);
 
        /* Also replace padding, if we regenerated the header. */
        memset(buffer, 0, pad_bytes);
        data = buffer;
        len = pad_bytes;
 
        /* Don't do this again unless we replace another header. */
        mystreamer->rearchive_member = false;
    }
    else if (context == BBSTREAMER_ARCHIVE_TRAILER)
    {
        /* Trailer should always be two blocks of zero bytes. */
        memset(buffer, 0, 2 * TAR_BLOCK_SIZE);
        data = buffer;
        len = 2 * TAR_BLOCK_SIZE;
    }
 
    bbstreamer_content(streamer->bbs_next, member, data, len, context);
}

References Assert(), bbstreamer::bbs_next, BBSTREAMER_ARCHIVE_TRAILER, bbstreamer_content(), BBSTREAMER_MEMBER_HEADER, BBSTREAMER_MEMBER_TRAILER, BBSTREAMER_UNKNOWN, data, bbstreamer_member::gid, len, bbstreamer_member::mode, bbstreamer_member::pathname, bbstreamer_tar_archiver::rearchive_member, bbstreamer_member::size, TAR_BLOCK_SIZE, tarCreateHeader(), tarPaddingBytesRequired(), and bbstreamer_member::uid.

bbstreamer_tar_archiver_finalize()

static void bbstreamer_tar_archiver_finalize ( bbstreamer *  streamer )

static

Definition at line 444 of file bbstreamer_tar.c.

{
    bbstreamer_finalize(streamer->bbs_next);
}

References bbstreamer::bbs_next, and bbstreamer_finalize().

bbstreamer_tar_archiver_free()

static void bbstreamer_tar_archiver_free ( bbstreamer *  streamer )

static

Definition at line 453 of file bbstreamer_tar.c.

{
    bbstreamer_free(streamer->bbs_next);
    pfree(streamer);
}

References bbstreamer::bbs_next, bbstreamer_free(), and pfree().

bbstreamer_tar_archiver_new()

bbstreamer* bbstreamer_tar_archiver_new

(

bbstreamer *

next

)

Definition at line 358 of file bbstreamer_tar.c.

{
    bbstreamer_tar_archiver *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_tar_archiver));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_tar_archiver_ops;
    streamer->base.bbs_next = next;
 
    return &streamer->base;
}

References bbstreamer_tar_archiver::base, bbstreamer::bbs_next, bbstreamer::bbs_ops, bbstreamer_tar_archiver_ops, next, and palloc0().

Referenced by CreateBackupStreamer().

bbstreamer_tar_header()

static bool bbstreamer_tar_header ( bbstreamer_tar_parser *  mystreamer )

static

Definition at line 261 of file bbstreamer_tar.c.

{
    bool        has_nonzero_byte = false;
    int         i;
    bbstreamer_member *member = &mystreamer->member;
    char       *buffer = mystreamer->base.bbs_buffer.data;
 
    Assert(mystreamer->base.bbs_buffer.len == TAR_BLOCK_SIZE);
 
    /* Check whether we've got a block of all zero bytes. */
    for (i = 0; i < TAR_BLOCK_SIZE; ++i)
    {
        if (buffer[i] != '\0')
        {
            has_nonzero_byte = true;
            break;
        }
    }
 
    /*
     * If the entire block was zeros, this is the end of the archive, not the
     * start of the next file.
     */
    if (!has_nonzero_byte)
        return false;
 
    /*
     * Parse key fields out of the header.
     *
     * FIXME: It's terrible that we use hard-coded values here instead of some
     * more principled approach. It's been like this for a long time, but we
     * ought to do better.
     */
    strlcpy(member->pathname, &buffer[0], MAXPGPATH);
    if (member->pathname[0] == '\0')
        pg_fatal("tar member has empty name");
    member->size = read_tar_number(&buffer[124], 12);
    member->mode = read_tar_number(&buffer[100], 8);
    member->uid = read_tar_number(&buffer[108], 8);
    member->gid = read_tar_number(&buffer[116], 8);
    member->is_directory = (buffer[156] == '5');
    member->is_link = (buffer[156] == '2');
    if (member->is_link)
        strlcpy(member->linktarget, &buffer[157], 100);
 
    /* Compute number of padding bytes. */
    mystreamer->pad_bytes_expected = tarPaddingBytesRequired(member->size);
 
    /* Forward the entire header to the next bbstreamer. */
    bbstreamer_content(mystreamer->base.bbs_next, member,
                       buffer, TAR_BLOCK_SIZE,
                       BBSTREAMER_MEMBER_HEADER);
 
    return true;
}

References Assert(), bbstreamer_tar_parser::base, bbstreamer::bbs_buffer, bbstreamer::bbs_next, bbstreamer_content(), BBSTREAMER_MEMBER_HEADER, StringInfoData::data, bbstreamer_member::gid, i, bbstreamer_member::is_directory, bbstreamer_member::is_link, StringInfoData::len, bbstreamer_member::linktarget, MAXPGPATH, bbstreamer_tar_parser::member, bbstreamer_member::mode, bbstreamer_tar_parser::pad_bytes_expected, bbstreamer_member::pathname, pg_fatal, read_tar_number(), bbstreamer_member::size, strlcpy(), TAR_BLOCK_SIZE, tarPaddingBytesRequired(), and bbstreamer_member::uid.

Referenced by bbstreamer_tar_parser_content().

bbstreamer_tar_parser_content()

static void bbstreamer_tar_parser_content ( bbstreamer *  streamer, bbstreamer_member *  member, const char *  data, int  len, bbstreamer_archive_context  context  )

static

Definition at line 111 of file bbstreamer_tar.c.

{
    bbstreamer_tar_parser *mystreamer = (bbstreamer_tar_parser *) streamer;
    size_t      nbytes;
 
    /* Expect unparsed input. */
    Assert(member == NULL);
    Assert(context == BBSTREAMER_UNKNOWN);
 
    while (len > 0)
    {
        switch (mystreamer->next_context)
        {
            case BBSTREAMER_MEMBER_HEADER:
 
                /*
                 * If we're expecting an archive member header, accumulate a
                 * full block of data before doing anything further.
                 */
                if (!bbstreamer_buffer_until(streamer, &data, &len,
                                             TAR_BLOCK_SIZE))
                    return;
 
                /*
                 * Now we can process the header and get ready to process the
                 * file contents; however, we might find out that what we
                 * thought was the next file header is actually the start of
                 * the archive trailer. Switch modes accordingly.
                 */
                if (bbstreamer_tar_header(mystreamer))
                {
                    if (mystreamer->member.size == 0)
                    {
                        /* No content; trailer is zero-length. */
                        bbstreamer_content(mystreamer->base.bbs_next,
                                           &mystreamer->member,
                                           NULL, 0,
                                           BBSTREAMER_MEMBER_TRAILER);
 
                        /* Expect next header. */
                        mystreamer->next_context = BBSTREAMER_MEMBER_HEADER;
                    }
                    else
                    {
                        /* Expect contents. */
                        mystreamer->next_context = BBSTREAMER_MEMBER_CONTENTS;
                    }
                    mystreamer->base.bbs_buffer.len = 0;
                    mystreamer->file_bytes_sent = 0;
                }
                else
                    mystreamer->next_context = BBSTREAMER_ARCHIVE_TRAILER;
                break;
 
            case BBSTREAMER_MEMBER_CONTENTS:
 
                /*
                 * Send as much content as we have, but not more than the
                 * remaining file length.
                 */
                Assert(mystreamer->file_bytes_sent < mystreamer->member.size);
                nbytes = mystreamer->member.size - mystreamer->file_bytes_sent;
                nbytes = Min(nbytes, len);
                Assert(nbytes > 0);
                bbstreamer_content(mystreamer->base.bbs_next,
                                   &mystreamer->member,
                                   data, nbytes,
                                   BBSTREAMER_MEMBER_CONTENTS);
                mystreamer->file_bytes_sent += nbytes;
                data += nbytes;
                len -= nbytes;
 
                /*
                 * If we've not yet sent the whole file, then there's more
                 * content to come; otherwise, it's time to expect the file
                 * trailer.
                 */
                Assert(mystreamer->file_bytes_sent <= mystreamer->member.size);
                if (mystreamer->file_bytes_sent == mystreamer->member.size)
                {
                    if (mystreamer->pad_bytes_expected == 0)
                    {
                        /* Trailer is zero-length. */
                        bbstreamer_content(mystreamer->base.bbs_next,
                                           &mystreamer->member,
                                           NULL, 0,
                                           BBSTREAMER_MEMBER_TRAILER);
 
                        /* Expect next header. */
                        mystreamer->next_context = BBSTREAMER_MEMBER_HEADER;
                    }
                    else
                    {
                        /* Trailer is not zero-length. */
                        mystreamer->next_context = BBSTREAMER_MEMBER_TRAILER;
                    }
                    mystreamer->base.bbs_buffer.len = 0;
                }
                break;
 
            case BBSTREAMER_MEMBER_TRAILER:
 
                /*
                 * If we're expecting an archive member trailer, accumulate
                 * the expected number of padding bytes before sending
                 * anything onward.
                 */
                if (!bbstreamer_buffer_until(streamer, &data, &len,
                                             mystreamer->pad_bytes_expected))
                    return;
 
                /* OK, now we can send it. */
                bbstreamer_content(mystreamer->base.bbs_next,
                                   &mystreamer->member,
                                   data, mystreamer->pad_bytes_expected,
                                   BBSTREAMER_MEMBER_TRAILER);
 
                /* Expect next file header. */
                mystreamer->next_context = BBSTREAMER_MEMBER_HEADER;
                mystreamer->base.bbs_buffer.len = 0;
                break;
 
            case BBSTREAMER_ARCHIVE_TRAILER:
 
                /*
                 * We've seen an end-of-archive indicator, so anything more is
                 * buffered and sent as part of the archive trailer. But we
                 * don't expect more than 2 blocks.
                 */
                bbstreamer_buffer_bytes(streamer, &data, &len, len);
                if (len > 2 * TAR_BLOCK_SIZE)
                    pg_fatal("tar file trailer exceeds 2 blocks");
                return;
 
            default:
                /* Shouldn't happen. */
                pg_fatal("unexpected state while parsing tar archive");
        }
    }
}

References Assert(), bbstreamer_tar_parser::base, bbstreamer::bbs_buffer, bbstreamer::bbs_next, BBSTREAMER_ARCHIVE_TRAILER, bbstreamer_buffer_bytes(), bbstreamer_buffer_until(), bbstreamer_content(), BBSTREAMER_MEMBER_CONTENTS, BBSTREAMER_MEMBER_HEADER, BBSTREAMER_MEMBER_TRAILER, bbstreamer_tar_header(), BBSTREAMER_UNKNOWN, data, bbstreamer_tar_parser::file_bytes_sent, StringInfoData::len, len, bbstreamer_tar_parser::member, Min, bbstreamer_tar_parser::next_context, bbstreamer_tar_parser::pad_bytes_expected, pg_fatal, bbstreamer_member::size, and TAR_BLOCK_SIZE.

bbstreamer_tar_parser_finalize()

static void bbstreamer_tar_parser_finalize ( bbstreamer *  streamer )

static

Definition at line 321 of file bbstreamer_tar.c.

{
    bbstreamer_tar_parser *mystreamer = (bbstreamer_tar_parser *) streamer;
 
    if (mystreamer->next_context != BBSTREAMER_ARCHIVE_TRAILER &&
        (mystreamer->next_context != BBSTREAMER_MEMBER_HEADER ||
         mystreamer->base.bbs_buffer.len > 0))
        pg_fatal("COPY stream ended before last file was finished");
 
    /* Send the archive trailer, even if empty. */
    bbstreamer_content(streamer->bbs_next, NULL,
                       streamer->bbs_buffer.data, streamer->bbs_buffer.len,
                       BBSTREAMER_ARCHIVE_TRAILER);
 
    /* Now finalize successor. */
    bbstreamer_finalize(streamer->bbs_next);
}

References bbstreamer_tar_parser::base, bbstreamer::bbs_buffer, bbstreamer::bbs_next, BBSTREAMER_ARCHIVE_TRAILER, bbstreamer_content(), bbstreamer_finalize(), BBSTREAMER_MEMBER_HEADER, StringInfoData::data, StringInfoData::len, bbstreamer_tar_parser::next_context, and pg_fatal.

bbstreamer_tar_parser_free()

static void bbstreamer_tar_parser_free ( bbstreamer *  streamer )

static

Definition at line 343 of file bbstreamer_tar.c.

{
    pfree(streamer->bbs_buffer.data);
    bbstreamer_free(streamer->bbs_next);
}

References bbstreamer::bbs_buffer, bbstreamer::bbs_next, bbstreamer_free(), StringInfoData::data, and pfree().

bbstreamer_tar_parser_new()

bbstreamer* bbstreamer_tar_parser_new

(

bbstreamer *

next

)

Definition at line 93 of file bbstreamer_tar.c.

{
    bbstreamer_tar_parser *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_tar_parser));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_tar_parser_ops;
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
    streamer->next_context = BBSTREAMER_MEMBER_HEADER;
 
    return &streamer->base;
}

References bbstreamer_tar_parser::base, bbstreamer::bbs_buffer, bbstreamer::bbs_next, bbstreamer::bbs_ops, BBSTREAMER_MEMBER_HEADER, bbstreamer_tar_parser_ops, initStringInfo(), next, bbstreamer_tar_parser::next_context, and palloc0().

Referenced by CreateBackupStreamer().

bbstreamer_tar_terminator_content()

static void bbstreamer_tar_terminator_content ( bbstreamer *  streamer, bbstreamer_member *  member, const char *  data, int  len, bbstreamer_archive_context  context  )

static

Definition at line 480 of file bbstreamer_tar.c.

{
    /* Expect unparsed input. */
    Assert(member == NULL);
    Assert(context == BBSTREAMER_UNKNOWN);
 
    /* Just forward it. */
    bbstreamer_content(streamer->bbs_next, member, data, len, context);
}

References Assert(), bbstreamer::bbs_next, bbstreamer_content(), BBSTREAMER_UNKNOWN, data, and len.

bbstreamer_tar_terminator_finalize()

static void bbstreamer_tar_terminator_finalize ( bbstreamer *  streamer )

static

Definition at line 498 of file bbstreamer_tar.c.

{
    char        buffer[2 * TAR_BLOCK_SIZE];
 
    memset(buffer, 0, 2 * TAR_BLOCK_SIZE);
    bbstreamer_content(streamer->bbs_next, NULL, buffer,
                       2 * TAR_BLOCK_SIZE, BBSTREAMER_UNKNOWN);
    bbstreamer_finalize(streamer->bbs_next);
}

References bbstreamer::bbs_next, bbstreamer_content(), bbstreamer_finalize(), BBSTREAMER_UNKNOWN, and TAR_BLOCK_SIZE.

bbstreamer_tar_terminator_free()

static void bbstreamer_tar_terminator_free ( bbstreamer *  streamer )

static

Definition at line 512 of file bbstreamer_tar.c.

{
    bbstreamer_free(streamer->bbs_next);
    pfree(streamer);
}

References bbstreamer::bbs_next, bbstreamer_free(), and pfree().

bbstreamer_tar_terminator_new()

bbstreamer* bbstreamer_tar_terminator_new

(

bbstreamer *

next

)

Definition at line 464 of file bbstreamer_tar.c.

{
    bbstreamer *streamer;
 
    streamer = palloc0(sizeof(bbstreamer));
    *((const bbstreamer_ops **) &streamer->bbs_ops) =
        &bbstreamer_tar_terminator_ops;
    streamer->bbs_next = next;
 
    return streamer;
}

References bbstreamer::bbs_next, bbstreamer::bbs_ops, bbstreamer_tar_terminator_ops, next, and palloc0().

Referenced by CreateBackupStreamer().

Variable Documentation

bbstreamer_tar_archiver_ops

const bbstreamer_ops bbstreamer_tar_archiver_ops

Initial value:

= {
    .content = bbstreamer_tar_archiver_content,
    .finalize = bbstreamer_tar_archiver_finalize,
    .free = bbstreamer_tar_archiver_free
}

Definition at line 66 of file bbstreamer_tar.c.

Referenced by bbstreamer_tar_archiver_new().

bbstreamer_tar_parser_ops

const bbstreamer_ops bbstreamer_tar_parser_ops

Initial value:

= {
    .content = bbstreamer_tar_parser_content,
    .finalize = bbstreamer_tar_parser_finalize,
    .free = bbstreamer_tar_parser_free
}

Definition at line 53 of file bbstreamer_tar.c.

Referenced by bbstreamer_tar_parser_new().

bbstreamer_tar_terminator_ops

const bbstreamer_ops bbstreamer_tar_terminator_ops

Initial value:

= {
    .content = bbstreamer_tar_terminator_content,
    .finalize = bbstreamer_tar_terminator_finalize,
    .free = bbstreamer_tar_terminator_free
}

Definition at line 79 of file bbstreamer_tar.c.

Referenced by bbstreamer_tar_terminator_new().