TimeZoneUtil.cpp

/*
 * PROGRAM: Firebird interface.
 * MODULE: TimeZoneUtil.h
 * DESCRIPTION: Time zone utility functions.
 *
 * The contents of this file are subject to the Initial
 * Developer's Public License Version 1.0 (the "License");
 * you may not use this file except in compliance with the
 * License. You may obtain a copy of the License at
 * http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
 *
 * Software distributed under the License is distributed AS IS,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied.
 * See the License for the specific language governing rights
 * and limitations under the License.
 *
 * The Original Code was created by Adriano dos Santos Fernandes
 * for the Firebird Open Source RDBMS project.
 *
 * Copyright (c) 2018 Adriano dos Santos Fernandes <adrianosf@gmail.com>
 * and all contributors signed below.
 *
 * All Rights Reserved.
 * Contributor(s): ______________________________________.
*/

#include"firebird.h"
#include"../common/TimeZoneUtil.h"
#include"../common/TimeZones.h"
#include"../common/StatusHolder.h"
#include"../common/classes/rwlock.h"
#include"../common/classes/timestamp.h"
#include"../common/classes/GenericMap.h"
#include"../common/config/config.h"
#include"../common/os/path_utils.h"
#include"../common/os/os_utils.h"
#include"unicode/ucal.h"

usingnamespaceFirebird;

namespace
{
classTimeZoneDesc
 {
public:
TimeZoneDesc(MemoryPool& pool)
 : asciiName(pool),
unicodeName(pool),
 icuCachedCalendar(nullptr)
 {
 }

~TimeZoneDesc()
 {
if (constauto calendar = icuCachedCalendar.exchange(nullptr))
 {
auto& icuLib = Jrd::UnicodeUtil::getConversionICU();
 icuLib.ucalClose(calendar);
 }
 }

public:
voidsetName(constchar* name)
 {
 asciiName = name;

for (constauto c : asciiName)
 unicodeName.push(c);

 unicodeName.push(0);
 }

constchar* getAsciiName() const
 {
return asciiName.c_str();
 }

const UChar* getUnicodeName() const
 {
return unicodeName.begin();
 }

 IcuCalendarWrapper getCalendar(const Jrd::UnicodeUtil::ConversionICU& icuLib, UErrorCode* err = nullptr) const
 {
auto calendar = icuCachedCalendar.exchange(nullptr);
 UErrorCode internalErr = U_ZERO_ERROR;

if (!calendar)
 calendar = icuLib.ucalOpen(getUnicodeName(), -1, nullptr, UCAL_GREGORIAN, (err ? err : &internalErr));

returnIcuCalendarWrapper(calendar, &icuCachedCalendar);
 }

private:
 string asciiName;
 Array<UChar> unicodeName;
mutable std::atomic<UCalendar*> icuCachedCalendar;
 };
}

//-------------------------------------

staticconst TimeZoneDesc* getDesc(USHORT timeZone);
staticinlineboolisOffset(USHORT timeZone);
static USHORT makeFromOffset(int sign, unsigned tzh, unsigned tzm);
staticinline SSHORT offsetZoneToDisplacement(USHORT timeZone);
staticinline USHORT displacementToOffsetZone(SSHORT displacement);
staticintparseNumber(constchar*& p, constchar* end);
staticvoidskipSpaces(constchar*& p, constchar* end);

//-------------------------------------

