astreamer_verify.c File Reference

#include "postgres_fe.h"
#include "access/xlog_internal.h"
#include "catalog/pg_control.h"
#include "pg_verifybackup.h"

Include dependency graph for astreamer_verify.c:

Go to the source code of this file.

Data Structures
struct	astreamer_verify

Typedefs
typedef struct astreamer_verify	astreamer_verify

Functions
static void	astreamer_verify_content (astreamer *streamer, astreamer_member *member, const char *data, int len, astreamer_archive_context context)
static void	astreamer_verify_finalize (astreamer *streamer)
static void	astreamer_verify_free (astreamer *streamer)
static void	member_verify_header (astreamer *streamer, astreamer_member *member)
static void	member_compute_checksum (astreamer *streamer, astreamer_member *member, const char *data, int len)
static void	member_verify_checksum (astreamer *streamer)
static void	member_copy_control_data (astreamer *streamer, astreamer_member *member, const char *data, int len)
static void	member_verify_control_data (astreamer *streamer)
static void	member_reset_info (astreamer *streamer)
astreamer *	astreamer_verify_content_new (astreamer *next, verifier_context *context, char *archive_name, Oid tblspc_oid)

Variables
static const astreamer_ops	astreamer_verify_ops

Typedef Documentation

astreamer_verify

typedef struct astreamer_verify astreamer_verify

Function Documentation

astreamer_verify_content()

static void astreamer_verify_content ( astreamer *  streamer, astreamer_member *  member, const char *  data, int  len, astreamer_archive_context  context  )

static

Definition at line 91 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
 
    Assert(context != ASTREAMER_UNKNOWN);
 
    switch (context)
    {
        case ASTREAMER_MEMBER_HEADER:
            /* Initial setup plus decide which checks to perform. */
            member_verify_header(streamer, member);
            break;
 
        case ASTREAMER_MEMBER_CONTENTS:
            /* Incremental work required to verify file contents. */
            if (mystreamer->verify_checksum)
                member_compute_checksum(streamer, member, data, len);
            if (mystreamer->verify_control_data)
                member_copy_control_data(streamer, member, data, len);
            break;
 
        case ASTREAMER_MEMBER_TRAILER:
            /* Now we've got all the file data. */
            if (mystreamer->verify_checksum)
                member_verify_checksum(streamer);
            if (mystreamer->verify_control_data)
                member_verify_control_data(streamer);
 
            /* Reset for next archive member. */
            member_reset_info(streamer);
            break;
 
        case ASTREAMER_ARCHIVE_TRAILER:
            break;
 
        default:
            /* Shouldn't happen. */
            pg_fatal("unexpected state while parsing tar archive");
    }
}

References Assert(), ASTREAMER_ARCHIVE_TRAILER, ASTREAMER_MEMBER_CONTENTS, ASTREAMER_MEMBER_HEADER, ASTREAMER_MEMBER_TRAILER, ASTREAMER_UNKNOWN, data, len, member_compute_checksum(), member_copy_control_data(), member_reset_info(), member_verify_checksum(), member_verify_control_data(), member_verify_header(), pg_fatal, astreamer_verify::verify_checksum, and astreamer_verify::verify_control_data.

astreamer_verify_content_new()

astreamer * astreamer_verify_content_new	(	astreamer *	next,
		verifier_context *	context,
		char *	archive_name,
		Oid	tblspc_oid
	)

Definition at line 67 of file astreamer_verify.c.

{
    astreamer_verify *streamer;
 
    streamer = palloc0(sizeof(astreamer_verify));
    *((const astreamer_ops **) &streamer->base.bbs_ops) =
        &astreamer_verify_ops;
 
    streamer->base.bbs_next = next;
    streamer->context = context;
    streamer->archive_name = archive_name;
    streamer->tblspc_oid = tblspc_oid;
 
    if (!context->skip_checksums)
        streamer->checksum_ctx = pg_malloc(sizeof(pg_checksum_context));
 
    return &streamer->base;
}

References astreamer_verify::archive_name, astreamer_verify_ops, astreamer_verify::base, astreamer::bbs_next, astreamer::bbs_ops, astreamer_verify::checksum_ctx, astreamer_verify::context, next, palloc0(), pg_malloc(), verifier_context::skip_checksums, and astreamer_verify::tblspc_oid.

