/*-------------------------------------------------------------------------
 *
 * tzparser.c
 *   Functions for parsing timezone offset files
 *
 * Note: this code is invoked from the check_hook for the GUC variable
 * timezone_abbreviations.  Therefore, it should report problems using
 * GUC_check_errmsg() and related functions, and try to avoid throwing
 * elog(ERROR).  This is not completely bulletproof at present --- in
 * particular out-of-memory will throw an error.  Could probably fix with
 * PG_TRY if necessary.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *   src/backend/utils/misc/tzparser.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include <ctype.h>

#include "miscadmin.h"
#include "storage/fd.h"
#include "utils/datetime.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/tzparser.h"


#define WHITESPACE " \t\n\r"

static bool validateTzEntry(tzEntry *tzentry);
static bool splitTzLine(const char *filename, int lineno,
      char *line, tzEntry *tzentry);
static int addToArray(tzEntry **base, int *arraysize, int n,
        tzEntry *entry, bool override);
static int ParseTzFile(const char *filename, int depth,
      tzEntry **base, int *arraysize, int n);


/*
 * Apply additional validation checks to a tzEntry
 *
 * Returns true if OK, else false
 */
static bool
validateTzEntry(tzEntry *tzentry)
{
 unsigned char *p;

 /*
  * Check restrictions imposed by datetktbl storage format (see datetime.c)
 */
 if (strlen(tzentry->abbrev) > TOKMAXLEN)
 {
  GUC_check_errmsg("time zone abbreviation \"%s\" is too long (maximum %d characters) in time zone file \"%s\", line %d",
       tzentry->abbrev, TOKMAXLEN,
       tzentry->filename, tzentry->lineno);
  return false;
 }

 /*
  * Sanity-check the offset: shouldn't exceed 14 hours
 */
 if (tzentry->offset > 14 * SECS_PER_HOUR ||
  tzentry->offset < -14 * SECS_PER_HOUR)
 {
  GUC_check_errmsg("time zone offset %d is out of range in time zone file \"%s\", line %d",
       tzentry->offset,
       tzentry->filename, tzentry->lineno);
  return false;
 }

 /*
  * Convert abbrev to lowercase (must match datetime.c's conversion)
 */
 for (p = (unsigned char *) tzentry->abbrev; *p; p++)
  *p = pg_tolower(*p);

 return true;
}

/*
 * Attempt to parse the line as a timezone abbrev spec
 *
 * Valid formats are:
 * name  zone
 * name  offset  dst
 *
 * Returns true if OK, else false; data is stored in *tzentry
 */
static bool
splitTzLine(const char *filename, int lineno, char *line, tzEntry *tzentry)
{
 char    *brkl;
 char    *abbrev;
 char    *offset;
 char    *offset_endptr;
 char    *remain;
 char    *is_dst;

 tzentry->lineno = lineno;
 tzentry->filename = filename;

 abbrev = strtok_r(line, WHITESPACE, &brkl);
 if (!abbrev)
 {
  GUC_check_errmsg("missing time zone abbreviation in time zone file \"%s\", line %d",
       filename, lineno);
  return false;
 }
 tzentry->abbrev = pstrdup(abbrev);

 offset = strtok_r(NULL, WHITESPACE, &brkl);
 if (!offset)
 {
  GUC_check_errmsg("missing time zone offset in time zone file \"%s\", line %d",
       filename, lineno);
  return false;
 }

 /* We assume zone names don't begin with a digit or sign */
 if (isdigit((unsigned char) *offset) || *offset == '+' || *offset == '-')
 {
  tzentry->zone = NULL;
  tzentry->offset = strtol(offset, &offset_endptr, 10);
  if (offset_endptr == offset || *offset_endptr != '\0')
  {
   GUC_check_errmsg("invalid number for time zone offset in time zone file \"%s\", line %d",
        filename, lineno);
   return false;
  }

  is_dst = strtok_r(NULL, WHITESPACE, &brkl);
  if (is_dst && pg_strcasecmp(is_dst, "D") == 0)
  {
   tzentry->is_dst = true;
   remain = strtok_r(NULL, WHITESPACE, &brkl);
  }
  else
  {
   /* there was no 'D' dst specifier */
   tzentry->is_dst = false;
   remain = is_dst;
  }
 }
 else
 {
  /*
   * Assume entry is a zone name.  We do not try to validate it by
   * looking up the zone, because that would force loading of a lot of
   * zones that probably will never be used in the current session.
 */
  tzentry->zone = pstrdup(offset);
  tzentry->offset = 0 * SECS_PER_HOUR;
  tzentry->is_dst = false;
  remain = strtok_r(NULL, WHITESPACE, &brkl);
 }

 if (!remain)    /* no more non-whitespace chars */
  return true;

 if (remain[0] != '#')  /* must be a comment */
 {
  GUC_check_errmsg("invalid syntax in time zone file \"%s\", line %d",
       filename, lineno);
  return false;
 }
 return true;
}