namespace
{
classTimeZoneDataPath
 {
public:
TimeZoneDataPath(MemoryPool& pool)
 : path(pool)
 {
 PathName temp;

// Could not call fb_utils::getPrefix here.
if (FB_TZDATADIR[0] && PathUtils::isRelative(FB_TZDATADIR))
PathUtils::concatPath(temp, Config::getRootDirectory(), FB_TZDATADIR);
elseif (FB_TZDATADIR[0])
 temp = FB_TZDATADIR;
else
 {
#ifdef ANDROID
 temp = Config::getRootDirectory();
#else
PathUtils::concatPath(temp, Config::getRootDirectory(), "tzdata");
#endif
 }

conststaticchar* const ICU_TIMEZONE_FILES_DIR = "ICU_TIMEZONE_FILES_DIR";

// Do not update ICU_TIMEZONE_FILES_DIR if it's already set.
fb_utils::setenv(ICU_TIMEZONE_FILES_DIR, temp.c_str(), false);
fb_utils::readenv(ICU_TIMEZONE_FILES_DIR, path);
 }

const PathName& get()
 {
return path;
 }

private:
 PathName path;
 };

classTimeZoneStartup
 {
public:
TimeZoneStartup(MemoryPool& pool)
 : timeZoneList(pool),
nameIdMap(pool)
 {
if (!initFromFile())
 {
for (USHORT i = 0; i < FB_NELEM(BUILTIN_TIME_ZONE_LIST); ++i)
 {
auto& timeZone = timeZoneList.add();
 timeZone.setName(BUILTIN_TIME_ZONE_LIST[i]);
 }
 }

unsigned id = 0;

for (constauto& timeZone : timeZoneList)
 {
 string name = timeZone.getAsciiName();
 name.upper();
 nameIdMap.put(name, id++);
 }
 }

const ObjectsArray<TimeZoneDesc>& getTimeZoneList()
 {
return timeZoneList;
 }

boolgetId(string name, USHORT& id)
 {
 USHORT index;
 name.upper();

if (nameIdMap.get(name, index))
 {
 id = MAX_USHORT - index;
returntrue;
 }
else
returnfalse;
 }

private:
boolinitFromFile()
 {
 PathName idsPath;
PathUtils::concatPath(idsPath, TimeZoneUtil::getTzDataPath(), "ids.dat");
constint fileHandle = os_utils::open(idsPath.c_str(), O_RDONLY | O_BINARY, 0);

if (fileHandle == -1)
returnfalse;

structSTAT stat;
if (os_utils::fstat(fileHandle, &stat) != 0)
 {
close(fileHandle);
returnfalse;
 }

 Array<UCHAR> buffer(stat.st_size);
 buffer.resize(stat.st_size);
constlong bytesRead = read(fileHandle, buffer.begin(), buffer.getCount());

close(fileHandle);

if (bytesRead != buffer.getCount())
returnfalse;

const UCHAR* p = buffer.begin();
const UCHAR* end = buffer.end();

if (buffer.getCount() > 10)
 {
// file signature
if (memcmp(p, "FBTZ", 5) == 0)
 {
 p += 5;
if (isc_portable_integer(p, 2) == 1) // file version: must be 1
 {
 string databaseVersion;

for (p += 2; p < end && *p; ++p)
 databaseVersion += *p;

 ++p;

if (end - p >= 2)
 {
unsigned count = isc_portable_integer(p, 2);

// Our main criteria to choose the file or the builtin data is the count
// of entries. TZ database version is the second, as new version could
// have the same entries as before.

if (count < FB_NELEM(BUILTIN_TIME_ZONE_LIST))
 {
gds__log("tzdata ids.dat file is older than builtin time zone list.");
returnfalse;
 }
elseif (count == FB_NELEM(BUILTIN_TIME_ZONE_LIST) &&
 databaseVersion <= BUILTIN_TIME_ZONE_VERSION)
 {
returnfalse;
 }

for (p += 2; p < end; ++p)
 {
auto& timeZone = timeZoneList.add();
 string name;

for (; p < end && *p; ++p)
 name += *p;

 timeZone.setName(name.c_str());

if (p >= end)
 {
 timeZoneList.clear();
break;
 }
 }

if (timeZoneList.getCount() == count)
returntrue;
 }
 }
 }
 }

gds__log("tzdata ids.dat file is corrupted.");

 timeZoneList.clear();

returnfalse;
 }

private:
 ObjectsArray<TimeZoneDesc> timeZoneList;
 GenericMap<Pair<Left<string, USHORT> > > nameIdMap;
 };
} // namespace

//-------------------------------------

staticconst UDate MIN_ICU_TIMESTAMP = TimeZoneUtil::timeStampToIcuDate(TimeStamp::MIN_TIMESTAMP);
staticconst UDate MAX_ICU_TIMESTAMP = TimeZoneUtil::timeStampToIcuDate(TimeStamp::MAX_TIMESTAMP);
staticconstunsigned ONE_DAY = 24 * 60 - 1; // used for offset encoding
static InitInstance<TimeZoneDataPath> timeZoneDataPath;
static InitInstance<TimeZoneStartup> timeZoneStartup;

//-------------------------------------


