parse_manifest.c File Reference

#include "postgres_fe.h"
#include "common/jsonapi.h"
#include "common/parse_manifest.h"

Include dependency graph for parse_manifest.c:

Go to the source code of this file.

Data Structures
struct	JsonManifestParseState
struct	JsonManifestParseIncrementalState

Enumerations
enum	JsonManifestSemanticState {   JM_EXPECT_TOPLEVEL_START , JM_EXPECT_TOPLEVEL_END , JM_EXPECT_TOPLEVEL_FIELD , JM_EXPECT_VERSION_VALUE ,   JM_EXPECT_SYSTEM_IDENTIFIER_VALUE , JM_EXPECT_FILES_START , JM_EXPECT_FILES_NEXT , JM_EXPECT_THIS_FILE_FIELD ,   JM_EXPECT_THIS_FILE_VALUE , JM_EXPECT_WAL_RANGES_START , JM_EXPECT_WAL_RANGES_NEXT , JM_EXPECT_THIS_WAL_RANGE_FIELD ,   JM_EXPECT_THIS_WAL_RANGE_VALUE , JM_EXPECT_MANIFEST_CHECKSUM_VALUE , JM_EXPECT_EOF }
enum	JsonManifestFileField {   JMFF_PATH , JMFF_ENCODED_PATH , JMFF_SIZE , JMFF_LAST_MODIFIED ,   JMFF_CHECKSUM_ALGORITHM , JMFF_CHECKSUM }
enum	JsonManifestWALRangeField { JMWRF_TIMELINE , JMWRF_START_LSN , JMWRF_END_LSN }

Functions
static JsonParseErrorType	json_manifest_object_start (void *state)
static JsonParseErrorType	json_manifest_object_end (void *state)
static JsonParseErrorType	json_manifest_array_start (void *state)
static JsonParseErrorType	json_manifest_array_end (void *state)
static JsonParseErrorType	json_manifest_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	json_manifest_scalar (void *state, char *token, JsonTokenType tokentype)
static void	json_manifest_finalize_version (JsonManifestParseState *parse)
static void	json_manifest_finalize_system_identifier (JsonManifestParseState *parse)
static void	json_manifest_finalize_file (JsonManifestParseState *parse)
static void	json_manifest_finalize_wal_range (JsonManifestParseState *parse)
static void	verify_manifest_checksum (JsonManifestParseState *parse, const char *buffer, size_t size, pg_cryptohash_ctx *incr_ctx)
static pg_noreturn void	json_manifest_parse_failure (JsonManifestParseContext *context, char *msg)
static int	hexdecode_char (char c)
static bool	hexdecode_string (uint8 *result, char *input, int nbytes)
static bool	parse_xlogrecptr (XLogRecPtr *result, char *input)
JsonManifestParseIncrementalState *	json_parse_manifest_incremental_init (JsonManifestParseContext *context)
void	json_parse_manifest_incremental_shutdown (JsonManifestParseIncrementalState *incstate)
void	json_parse_manifest_incremental_chunk (JsonManifestParseIncrementalState *incstate, const char *chunk, size_t size, bool is_last)
void	json_parse_manifest (JsonManifestParseContext *context, const char *buffer, size_t size)

Enumeration Type Documentation

JsonManifestFileField

enum JsonManifestFileField

Enumerator
JMFF_PATH
JMFF_ENCODED_PATH
JMFF_SIZE
JMFF_LAST_MODIFIED
JMFF_CHECKSUM_ALGORITHM
JMFF_CHECKSUM

Definition at line 44 of file parse_manifest.c.

{
    JMFF_PATH,
    JMFF_ENCODED_PATH,
    JMFF_SIZE,
    JMFF_LAST_MODIFIED,
    JMFF_CHECKSUM_ALGORITHM,
    JMFF_CHECKSUM,
} JsonManifestFileField;

JsonManifestSemanticState

enum JsonManifestSemanticState

Enumerator
JM_EXPECT_TOPLEVEL_START
JM_EXPECT_TOPLEVEL_END
JM_EXPECT_TOPLEVEL_FIELD
JM_EXPECT_VERSION_VALUE
JM_EXPECT_SYSTEM_IDENTIFIER_VALUE
JM_EXPECT_FILES_START
JM_EXPECT_FILES_NEXT
JM_EXPECT_THIS_FILE_FIELD
JM_EXPECT_THIS_FILE_VALUE
JM_EXPECT_WAL_RANGES_START
JM_EXPECT_WAL_RANGES_NEXT
JM_EXPECT_THIS_WAL_RANGE_FIELD
JM_EXPECT_THIS_WAL_RANGE_VALUE
JM_EXPECT_MANIFEST_CHECKSUM_VALUE
JM_EXPECT_EOF

Definition at line 22 of file parse_manifest.c.

