[フレーム]

parse_manifest.h File Reference

#include "access/xlogdefs.h"
#include "common/checksum_helper.h"
#include "mb/pg_wchar.h"

Include dependency graph for parse_manifest.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct JsonManifestParseContext

Typedefs

typedef struct JsonManifestParseContext JsonManifestParseContext

typedef struct JsonManifestParseIncrementalState JsonManifestParseIncrementalState

typedef void(* json_manifest_version_callback) (JsonManifestParseContext *, int manifest_version)

typedef void(* json_manifest_system_identifier_callback) (JsonManifestParseContext *, uint64 manifest_system_identifier)

typedef void(* json_manifest_per_file_callback) (JsonManifestParseContext *, const char *pathname, uint64 size, pg_checksum_type checksum_type, int checksum_length, uint8 *checksum_payload)

typedef void(* json_manifest_per_wal_range_callback) (JsonManifestParseContext *, TimeLineID tli, XLogRecPtr start_lsn, XLogRecPtr end_lsn)

typedef void(* json_manifest_error_callback) (JsonManifestParseContext *, const char *fmt,...) pg_attribute_printf(2

Functions

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

JsonManifestParseIncrementalState * json_parse_manifest_incremental_init (JsonManifestParseContext *context)

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

void json_parse_manifest_incremental_shutdown (JsonManifestParseIncrementalState *incstate)

Typedef Documentation

◆ json_manifest_error_callback

typedef void(* json_manifest_error_callback) (JsonManifestParseContext *, const char *fmt,...) pg_attribute_printf(2

Definition at line 36 of file parse_manifest.h.

◆ json_manifest_per_file_callback

typedef void(* json_manifest_per_file_callback) (JsonManifestParseContext *, const char *pathname, uint64 size, pg_checksum_type checksum_type, int checksum_length, uint8 *checksum_payload)

Definition at line 29 of file parse_manifest.h.

◆ json_manifest_per_wal_range_callback

typedef void(* json_manifest_per_wal_range_callback) (JsonManifestParseContext *, TimeLineID tli, XLogRecPtr start_lsn, XLogRecPtr end_lsn)

Definition at line 33 of file parse_manifest.h.

◆ json_manifest_system_identifier_callback

typedef void(* json_manifest_system_identifier_callback) (JsonManifestParseContext *, uint64 manifest_system_identifier)

Definition at line 27 of file parse_manifest.h.

◆ json_manifest_version_callback

typedef void(* json_manifest_version_callback) (JsonManifestParseContext *, int manifest_version)

Definition at line 25 of file parse_manifest.h.

◆ JsonManifestParseContext

typedef struct JsonManifestParseContext JsonManifestParseContext

Definition at line 22 of file parse_manifest.h.

◆ JsonManifestParseIncrementalState

typedef struct JsonManifestParseIncrementalState JsonManifestParseIncrementalState

Definition at line 23 of file parse_manifest.h.

Function Documentation

◆ json_parse_manifest()

void json_parse_manifest ( JsonManifestParseContext * context,

const char * buffer,

size_t size

)

Definition at line 227 of file parse_manifest.c.

229{

230 JsonLexContext *lex;

231 JsonParseErrorType json_error;

232 JsonSemAction sem;

233 JsonManifestParseState parse;

234

235 /* Set up our private parsing context. */

236 parse.context = context;

237 parse.state = JM_EXPECT_TOPLEVEL_START;

238 parse.saw_version_field = false;

239

240 /* Create a JSON lexing context. */

241 lex = makeJsonLexContextCstringLen(NULL, buffer, size, PG_UTF8, true);

242

243 /* Set up semantic actions. */

244 sem.semstate = &parse;

245 sem.object_start = json_manifest_object_start;

246 sem.object_end = json_manifest_object_end;

247 sem.array_start = json_manifest_array_start;

248 sem.array_end = json_manifest_array_end;

249 sem.object_field_start = json_manifest_object_field_start;

250 sem.object_field_end = NULL;

251 sem.array_element_start = NULL;

252 sem.array_element_end = NULL;

253 sem.scalar = json_manifest_scalar;

254

255 /* Run the actual JSON parser. */

256 json_error = pg_parse_json(lex, &sem);

257 if (json_error != JSON_SUCCESS)

258 json_manifest_parse_failure(context, json_errdetail(json_error, lex));

259 if (parse.state != JM_EXPECT_EOF)

260 json_manifest_parse_failure(context, "manifest ended unexpectedly");

261

262 /* Verify the manifest checksum. */

263 verify_manifest_checksum(&parse, buffer, size, NULL);

264

265 freeJsonLexContext(lex);

266}

pg_parse_json

JsonParseErrorType pg_parse_json(JsonLexContext *lex, const JsonSemAction *sem)

Definition: jsonapi.c:744

makeJsonLexContextCstringLen

JsonLexContext * makeJsonLexContextCstringLen(JsonLexContext *lex, const char *json, size_t len, int encoding, bool need_escapes)

Definition: jsonapi.c:392

json_errdetail

char * json_errdetail(JsonParseErrorType error, JsonLexContext *lex)

Definition: jsonapi.c:2404

freeJsonLexContext

void freeJsonLexContext(JsonLexContext *lex)

Definition: jsonapi.c:687

JsonParseErrorType

Definition: jsonapi.h:35

JSON_SUCCESS

@ JSON_SUCCESS

Definition: jsonapi.h:36

JM_EXPECT_TOPLEVEL_START

@ JM_EXPECT_TOPLEVEL_START

Definition: parse_manifest.c:24

JM_EXPECT_EOF

@ JM_EXPECT_EOF

Definition: parse_manifest.c:38

json_manifest_array_start

static JsonParseErrorType json_manifest_array_start(void *state)

Definition: parse_manifest.c:351

json_manifest_object_field_start

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

Definition: parse_manifest.c:401

json_manifest_object_end

static JsonParseErrorType json_manifest_object_end(void *state)

Definition: parse_manifest.c:317

json_manifest_object_start

static JsonParseErrorType json_manifest_object_start(void *state)

Definition: parse_manifest.c:276

json_manifest_scalar

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

Definition: parse_manifest.c:517

json_manifest_parse_failure

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

Definition: parse_manifest.c:889

json_manifest_array_end

static JsonParseErrorType json_manifest_array_end(void *state)

Definition: parse_manifest.c:378

verify_manifest_checksum

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

Definition: parse_manifest.c:812

PG_UTF8

@ PG_UTF8

Definition: pg_wchar.h:232

parse

static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)

Definition: regcomp.c:717

JsonLexContext

Definition: jsonapi.h:101

JsonManifestParseState

Definition: parse_manifest.c:68

JsonSemAction

Definition: jsonapi.h:152

JsonSemAction::array_end

json_struct_action array_end

Definition: jsonapi.h:157

JsonSemAction::object_start

json_struct_action object_start

Definition: jsonapi.h:154

JsonSemAction::object_field_start

json_ofield_action object_field_start

Definition: jsonapi.h:158

JsonSemAction::array_element_start

json_aelem_action array_element_start

Definition: jsonapi.h:160

JsonSemAction::scalar

json_scalar_action scalar

Definition: jsonapi.h:162

JsonSemAction::semstate

void * semstate

Definition: jsonapi.h:153

JsonSemAction::array_element_end

json_aelem_action array_element_end

Definition: jsonapi.h:161

JsonSemAction::array_start

json_struct_action array_start

Definition: jsonapi.h:156

JsonSemAction::object_end

json_struct_action object_end

Definition: jsonapi.h:155

JsonSemAction::object_field_end

json_ofield_action object_field_end

Definition: jsonapi.h:159

sem

static JsonSemAction sem

Definition: test_json_parser_incremental.c:72

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.

187{

188 JsonParseErrorType res,

189 expected;

190 JsonManifestParseState *parse = incstate->sem.semstate;

191 JsonManifestParseContext *context = parse->context;

192

193 res = pg_parse_json_incremental(&(incstate->lex), &(incstate->sem),

194 chunk, size, is_last);

195

196 expected = is_last ? JSON_SUCCESS : JSON_INCOMPLETE;

197

198 if (res != expected)

199 json_manifest_parse_failure(context,

200 json_errdetail(res, &(incstate->lex)));

201

202 if (is_last && parse->state != JM_EXPECT_EOF)

203 json_manifest_parse_failure(context, "manifest ended unexpectedly");

204

205 if (!is_last)

206 {

207 if (pg_cryptohash_update(incstate->manifest_ctx,

208 (const uint8 *) chunk, size) < 0)

209 context->error_cb(context, "could not update checksum of manifest");

210 }

211 else

212 {

213 verify_manifest_checksum(parse, chunk, size, incstate->manifest_ctx);

214 }

215}

uint8

uint8_t uint8

Definition: c.h:536

pg_cryptohash_update

int pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len)