/*
 * Insert entry into sorted array
 *
 * *base: base address of array (changeable if must enlarge array)
 * *arraysize: allocated length of array (changeable if must enlarge array)
 * n: current number of valid elements in array
 * entry: new data to insert
 * override: true if OK to override
 *
 * Returns the new array length (new value for n), or -1 if error
 */
static int
addToArray(tzEntry **base, int *arraysize, int n,
     tzEntry *entry, bool override)
{
 tzEntry    *arrayptr;
 int   low;
 int   high;

 /*
  * Search the array for a duplicate; as a useful side effect, the array is
  * maintained in sorted order.  We use strcmp() to ensure we match the
  * sort order datetime.c expects.
 */
 arrayptr = *base;
 low = 0;
 high = n - 1;
 while (low <= high)
 {
  int   mid = (low + high) >> 1;
  tzEntry    *midptr = arrayptr + mid;
  int   cmp;

  cmp = strcmp(entry->abbrev, midptr->abbrev);
  if (cmp < 0)
   high = mid - 1;
  else if (cmp > 0)
   low = mid + 1;
  else
  {
   /*
    * Found a duplicate entry; complain unless it's the same.
 */
   if ((midptr->zone == NULL && entry->zone == NULL &&
     midptr->offset == entry->offset &&
     midptr->is_dst == entry->is_dst) ||
    (midptr->zone != NULL && entry->zone != NULL &&
     strcmp(midptr->zone, entry->zone) == 0))
   {
    /* return unchanged array */
    return n;
   }
   if (override)
   {
    /* same abbrev but something is different, override */
    midptr->zone = entry->zone;
    midptr->offset = entry->offset;
    midptr->is_dst = entry->is_dst;
    return n;
   }
   /* same abbrev but something is different, complain */
   GUC_check_errmsg("time zone abbreviation \"%s\" is multiply defined",
        entry->abbrev);
   GUC_check_errdetail("Entry in time zone file \"%s\", line %d, conflicts with entry in file \"%s\", line %d.",
        midptr->filename, midptr->lineno,
        entry->filename, entry->lineno);
   return -1;
  }
 }

 /*
  * No match, insert at position "low".
 */
 if (n >= *arraysize)
 {
  *arraysize *= 2;
  *base = (tzEntry *) repalloc(*base, *arraysize * sizeof(tzEntry));
 }

 arrayptr = *base + low;

 memmove(arrayptr + 1, arrayptr, (n - low) * sizeof(tzEntry));

 memcpy(arrayptr, entry, sizeof(tzEntry));

 return n + 1;
}

/*
 * Parse a single timezone abbrev file --- can recurse to handle @INCLUDE
 *
 * filename: user-specified file name (does not include path)
 * depth: current recursion depth
 * *base: array for results (changeable if must enlarge array)
 * *arraysize: allocated length of array (changeable if must enlarge array)
 * n: current number of valid elements in array
 *
 * Returns the new array length (new value for n), or -1 if error
 */