{
    JM_EXPECT_TOPLEVEL_START,
    JM_EXPECT_TOPLEVEL_END,
    JM_EXPECT_TOPLEVEL_FIELD,
    JM_EXPECT_VERSION_VALUE,
    JM_EXPECT_SYSTEM_IDENTIFIER_VALUE,
    JM_EXPECT_FILES_START,
    JM_EXPECT_FILES_NEXT,
    JM_EXPECT_THIS_FILE_FIELD,
    JM_EXPECT_THIS_FILE_VALUE,
    JM_EXPECT_WAL_RANGES_START,
    JM_EXPECT_WAL_RANGES_NEXT,
    JM_EXPECT_THIS_WAL_RANGE_FIELD,
    JM_EXPECT_THIS_WAL_RANGE_VALUE,
    JM_EXPECT_MANIFEST_CHECKSUM_VALUE,
    JM_EXPECT_EOF,
} JsonManifestSemanticState;

JsonManifestWALRangeField

enum JsonManifestWALRangeField

Enumerator
JMWRF_TIMELINE
JMWRF_START_LSN
JMWRF_END_LSN

Definition at line 57 of file parse_manifest.c.

{
    JMWRF_TIMELINE,
    JMWRF_START_LSN,
    JMWRF_END_LSN,
} JsonManifestWALRangeField;

Function Documentation

hexdecode_char()

static int hexdecode_char ( char  c )

static

Definition at line 901 of file parse_manifest.c.

{
    if (c >= '0' && c <= '9')
        return c - '0';
    if (c >= 'a' && c <= 'f')
        return c - 'a' + 10;
    if (c >= 'A' && c <= 'F')
        return c - 'A' + 10;
 
    return -1;
}

Referenced by hexdecode_string().

hexdecode_string()

static bool hexdecode_string ( uint8 *  result, char *  input, int  nbytes  )

static

Definition at line 919 of file parse_manifest.c.

{
    int         i;
 
    for (i = 0; i < nbytes; ++i)
    {
        int         n1 = hexdecode_char(input[i * 2]);
        int         n2 = hexdecode_char(input[i * 2 + 1]);
 
        if (n1 < 0 || n2 < 0)
            return false;
        result[i] = n1 * 16 + n2;
    }
 
    return true;
}

References hexdecode_char(), i, and input.

Referenced by json_manifest_finalize_file(), and verify_manifest_checksum().

json_manifest_array_end()

static JsonParseErrorType json_manifest_array_end ( void *  state )

static

Definition at line 378 of file parse_manifest.c.

{
    JsonManifestParseState *parse = state;
 
    switch (parse->state)
    {
        case JM_EXPECT_FILES_NEXT:
        case JM_EXPECT_WAL_RANGES_NEXT:
            parse->state = JM_EXPECT_TOPLEVEL_FIELD;
            break;
        default:
            json_manifest_parse_failure(parse->context,
                                        "unexpected array end");
            break;
    }
 
    return JSON_SUCCESS;
}

References JM_EXPECT_FILES_NEXT, JM_EXPECT_TOPLEVEL_FIELD, JM_EXPECT_WAL_RANGES_NEXT, json_manifest_parse_failure(), JSON_SUCCESS, and parse().

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_init().

json_manifest_array_start()

static JsonParseErrorType json_manifest_array_start ( void *  state )

static

Definition at line 351 of file parse_manifest.c.

{
    JsonManifestParseState *parse = state;
 
    switch (parse->state)
    {
        case JM_EXPECT_FILES_START:
            parse->state = JM_EXPECT_FILES_NEXT;
            break;
        case JM_EXPECT_WAL_RANGES_START:
            parse->state = JM_EXPECT_WAL_RANGES_NEXT;
            break;
        default:
            json_manifest_parse_failure(parse->context,
                                        "unexpected array start");
            break;
    }
 
    return JSON_SUCCESS;
}

References JM_EXPECT_FILES_NEXT, JM_EXPECT_FILES_START, JM_EXPECT_WAL_RANGES_NEXT, JM_EXPECT_WAL_RANGES_START, json_manifest_parse_failure(), JSON_SUCCESS, and parse().

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_init().

json_manifest_finalize_file()

static void json_manifest_finalize_file ( JsonManifestParseState *  parse )

static

Definition at line 649 of file parse_manifest.c.

