pgtz.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <fcntl.h>
#include <time.h>
#include "common/file_utils.h"
#include "datatype/timestamp.h"
#include "miscadmin.h"
#include "pgtz.h"
#include "storage/fd.h"
#include "utils/hsearch.h"

Include dependency graph for pgtz.c:

Go to the source code of this file.

Data Structures
struct	pg_tz_cache
struct	pg_tzenum

Macros
#define	MAX_TZDIR_DEPTH   10

Functions
static bool	scan_directory_ci (const char *dirname, const char *fname, int fnamelen, char *canonname, int canonnamelen)
static const char *	pg_TZDIR (void)
int	pg_open_tzfile (const char *name, char *canonname)
static bool	init_timezone_hashtable (void)
pg_tz *	pg_tzset (const char *tzname)
pg_tz *	pg_tzset_offset (long gmtoffset)
void	pg_timezone_initialize (void)
pg_tzenum *	pg_tzenumerate_start (void)
void	pg_tzenumerate_end (pg_tzenum *dir)
pg_tz *	pg_tzenumerate_next (pg_tzenum *dir)

Variables
pg_tz *	session_timezone = NULL
pg_tz *	log_timezone = NULL
static HTAB *	timezone_cache = NULL

Macro Definition Documentation

MAX_TZDIR_DEPTH

#define MAX_TZDIR_DEPTH   10

Definition at line 363 of file pgtz.c.

Function Documentation

init_timezone_hashtable()

static bool init_timezone_hashtable ( void  )

static

Definition at line 202 of file pgtz.c.

{
    HASHCTL     hash_ctl;
 
    hash_ctl.keysize = TZ_STRLEN_MAX + 1;
    hash_ctl.entrysize = sizeof(pg_tz_cache);
 
    timezone_cache = hash_create("Timezones",
                                 4,
                                 &hash_ctl,
                                 HASH_ELEM | HASH_STRINGS);
    if (!timezone_cache)
        return false;
 
    return true;
}

References fb(), hash_create(), HASH_ELEM, HASH_STRINGS, HASHCTL::keysize, timezone_cache, and TZ_STRLEN_MAX.

Referenced by pg_tzset().

pg_open_tzfile()

int pg_open_tzfile	(	const char *	name,
		char *	canonname
	)

Definition at line 76 of file pgtz.c.

{
    const char *fname;
    char        fullname[MAXPGPATH];
    int         fullnamelen;
    int         orignamelen;
 
    /* Initialize fullname with base name of tzdata directory */
    strlcpy(fullname, pg_TZDIR(), sizeof(fullname));
    orignamelen = fullnamelen = strlen(fullname);
 
    if (fullnamelen + 1 + strlen(name) >= MAXPGPATH)
        return -1;              /* not gonna fit */
 
    /*
     * If the caller doesn't need the canonical spelling, first just try to
     * open the name as-is.  This can be expected to succeed if the given name
     * is already case-correct, or if the filesystem is case-insensitive; and
     * we don't need to distinguish those situations if we aren't tasked with
     * reporting the canonical spelling.
     */
    if (canonname == NULL)
    {
        int         result;
 
        fullname[fullnamelen] = '/';
        /* test above ensured this will fit: */
        strcpy(fullname + fullnamelen + 1, name);
        result = open(fullname, O_RDONLY | PG_BINARY, 0);
        if (result >= 0)
            return result;
        /* If that didn't work, fall through to do it the hard way */
        fullname[fullnamelen] = '\0';
    }
 
    /*
     * Loop to split the given name into directory levels; for each level,
     * search using scan_directory_ci().
     */
    fname = name;
    for (;;)
    {
        const char *slashptr;
        int         fnamelen;
 
        slashptr = strchr(fname, '/');
        if (slashptr)
            fnamelen = slashptr - fname;
        else
            fnamelen = strlen(fname);
        if (!scan_directory_ci(fullname, fname, fnamelen,
                               fullname + fullnamelen + 1,
                               MAXPGPATH - fullnamelen - 1))
            return -1;
        fullname[fullnamelen++] = '/';
        fullnamelen += strlen(fullname + fullnamelen);
        if (slashptr)
            fname = slashptr + 1;
        else
            break;
    }
 
    if (canonname)
        strlcpy(canonname, fullname + orignamelen + 1, TZ_STRLEN_MAX + 1);
 
    return open(fullname, O_RDONLY | PG_BINARY, 0);
}