const ISC_DATE TimeZoneUtil::TIME_TZ_BASE_DATE = 58849; // 2020-01-01
constchar TimeZoneUtil::GMT_FALLBACK[5] = "GMT*";

voidTimeZoneUtil::initTimeZoneEnv()
{
timeZoneDataPath();
}

const PathName& TimeZoneUtil::getTzDataPath()
{
returntimeZoneDataPath().get();
}

// Return the current user's time zone.
USHORT TimeZoneUtil::getSystemTimeZone()
{
staticvolatilebool cachedError = false;
staticvolatile USHORT cachedTimeZoneId = TimeZoneUtil::GMT_ZONE;
staticvolatileint32_t cachedTimeZoneNameLen = -1;
staticchar cachedTimeZoneName[TimeZoneUtil::MAX_SIZE];
static GlobalPtr<RWLock> lock;

if (cachedError)
return cachedTimeZoneId;

// ASF: The code below in this function is prepared to detect changes in OS time zone or config setting, but
// the called functions are not. So cache and return directly the previously detected time zone.
if (cachedTimeZoneNameLen != -1)
return cachedTimeZoneId;

 UErrorCode icuErrorCode = U_ZERO_ERROR;
 Jrd::UnicodeUtil::ConversionICU& icuLib = Jrd::UnicodeUtil::getConversionICU();

char buffer[TimeZoneUtil::MAX_SIZE];
constchar* str = buffer;
int32_t len;
constchar* configDefault = Config::getDefaultTimeZone();
bool strictParse = true;

if (configDefault && configDefault[0])
 {
 str = configDefault;
 len = strlen(str);
 }
else
 {
 UChar unicodeBuffer[TimeZoneUtil::MAX_LEN];
 len = icuLib.ucalGetDefaultTimeZone(unicodeBuffer, FB_NELEM(unicodeBuffer), &icuErrorCode);

if (!U_FAILURE(icuErrorCode))
 {
 UChar* src = unicodeBuffer;
char* dst = buffer;

while (src - unicodeBuffer < len)
 *dst++ = (char) *src++;

 str = buffer;
 buffer[len] = '\0';

 strictParse = false;
 }
else
 {
gds__log("ICU error (%d) retrieving the system time zone. Falling back to displacement.",
int(icuErrorCode));
 }
 }

 ReadLockGuard readGuard(lock, "TimeZoneUtil::getSystemTimeZone");

if (!U_FAILURE(icuErrorCode) &&
 cachedTimeZoneNameLen != -1 &&
 len == cachedTimeZoneNameLen &&
memcmp(str, cachedTimeZoneName, len) == 0)
 {
return cachedTimeZoneId;
 }

 readGuard.release();
 WriteLockGuard writeGuard(lock, "TimeZoneUtil::getSystemTimeZone");

if (!U_FAILURE(icuErrorCode))
 {
try
 {
 USHORT id = parse(str, len, strictParse);
 cachedTimeZoneId = id;
 cachedTimeZoneNameLen = len;
return cachedTimeZoneId;
 }
catch (status_exception&)
 {
gds__log("Invalid time zone (%s). Falling back to displacement.", str);
 }
 }

 icuErrorCode = U_ZERO_ERROR;

 UCalendar* icuCalendar = icuLib.ucalOpen(NULL, -1, NULL, UCAL_GREGORIAN, &icuErrorCode);

if (!icuCalendar)
 {
gds__log("ICU's ucal_open error opening the default calendar.");
 cachedError = true;
return cachedTimeZoneId; // GMT
 }

int32_t displacement = (icuLib.ucalGet(icuCalendar, UCAL_ZONE_OFFSET, &icuErrorCode) +
 icuLib.ucalGet(icuCalendar, UCAL_DST_OFFSET, &icuErrorCode)) / U_MILLIS_PER_MINUTE;

 icuLib.ucalClose(icuCalendar);

if (!U_FAILURE(icuErrorCode))
 {
int sign = displacement < 0 ? -1 : 1;
unsigned tzh = (unsigned) abs(int(displacement / 60));
unsigned tzm = (unsigned) abs(int(displacement % 60));
 cachedTimeZoneId = makeFromOffset(sign, tzh, tzm);
 }
else
gds__log("Cannot retrieve the system time zone: %d.", int(icuErrorCode));

 cachedError = true;

return cachedTimeZoneId;
}