{
    JsonManifestParseContext *context = parse->context;
    uint64      size;
    char       *ep;
    int         checksum_string_length;
    pg_checksum_type checksum_type;
    int         checksum_length;
    uint8      *checksum_payload;
 
    /* Pathname and size are required. */
    if (parse->pathname == NULL && parse->encoded_pathname == NULL)
        json_manifest_parse_failure(parse->context, "missing path name");
    if (parse->pathname != NULL && parse->encoded_pathname != NULL)
        json_manifest_parse_failure(parse->context,
                                    "both path name and encoded path name");
    if (parse->size == NULL)
        json_manifest_parse_failure(parse->context, "missing size");
    if (parse->algorithm == NULL && parse->checksum != NULL)
        json_manifest_parse_failure(parse->context,
                                    "checksum without algorithm");
 
    /* Decode encoded pathname, if that's what we have. */
    if (parse->encoded_pathname != NULL)
    {
        int         encoded_length = strlen(parse->encoded_pathname);
        int         raw_length = encoded_length / 2;
 
        parse->pathname = palloc(raw_length + 1);
        if (encoded_length % 2 != 0 ||
            !hexdecode_string((uint8 *) parse->pathname,
                              parse->encoded_pathname,
                              raw_length))
            json_manifest_parse_failure(parse->context,
                                        "could not decode file name");
        parse->pathname[raw_length] = '\0';
        pfree(parse->encoded_pathname);
        parse->encoded_pathname = NULL;
    }
 
    /* Parse size. */
    size = strtou64(parse->size, &ep, 10);
    if (*ep)
        json_manifest_parse_failure(parse->context,
                                    "file size is not an integer");
 
    /* Parse the checksum algorithm, if it's present. */
    if (parse->algorithm == NULL)
        checksum_type = CHECKSUM_TYPE_NONE;
    else if (!pg_checksum_parse_type(parse->algorithm, &checksum_type))
        context->error_cb(context, "unrecognized checksum algorithm: \"%s\"",
                          parse->algorithm);
 
    /* Parse the checksum payload, if it's present. */
    checksum_string_length = parse->checksum == NULL ? 0
        : strlen(parse->checksum);
    if (checksum_string_length == 0)
    {
        checksum_length = 0;
        checksum_payload = NULL;
    }
    else
    {
        checksum_length = checksum_string_length / 2;
        checksum_payload = palloc(checksum_length);
        if (checksum_string_length % 2 != 0 ||
            !hexdecode_string(checksum_payload, parse->checksum,
                              checksum_length))
            context->error_cb(context,
                              "invalid checksum for file \"%s\": \"%s\"",
                              parse->pathname, parse->checksum);
    }
 
    /* Invoke the callback with the details we've gathered. */
    context->per_file_cb(context, parse->pathname, size,
                         checksum_type, checksum_length, checksum_payload);
 
    /* Free memory we no longer need. */
    if (parse->size != NULL)
    {
        pfree(parse->size);
        parse->size = NULL;
    }
    if (parse->algorithm != NULL)
    {
        pfree(parse->algorithm);
        parse->algorithm = NULL;
    }
    if (parse->checksum != NULL)
    {
        pfree(parse->checksum);
        parse->checksum = NULL;
    }
}

References CHECKSUM_TYPE_NONE, JsonManifestParseContext::error_cb, hexdecode_string(), json_manifest_parse_failure(), palloc(), parse(), JsonManifestParseContext::per_file_cb, pfree(), and pg_checksum_parse_type().

Referenced by json_manifest_object_end().

json_manifest_finalize_system_identifier()

static void json_manifest_finalize_system_identifier ( JsonManifestParseState *  parse )

static

Definition at line 624 of file parse_manifest.c.

{
    JsonManifestParseContext *context = parse->context;
    uint64      system_identifier;
    char       *ep;
 
    Assert(parse->manifest_system_identifier != NULL);
 
    /* Parse system identifier. */
    system_identifier = strtou64(parse->manifest_system_identifier, &ep, 10);
    if (*ep)
        json_manifest_parse_failure(parse->context,
                                    "system identifier in manifest not an integer");
 
    /* Invoke the callback for system identifier */
    context->system_identifier_cb(context, system_identifier);
}

References Assert(), json_manifest_parse_failure(), parse(), and JsonManifestParseContext::system_identifier_cb.

Referenced by json_manifest_scalar().

json_manifest_finalize_version()

static void json_manifest_finalize_version ( JsonManifestParseState *  parse )

static

Definition at line 596 of file parse_manifest.c.

{
    JsonManifestParseContext *context = parse->context;
    int         version;
    char       *ep;
 
    Assert(parse->saw_version_field);
 
    /* Parse version. */
    version = strtoi64(parse->manifest_version, &ep, 10);
    if (*ep)
        json_manifest_parse_failure(parse->context,
                                    "manifest version not an integer");
 
    if (version != 1 && version != 2)
        json_manifest_parse_failure(parse->context,
                                    "unexpected manifest version");
 
    /* Invoke the callback for version */
    context->version_cb(context, version);
}

References Assert(), json_manifest_parse_failure(), parse(), and JsonManifestParseContext::version_cb.

Referenced by json_manifest_scalar().

json_manifest_finalize_wal_range()

static void json_manifest_finalize_wal_range ( JsonManifestParseState *  parse )

static

Definition at line 751 of file parse_manifest.c.