References fb(), MAXPGPATH, name, PG_BINARY, pg_TZDIR(), result, scan_directory_ci(), strlcpy(), and TZ_STRLEN_MAX.

pg_timezone_initialize()

void pg_timezone_initialize

(

void

)

Definition at line 341 of file pgtz.c.

{
    /*
     * We may not yet know where PGSHAREDIR is (in particular this is true in
     * an EXEC_BACKEND subprocess).  So use "GMT", which pg_tzset forces to be
     * interpreted without reference to the filesystem.  This corresponds to
     * the bootstrap default for these variables in guc_parameters.dat,
     * although in principle it could be different.
     */
    session_timezone = pg_tzset("GMT");
    log_timezone = session_timezone;
}

References log_timezone, pg_tzset(), and session_timezone.

Referenced by InitializeGUCOptions().

pg_TZDIR()

static const char * pg_TZDIR ( void  )

static

Definition at line 43 of file pgtz.c.

{
#ifndef SYSTEMTZDIR
    /* normal case: timezone stuff is under our share dir */
    static bool done_tzdir = false;
    static char tzdir[MAXPGPATH];
 
    if (done_tzdir)
        return tzdir;
 
    get_share_path(my_exec_path, tzdir);
    strlcpy(tzdir + strlen(tzdir), "/timezone", MAXPGPATH - strlen(tzdir));
 
    done_tzdir = true;
    return tzdir;
#else
    /* we're configured to use system's timezone database */
    return SYSTEMTZDIR;
#endif
}

References fb(), get_share_path(), MAXPGPATH, my_exec_path, and strlcpy().

Referenced by pg_open_tzfile(), and pg_tzenumerate_start().

pg_tzenumerate_end()

void pg_tzenumerate_end

(

pg_tzenum *

dir

)

Definition at line 394 of file pgtz.c.

{
    while (dir->depth >= 0)
    {
        FreeDir(dir->dirdesc[dir->depth]);
        pfree(dir->dirname[dir->depth]);
        dir->depth--;
    }
    pfree(dir);
}

References pg_tzenum::depth, pg_tzenum::dirdesc, pg_tzenum::dirname, FreeDir(), and pfree().

Referenced by pg_timezone_names().

pg_tzenumerate_next()

pg_tz * pg_tzenumerate_next

(

pg_tzenum *

dir

)

Definition at line 406 of file pgtz.c.

{
    while (dir->depth >= 0)
    {
        struct dirent *direntry;
        char        fullname[MAXPGPATH * 2];
 
        direntry = ReadDir(dir->dirdesc[dir->depth], dir->dirname[dir->depth]);
 
        if (!direntry)
        {
            /* End of this directory */
            FreeDir(dir->dirdesc[dir->depth]);
            pfree(dir->dirname[dir->depth]);
            dir->depth--;
            continue;
        }
 
        if (direntry->d_name[0] == '.')
            continue;
 
        snprintf(fullname, sizeof(fullname), "%s/%s",
                 dir->dirname[dir->depth], direntry->d_name);
 
        if (get_dirent_type(fullname, direntry, true, ERROR) == PGFILETYPE_DIR)
        {
            /* Step into the subdirectory */
            if (dir->depth >= MAX_TZDIR_DEPTH - 1)
                ereport(ERROR,
                        (errmsg_internal("timezone directory stack overflow")));
            dir->depth++;
            dir->dirname[dir->depth] = pstrdup(fullname);
            dir->dirdesc[dir->depth] = AllocateDir(fullname);
            if (!dir->dirdesc[dir->depth])
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not open directory \"%s\": %m",
                                fullname)));
 
            /* Start over reading in the new directory */
            continue;
        }
 
        /*
         * Load this timezone using pg_tzload() not pg_tzset(), so we don't
         * fill the cache.  Also, don't ask for the canonical spelling: we
         * already know it, and pg_open_tzfile's way of finding it out is
         * pretty inefficient.
         */
        if (!pg_tzload(fullname + dir->baselen, NULL, &dir->tz.state))
        {
            /* Zone could not be loaded, ignore it */
            continue;
        }
 
        if (!pg_tz_acceptable(&dir->tz))
        {
            /* Ignore leap-second zones */
            continue;
        }
 
        /* OK, return the canonical zone name spelling. */
        strlcpy(dir->tz.TZname, fullname + dir->baselen,
                sizeof(dir->tz.TZname));
 
        /* Timezone loaded OK. */
        return &dir->tz;
    }
 
    /* Nothing more found */
    return NULL;
}