voidTimeZoneUtil::getDatabaseVersion(Firebird::string& str)
{
 Jrd::UnicodeUtil::ConversionICU& icuLib = Jrd::UnicodeUtil::getConversionICU();
 UErrorCode icuErrorCode = U_ZERO_ERROR;

constchar* version = icuLib.ucalGetTZDataVersion(&icuErrorCode);

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_getTZDataVersion.");

 str = version;
}

voidTimeZoneUtil::iterateRegions(std::function<void (USHORT, constchar*)> func)
{
for (USHORT i = 0; i < timeZoneStartup().getTimeZoneList().getCount(); ++i)
func(MAX_USHORT - i, timeZoneStartup().getTimeZoneList()[i].getAsciiName());
}

// Parses a time zone, offset- or region-based.
USHORT TimeZoneUtil::parse(constchar* str, unsigned strLen, bool strict)
{
// Non-strict parse is used to detect OS time zone.

constchar* end = str + strLen;
constchar* p = str;

skipSpaces(p, end);

constauto start = str;

if (p < end && (*p == '-' || *p == '+'))
 {
int sign = *p++ == '-' ? -1 : 1;
skipSpaces(p, end);

int tzh = parseNumber(p, end);

if (tzh >= 0)
 {
skipSpaces(p, end);

if (!strict && p == end)
returnmakeFromOffset(sign, tzh, 0);

if (p < end && *p == ':')
 {
 ++p;
skipSpaces(p, end);
int tzm = parseNumber(p, end);

if (tzm >= 0)
 {
skipSpaces(p, end);

if (p == end)
returnmakeFromOffset(sign, tzh, tzm);
 }
 }
 }

status_exception::raise(Arg::Gds(isc_invalid_timezone_offset) << string(start, end));
return0; // avoid warning
 }

returnparseRegion(p, str + strLen - p);
}

// Parses a time zone id from a region string.
USHORT TimeZoneUtil::parseRegion(constchar* str, unsigned strLen)
{
constchar* end = str + strLen;

skipSpaces(str, end);

constchar* start = str;

while (str < end &&
 ((*str >= 'a' && *str <= 'z') ||
 (*str >= 'A' && *str <= 'Z') ||
 *str == '_' ||
 *str == '/' ||
 (str != start && *str >= '0' && *str <= '9') ||
 (str != start && *str == '+') ||
 (str != start && *str == '-')))
 {
 ++str;
 }

unsigned len = str - start;

skipSpaces(str, end);

if (str == end)
 {
 string s(start, len);
 USHORT id;

if (timeZoneStartup().getId(s, id))
return id;
 }

status_exception::raise(Arg::Gds(isc_invalid_timezone_region) << string(start, end));
return0;
}

// Format a time zone to string, as offset or region.
unsignedTimeZoneUtil::format(char* buffer, size_t bufferSize, USHORT timeZone, bool fallback, SLONG offset)
{
char* p = buffer;

if (fallback)
 {
if (offset == NO_OFFSET)
 p += fb_utils::snprintf(p, bufferSize - (p - buffer), "%s", GMT_FALLBACK);
else
 {
if (offset != 0)
 *p++ = offset < 0 ? '-' : '+';

if (offset < 0)
 offset = -offset;

int minutes = offset % 60;
 offset /= 60;
 p += fb_utils::snprintf(p, bufferSize - (p - buffer), "%02d:%02d", offset, minutes);
 }
 }
elseif (isOffset(timeZone))
 {
 SSHORT displacement = offsetZoneToDisplacement(timeZone);

 *p++ = displacement < 0 ? '-' : '+';

if (displacement < 0)
 displacement = -displacement;

 p += fb_utils::snprintf(p, bufferSize - 1, "%2.2d:%2.2d", displacement / 60, displacement % 60);
 }
else
 {
strncpy(buffer, getDesc(timeZone)->getAsciiName(), bufferSize);

 p += strlen(buffer);
 }

return p - buffer;
}

// Returns if the offsets are valid.
boolTimeZoneUtil::isValidOffset(int sign, unsigned tzh, unsigned tzm)
{
fb_assert(sign >= -1 && sign <= 1);
return tzm <= 59 && (tzh < 14 || (tzh == 14 && tzm == 0));
}

