PostgreSQL Source Code  git master
parse_manifest.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * parse_manifest.c
4  * Parse a backup manifest in JSON format.
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  * src/common/parse_manifest.c
10  *
11  *-------------------------------------------------------------------------
12  */
13 
14 #include "postgres_fe.h"
15 
16 #include "common/jsonapi.h"
17 #include "common/parse_manifest.h"
18 
19 /*
20  * Semantic states for JSON manifest parsing.
21  */
22 typedef enum
23 {
39 
40 /*
41  * Possible fields for one file as described by the manifest.
42  */
43 typedef enum
44 {
52 
53 /*
54  * Possible fields for one file as described by the manifest.
55  */
56 typedef enum
57 {
62 
63 /*
64  * Internal state used while decoding the JSON-format backup manifest.
65  */
66 typedef struct
67 {
70 
71  /* These fields are used for parsing objects in the list of files. */
73  char *pathname;
75  char *size;
76  char *algorithm;
78  char *checksum;
79 
80  /* These fields are used for parsing objects in the list of WAL ranges. */
82  char *timeline;
83  char *start_lsn;
84  char *end_lsn;
85 
86  /* Miscellaneous other stuff. */
90 
96  bool isnull);
98  JsonTokenType tokentype);
102  char *buffer, size_t size);
104  char *msg);
105 
106 static int hexdecode_char(char c);
107 static bool hexdecode_string(uint8 *result, char *input, int nbytes);
108 static bool parse_xlogrecptr(XLogRecPtr *result, char *input);
109 
110 /*
111  * Main entrypoint to parse a JSON-format backup manifest.
112  *
113  * Caller should set up the parsing context and then invoke this function.
114  * For each file whose information is extracted from the manifest,
115  * context->per_file_cb is invoked. In case of trouble, context->error_cb is
116  * invoked and is expected not to return.
117  */
118 void
120  size_t size)
121 {
122  JsonLexContext *lex;
123  JsonParseErrorType json_error;
124  JsonSemAction sem;
126 
127  /* Set up our private parsing context. */
128  parse.context = context;
130  parse.saw_version_field = false;
131 
132  /* Create a JSON lexing context. */
133  lex = makeJsonLexContextCstringLen(NULL, buffer, size, PG_UTF8, true);
134 
135  /* Set up semantic actions. */
136  sem.semstate = &parse;
142  sem.object_field_end = NULL;
143  sem.array_element_start = NULL;
144  sem.array_element_end = NULL;
146 
147  /* Run the actual JSON parser. */
148  json_error = pg_parse_json(lex, &sem);
149  if (json_error != JSON_SUCCESS)
150  json_manifest_parse_failure(context, "parsing failed");
151  if (parse.state != JM_EXPECT_EOF)
152  json_manifest_parse_failure(context, "manifest ended unexpectedly");
153 
154  /* Verify the manifest checksum. */
155  verify_manifest_checksum(&parse, buffer, size);
156 
157  freeJsonLexContext(lex);
158 }
159 
160 /*
161  * Invoked at the start of each object in the JSON document.
162  *
163  * The document as a whole is expected to be an object; each file and each
164  * WAL range is also expected to be an object. If we're anywhere else in the
165  * document, it's an error.
166  */
167 static JsonParseErrorType
169 {
171 
172  switch (parse->state)
173  {
176  break;
179  parse->pathname = NULL;
180  parse->encoded_pathname = NULL;
181  parse->size = NULL;
182  parse->algorithm = NULL;
183  parse->checksum = NULL;
184  break;
187  parse->timeline = NULL;
188  parse->start_lsn = NULL;
189  parse->end_lsn = NULL;
190  break;
191  default:
193  "unexpected object start");
194  break;
195  }
196 
197  return JSON_SUCCESS;
198 }
199 
200 /*
201  * Invoked at the end of each object in the JSON document.
202  *
203  * The possible cases here are the same as for json_manifest_object_start.
204  * There's nothing special to do at the end of the document, but when we
205  * reach the end of an object representing a particular file or WAL range,
206  * we must call json_manifest_finalize_file() to save the associated details.
207  */
208 static JsonParseErrorType
210 {
212 
213  switch (parse->state)
214  {
216  parse->state = JM_EXPECT_EOF;
217  break;
220  parse->state = JM_EXPECT_FILES_NEXT;
221  break;
225  break;
226  default:
228  "unexpected object end");
229  break;
230  }
231 
232  return JSON_SUCCESS;
233 }
234 
235 /*
236  * Invoked at the start of each array in the JSON document.
237  *
238  * Within the toplevel object, the value associated with the "Files" key
239  * should be an array. Similarly for the "WAL-Ranges" key. No other arrays
240  * are expected.
241  */
242 static JsonParseErrorType
244 {
246 
247  switch (parse->state)
248  {
250  parse->state = JM_EXPECT_FILES_NEXT;
251  break;
254  break;
255  default:
257  "unexpected array start");
258  break;
259  }
260 
261  return JSON_SUCCESS;
262 }
263 
264 /*
265  * Invoked at the end of each array in the JSON document.
266  *
267  * The cases here are analogous to those in json_manifest_array_start.
268  */
269 static JsonParseErrorType
271 {
273 
274  switch (parse->state)
275  {
279  break;
280  default:
282  "unexpected array end");
283  break;
284  }
285 
286  return JSON_SUCCESS;
287 }
288 
289 /*
290  * Invoked at the start of each object field in the JSON document.
291  */
292 static JsonParseErrorType
293 json_manifest_object_field_start(void *state, char *fname, bool isnull)
294 {
296 
297  switch (parse->state)
298  {
300 
301  /*
302  * Inside toplevel object. The version indicator should always be
303  * the first field.
304  */
305  if (!parse->saw_version_field)
306  {
307  if (strcmp(fname, "PostgreSQL-Backup-Manifest-Version") != 0)
309  "expected version indicator");
311  parse->saw_version_field = true;
312  break;
313  }
314 
315  /* Is this the list of files? */
316  if (strcmp(fname, "Files") == 0)
317  {
318  parse->state = JM_EXPECT_FILES_START;
319  break;
320  }
321 
322  /* Is this the list of WAL ranges? */
323  if (strcmp(fname, "WAL-Ranges") == 0)
324  {
326  break;
327  }
328 
329  /* Is this the manifest checksum? */
330  if (strcmp(fname, "Manifest-Checksum") == 0)
331  {
333  break;
334  }
335 
336  /* It's not a field we recognize. */
338  "unrecognized top-level field");
339  break;
340 
342  /* Inside object for one file; which key have we got? */
343  if (strcmp(fname, "Path") == 0)
344  parse->file_field = JMFF_PATH;
345  else if (strcmp(fname, "Encoded-Path") == 0)
346  parse->file_field = JMFF_ENCODED_PATH;
347  else if (strcmp(fname, "Size") == 0)
348  parse->file_field = JMFF_SIZE;
349  else if (strcmp(fname, "Last-Modified") == 0)
350  parse->file_field = JMFF_LAST_MODIFIED;
351  else if (strcmp(fname, "Checksum-Algorithm") == 0)
352  parse->file_field = JMFF_CHECKSUM_ALGORITHM;
353  else if (strcmp(fname, "Checksum") == 0)
354  parse->file_field = JMFF_CHECKSUM;
355  else
357  "unexpected file field");
359  break;
360 
362  /* Inside object for one file; which key have we got? */
363  if (strcmp(fname, "Timeline") == 0)
364  parse->wal_range_field = JMWRF_TIMELINE;
365  else if (strcmp(fname, "Start-LSN") == 0)
366  parse->wal_range_field = JMWRF_START_LSN;
367  else if (strcmp(fname, "End-LSN") == 0)
368  parse->wal_range_field = JMWRF_END_LSN;
369  else
371  "unexpected WAL range field");
373  break;
374 
375  default:
377  "unexpected object field");
378  break;
379  }
380 
381  return JSON_SUCCESS;
382 }
383 
384 /*
385  * Invoked at the start of each scalar in the JSON document.
386  *
387  * Object field names don't reach this code; those are handled by
388  * json_manifest_object_field_start. When we're inside of the object for
389  * a particular file or WAL range, that function will have noticed the name
390  * of the field, and we'll get the corresponding value here. When we're in
391  * the toplevel object, the parse state itself tells us which field this is.
392  *
393  * In all cases except for PostgreSQL-Backup-Manifest-Version, which we
394  * can just check on the spot, the goal here is just to save the value in
395  * the parse state for later use. We don't actually do anything until we
396  * reach either the end of the object representing this file, or the end
397  * of the manifest, as the case may be.
398  */
399 static JsonParseErrorType
401 {
403 
404  switch (parse->state)
405  {
407  if (strcmp(token, "1") != 0)
409  "unexpected manifest version");
411  break;
412 
414  switch (parse->file_field)
415  {
416  case JMFF_PATH:
417  parse->pathname = token;
418  break;
419  case JMFF_ENCODED_PATH:
420  parse->encoded_pathname = token;
421  break;
422  case JMFF_SIZE:
423  parse->size = token;
424  break;
425  case JMFF_LAST_MODIFIED:
426  pfree(token); /* unused */
427  break;
429  parse->algorithm = token;
430  break;
431  case JMFF_CHECKSUM:
432  parse->checksum = token;
433  break;
434  }
436  break;
437 
439  switch (parse->wal_range_field)
440  {
441  case JMWRF_TIMELINE:
442  parse->timeline = token;
443  break;
444  case JMWRF_START_LSN:
445  parse->start_lsn = token;
446  break;
447  case JMWRF_END_LSN:
448  parse->end_lsn = token;
449  break;
450  }
452  break;
453 
455  parse->state = JM_EXPECT_TOPLEVEL_END;
456  parse->manifest_checksum = token;
457  break;
458 
459  default:
460  json_manifest_parse_failure(parse->context, "unexpected scalar");
461  break;
462  }
463 
464  return JSON_SUCCESS;
465 }
466 
467 /*
468  * Do additional parsing and sanity-checking of the details gathered for one
469  * file, and invoke the per-file callback so that the caller gets those
470  * details. This happens for each file when the corresponding JSON object is
471  * completely parsed.
472  */
473 static void
475 {
476  JsonManifestParseContext *context = parse->context;
477  size_t size;
478  char *ep;
479  int checksum_string_length;
480  pg_checksum_type checksum_type;
481  int checksum_length;
482  uint8 *checksum_payload;
483 
484  /* Pathname and size are required. */
485  if (parse->pathname == NULL && parse->encoded_pathname == NULL)
486  json_manifest_parse_failure(parse->context, "missing path name");
487  if (parse->pathname != NULL && parse->encoded_pathname != NULL)
489  "both path name and encoded path name");
490  if (parse->size == NULL)
491  json_manifest_parse_failure(parse->context, "missing size");
492  if (parse->algorithm == NULL && parse->checksum != NULL)
494  "checksum without algorithm");
495 
496  /* Decode encoded pathname, if that's what we have. */
497  if (parse->encoded_pathname != NULL)
498  {
499  int encoded_length = strlen(parse->encoded_pathname);
500  int raw_length = encoded_length / 2;
501 
502  parse->pathname = palloc(raw_length + 1);
503  if (encoded_length % 2 != 0 ||
504  !hexdecode_string((uint8 *) parse->pathname,
505  parse->encoded_pathname,
506  raw_length))
508  "could not decode file name");
509  parse->pathname[raw_length] = '\0';
510  pfree(parse->encoded_pathname);
511  parse->encoded_pathname = NULL;
512  }
513 
514  /* Parse size. */
515  size = strtoul(parse->size, &ep, 10);
516  if (*ep)
518  "file size is not an integer");
519 
520  /* Parse the checksum algorithm, if it's present. */
521  if (parse->algorithm == NULL)
522  checksum_type = CHECKSUM_TYPE_NONE;
523  else if (!pg_checksum_parse_type(parse->algorithm, &checksum_type))
524  context->error_cb(context, "unrecognized checksum algorithm: \"%s\"",
525  parse->algorithm);
526 
527  /* Parse the checksum payload, if it's present. */
528  checksum_string_length = parse->checksum == NULL ? 0
529  : strlen(parse->checksum);
530  if (checksum_string_length == 0)
531  {
532  checksum_length = 0;
533  checksum_payload = NULL;
534  }
535  else
536  {
537  checksum_length = checksum_string_length / 2;
538  checksum_payload = palloc(checksum_length);
539  if (checksum_string_length % 2 != 0 ||
540  !hexdecode_string(checksum_payload, parse->checksum,
541  checksum_length))
542  context->error_cb(context,
543  "invalid checksum for file \"%s\": \"%s\"",
544  parse->pathname, parse->checksum);
545  }
546 
547  /* Invoke the callback with the details we've gathered. */
548  context->per_file_cb(context, parse->pathname, size,
549  checksum_type, checksum_length, checksum_payload);
550 
551  /* Free memory we no longer need. */
552  if (parse->size != NULL)
553  {
554  pfree(parse->size);
555  parse->size = NULL;
556  }
557  if (parse->algorithm != NULL)
558  {
559  pfree(parse->algorithm);
560  parse->algorithm = NULL;
561  }
562  if (parse->checksum != NULL)
563  {
564  pfree(parse->checksum);
565  parse->checksum = NULL;
566  }
567 }
568 
569 /*
570  * Do additional parsing and sanity-checking of the details gathered for one
571  * WAL range, and invoke the per-WAL-range callback so that the caller gets
572  * those details. This happens for each WAL range when the corresponding JSON
573  * object is completely parsed.
574  */
575 static void
577 {
578  JsonManifestParseContext *context = parse->context;
579  TimeLineID tli;
580  XLogRecPtr start_lsn,
581  end_lsn;
582  char *ep;
583 
584  /* Make sure all fields are present. */
585  if (parse->timeline == NULL)
586  json_manifest_parse_failure(parse->context, "missing timeline");
587  if (parse->start_lsn == NULL)
588  json_manifest_parse_failure(parse->context, "missing start LSN");
589  if (parse->end_lsn == NULL)
590  json_manifest_parse_failure(parse->context, "missing end LSN");
591 
592  /* Parse timeline. */
593  tli = strtoul(parse->timeline, &ep, 10);
594  if (*ep)
596  "timeline is not an integer");
597  if (!parse_xlogrecptr(&start_lsn, parse->start_lsn))
599  "could not parse start LSN");
600  if (!parse_xlogrecptr(&end_lsn, parse->end_lsn))
602  "could not parse end LSN");
603 
604  /* Invoke the callback with the details we've gathered. */
605  context->per_wal_range_cb(context, tli, start_lsn, end_lsn);
606 
607  /* Free memory we no longer need. */
608  if (parse->timeline != NULL)
609  {
610  pfree(parse->timeline);
611  parse->timeline = NULL;
612  }
613  if (parse->start_lsn != NULL)
614  {
615  pfree(parse->start_lsn);
616  parse->start_lsn = NULL;
617  }
618  if (parse->end_lsn != NULL)
619  {
620  pfree(parse->end_lsn);
621  parse->end_lsn = NULL;
622  }
623 }
624 
625 /*
626  * Verify that the manifest checksum is correct.
627  *
628  * The last line of the manifest file is excluded from the manifest checksum,
629  * because the last line is expected to contain the checksum that covers
630  * the rest of the file.
631  */
632 static void
634  size_t size)
635 {
636  JsonManifestParseContext *context = parse->context;
637  size_t i;
638  size_t number_of_newlines = 0;
639  size_t ultimate_newline = 0;
640  size_t penultimate_newline = 0;
641  pg_cryptohash_ctx *manifest_ctx;
642  uint8 manifest_checksum_actual[PG_SHA256_DIGEST_LENGTH];
643  uint8 manifest_checksum_expected[PG_SHA256_DIGEST_LENGTH];
644 
645  /* Find the last two newlines in the file. */
646  for (i = 0; i < size; ++i)
647  {
648  if (buffer[i] == '\n')
649  {
650  ++number_of_newlines;
651  penultimate_newline = ultimate_newline;
652  ultimate_newline = i;
653  }
654  }
655 
656  /*
657  * Make sure that the last newline is right at the end, and that there are
658  * at least two lines total. We need this to be true in order for the
659  * following code, which computes the manifest checksum, to work properly.
660  */
661  if (number_of_newlines < 2)
663  "expected at least 2 lines");
664  if (ultimate_newline != size - 1)
666  "last line not newline-terminated");
667 
668  /* Checksum the rest. */
669  manifest_ctx = pg_cryptohash_create(PG_SHA256);
670  if (manifest_ctx == NULL)
671  context->error_cb(context, "out of memory");
672  if (pg_cryptohash_init(manifest_ctx) < 0)
673  context->error_cb(context, "could not initialize checksum of manifest");
674  if (pg_cryptohash_update(manifest_ctx, (uint8 *) buffer, penultimate_newline + 1) < 0)
675  context->error_cb(context, "could not update checksum of manifest");
676  if (pg_cryptohash_final(manifest_ctx, manifest_checksum_actual,
677  sizeof(manifest_checksum_actual)) < 0)
678  context->error_cb(context, "could not finalize checksum of manifest");
679 
680  /* Now verify it. */
681  if (parse->manifest_checksum == NULL)
682  context->error_cb(parse->context, "manifest has no checksum");
683  if (strlen(parse->manifest_checksum) != PG_SHA256_DIGEST_LENGTH * 2 ||
684  !hexdecode_string(manifest_checksum_expected, parse->manifest_checksum,
686  context->error_cb(context, "invalid manifest checksum: \"%s\"",
687  parse->manifest_checksum);
688  if (memcmp(manifest_checksum_actual, manifest_checksum_expected,
690  context->error_cb(context, "manifest checksum mismatch");
691  pg_cryptohash_free(manifest_ctx);
692 }
693 
694 /*
695  * Report a parse error.
696  *
697  * This is intended to be used for fairly low-level failures that probably
698  * shouldn't occur unless somebody has deliberately constructed a bad manifest,
699  * or unless the server is generating bad manifests due to some bug. msg should
700  * be a short string giving some hint as to what the problem is.
701  */
702 static void
704 {
705  context->error_cb(context, "could not parse backup manifest: %s", msg);
706 }
707 
708 /*
709  * Convert a character which represents a hexadecimal digit to an integer.
710  *
711  * Returns -1 if the character is not a hexadecimal digit.
712  */
713 static int
715 {
716  if (c >= '0' && c <= '9')
717  return c - '0';
718  if (c >= 'a' && c <= 'f')
719  return c - 'a' + 10;
720  if (c >= 'A' && c <= 'F')
721  return c - 'A' + 10;
722 
723  return -1;
724 }
725 
726 /*
727  * Decode a hex string into a byte string, 2 hex chars per byte.
728  *
729  * Returns false if invalid characters are encountered; otherwise true.
730  */
731 static bool
732 hexdecode_string(uint8 *result, char *input, int nbytes)
733 {
734  int i;
735 
736  for (i = 0; i < nbytes; ++i)
737  {
738  int n1 = hexdecode_char(input[i * 2]);
739  int n2 = hexdecode_char(input[i * 2 + 1]);
740 
741  if (n1 < 0 || n2 < 0)
742  return false;
743  result[i] = n1 * 16 + n2;
744  }
745 
746  return true;
747 }
748 
749 /*
750  * Parse an XLogRecPtr expressed using the usual string format.
751  */
752 static bool
754 {
755  uint32 hi;
756  uint32 lo;
757 
758  if (sscanf(input, "%X/%X", &hi, &lo) != 2)
759  return false;
760  *result = ((uint64) hi) << 32 | lo;
761  return true;
762 }
unsigned int uint32
Definition: c.h:495
unsigned char uint8
Definition: c.h:493
bool pg_checksum_parse_type(char *name, pg_checksum_type *type)
pg_checksum_type
@ CHECKSUM_TYPE_NONE
int pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len)
Definition: cryptohash.c:136
int pg_cryptohash_init(pg_cryptohash_ctx *ctx)
Definition: cryptohash.c:100
void pg_cryptohash_free(pg_cryptohash_ctx *ctx)
Definition: cryptohash.c:238
pg_cryptohash_ctx * pg_cryptohash_create(pg_cryptohash_type type)
Definition: cryptohash.c:74
int pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest, size_t len)
Definition: cryptohash.c:172
@ PG_SHA256
Definition: cryptohash.h:24
#define token
Definition: indent_globs.h:126
FILE * input
int i
Definition: isn.c:73
JsonParseErrorType pg_parse_json(JsonLexContext *lex, JsonSemAction *sem)
Definition: jsonapi.c:205
JsonLexContext * makeJsonLexContextCstringLen(JsonLexContext *lex, char *json, int len, int encoding, bool need_escapes)
Definition: jsonapi.c:153
void freeJsonLexContext(JsonLexContext *lex)
Definition: jsonapi.c:183
JsonParseErrorType
Definition: jsonapi.h:37
@ JSON_SUCCESS
Definition: jsonapi.h:38
JsonTokenType
Definition: jsonapi.h:20
void pfree(void *pointer)
Definition: mcxt.c:1431
void * palloc(Size size)
Definition: mcxt.c:1201
JsonManifestSemanticState
@ JM_EXPECT_TOPLEVEL_END
@ JM_EXPECT_FILES_START
@ JM_EXPECT_TOPLEVEL_START
@ JM_EXPECT_EOF
@ JM_EXPECT_WAL_RANGES_START
@ JM_EXPECT_FILES_NEXT
@ JM_EXPECT_THIS_FILE_FIELD
@ JM_EXPECT_THIS_FILE_VALUE
@ JM_EXPECT_THIS_WAL_RANGE_VALUE
@ JM_EXPECT_VERSION_VALUE
@ JM_EXPECT_MANIFEST_CHECKSUM_VALUE
@ JM_EXPECT_THIS_WAL_RANGE_FIELD
@ JM_EXPECT_TOPLEVEL_FIELD
@ JM_EXPECT_WAL_RANGES_NEXT
static JsonParseErrorType json_manifest_array_start(void *state)
JsonManifestWALRangeField
@ JMWRF_START_LSN
@ JMWRF_TIMELINE
@ JMWRF_END_LSN
static bool parse_xlogrecptr(XLogRecPtr *result, char *input)
static void json_manifest_finalize_wal_range(JsonManifestParseState *parse)
static JsonParseErrorType json_manifest_object_field_start(void *state, char *fname, bool isnull)
static void json_manifest_finalize_file(JsonManifestParseState *parse)
static JsonParseErrorType json_manifest_object_end(void *state)
static JsonParseErrorType json_manifest_object_start(void *state)
static JsonParseErrorType json_manifest_scalar(void *state, char *token, JsonTokenType tokentype)
static void json_manifest_parse_failure(JsonManifestParseContext *context, char *msg)
static JsonParseErrorType json_manifest_array_end(void *state)
JsonManifestFileField
@ JMFF_ENCODED_PATH
@ JMFF_PATH
@ JMFF_LAST_MODIFIED
@ JMFF_CHECKSUM_ALGORITHM
@ JMFF_CHECKSUM
@ JMFF_SIZE
void json_parse_manifest(JsonManifestParseContext *context, char *buffer, size_t size)
static int hexdecode_char(char c)
static bool hexdecode_string(uint8 *result, char *input, int nbytes)
static void verify_manifest_checksum(JsonManifestParseState *parse, char *buffer, size_t size)
@ PG_UTF8
Definition: pg_wchar.h:233
char * c
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:715
#define PG_SHA256_DIGEST_LENGTH
Definition: sha2.h:23
json_manifest_per_wal_range_callback per_wal_range_cb
json_manifest_error_callback error_cb
json_manifest_per_file_callback per_file_cb
JsonManifestWALRangeField wal_range_field
JsonManifestParseContext * context
JsonManifestFileField file_field
pg_checksum_type checksum_algorithm
JsonManifestSemanticState state
json_struct_action array_end
Definition: jsonapi.h:123
json_struct_action object_start
Definition: jsonapi.h:120
json_ofield_action object_field_start
Definition: jsonapi.h:124
json_aelem_action array_element_start
Definition: jsonapi.h:126
json_scalar_action scalar
Definition: jsonapi.h:128
void * semstate
Definition: jsonapi.h:119
json_aelem_action array_element_end
Definition: jsonapi.h:127
json_struct_action array_start
Definition: jsonapi.h:122
json_struct_action object_end
Definition: jsonapi.h:121
json_ofield_action object_field_end
Definition: jsonapi.h:125
Definition: regguts.h:323
uint64 XLogRecPtr
Definition: xlogdefs.h:21
uint32 TimeLineID
Definition: xlogdefs.h:59