tzparser.c File Reference

#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"

Include dependency graph for tzparser.c:

Go to the source code of this file.

Macros
#define	WHITESPACE   " \t\n\r"

Functions
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)
TimeZoneAbbrevTable *	load_tzoffsets (const char *filename)

Macro Definition Documentation

WHITESPACE

#define WHITESPACE   " \t\n\r"

Definition at line 35 of file tzparser.c.

Function Documentation

addToArray()

static int addToArray ( tzEntry **  base, int *  arraysize, int  n, tzEntry *  entry, bool  override  )

static

Definition at line 189 of file tzparser.c.

{
    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;
}

References tzEntry::abbrev, cmp(), tzEntry::filename, GUC_check_errdetail, GUC_check_errmsg, tzEntry::is_dst, tzEntry::lineno, tzEntry::offset, repalloc(), and tzEntry::zone.

Referenced by ParseTzFile().

load_tzoffsets()

TimeZoneAbbrevTable* load_tzoffsets

(

const char *

filename

)

Definition at line 449 of file tzparser.c.

{
    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;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, ConvertTimeZoneAbbrevs(), CurrentMemoryContext, filename, GUC_check_errmsg, MemoryContextDelete(), MemoryContextSwitchTo(), palloc(), and ParseTzFile().

Referenced by check_timezone_abbreviations().

ParseTzFile()

static int ParseTzFile ( const char *  filename, int  depth, tzEntry **  base, int *  arraysize, int  n  )

static

Definition at line 277 of file tzparser.c.

{
    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;
}

References addToArray(), AllocateDir(), AllocateFile(), filename, FreeDir(), FreeFile(), get_share_path(), GUC_check_errhint, GUC_check_errmsg, MAXPGPATH, my_exec_path, pg_strncasecmp(), pstrdup(), share_path, snprintf, splitTzLine(), strtok_r, validateTzEntry(), and WHITESPACE.

Referenced by load_tzoffsets().

splitTzLine()

static bool splitTzLine ( const char *  filename, int  lineno, char *  line, tzEntry *  tzentry  )

static

Definition at line 98 of file tzparser.c.

{
    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;
}

References tzEntry::abbrev, filename, tzEntry::filename, GUC_check_errmsg, tzEntry::is_dst, tzEntry::lineno, tzEntry::offset, pg_strcasecmp(), pstrdup(), SECS_PER_HOUR, strtok_r, WHITESPACE, and tzEntry::zone.

Referenced by ParseTzFile().

validateTzEntry()

static bool validateTzEntry ( tzEntry *  tzentry )

static

Definition at line 52 of file tzparser.c.

{
    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;
}

References tzEntry::abbrev, tzEntry::filename, GUC_check_errmsg, tzEntry::lineno, tzEntry::offset, pg_tolower(), SECS_PER_HOUR, and TOKMAXLEN.

Referenced by ParseTzFile().