Referenced by create_archive_verifier().

astreamer_verify_finalize()

static void astreamer_verify_finalize ( astreamer *  streamer )

static

Definition at line 138 of file astreamer_verify.c.

{
    Assert(streamer->bbs_next == NULL);
}

References Assert(), and astreamer::bbs_next.

astreamer_verify_free()

static void astreamer_verify_free ( astreamer *  streamer )

static

Definition at line 147 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
 
    if (mystreamer->checksum_ctx)
        pfree(mystreamer->checksum_ctx);
 
    pfree(streamer);
}

References astreamer_verify::checksum_ctx, and pfree().

member_compute_checksum()

static void member_compute_checksum ( astreamer *  streamer, astreamer_member *  member, const char *  data, int  len  )

static

Definition at line 254 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
    pg_checksum_context *checksum_ctx = mystreamer->checksum_ctx;
    manifest_file *m = mystreamer->mfile;
 
    Assert(mystreamer->verify_checksum);
    Assert(m->checksum_type == checksum_ctx->type);
 
    /*
     * Update the total count of computed checksum bytes so that we can
     * cross-check against the file size.
     */
    mystreamer->checksum_bytes += len;
 
    /* Feed these bytes to the checksum calculation. */
    if (pg_checksum_update(checksum_ctx, (uint8 *) data, len) < 0)
    {
        report_backup_error(mystreamer->context,
                            "could not update checksum of file \"%s\"",
                            m->pathname);
        mystreamer->verify_checksum = false;
    }
}

References Assert(), astreamer_verify::checksum_bytes, astreamer_verify::checksum_ctx, manifest_file::checksum_type, astreamer_verify::context, data, len, astreamer_verify::mfile, manifest_file::pathname, pg_checksum_update(), report_backup_error(), pg_checksum_context::type, and astreamer_verify::verify_checksum.

Referenced by astreamer_verify_content().

member_copy_control_data()

static void member_copy_control_data ( astreamer *  streamer, astreamer_member *  member, const char *  data, int  len  )

static

Definition at line 334 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
 
    /* Should be here only for control file */
    Assert(mystreamer->verify_control_data);
 
    /*
     * Copy the new data into the control file buffer, but do not overrun the
     * buffer. Note that the on-disk length of the control file is expected to
     * be PG_CONTROL_FILE_SIZE, but the part that fits in our buffer is
     * shorter, just sizeof(ControlFileData).
     */
    if (mystreamer->control_file_bytes < sizeof(ControlFileData))
    {
        size_t      remaining;
 
        remaining = sizeof(ControlFileData) - mystreamer->control_file_bytes;
        memcpy(((char *) &mystreamer->control_file)
               + mystreamer->control_file_bytes,
               data, Min((size_t) len, remaining));
    }
 
    /* Remember how many bytes we saw, even if we didn't buffer them. */
    mystreamer->control_file_bytes += len;
}

References Assert(), astreamer_verify::control_file, astreamer_verify::control_file_bytes, data, len, Min, remaining, and astreamer_verify::verify_control_data.

Referenced by astreamer_verify_content().

member_reset_info()

static void member_reset_info ( astreamer *  streamer )

static

Definition at line 423 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
 
    mystreamer->mfile = NULL;
    mystreamer->verify_checksum = false;
    mystreamer->verify_control_data = false;
    mystreamer->checksum_bytes = 0;
    mystreamer->control_file_bytes = 0;
}

References astreamer_verify::checksum_bytes, astreamer_verify::control_file_bytes, astreamer_verify::mfile, astreamer_verify::verify_checksum, and astreamer_verify::verify_control_data.

Referenced by astreamer_verify_content().

member_verify_checksum()

static void member_verify_checksum ( astreamer *  streamer )

static