// Extracts the offsets from a offset- or region-based datetime with time zone.
voidTimeZoneUtil::extractOffset(const ISC_TIMESTAMP_TZ& timeStampTz, int* sign, unsigned* tzh, unsigned* tzm)
{
 SSHORT displacement;
extractOffset(timeStampTz, &displacement);

 *sign = displacement < 0 ? -1 : 1;
 displacement = displacement < 0 ? -displacement : displacement;

 *tzh = displacement / 60;
 *tzm = displacement % 60;
}

// Extracts the offset (+- minutes) from a offset- or region-based datetime with time zone.
voidTimeZoneUtil::extractOffset(const ISC_TIMESTAMP_TZ& timeStampTz, SSHORT* offset)
{
 SSHORT displacement;

if (timeStampTz.time_zone == GMT_ZONE)
 displacement = 0;
elseif (isOffset(timeStampTz.time_zone))
 displacement = offsetZoneToDisplacement(timeStampTz.time_zone);
else
 {
 UErrorCode icuErrorCode = U_ZERO_ERROR;

 Jrd::UnicodeUtil::ConversionICU& icuLib = Jrd::UnicodeUtil::getConversionICU();

auto icuCalendar = getDesc(timeStampTz.time_zone)->getCalendar(icuLib, &icuErrorCode);

if (!icuCalendar)
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_open.");

 icuLib.ucalSetMillis(icuCalendar, timeStampToIcuDate(timeStampTz.utc_timestamp), &icuErrorCode);

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_setMillis.");

 displacement = (icuLib.ucalGet(icuCalendar, UCAL_ZONE_OFFSET, &icuErrorCode) +
 icuLib.ucalGet(icuCalendar, UCAL_DST_OFFSET, &icuErrorCode)) / U_MILLIS_PER_MINUTE;

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_get.");
 }

 *offset = displacement;
}

// Extracts the offset (+- minutes) from a offset- or region-based time with time zone.
voidTimeZoneUtil::extractOffset(const ISC_TIME_TZ& timeTz, SSHORT* offset)
{
 ISC_TIMESTAMP_TZ tsTz;
 tsTz.utc_timestamp.timestamp_date = TIME_TZ_BASE_DATE;
 tsTz.utc_timestamp.timestamp_time = timeTz.utc_time;
 tsTz.time_zone = timeTz.time_zone;

extractOffset(tsTz, offset);
}

// Converts a time from local to UTC.
voidTimeZoneUtil::localTimeToUtc(ISC_TIME& time, ISC_USHORT timeZone)
{
 ISC_TIME_TZ timeTz;
 timeTz.utc_time = time;
 timeTz.time_zone = timeZone;
localTimeToUtc(timeTz);

time = timeTz.utc_time;
}

// Converts a time from local to UTC.
voidTimeZoneUtil::localTimeToUtc(ISC_TIME_TZ& timeTz)
{
 ISC_TIMESTAMP_TZ tsTz;
 tsTz.utc_timestamp.timestamp_date = TIME_TZ_BASE_DATE;
 tsTz.utc_timestamp.timestamp_time = timeTz.utc_time;
 tsTz.time_zone = timeTz.time_zone;
localTimeStampToUtc(tsTz);

 timeTz.utc_time = tsTz.utc_timestamp.timestamp_time;
}

// Converts a timestamp from its local datetime fields to UTC.
voidTimeZoneUtil::localTimeStampToUtc(ISC_TIMESTAMP& timeStamp, Callbacks* cb)
{
 ISC_TIMESTAMP_TZ tsTz;
 tsTz.utc_timestamp.timestamp_date = timeStamp.timestamp_date;
 tsTz.utc_timestamp.timestamp_time = timeStamp.timestamp_time;
 tsTz.time_zone = cb->getSessionTimeZone();

localTimeStampToUtc(tsTz);

 timeStamp.timestamp_date = tsTz.utc_timestamp.timestamp_date;
 timeStamp.timestamp_time = tsTz.utc_timestamp.timestamp_time;
}