References AllocateDir(), pg_tzenum::baselen, pg_tzenum::depth, pg_tzenum::dirdesc, pg_tzenum::dirname, ereport, errcode_for_file_access(), errmsg, errmsg_internal(), ERROR, fb(), FreeDir(), get_dirent_type(), MAX_TZDIR_DEPTH, MAXPGPATH, pfree(), pg_tz_acceptable(), pg_tzload(), PGFILETYPE_DIR, pstrdup(), ReadDir(), snprintf, pg_tz::state, strlcpy(), pg_tzenum::tz, and pg_tz::TZname.

Referenced by pg_timezone_names().

pg_tzenumerate_start()

pg_tzenum * pg_tzenumerate_start

(

void

)

Definition at line 377 of file pgtz.c.

{
    pg_tzenum  *ret = palloc0_object(pg_tzenum);
    char       *startdir = pstrdup(pg_TZDIR());
 
    ret->baselen = strlen(startdir) + 1;
    ret->depth = 0;
    ret->dirname[0] = startdir;
    ret->dirdesc[0] = AllocateDir(startdir);
    if (!ret->dirdesc[0])
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open directory \"%s\": %m", startdir)));
    return ret;
}

References AllocateDir(), pg_tzenum::baselen, pg_tzenum::depth, pg_tzenum::dirdesc, pg_tzenum::dirname, ereport, errcode_for_file_access(), errmsg, ERROR, fb(), palloc0_object, pg_TZDIR(), and pstrdup().

Referenced by pg_timezone_names().

pg_tzset()

pg_tz * pg_tzset

(

const char *

tzname

)

Definition at line 224 of file pgtz.c.

{
    pg_tz_cache *tzp;
    struct state tzstate;
    char        uppername[TZ_STRLEN_MAX + 1];
    char        canonname[TZ_STRLEN_MAX + 1];
    char       *p;
 
    if (strlen(tzname) > TZ_STRLEN_MAX)
        return NULL;            /* not going to fit */
 
    if (!timezone_cache)
        if (!init_timezone_hashtable())
            return NULL;
 
    /*
     * Upcase the given name to perform a case-insensitive hashtable search.
     * (We could alternatively downcase it, but we prefer upcase so that we
     * can get consistently upcased results from pg_tzload() in case the name
     * is a POSIX-style timezone spec.)
     */
    p = uppername;
    while (*tzname)
        *p++ = pg_toupper((unsigned char) *tzname++);
    *p = '\0';
 
    tzp = (pg_tz_cache *) hash_search(timezone_cache,
                                      uppername,
                                      HASH_FIND,
                                      NULL);
    if (tzp)
    {
        /* Timezone found in cache, nothing more to do */
        return &tzp->tz;
    }
 
    /*
     * Let the IANA tzdb code interpret the time zone name.
     */
    if (!pg_tzload(uppername, canonname, &tzstate))
    {
        if (strcmp(uppername, "GMT") == 0)
        {
            /* This really, really should not happen ... */
            elog(ERROR, "could not initialize GMT time zone");
        }
        /* Unknown timezone. Fail our call instead of loading GMT! */
        return NULL;
    }
 
    /* Save timezone in the cache */
    tzp = (pg_tz_cache *) hash_search(timezone_cache,
                                      uppername,
                                      HASH_ENTER,
                                      NULL);
 
    /* hash_search already copied uppername into the hash key */
    strcpy(tzp->tz.TZname, canonname);
    memcpy(&tzp->tz.state, &tzstate, sizeof(tzstate));
 
    return &tzp->tz;
}

References elog, ERROR, fb(), HASH_ENTER, HASH_FIND, hash_search(), init_timezone_hashtable(), memcpy(), pg_toupper(), pg_tzload(), pg_tz::state, timezone_cache, pg_tz_cache::tz, TZ_STRLEN_MAX, and pg_tz::TZname.