{
    JsonManifestParseContext *context = parse->context;
    TimeLineID  tli;
    XLogRecPtr  start_lsn,
                end_lsn;
    char       *ep;
 
    /* Make sure all fields are present. */
    if (parse->timeline == NULL)
        json_manifest_parse_failure(parse->context, "missing timeline");
    if (parse->start_lsn == NULL)
        json_manifest_parse_failure(parse->context, "missing start LSN");
    if (parse->end_lsn == NULL)
        json_manifest_parse_failure(parse->context, "missing end LSN");
 
    /* Parse timeline. */
    tli = strtoul(parse->timeline, &ep, 10);
    if (*ep)
        json_manifest_parse_failure(parse->context,
                                    "timeline is not an integer");
    if (!parse_xlogrecptr(&start_lsn, parse->start_lsn))
        json_manifest_parse_failure(parse->context,
                                    "could not parse start LSN");
    if (!parse_xlogrecptr(&end_lsn, parse->end_lsn))
        json_manifest_parse_failure(parse->context,
                                    "could not parse end LSN");
 
    /* Invoke the callback with the details we've gathered. */
    context->per_wal_range_cb(context, tli, start_lsn, end_lsn);
 
    /* Free memory we no longer need. */
    if (parse->timeline != NULL)
    {
        pfree(parse->timeline);
        parse->timeline = NULL;
    }
    if (parse->start_lsn != NULL)
    {
        pfree(parse->start_lsn);
        parse->start_lsn = NULL;
    }
    if (parse->end_lsn != NULL)
    {
        pfree(parse->end_lsn);
        parse->end_lsn = NULL;
    }
}

References json_manifest_parse_failure(), parse(), parse_xlogrecptr(), JsonManifestParseContext::per_wal_range_cb, and pfree().

Referenced by json_manifest_object_end().

json_manifest_object_end()

static JsonParseErrorType json_manifest_object_end ( void *  state )

static

Definition at line 317 of file parse_manifest.c.

{
    JsonManifestParseState *parse = state;
 
    switch (parse->state)
    {
        case JM_EXPECT_TOPLEVEL_END:
            parse->state = JM_EXPECT_EOF;
            break;
        case JM_EXPECT_THIS_FILE_FIELD:
            json_manifest_finalize_file(parse);
            parse->state = JM_EXPECT_FILES_NEXT;
            break;
        case JM_EXPECT_THIS_WAL_RANGE_FIELD:
            json_manifest_finalize_wal_range(parse);
            parse->state = JM_EXPECT_WAL_RANGES_NEXT;
            break;
        default:
            json_manifest_parse_failure(parse->context,
                                        "unexpected object end");
            break;
    }
 
    return JSON_SUCCESS;
}

References JM_EXPECT_EOF, JM_EXPECT_FILES_NEXT, JM_EXPECT_THIS_FILE_FIELD, JM_EXPECT_THIS_WAL_RANGE_FIELD, JM_EXPECT_TOPLEVEL_END, JM_EXPECT_WAL_RANGES_NEXT, json_manifest_finalize_file(), json_manifest_finalize_wal_range(), json_manifest_parse_failure(), JSON_SUCCESS, and parse().

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_init().

json_manifest_object_field_start()

static JsonParseErrorType json_manifest_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 401 of file parse_manifest.c.