// Converts a timestamp from its local datetime fields to UTC.
voidTimeZoneUtil::localTimeStampToUtc(ISC_TIMESTAMP_TZ& timeStampTz)
{
int displacement;

if (timeStampTz.time_zone == GMT_ZONE)
return;
elseif (isOffset(timeStampTz.time_zone))
 displacement = offsetZoneToDisplacement(timeStampTz.time_zone);
else
 {
tm times;
TimeStamp::decode_timestamp(*(ISC_TIMESTAMP*) &timeStampTz, &times, nullptr);

 UErrorCode icuErrorCode = U_ZERO_ERROR;

 Jrd::UnicodeUtil::ConversionICU& icuLib = Jrd::UnicodeUtil::getConversionICU();

auto icuCalendar = getDesc(timeStampTz.time_zone)->getCalendar(icuLib, &icuErrorCode);

if (!icuCalendar)
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_open.");

 icuLib.ucalSetAttribute(icuCalendar, UCAL_REPEATED_WALL_TIME, UCAL_WALLTIME_FIRST);
 icuLib.ucalSetAttribute(icuCalendar, UCAL_SKIPPED_WALL_TIME, UCAL_WALLTIME_FIRST);

 icuLib.ucalSetDateTime(icuCalendar, 1900 + times.tm_year, times.tm_mon, times.tm_mday,
 times.tm_hour, times.tm_min, times.tm_sec, &icuErrorCode);

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_setDateTime.");

 displacement = (icuLib.ucalGet(icuCalendar, UCAL_ZONE_OFFSET, &icuErrorCode) +
 icuLib.ucalGet(icuCalendar, UCAL_DST_OFFSET, &icuErrorCode)) / U_MILLIS_PER_MINUTE;

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_get.");
 }

constauto ticks = TimeStamp::timeStampToTicks(timeStampTz.utc_timestamp) -
 (displacement * 60 * ISC_TIME_SECONDS_PRECISION);

 timeStampTz.utc_timestamp = TimeStamp::ticksToTimeStamp(ticks);
}

boolTimeZoneUtil::decodeTime(const ISC_TIME_TZ& timeTz, bool gmtFallback, SLONG gmtOffset,
structtm* times, int* fractions)
{
 ISC_TIMESTAMP_TZ timeStampTz;
 timeStampTz.utc_timestamp.timestamp_date = TIME_TZ_BASE_DATE;
 timeStampTz.utc_timestamp.timestamp_time = timeTz.utc_time;
 timeStampTz.time_zone = timeTz.time_zone;

returndecodeTimeStamp(timeStampTz, gmtFallback, gmtOffset, times, fractions);
}

boolTimeZoneUtil::decodeTimeStamp(const ISC_TIMESTAMP_TZ& timeStampTz, bool gmtFallback, SLONG gmtOffset,
structtm* times, int* fractions)
{
bool icuFail = false;
int displacement;

if (timeStampTz.time_zone == GMT_ZONE)
 displacement = 0;
elseif (isOffset(timeStampTz.time_zone))
 displacement = offsetZoneToDisplacement(timeStampTz.time_zone);
else
 {
 UErrorCode icuErrorCode = U_ZERO_ERROR;

try
 {
#ifdef DEV_BUILD
if (gmtFallback && getenv("MISSING_ICU_EMULATION"))
 (Arg::Gds(isc_random) << "Emulating missing ICU").raise();
#endif
 Jrd::UnicodeUtil::ConversionICU& icuLib = Jrd::UnicodeUtil::getConversionICU();

auto icuCalendar = getDesc(timeStampTz.time_zone)->getCalendar(icuLib, &icuErrorCode);

if (!icuCalendar)
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_open.");

 icuLib.ucalSetMillis(icuCalendar, timeStampToIcuDate(timeStampTz.utc_timestamp), &icuErrorCode);

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_setMillis.");

 displacement = (icuLib.ucalGet(icuCalendar, UCAL_ZONE_OFFSET, &icuErrorCode) +
 icuLib.ucalGet(icuCalendar, UCAL_DST_OFFSET, &icuErrorCode)) / U_MILLIS_PER_MINUTE;

if (U_FAILURE(icuErrorCode))
status_exception::raise(Arg::Gds(isc_random) << "Error calling ICU's ucal_get.");
 }
catch (const Exception&)
 {
if (!gmtFallback)
throw;

 icuFail = true;
 displacement = gmtOffset == NO_OFFSET ? 0 : gmtOffset;
 }
 }

constauto ticks = TimeStamp::timeStampToTicks(timeStampTz.utc_timestamp) +
 (displacement * 60 * ISC_TIME_SECONDS_PRECISION);

TimeStamp::decode_timestamp(TimeStamp::ticksToTimeStamp(ticks), times, fractions);

return !icuFail;
}

