/*-------------------------------------------------------------------------
 *
 * Read and manipulate backup label files
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/bin/pg_combinebackup/backup_label.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres_fe.h"

#include <unistd.h>

#include "access/xlogdefs.h"
#include "backup_label.h"
#include "common/file_perm.h"
#include "common/logging.h"
#include "write_manifest.h"

static int get_eol_offset(StringInfo buf);
static bool line_starts_with(char *s, char *e, char *match, char **sout);
static bool parse_lsn(char *s, char *e, XLogRecPtr *lsn, char **c);
static bool parse_tli(char *s, char *e, TimeLineID *tli);

/*
 * Parse a backup label file, starting at buf->cursor.
 *
 * We expect to find a START WAL LOCATION line, followed by a LSN, followed
 * by a space; the resulting LSN is stored into *start_lsn.
 *
 * We expect to find a START TIMELINE line, followed by a TLI, followed by
 * a newline; the resulting TLI is stored into *start_tli.
 *
 * We expect to find either both INCREMENTAL FROM LSN and INCREMENTAL FROM TLI
 * or neither. If these are found, they should be followed by an LSN or TLI
 * respectively and then by a newline, and the values will be stored into
 * *previous_lsn and *previous_tli, respectively.
 *
 * Other lines in the provided backup_label data are ignored. filename is used
 * for error reporting; errors are fatal.
 */
void
parse_backup_label(char *filename, StringInfo buf,
       TimeLineID *start_tli, XLogRecPtr *start_lsn,
       TimeLineID *previous_tli, XLogRecPtr *previous_lsn)
{
 int   found = 0;

 *start_tli = 0;
 *start_lsn = InvalidXLogRecPtr;
 *previous_tli = 0;
 *previous_lsn = InvalidXLogRecPtr;

 while (buf->cursor < buf->len)
 {
  char    *s = &buf->data[buf->cursor];
  int   eo = get_eol_offset(buf);
  char    *e = &buf->data[eo];
  char    *c;

  if (line_starts_with(s, e, "START WAL LOCATION: ", &s))
  {
   if (!parse_lsn(s, e, start_lsn, &c))
    pg_fatal("%s: could not parse %s",
       filename, "START WAL LOCATION");
   if (c >= e || *c != ' ')
    pg_fatal("%s: improper terminator for %s",
       filename, "START WAL LOCATION");
   found |= 1;
  }
  else if (line_starts_with(s, e, "START TIMELINE: ", &s))
  {
   if (!parse_tli(s, e, start_tli))
    pg_fatal("%s: could not parse TLI for %s",
       filename, "START TIMELINE");
   if (*start_tli == 0)
    pg_fatal("%s: invalid TLI", filename);
   found |= 2;
  }
  else if (line_starts_with(s, e, "INCREMENTAL FROM LSN: ", &s))
  {
   if (!parse_lsn(s, e, previous_lsn, &c))
    pg_fatal("%s: could not parse %s",
       filename, "INCREMENTAL FROM LSN");
   if (c >= e || *c != '\n')
    pg_fatal("%s: improper terminator for %s",
       filename, "INCREMENTAL FROM LSN");
   found |= 4;
  }
  else if (line_starts_with(s, e, "INCREMENTAL FROM TLI: ", &s))
  {
   if (!parse_tli(s, e, previous_tli))
    pg_fatal("%s: could not parse %s",
       filename, "INCREMENTAL FROM TLI");
   if (*previous_tli == 0)
    pg_fatal("%s: invalid TLI", filename);
   found |= 8;
  }

  buf->cursor = eo;
 }

 if ((found & 1) == 0)
  pg_fatal("%s: could not find %s", filename, "START WAL LOCATION");
 if ((found & 2) == 0)
  pg_fatal("%s: could not find %s", filename, "START TIMELINE");
 if ((found & 4) != 0 && (found & 8) == 0)
  pg_fatal("%s: %s requires %s", filename,
     "INCREMENTAL FROM LSN", "INCREMENTAL FROM TLI");
 if ((found & 8) != 0 && (found & 4) == 0)
  pg_fatal("%s: %s requires %s", filename,
     "INCREMENTAL FROM TLI", "INCREMENTAL FROM LSN");
}

/*
 * Write a backup label file to the output directory.
 *
 * This will be identical to the provided backup_label file, except that the
 * INCREMENTAL FROM LSN and INCREMENTAL FROM TLI lines will be omitted.
 *
 * The new file will be checksummed using the specified algorithm. If
 * mwriter != NULL, it will be added to the manifest.
 */