{
    JsonManifestParseState *parse = state;
 
    switch (parse->state)
    {
        case JM_EXPECT_TOPLEVEL_FIELD:
 
            /*
             * Inside toplevel object. The version indicator should always be
             * the first field.
             */
            if (!parse->saw_version_field)
            {
                if (strcmp(fname, "PostgreSQL-Backup-Manifest-Version") != 0)
                    json_manifest_parse_failure(parse->context,
                                                "expected version indicator");
                parse->state = JM_EXPECT_VERSION_VALUE;
                parse->saw_version_field = true;
                break;
            }
 
            /* Is this the system identifier? */
            if (strcmp(fname, "System-Identifier") == 0)
            {
                parse->state = JM_EXPECT_SYSTEM_IDENTIFIER_VALUE;
                break;
            }
 
            /* Is this the list of files? */
            if (strcmp(fname, "Files") == 0)
            {
                parse->state = JM_EXPECT_FILES_START;
                break;
            }
 
            /* Is this the list of WAL ranges? */
            if (strcmp(fname, "WAL-Ranges") == 0)
            {
                parse->state = JM_EXPECT_WAL_RANGES_START;
                break;
            }
 
            /* Is this the manifest checksum? */
            if (strcmp(fname, "Manifest-Checksum") == 0)
            {
                parse->state = JM_EXPECT_MANIFEST_CHECKSUM_VALUE;
                break;
            }
 
            /* It's not a field we recognize. */
            json_manifest_parse_failure(parse->context,
                                        "unrecognized top-level field");
            break;
 
        case JM_EXPECT_THIS_FILE_FIELD:
            /* Inside object for one file; which key have we got? */
            if (strcmp(fname, "Path") == 0)
                parse->file_field = JMFF_PATH;
            else if (strcmp(fname, "Encoded-Path") == 0)
                parse->file_field = JMFF_ENCODED_PATH;
            else if (strcmp(fname, "Size") == 0)
                parse->file_field = JMFF_SIZE;
            else if (strcmp(fname, "Last-Modified") == 0)
                parse->file_field = JMFF_LAST_MODIFIED;
            else if (strcmp(fname, "Checksum-Algorithm") == 0)
                parse->file_field = JMFF_CHECKSUM_ALGORITHM;
            else if (strcmp(fname, "Checksum") == 0)
                parse->file_field = JMFF_CHECKSUM;
            else
                json_manifest_parse_failure(parse->context,
                                            "unexpected file field");
            parse->state = JM_EXPECT_THIS_FILE_VALUE;
            break;
 
        case JM_EXPECT_THIS_WAL_RANGE_FIELD:
            /* Inside object for one file; which key have we got? */
            if (strcmp(fname, "Timeline") == 0)
                parse->wal_range_field = JMWRF_TIMELINE;
            else if (strcmp(fname, "Start-LSN") == 0)
                parse->wal_range_field = JMWRF_START_LSN;
            else if (strcmp(fname, "End-LSN") == 0)
                parse->wal_range_field = JMWRF_END_LSN;
            else
                json_manifest_parse_failure(parse->context,
                                            "unexpected WAL range field");
            parse->state = JM_EXPECT_THIS_WAL_RANGE_VALUE;
            break;
 
        default:
            json_manifest_parse_failure(parse->context,
                                        "unexpected object field");
            break;
    }
 
    pfree(fname);
 
    return JSON_SUCCESS;
}

References JM_EXPECT_FILES_START, JM_EXPECT_MANIFEST_CHECKSUM_VALUE, JM_EXPECT_SYSTEM_IDENTIFIER_VALUE, JM_EXPECT_THIS_FILE_FIELD, JM_EXPECT_THIS_FILE_VALUE, JM_EXPECT_THIS_WAL_RANGE_FIELD, JM_EXPECT_THIS_WAL_RANGE_VALUE, JM_EXPECT_TOPLEVEL_FIELD, JM_EXPECT_VERSION_VALUE, JM_EXPECT_WAL_RANGES_START, JMFF_CHECKSUM, JMFF_CHECKSUM_ALGORITHM, JMFF_ENCODED_PATH, JMFF_LAST_MODIFIED, JMFF_PATH, JMFF_SIZE, JMWRF_END_LSN, JMWRF_START_LSN, JMWRF_TIMELINE, json_manifest_parse_failure(), JSON_SUCCESS, parse(), and pfree().

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_init().

json_manifest_object_start()

static JsonParseErrorType json_manifest_object_start ( void *  state )

static

Definition at line 276 of file parse_manifest.c.

{
    JsonManifestParseState *parse = state;
 
    switch (parse->state)
    {
        case JM_EXPECT_TOPLEVEL_START:
            parse->state = JM_EXPECT_TOPLEVEL_FIELD;
            break;
        case JM_EXPECT_FILES_NEXT:
            parse->state = JM_EXPECT_THIS_FILE_FIELD;
            parse->pathname = NULL;
            parse->encoded_pathname = NULL;
            parse->size = NULL;
            parse->algorithm = NULL;
            parse->checksum = NULL;
            break;
        case JM_EXPECT_WAL_RANGES_NEXT:
            parse->state = JM_EXPECT_THIS_WAL_RANGE_FIELD;
            parse->timeline = NULL;
            parse->start_lsn = NULL;
            parse->end_lsn = NULL;
            break;
        default:
            json_manifest_parse_failure(parse->context,
                                        "unexpected object start");
            break;
    }
 
    return JSON_SUCCESS;
}

References JM_EXPECT_FILES_NEXT, JM_EXPECT_THIS_FILE_FIELD, JM_EXPECT_THIS_WAL_RANGE_FIELD, JM_EXPECT_TOPLEVEL_FIELD, JM_EXPECT_TOPLEVEL_START, JM_EXPECT_WAL_RANGES_NEXT, json_manifest_parse_failure(), JSON_SUCCESS, and parse().

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_init().

json_manifest_parse_failure()

static void json_manifest_parse_failure ( JsonManifestParseContext *  context, char *  msg  )

static

Definition at line 889 of file parse_manifest.c.

{
    context->error_cb(context, "could not parse backup manifest: %s", msg);
    pg_unreachable();
}

References JsonManifestParseContext::error_cb, and pg_unreachable.