ISC_TIMESTAMP_TZ TimeZoneUtil::getCurrentSystemTimeStamp()
{
auto tsTz = getCurrentGmtTimeStamp();
 tsTz.time_zone = getSystemTimeZone();
return tsTz;
}

ISC_TIMESTAMP_TZ TimeZoneUtil::getCurrentGmtTimeStamp()
{
 NoThrowTimeStamp now;

// ASF: This comment is copied from NoThrowTimeStamp::getCurrentTimeStamp.
// NS: We round generated timestamps to whole millisecond.
// Not many applications can deal with fractional milliseconds properly and
// we do not use high resolution timers either so actual time granularity
// is going to to be somewhere in range between 1 ms (like on UNIX/Risc)
// and 53 ms (such as Win9X)

int milliseconds;

#ifdef WIN_NT
 SYSTEMTIME stUtc;
GetSystemTime(&stUtc);
 milliseconds = stUtc.wMilliseconds;
#else
time_t seconds; // UTC time

#ifdef HAVE_GETTIMEOFDAY
structtimeval tp;
GETTIMEOFDAY(&tp);
 seconds = tp.tv_sec;
 milliseconds = tp.tv_usec / 1000;
#else
structtimeb time_buffer;
ftime(&time_buffer);
 seconds = time_buffer.time;
 milliseconds = time_buffer.millitm;
#endif
#endif// WIN_NT

constint fractions = milliseconds * ISC_TIME_SECONDS_PRECISION / 1000;

#ifdef WIN_NT
// Manually convert SYSTEMTIME to "struct tm" used below

structtm times, *ptimes = &times;

 times.tm_sec = stUtc.wSecond; // seconds after the minute - [0,59]
 times.tm_min = stUtc.wMinute; // minutes after the hour - [0,59]
 times.tm_hour = stUtc.wHour; // hours since midnight - [0,23]
 times.tm_mday = stUtc.wDay; // day of the month - [1,31]
 times.tm_mon = stUtc.wMonth - 1; // months since January - [0,11]
 times.tm_year = stUtc.wYear - 1900; // years since 1900
 times.tm_wday = stUtc.wDayOfWeek; // days since Sunday - [0,6]

// --- no used for encoding below
 times.tm_yday = 0; // days since January 1 - [0,365]
 times.tm_isdst = -1; // daylight savings time flag
#else
#ifdef HAVE_GMTIME_R
structtm times, *ptimes = &times;
if (!gmtime_r(&seconds, &times))
system_call_failed::raise("gmtime_r");
#else
structtm *ptimes = gmtime(&seconds);
if (!ptimes)
system_call_failed::raise("gmtime");
#endif
#endif// WIN_NT

 now.encode(ptimes, fractions);

 ISC_TIMESTAMP_TZ tsTz;
 tsTz.utc_timestamp = now.value();
 tsTz.time_zone = GMT_ZONE;

return tsTz;
}

voidTimeZoneUtil::validateGmtTimeStamp(NoThrowTimeStamp& ts)
{
if (ts.isEmpty())
 ts.value() = getCurrentGmtTimeStamp().utc_timestamp;
}

// Converts a time-tz to a time.
ISC_TIME TimeZoneUtil::timeTzToTime(const ISC_TIME_TZ& timeTz, Callbacks* cb)
{
 ISC_TIMESTAMP_TZ tsTz;
 tsTz.utc_timestamp.timestamp_date = TIME_TZ_BASE_DATE;
 tsTz.utc_timestamp.timestamp_time = timeTz.utc_time;
 tsTz.time_zone = timeTz.time_zone;

structtm times;
int fractions;
decodeTimeStamp(tsTz, false, NO_OFFSET, &times, &fractions);

 tsTz.utc_timestamp.timestamp_date = cb->getLocalDate();
 tsTz.utc_timestamp.timestamp_time =
TimeStamp::encode_time(times.tm_hour, times.tm_min, times.tm_sec, fractions);

localTimeStampToUtc(tsTz);

returntimeStampTzToTimeStamp(tsTz, cb->getSessionTimeZone()).timestamp_time;
}