Referenced by check_log_timezone(), check_timezone(), DecodeDateTime(), DecodeTimeOnly(), DecodeTimezoneName(), FetchDynamicTimeZone(), pg_timezone_initialize(), and pg_tzset_offset().

pg_tzset_offset()

pg_tz * pg_tzset_offset

(

long

gmtoffset

)

Definition at line 300 of file pgtz.c.

{
    long        absoffset = (gmtoffset < 0) ? -gmtoffset : gmtoffset;
    char        offsetstr[64];
    char        tzname[128];
 
    snprintf(offsetstr, sizeof(offsetstr),
             "%02ld", absoffset / SECS_PER_HOUR);
    absoffset %= SECS_PER_HOUR;
    if (absoffset != 0)
    {
        snprintf(offsetstr + strlen(offsetstr),
                 sizeof(offsetstr) - strlen(offsetstr),
                 ":%02ld", absoffset / SECS_PER_MINUTE);
        absoffset %= SECS_PER_MINUTE;
        if (absoffset != 0)
            snprintf(offsetstr + strlen(offsetstr),
                     sizeof(offsetstr) - strlen(offsetstr),
                     ":%02ld", absoffset);
    }
    if (gmtoffset > 0)
        snprintf(tzname, sizeof(tzname), "<-%s>+%s",
                 offsetstr, offsetstr);
    else
        snprintf(tzname, sizeof(tzname), "<+%s>-%s",
                 offsetstr, offsetstr);
 
    return pg_tzset(tzname);
}

References fb(), pg_tzset(), SECS_PER_HOUR, SECS_PER_MINUTE, and snprintf.

Referenced by check_timezone(), and DecodeTimezoneNameToTz().

scan_directory_ci()

static bool scan_directory_ci ( const char *  dirname, const char *  fname, int  fnamelen, char *  canonname, int  canonnamelen  )

static

Definition at line 151 of file pgtz.c.

{
    bool        found = false;
    DIR        *dirdesc;
    struct dirent *direntry;
 
    dirdesc = AllocateDir(dirname);
 
    while ((direntry = ReadDirExtended(dirdesc, dirname, LOG)) != NULL)
    {
        /*
         * Ignore . and .., plus any other "hidden" files.  This is a security
         * measure to prevent access to files outside the timezone directory.
         */
        if (direntry->d_name[0] == '.')
            continue;
 
        if (strlen(direntry->d_name) == fnamelen &&
            pg_strncasecmp(direntry->d_name, fname, fnamelen) == 0)
        {
            /* Found our match */
            strlcpy(canonname, direntry->d_name, canonnamelen);
            found = true;
            break;
        }
    }
 
    FreeDir(dirdesc);
 
    return found;
}

References AllocateDir(), fb(), FreeDir(), LOG, pg_strncasecmp(), ReadDirExtended(), and strlcpy().

Referenced by pg_open_tzfile().

Variable Documentation

log_timezone

pg_tz* log_timezone = NULL

Definition at line 31 of file pgtz.c.

Referenced by assign_log_timezone(), build_backup_content(), get_formatted_log_time(), get_formatted_start_time(), log_status_format(), logfile_getname(), pg_timezone_initialize(), set_next_rotation_time(), show_log_timezone(), and str_time().

session_timezone

pg_tz* session_timezone = NULL

Definition at line 28 of file pgtz.c.

Referenced by assign_timezone(), date2timestamptz_safe(), DecodeDateTime(), DecodeTimeOnly(), DecodeTimezoneAbbrev(), DecodeTimezoneAbbrevPrefix(), executeDateTimeMethod(), generate_series_timestamptz_internal(), GetCurrentTimeUsec(), pg_timezone_abbrevs_zone(), pg_timezone_initialize(), show_timezone(), time_timetz(), timeofday(), timestamp2timestamptz_safe(), timestamp2tm(), TimestampTimestampTzRequiresRewrite(), timestamptz_pl_interval_internal(), timestamptz_trunc(), timetz_at_local(), and to_timestamp().

timezone_cache

HTAB* timezone_cache = NULL

static

Definition at line 198 of file pgtz.c.

Referenced by init_timezone_hashtable(), and pg_tzset().