Referenced by json_manifest_array_end(), json_manifest_array_start(), json_manifest_finalize_file(), json_manifest_finalize_system_identifier(), json_manifest_finalize_version(), json_manifest_finalize_wal_range(), json_manifest_object_end(), json_manifest_object_field_start(), json_manifest_object_start(), json_manifest_scalar(), json_parse_manifest(), json_parse_manifest_incremental_chunk(), and verify_manifest_checksum().

json_manifest_scalar()

static JsonParseErrorType json_manifest_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 517 of file parse_manifest.c.

{
    JsonManifestParseState *parse = state;
 
    switch (parse->state)
    {
        case JM_EXPECT_VERSION_VALUE:
            parse->manifest_version = token;
            json_manifest_finalize_version(parse);
            parse->state = JM_EXPECT_TOPLEVEL_FIELD;
            break;
 
        case JM_EXPECT_SYSTEM_IDENTIFIER_VALUE:
            parse->manifest_system_identifier = token;
            json_manifest_finalize_system_identifier(parse);
            parse->state = JM_EXPECT_TOPLEVEL_FIELD;
            break;
 
        case JM_EXPECT_THIS_FILE_VALUE:
            switch (parse->file_field)
            {
                case JMFF_PATH:
                    parse->pathname = token;
                    break;
                case JMFF_ENCODED_PATH:
                    parse->encoded_pathname = token;
                    break;
                case JMFF_SIZE:
                    parse->size = token;
                    break;
                case JMFF_LAST_MODIFIED:
                    pfree(token);   /* unused */
                    break;
                case JMFF_CHECKSUM_ALGORITHM:
                    parse->algorithm = token;
                    break;
                case JMFF_CHECKSUM:
                    parse->checksum = token;
                    break;
            }
            parse->state = JM_EXPECT_THIS_FILE_FIELD;
            break;
 
        case JM_EXPECT_THIS_WAL_RANGE_VALUE:
            switch (parse->wal_range_field)
            {
                case JMWRF_TIMELINE:
                    parse->timeline = token;
                    break;
                case JMWRF_START_LSN:
                    parse->start_lsn = token;
                    break;
                case JMWRF_END_LSN:
                    parse->end_lsn = token;
                    break;
            }
            parse->state = JM_EXPECT_THIS_WAL_RANGE_FIELD;
            break;
 
        case JM_EXPECT_MANIFEST_CHECKSUM_VALUE:
            parse->state = JM_EXPECT_TOPLEVEL_END;
            parse->manifest_checksum = token;
            break;
 
        default:
            json_manifest_parse_failure(parse->context, "unexpected scalar");
            break;
    }
 
    return JSON_SUCCESS;
}

References JM_EXPECT_MANIFEST_CHECKSUM_VALUE, JM_EXPECT_SYSTEM_IDENTIFIER_VALUE, JM_EXPECT_THIS_FILE_FIELD, JM_EXPECT_THIS_FILE_VALUE, JM_EXPECT_THIS_WAL_RANGE_FIELD, JM_EXPECT_THIS_WAL_RANGE_VALUE, JM_EXPECT_TOPLEVEL_END, JM_EXPECT_TOPLEVEL_FIELD, JM_EXPECT_VERSION_VALUE, JMFF_CHECKSUM, JMFF_CHECKSUM_ALGORITHM, JMFF_ENCODED_PATH, JMFF_LAST_MODIFIED, JMFF_PATH, JMFF_SIZE, JMWRF_END_LSN, JMWRF_START_LSN, JMWRF_TIMELINE, json_manifest_finalize_system_identifier(), json_manifest_finalize_version(), json_manifest_parse_failure(), JSON_SUCCESS, parse(), pfree(), and token.

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_init().

json_parse_manifest()

void json_parse_manifest	(	JsonManifestParseContext *	context,
		const char *	buffer,
		size_t	size
	)

Definition at line 227 of file parse_manifest.c.