// Converts a timestamp-tz to a timestamp in a given zone.
ISC_TIMESTAMP TimeZoneUtil::timeStampTzToTimeStamp(const ISC_TIMESTAMP_TZ& timeStampTz, USHORT toTimeZone)
{
 ISC_TIMESTAMP_TZ tsTz = timeStampTz;
 tsTz.time_zone = toTimeZone;

structtm times;
int fractions;
decodeTimeStamp(tsTz, false, NO_OFFSET, &times, &fractions);

returnTimeStamp::encode_timestamp(&times, fractions);
}

// Converts a time to timestamp-tz.
ISC_TIMESTAMP_TZ TimeZoneUtil::timeToTimeStampTz(const ISC_TIME& time, Callbacks* cb)
{
// SQL: source => TIMESTAMP WITHOUT TIME ZONE => TIMESTAMP WITH TIME ZONE

 ISC_TIMESTAMP_TZ tsTz;
 tsTz.utc_timestamp.timestamp_date = cb->getLocalDate();
 tsTz.utc_timestamp.timestamp_time = time;
 tsTz.time_zone = cb->getSessionTimeZone();
localTimeStampToUtc(tsTz);

return tsTz;
}

// Converts a time to time-tz.
ISC_TIME_TZ TimeZoneUtil::timeToTimeTz(const ISC_TIME& time, Callbacks* cb)
{
 ISC_TIMESTAMP_TZ tsTz;
 tsTz.time_zone = cb->getSessionTimeZone();
 tsTz.utc_timestamp.timestamp_date = TIME_TZ_BASE_DATE;
 tsTz.utc_timestamp.timestamp_time = time;

localTimeStampToUtc(tsTz);

 ISC_TIME_TZ timeTz;
 timeTz.time_zone = tsTz.time_zone;
 timeTz.utc_time = tsTz.utc_timestamp.timestamp_time;

return timeTz;
}

// Converts a time-tz to timestamp-tz.
ISC_TIMESTAMP_TZ TimeZoneUtil::timeTzToTimeStampTz(const ISC_TIME_TZ& timeTz, Callbacks* cb)
{
// SQL: Copy date fields from CURRENT_DATE and time and time zone fields from the source.

structtm localTimes;
TimeStamp::decode_date(cb->getLocalDate(), &localTimes);

 ISC_TIMESTAMP_TZ tsTz;
 tsTz.time_zone = timeTz.time_zone;
 tsTz.utc_timestamp.timestamp_date = TIME_TZ_BASE_DATE;
 tsTz.utc_timestamp.timestamp_time = timeTz.utc_time;

structtm times;
int fractions;
decodeTimeStamp(tsTz, false, NO_OFFSET, &times, &fractions);

 times.tm_mday = localTimes.tm_mday;
 times.tm_mon = localTimes.tm_mon;
 times.tm_year = localTimes.tm_year;

 tsTz.utc_timestamp = TimeStamp::encode_timestamp(&times, fractions);
localTimeStampToUtc(tsTz);

return tsTz;
}

// Converts a time-tz to timestamp.
ISC_TIMESTAMP TimeZoneUtil::timeTzToTimeStamp(const ISC_TIME_TZ& timeTz, Callbacks* cb)
{
// SQL: source => TIMESTAMP WITH TIME ZONE => TIMESTAMP WITHOUT TIME ZONE

 ISC_TIMESTAMP_TZ tsTz = timeTzToTimeStampTz(timeTz, cb);

returntimeStampTzToTimeStamp(tsTz, cb->getSessionTimeZone());
}

// Converts a timestamp-tz to timestamp.
ISC_TIMESTAMP TimeZoneUtil::timeStampTzToTimeStamp(const ISC_TIMESTAMP_TZ& timeStampTz, Callbacks* cb)
{
returntimeStampTzToTimeStamp(timeStampTz, cb->getSessionTimeZone());
}

// Converts a timestamp-tz to time-tz.
ISC_TIME_TZ TimeZoneUtil::timeStampTzToTimeTz(const ISC_TIMESTAMP_TZ& timeStampTz)
{
structtm times;
int fractions;
decodeTimeStamp(timeStampTz, false, NO_OFFSET, &times, &fractions);