Definition at line 285 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
    manifest_file *m = mystreamer->mfile;
    uint8       checksumbuf[PG_CHECKSUM_MAX_LENGTH];
    int         checksumlen;
 
    Assert(mystreamer->verify_checksum);
 
    /*
     * It's unclear how this could fail, but let's check anyway to be safe.
     */
    if (mystreamer->checksum_bytes != m->size)
    {
        report_backup_error(mystreamer->context,
                            "file \"%s\" in archive \"%s\" should contain %" PRIu64 " bytes, but %" PRIu64 " bytes were read",
                            m->pathname, mystreamer->archive_name,
                            m->size,
                            mystreamer->checksum_bytes);
        return;
    }
 
    /* Get the final checksum. */
    checksumlen = pg_checksum_final(mystreamer->checksum_ctx, checksumbuf);
    if (checksumlen < 0)
    {
        report_backup_error(mystreamer->context,
                            "could not finalize checksum of file \"%s\"",
                            m->pathname);
        return;
    }
 
    /* And check it against the manifest. */
    if (checksumlen != m->checksum_length)
        report_backup_error(mystreamer->context,
                            "file \"%s\" in archive \"%s\" has checksum of length %d, but expected %d",
                            m->pathname, mystreamer->archive_name,
                            m->checksum_length, checksumlen);
    else if (memcmp(checksumbuf, m->checksum_payload, checksumlen) != 0)
        report_backup_error(mystreamer->context,
                            "checksum mismatch for file \"%s\" in archive \"%s\"",
                            m->pathname, mystreamer->archive_name);
}

References astreamer_verify::archive_name, Assert(), astreamer_verify::checksum_bytes, astreamer_verify::checksum_ctx, manifest_file::checksum_length, manifest_file::checksum_payload, astreamer_verify::context, astreamer_verify::mfile, manifest_file::pathname, pg_checksum_final(), PG_CHECKSUM_MAX_LENGTH, report_backup_error(), manifest_file::size, and astreamer_verify::verify_checksum.

Referenced by astreamer_verify_content().

member_verify_control_data()

static void member_verify_control_data ( astreamer *  streamer )

static

Definition at line 367 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
    manifest_data *manifest = mystreamer->context->manifest;
    pg_crc32c   crc;
 
    /* Should be here only for control file */
    Assert(strcmp(mystreamer->mfile->pathname, XLOG_CONTROL_FILE) == 0);
    Assert(mystreamer->verify_control_data);
 
    /*
     * If the control file is not the right length, that's a big problem.
     *
     * NB: There is a theoretical overflow risk here from casting to int, but
     * it isn't likely to be a real problem and this enables us to match the
     * same format string that pg_rewind uses for this case. Perhaps both this
     * and pg_rewind should use an unsigned 64-bit value, but for now we don't
     * worry about it.
     */
    if (mystreamer->control_file_bytes != PG_CONTROL_FILE_SIZE)
        report_fatal_error("unexpected control file size %d, expected %d",
                           (int) mystreamer->control_file_bytes,
                           PG_CONTROL_FILE_SIZE);
 
    /* Compute the CRC. */
    INIT_CRC32C(crc);
    COMP_CRC32C(crc, &mystreamer->control_file,
                offsetof(ControlFileData, crc));
    FIN_CRC32C(crc);
 
    /* Control file contents not meaningful if CRC is bad. */
    if (!EQ_CRC32C(crc, mystreamer->control_file.crc))
        report_fatal_error("%s: %s: CRC is incorrect",
                           mystreamer->archive_name,
                           mystreamer->mfile->pathname);
 
    /* Can't interpret control file if not current version. */
    if (mystreamer->control_file.pg_control_version != PG_CONTROL_VERSION)
        report_fatal_error("%s: %s: unexpected control file version",
                           mystreamer->archive_name,
                           mystreamer->mfile->pathname);
 
    /* System identifiers should match. */
    if (manifest->system_identifier !=
        mystreamer->control_file.system_identifier)
        report_fatal_error("%s: %s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
                           mystreamer->archive_name,
                           mystreamer->mfile->pathname,
                           manifest->system_identifier,
                           mystreamer->control_file.system_identifier);
}

References astreamer_verify::archive_name, Assert(), COMP_CRC32C, astreamer_verify::context, astreamer_verify::control_file, astreamer_verify::control_file_bytes, ControlFileData::crc, crc, EQ_CRC32C, FIN_CRC32C, INIT_CRC32C, manifest, verifier_context::manifest, astreamer_verify::mfile, manifest_file::pathname, PG_CONTROL_FILE_SIZE, PG_CONTROL_VERSION, ControlFileData::pg_control_version, report_fatal_error(), ControlFileData::system_identifier, astreamer_verify::verify_control_data, and XLOG_CONTROL_FILE.

Referenced by astreamer_verify_content().

member_verify_header()