{
    JsonLexContext *lex;
    JsonParseErrorType json_error;
    JsonSemAction sem;
    JsonManifestParseState parse;
 
    /* Set up our private parsing context. */
    parse.context = context;
    parse.state = JM_EXPECT_TOPLEVEL_START;
    parse.saw_version_field = false;
 
    /* Create a JSON lexing context. */
    lex = makeJsonLexContextCstringLen(NULL, buffer, size, PG_UTF8, true);
 
    /* Set up semantic actions. */
    sem.semstate = &parse;
    sem.object_start = json_manifest_object_start;
    sem.object_end = json_manifest_object_end;
    sem.array_start = json_manifest_array_start;
    sem.array_end = json_manifest_array_end;
    sem.object_field_start = json_manifest_object_field_start;
    sem.object_field_end = NULL;
    sem.array_element_start = NULL;
    sem.array_element_end = NULL;
    sem.scalar = json_manifest_scalar;
 
    /* Run the actual JSON parser. */
    json_error = pg_parse_json(lex, &sem);
    if (json_error != JSON_SUCCESS)
        json_manifest_parse_failure(context, json_errdetail(json_error, lex));
    if (parse.state != JM_EXPECT_EOF)
        json_manifest_parse_failure(context, "manifest ended unexpectedly");
 
    /* Verify the manifest checksum. */
    verify_manifest_checksum(&parse, buffer, size, NULL);
 
    freeJsonLexContext(lex);
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, freeJsonLexContext(), JM_EXPECT_EOF, JM_EXPECT_TOPLEVEL_START, json_errdetail(), json_manifest_array_end(), json_manifest_array_start(), json_manifest_object_end(), json_manifest_object_field_start(), json_manifest_object_start(), json_manifest_parse_failure(), json_manifest_scalar(), JSON_SUCCESS, makeJsonLexContextCstringLen(), JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, parse(), pg_parse_json(), PG_UTF8, JsonSemAction::scalar, sem, JsonSemAction::semstate, and verify_manifest_checksum().

Referenced by load_backup_manifest(), and parse_manifest_file().

json_parse_manifest_incremental_chunk()

void json_parse_manifest_incremental_chunk	(	JsonManifestParseIncrementalState *	incstate,
		const char *	chunk,
		size_t	size,
		bool	is_last
	)

Definition at line 185 of file parse_manifest.c.

{
    JsonParseErrorType res,
                expected;
    JsonManifestParseState *parse = incstate->sem.semstate;
    JsonManifestParseContext *context = parse->context;
 
    res = pg_parse_json_incremental(&(incstate->lex), &(incstate->sem),
                                    chunk, size, is_last);
 
    expected = is_last ? JSON_SUCCESS : JSON_INCOMPLETE;
 
    if (res != expected)
        json_manifest_parse_failure(context,
                                    json_errdetail(res, &(incstate->lex)));
 
    if (is_last && parse->state != JM_EXPECT_EOF)
        json_manifest_parse_failure(context, "manifest ended unexpectedly");
 
    if (!is_last)
    {
        if (pg_cryptohash_update(incstate->manifest_ctx,
                                 (const uint8 *) chunk, size) < 0)
            context->error_cb(context, "could not update checksum of manifest");
    }
    else
    {
        verify_manifest_checksum(parse, chunk, size, incstate->manifest_ctx);
    }
}

References JsonManifestParseContext::error_cb, JM_EXPECT_EOF, json_errdetail(), JSON_INCOMPLETE, json_manifest_parse_failure(), JSON_SUCCESS, JsonManifestParseIncrementalState::lex, JsonManifestParseIncrementalState::manifest_ctx, parse(), pg_cryptohash_update(), pg_parse_json_incremental(), JsonManifestParseIncrementalState::sem, JsonSemAction::semstate, and verify_manifest_checksum().

Referenced by AppendIncrementalManifestData(), FinalizeIncrementalManifest(), load_backup_manifest(), and parse_manifest_file().

json_parse_manifest_incremental_init()

JsonManifestParseIncrementalState * json_parse_manifest_incremental_init

(

JsonManifestParseContext *

context

)

Definition at line 129 of file parse_manifest.c.

{
    JsonManifestParseIncrementalState *incstate;
    JsonManifestParseState *parse;
    pg_cryptohash_ctx *manifest_ctx;
 
    incstate = palloc(sizeof(JsonManifestParseIncrementalState));
    parse = palloc(sizeof(JsonManifestParseState));
 
    parse->context = context;
    parse->state = JM_EXPECT_TOPLEVEL_START;
    parse->saw_version_field = false;
 
    makeJsonLexContextIncremental(&(incstate->lex), PG_UTF8, true);
 
    incstate->sem.semstate = parse;
    incstate->sem.object_start = json_manifest_object_start;
    incstate->sem.object_end = json_manifest_object_end;
    incstate->sem.array_start = json_manifest_array_start;
    incstate->sem.array_end = json_manifest_array_end;
    incstate->sem.object_field_start = json_manifest_object_field_start;
    incstate->sem.object_field_end = NULL;
    incstate->sem.array_element_start = NULL;
    incstate->sem.array_element_end = NULL;
    incstate->sem.scalar = json_manifest_scalar;
 
    manifest_ctx = pg_cryptohash_create(PG_SHA256);
    if (manifest_ctx == NULL)
        context->error_cb(context, "out of memory");
    if (pg_cryptohash_init(manifest_ctx) < 0)
        context->error_cb(context, "could not initialize checksum of manifest");
    incstate->manifest_ctx = manifest_ctx;
 
    return incstate;
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, JsonManifestParseContext::error_cb, JM_EXPECT_TOPLEVEL_START, json_manifest_array_end(), json_manifest_array_start(), json_manifest_object_end(), json_manifest_object_field_start(), json_manifest_object_start(), json_manifest_scalar(), JsonManifestParseIncrementalState::lex, makeJsonLexContextIncremental(), JsonManifestParseIncrementalState::manifest_ctx, JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc(), parse(), pg_cryptohash_create(), pg_cryptohash_init(), PG_SHA256, PG_UTF8, JsonSemAction::scalar, JsonManifestParseIncrementalState::sem, and JsonSemAction::semstate.

Referenced by CreateIncrementalBackupInfo(), load_backup_manifest(), and parse_manifest_file().

json_parse_manifest_incremental_shutdown()

void json_parse_manifest_incremental_shutdown

(

JsonManifestParseIncrementalState *

incstate

)

Definition at line 169 of file parse_manifest.c.

{
    pfree(incstate->sem.semstate);
    freeJsonLexContext(&(incstate->lex));
    /* incstate->manifest_ctx has already been freed */
    pfree(incstate);
}

References freeJsonLexContext(), JsonManifestParseIncrementalState::lex, pfree(), JsonManifestParseIncrementalState::sem, and JsonSemAction::semstate.

Referenced by FinalizeIncrementalManifest(), load_backup_manifest(), and parse_manifest_file().

parse_xlogrecptr()

static bool parse_xlogrecptr ( XLogRecPtr *  result, char *  input  )

static

Definition at line 940 of file parse_manifest.c.

{
    uint32      hi;
    uint32      lo;
 
    if (sscanf(input, "%X/%X", &hi, &lo) != 2)
        return false;
    *result = ((uint64) hi) << 32 | lo;
    return true;
}

References input.

Referenced by json_manifest_finalize_wal_range().

verify_manifest_checksum()

static void verify_manifest_checksum ( JsonManifestParseState *  parse, const char *  buffer, size_t  size, pg_cryptohash_ctx *  incr_ctx  )

static

Definition at line 812 of file parse_manifest.c.

{
    JsonManifestParseContext *context = parse->context;
    size_t      i;
    size_t      number_of_newlines = 0;
    size_t      ultimate_newline = 0;
    size_t      penultimate_newline = 0;
    pg_cryptohash_ctx *manifest_ctx;
    uint8       manifest_checksum_actual[PG_SHA256_DIGEST_LENGTH];
    uint8       manifest_checksum_expected[PG_SHA256_DIGEST_LENGTH];
 
    /* Find the last two newlines in the file. */
    for (i = 0; i < size; ++i)
    {
        if (buffer[i] == '\n')
        {
            ++number_of_newlines;
            penultimate_newline = ultimate_newline;
            ultimate_newline = i;
        }
    }
 
    /*
     * Make sure that the last newline is right at the end, and that there are
     * at least two lines total. We need this to be true in order for the
     * following code, which computes the manifest checksum, to work properly.
     */
    if (number_of_newlines < 2)
        json_manifest_parse_failure(parse->context,
                                    "expected at least 2 lines");
    if (ultimate_newline != size - 1)
        json_manifest_parse_failure(parse->context,
                                    "last line not newline-terminated");
 
    /* Checksum the rest. */
    if (incr_ctx == NULL)
    {
        manifest_ctx = pg_cryptohash_create(PG_SHA256);
        if (manifest_ctx == NULL)
            context->error_cb(context, "out of memory");
        if (pg_cryptohash_init(manifest_ctx) < 0)
            context->error_cb(context, "could not initialize checksum of manifest");
    }
    else
    {
        manifest_ctx = incr_ctx;
    }
    if (pg_cryptohash_update(manifest_ctx, (const uint8 *) buffer, penultimate_newline + 1) < 0)
        context->error_cb(context, "could not update checksum of manifest");
    if (pg_cryptohash_final(manifest_ctx, manifest_checksum_actual,
                            sizeof(manifest_checksum_actual)) < 0)
        context->error_cb(context, "could not finalize checksum of manifest");
 
    /* Now verify it. */
    if (parse->manifest_checksum == NULL)
        context->error_cb(parse->context, "manifest has no checksum");
    if (strlen(parse->manifest_checksum) != PG_SHA256_DIGEST_LENGTH * 2 ||
        !hexdecode_string(manifest_checksum_expected, parse->manifest_checksum,
                          PG_SHA256_DIGEST_LENGTH))
        context->error_cb(context, "invalid manifest checksum: \"%s\"",
                          parse->manifest_checksum);
    if (memcmp(manifest_checksum_actual, manifest_checksum_expected,
               PG_SHA256_DIGEST_LENGTH) != 0)
        context->error_cb(context, "manifest checksum mismatch");
    pg_cryptohash_free(manifest_ctx);
}

References JsonManifestParseContext::error_cb, hexdecode_string(), i, json_manifest_parse_failure(), parse(), pg_cryptohash_create(), pg_cryptohash_final(), pg_cryptohash_free(), pg_cryptohash_init(), pg_cryptohash_update(), PG_SHA256, and PG_SHA256_DIGEST_LENGTH.

Referenced by json_parse_manifest(), and json_parse_manifest_incremental_chunk().