Definition: cryptohash.c:136

pg_parse_json_incremental

JsonParseErrorType pg_parse_json_incremental(JsonLexContext *lex, const JsonSemAction *sem, const char *json, size_t len, bool is_last)

Definition: jsonapi.c:868

JSON_INCOMPLETE

@ JSON_INCOMPLETE

Definition: jsonapi.h:37

JsonManifestParseContext

Definition: parse_manifest.h:40

JsonManifestParseContext::error_cb

json_manifest_error_callback error_cb

Definition: parse_manifest.h:46

JsonManifestParseIncrementalState::manifest_ctx

pg_cryptohash_ctx * manifest_ctx

Definition: parse_manifest.c:99

JsonManifestParseIncrementalState::sem

JsonSemAction sem

Definition: parse_manifest.c:98

JsonManifestParseIncrementalState::lex

JsonLexContext lex

Definition: parse_manifest.c:97

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.

130{

131 JsonManifestParseIncrementalState *incstate;

132 JsonManifestParseState *parse;

133 pg_cryptohash_ctx *manifest_ctx;

134

135 incstate = palloc(sizeof(JsonManifestParseIncrementalState));

136 parse = palloc(sizeof(JsonManifestParseState));

137

138 parse->context = context;

139 parse->state = JM_EXPECT_TOPLEVEL_START;

140 parse->saw_version_field = false;

141

142 makeJsonLexContextIncremental(&(incstate->lex), PG_UTF8, true);

143

144 incstate->sem.semstate = parse;

145 incstate->sem.object_start = json_manifest_object_start;

146 incstate->sem.object_end = json_manifest_object_end;

147 incstate->sem.array_start = json_manifest_array_start;

148 incstate->sem.array_end = json_manifest_array_end;

149 incstate->sem.object_field_start = json_manifest_object_field_start;

150 incstate->sem.object_field_end = NULL;

151 incstate->sem.array_element_start = NULL;

152 incstate->sem.array_element_end = NULL;

153 incstate->sem.scalar = json_manifest_scalar;

154

155 manifest_ctx = pg_cryptohash_create(PG_SHA256);

156 if (manifest_ctx == NULL)

157 context->error_cb(context, "out of memory");

158 if (pg_cryptohash_init(manifest_ctx) < 0)

159 context->error_cb(context, "could not initialize checksum of manifest");

160 incstate->manifest_ctx = manifest_ctx;

161

162 return incstate;

163}

pg_cryptohash_create

pg_cryptohash_ctx * pg_cryptohash_create(pg_cryptohash_type type)

Definition: cryptohash.c:74

pg_cryptohash_init

int pg_cryptohash_init(pg_cryptohash_ctx *ctx)

Definition: cryptohash.c:100

PG_SHA256

@ PG_SHA256

Definition: cryptohash.h:24

makeJsonLexContextIncremental

JsonLexContext * makeJsonLexContextIncremental(JsonLexContext *lex, int encoding, bool need_escapes)

Definition: jsonapi.c:497

palloc

void * palloc(Size size)

Definition: mcxt.c:1365

JsonManifestParseIncrementalState

Definition: parse_manifest.c:96

pg_cryptohash_ctx

Definition: cryptohash.c:52

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.

170{

171 pfree(incstate->sem.semstate);

172 freeJsonLexContext(&(incstate->lex));

173 /* incstate->manifest_ctx has already been freed */

174 pfree(incstate);

175}

pfree

void pfree(void *pointer)

Definition: mcxt.c:1594

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

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