static int
ParseTzFile(const char *filename, int depth,
   tzEntry **base, int *arraysize, int n)
{
 char  share_path[MAXPGPATH];
 char  file_path[MAXPGPATH];
 FILE    *tzFile;
 char  tzbuf[1024];
 char    *line;
 tzEntry  tzentry;
 int   lineno = 0;
 bool  override = false;
 const char *p;

 /*
  * We enforce that the filename is all alpha characters.  This may be
  * overly restrictive, but we don't want to allow access to anything
  * outside the timezonesets directory, so for instance '/' *must* be
  * rejected.
 */
 for (p = filename; *p; p++)
 {
  if (!isalpha((unsigned char) *p))
  {
   /* at level 0, just use guc.c's regular "invalid value" message */
   if (depth > 0)
    GUC_check_errmsg("invalid time zone file name \"%s\"",
         filename);
   return -1;
  }
 }

 /*
  * The maximal recursion depth is a pretty arbitrary setting. It is hard
  * to imagine that someone needs more than 3 levels so stick with this
  * conservative setting until someone complains.
 */
 if (depth > 3)
 {
  GUC_check_errmsg("time zone file recursion limit exceeded in file \"%s\"",
       filename);
  return -1;
 }

 get_share_path(my_exec_path, share_path);
 snprintf(file_path, sizeof(file_path), "%s/timezonesets/%s",
    share_path, filename);
 tzFile = AllocateFile(file_path, "r");
 if (!tzFile)
 {
  /*
   * Check to see if the problem is not the filename but the directory.
   * This is worth troubling over because if the installation share/
   * directory is missing or unreadable, this is likely to be the first
   * place we notice a problem during postmaster startup.
 */
  int   save_errno = errno;
  DIR     *tzdir;

  snprintf(file_path, sizeof(file_path), "%s/timezonesets",
     share_path);
  tzdir = AllocateDir(file_path);
  if (tzdir == NULL)
  {
   GUC_check_errmsg("could not open directory \"%s\": %m",
        file_path);
   GUC_check_errhint("This may indicate an incomplete PostgreSQL installation, or that the file \"%s\" has been moved away from its proper location.",
         my_exec_path);
   return -1;
  }
  FreeDir(tzdir);
  errno = save_errno;

  /*
   * otherwise, if file doesn't exist and it's level 0, guc.c's
   * complaint is enough
 */
  if (errno != ENOENT || depth > 0)
   GUC_check_errmsg("could not read time zone file \"%s\": %m",
        filename);

  return -1;
 }

 while (!feof(tzFile))
 {
  lineno++;
  if (fgets(tzbuf, sizeof(tzbuf), tzFile) == NULL)
  {
   if (ferror(tzFile))
   {
    GUC_check_errmsg("could not read time zone file \"%s\": %m",
         filename);
    n = -1;
    break;
   }
   /* else we're at EOF after all */
   break;
  }
  if (strlen(tzbuf) == sizeof(tzbuf) - 1)
  {
   /* the line is too long for tzbuf */
   GUC_check_errmsg("line is too long in time zone file \"%s\", line %d",
        filename, lineno);
   n = -1;
   break;
  }

  /* skip over whitespace */
  line = tzbuf;
  while (*line && isspace((unsigned char) *line))
   line++;

  if (*line == '\0')  /* empty line */
   continue;
  if (*line == '#')  /* comment line */
   continue;

  if (pg_strncasecmp(line, "@INCLUDE", strlen("@INCLUDE")) == 0)
  {
   /* pstrdup so we can use filename in result data structure */
   char    *includeFile = pstrdup(line + strlen("@INCLUDE"));
   char    *brki;

   includeFile = strtok_r(includeFile, WHITESPACE, &brki);
   if (!includeFile || !*includeFile)
   {
    GUC_check_errmsg("@INCLUDE without file name in time zone file \"%s\", line %d",
         filename, lineno);
    n = -1;
    break;
   }
   n = ParseTzFile(includeFile, depth + 1,
       base, arraysize, n);
   if (n < 0)
    break;
   continue;
  }

  if (pg_strncasecmp(line, "@OVERRIDE", strlen("@OVERRIDE")) == 0)
  {
   override = true;
   continue;
  }

  if (!splitTzLine(filename, lineno, line, &tzentry))
  {
   n = -1;
   break;
  }
  if (!validateTzEntry(&tzentry))
  {
   n = -1;
   break;
  }
  n = addToArray(base, arraysize, n, &tzentry, override);
  if (n < 0)
   break;
 }

 FreeFile(tzFile);

 return n;
}

/*
 * load_tzoffsets --- read and parse the specified timezone offset file
 *
 * On success, return a filled-in TimeZoneAbbrevTable, which must have been
 * guc_malloc'd not palloc'd.  On failure, return NULL, using GUC_check_errmsg
 * and friends to give details of the problem.
 */
TimeZoneAbbrevTable *
load_tzoffsets(const char *filename)
{
 TimeZoneAbbrevTable *result = NULL;
 MemoryContext tmpContext;
 MemoryContext oldContext;
 tzEntry    *array;
 int   arraysize;
 int   n;

 /*
  * Create a temp memory context to work in.  This makes it easy to clean
  * up afterwards.
 */
 tmpContext = AllocSetContextCreate(CurrentMemoryContext,
            "TZParserMemory",
            ALLOCSET_SMALL_SIZES);
 oldContext = MemoryContextSwitchTo(tmpContext);

 /* Initialize array at a reasonable size */
 arraysize = 128;
 array = (tzEntry *) palloc(arraysize * sizeof(tzEntry));

 /* Parse the file(s) */
 n = ParseTzFile(filename, 0, &array, &arraysize, 0);

 /* If no errors so far, let datetime.c allocate memory & convert format */
 if (n >= 0)
 {
  result = ConvertTimeZoneAbbrevs(array, n);
  if (!result)
   GUC_check_errmsg("out of memory");
 }

 /* Clean up */
 MemoryContextSwitchTo(oldContext);
 MemoryContextDelete(tmpContext);

 return result;
}