static void member_verify_header ( astreamer *  streamer, astreamer_member *  member  )

static

Definition at line 161 of file astreamer_verify.c.

{
    astreamer_verify *mystreamer = (astreamer_verify *) streamer;
    manifest_file *m;
    char        pathname[MAXPGPATH];
 
    /* We are only interested in normal files. */
    if (member->is_directory || member->is_link)
        return;
 
    /*
     * The backup manifest stores a relative path to the base directory for
     * files belonging to a tablespace, while the tablespace backup tar
     * archive does not include this path.
     *
     * The pathname taken from the tar file could contain '.' or '..'
     * references, which we want to remove, so apply canonicalize_path(). It
     * could also be an absolute pathname, which we want to treat as a
     * relative path, so prepend "./" if we're not adding a tablespace prefix
     * to make sure that canonicalize_path() does what we want.
     */
    if (OidIsValid(mystreamer->tblspc_oid))
        snprintf(pathname, MAXPGPATH, "%s/%u/%s",
                 "pg_tblspc", mystreamer->tblspc_oid, member->pathname);
    else
        snprintf(pathname, MAXPGPATH, "./%s", member->pathname);
    canonicalize_path(pathname);
 
    /* Ignore any files that are listed in the ignore list. */
    if (should_ignore_relpath(mystreamer->context, pathname))
        return;
 
    /* Check whether there's an entry in the manifest hash. */
    m = manifest_files_lookup(mystreamer->context->manifest->files, pathname);
    if (m == NULL)
    {
        report_backup_error(mystreamer->context,
                            "file \"%s\" is present in archive \"%s\" but not in the manifest",
                            member->pathname, mystreamer->archive_name);
        return;
    }
    mystreamer->mfile = m;
 
    /* Flag this entry as having been encountered in a tar archive. */
    m->matched = true;
 
    /* Check that the size matches. */
    if (m->size != member->size)
    {
        report_backup_error(mystreamer->context,
                            "file \"%s\" has size %llu in archive \"%s\" but size %" PRIu64 " in the manifest",
                            member->pathname,
                            (unsigned long long) member->size,
                            mystreamer->archive_name,
                            m->size);
        m->bad = true;
        return;
    }
 
    /*
     * Decide whether we're going to verify the checksum for this file, and
     * whether we're going to perform the additional validation that we do
     * only for the control file.
     */
    mystreamer->verify_checksum =
        (!mystreamer->context->skip_checksums && should_verify_checksum(m));
    mystreamer->verify_control_data =
        mystreamer->context->manifest->version != 1 &&
        !m->bad && strcmp(m->pathname, XLOG_CONTROL_FILE) == 0;
 
    /* If we're going to verify the checksum, initial a checksum context. */
    if (mystreamer->verify_checksum &&
        pg_checksum_init(mystreamer->checksum_ctx, m->checksum_type) < 0)
    {
        report_backup_error(mystreamer->context,
                            "%s: could not initialize checksum of file \"%s\"",
                            mystreamer->archive_name, m->pathname);
 
        /*
         * Checksum verification cannot be performed without proper context
         * initialization.
         */
        mystreamer->verify_checksum = false;
    }
}

References astreamer_verify::archive_name, manifest_file::bad, canonicalize_path(), astreamer_verify::checksum_ctx, manifest_file::checksum_type, astreamer_verify::context, manifest_data::files, astreamer_member::is_directory, astreamer_member::is_link, verifier_context::manifest, manifest_file::matched, MAXPGPATH, astreamer_verify::mfile, OidIsValid, manifest_file::pathname, astreamer_member::pathname, pg_checksum_init(), report_backup_error(), should_ignore_relpath(), should_verify_checksum, manifest_file::size, astreamer_member::size, verifier_context::skip_checksums, snprintf, astreamer_verify::tblspc_oid, astreamer_verify::verify_checksum, astreamer_verify::verify_control_data, manifest_data::version, and XLOG_CONTROL_FILE.

Referenced by astreamer_verify_content().

Variable Documentation

astreamer_verify_ops

const astreamer_ops astreamer_verify_ops

static

Initial value:

= {
    .content = astreamer_verify_content,
    .finalize = astreamer_verify_finalize,
    .free = astreamer_verify_free
}

Definition at line 57 of file astreamer_verify.c.

Referenced by astreamer_verify_content_new().