void
write_backup_label(char *output_directory, StringInfo buf,
       pg_checksum_type checksum_type, manifest_writer *mwriter)
{
 char  output_filename[MAXPGPATH];
 int   output_fd;
 pg_checksum_context checksum_ctx;
 uint8  checksum_payload[PG_CHECKSUM_MAX_LENGTH];
 int   checksum_length;

 pg_checksum_init(&checksum_ctx, checksum_type);

 snprintf(output_filename, MAXPGPATH, "%s/backup_label", output_directory);

 if ((output_fd = open(output_filename,
        O_WRONLY | O_CREAT | O_EXCL | PG_BINARY,
        pg_file_create_mode)) < 0)
  pg_fatal("could not open file \"%s\": %m", output_filename);

 while (buf->cursor < buf->len)
 {
  char    *s = &buf->data[buf->cursor];
  int   eo = get_eol_offset(buf);
  char    *e = &buf->data[eo];

  if (!line_starts_with(s, e, "INCREMENTAL FROM LSN: ", NULL) &&
   !line_starts_with(s, e, "INCREMENTAL FROM TLI: ", NULL))
  {
   ssize_t  wb;

   wb = write(output_fd, s, e - s);
   if (wb != e - s)
   {
    if (wb < 0)
     pg_fatal("could not write file \"%s\": %m", output_filename);
    else
     pg_fatal("could not write file \"%s\": wrote %d of %d",
        output_filename, (int) wb, (int) (e - s));
   }
   if (pg_checksum_update(&checksum_ctx, (uint8 *) s, e - s) < 0)
    pg_fatal("could not update checksum of file \"%s\"",
       output_filename);
  }

  buf->cursor = eo;
 }

 if (close(output_fd) != 0)
  pg_fatal("could not close file \"%s\": %m", output_filename);

 checksum_length = pg_checksum_final(&checksum_ctx, checksum_payload);

 if (mwriter != NULL)
 {
  struct stat sb;

  /*
   * We could track the length ourselves, but must stat() to get the
   * mtime.
 */
  if (stat(output_filename, &sb) < 0)
   pg_fatal("could not stat file \"%s\": %m", output_filename);
  add_file_to_manifest(mwriter, "backup_label", sb.st_size,
        sb.st_mtime, checksum_type,
        checksum_length, checksum_payload);
 }
}

/*
 * Return the offset at which the next line in the buffer starts, or there
 * is none, the offset at which the buffer ends.
 *
 * The search begins at buf->cursor.
 */
static int
get_eol_offset(StringInfo buf)
{
 int   eo = buf->cursor;

 while (eo < buf->len)
 {
  if (buf->data[eo] == '\n')
   return eo + 1;
  ++eo;
 }

 return eo;
}

/*
 * Test whether the line that runs from s to e (inclusive of *s, but not
 * inclusive of *e) starts with the match string provided, and return true
 * or false according to whether or not this is the case.
 *
 * If the function returns true and if *sout != NULL, stores a pointer to the
 * byte following the match into *sout.
 */
static bool
line_starts_with(char *s, char *e, char *match, char **sout)
{
 while (s < e && *match != '\0' && *s == *match)
  ++s, ++match;

 if (*match == '\0' && sout != NULL)
  *sout = s;

 return (*match == '\0');
}

/*
 * Parse an LSN starting at s and not stopping at or before e. The return value
 * is true on success and otherwise false. On success, stores the result into
 * *lsn and sets *c to the first character that is not part of the LSN.
 */
static bool
parse_lsn(char *s, char *e, XLogRecPtr *lsn, char **c)
{
 char  save = *e;
 int   nchars;
 bool  success;
 unsigned hi;
 unsigned lo;

 *e = '\0';
 success = (sscanf(s, "%X/%X%n", &hi, &lo, &nchars) == 2);
 *e = save;

 if (success)
 {
  *lsn = ((XLogRecPtr) hi) << 32 | (XLogRecPtr) lo;
  *c = s + nchars;
 }

 return success;
}

/*
 * Parse a TLI starting at s and stopping at or before e. The return value is
 * true on success and otherwise false. On success, stores the result into
 * *tli. If the first character that is not part of the TLI is anything other
 * than a newline, that is deemed a failure.
 */
static bool
parse_tli(char *s, char *e, TimeLineID *tli)
{
 char  save = *e;
 int   nchars;
 bool  success;

 *e = '\0';
 success = (sscanf(s, "%u%n", tli, &nchars) == 1);
 *e = save;

 if (success && s[nchars] != '\n')
  success = false;

 return success;
}