FreeRDP/winpr/libwinpr/timezone/timezone.c
akallabeth 1d33095500
[warnings] fix cert-err33-c
Fix unused return values, cast to void if on purpose
2024-08-29 10:19:27 +02:00

931 lines
22 KiB
C

/**
* WinPR: Windows Portable Runtime
* Time Zone
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2024 Armin Novak <anovak@thincast.com>
* Copyright 2024 Thincast Technologies GmbH
*
* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <winpr/config.h>
#include <winpr/environment.h>
#include <winpr/wtypes.h>
#include <winpr/timezone.h>
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/file.h>
#include "../log.h"
#define TAG WINPR_TAG("timezone")
#ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
#include "TimeZoneNameMap.h"
#include "TimeZoneIanaAbbrevMap.h"
#ifndef _WIN32
#include <time.h>
#include <unistd.h>
#endif
#if !defined(_WIN32)
static char* winpr_read_unix_timezone_identifier_from_file(FILE* fp)
{
const INT CHUNK_SIZE = 32;
INT64 rc = 0;
INT64 read = 0;
INT64 length = CHUNK_SIZE;
char* tzid = NULL;
tzid = (char*)malloc((size_t)length);
if (!tzid)
return NULL;
do
{
rc = fread(tzid + read, 1, length - read - 1, fp);
if (rc > 0)
read += rc;
if (read < (length - 1))
break;
length += CHUNK_SIZE;
char* tmp = (char*)realloc(tzid, length);
if (!tmp)
{
free(tzid);
return NULL;
}
tzid = tmp;
} while (rc > 0);
if (ferror(fp))
{
free(tzid);
return NULL;
}
tzid[read] = '\0';
if (read > 0)
{
if (tzid[read - 1] == '\n')
tzid[read - 1] = '\0';
}
return tzid;
}
static char* winpr_get_timezone_from_link(const char* links[], size_t count)
{
const char* _links[] = { "/etc/localtime", "/etc/TZ" };
if (links == NULL)
{
links = _links;
count = ARRAYSIZE(_links);
}
/*
* On linux distros such as Redhat or Archlinux, a symlink at /etc/localtime
* will point to /usr/share/zoneinfo/region/place where region/place could be
* America/Montreal for example.
* Some distributions do have to symlink at /etc/TZ.
*/
for (size_t x = 0; x < count; x++)
{
char* tzid = NULL;
const char* link = links[x];
char* buf = realpath(link, NULL);
if (buf)
{
size_t sep = 0;
size_t alloc = 0;
size_t pos = 0;
size_t len = pos = strlen(buf);
/* find the position of the 2nd to last "/" */
for (size_t i = 1; i <= len; i++)
{
const size_t curpos = len - i;
const char cur = buf[curpos];
if (cur == '/')
sep++;
if (sep >= 2)
{
alloc = i;
pos = len - i + 1;
break;
}
}
if ((len == 0) || (sep != 2))
goto end;
tzid = (char*)calloc(alloc + 1, sizeof(char));
if (!tzid)
goto end;
strncpy(tzid, &buf[pos], alloc);
WLog_DBG(TAG, "tzid: %s", tzid);
goto end;
}
end:
free(buf);
if (tzid)
return tzid;
}
return NULL;
}
#if defined(ANDROID)
#include "../utils/android.h"
static char* winpr_get_android_timezone_identifier(void)
{
char* tzid = NULL;
JNIEnv* jniEnv;
/* Preferred: Try to get identifier from java TimeZone class */
if (jniVm && ((*jniVm)->GetEnv(jniVm, (void**)&jniEnv, JNI_VERSION_1_6) == JNI_OK))
{
const char* raw;
jclass jObjClass;
jobject jObj;
jmethodID jDefaultTimezone;
jmethodID jTimezoneIdentifier;
jstring tzJId;
jboolean attached = (*jniVm)->AttachCurrentThread(jniVm, &jniEnv, NULL);
jObjClass = (*jniEnv)->FindClass(jniEnv, "java/util/TimeZone");
if (!jObjClass)
goto fail;
jDefaultTimezone =
(*jniEnv)->GetStaticMethodID(jniEnv, jObjClass, "getDefault", "()Ljava/util/TimeZone;");
if (!jDefaultTimezone)
goto fail;
jObj = (*jniEnv)->CallStaticObjectMethod(jniEnv, jObjClass, jDefaultTimezone);
if (!jObj)
goto fail;
jTimezoneIdentifier =
(*jniEnv)->GetMethodID(jniEnv, jObjClass, "getID", "()Ljava/lang/String;");
if (!jTimezoneIdentifier)
goto fail;
tzJId = (*jniEnv)->CallObjectMethod(jniEnv, jObj, jTimezoneIdentifier);
if (!tzJId)
goto fail;
raw = (*jniEnv)->GetStringUTFChars(jniEnv, tzJId, 0);
if (raw)
tzid = _strdup(raw);
(*jniEnv)->ReleaseStringUTFChars(jniEnv, tzJId, raw);
fail:
if (attached)
(*jniVm)->DetachCurrentThread(jniVm);
}
/* Fall back to property, might not be available. */
if (!tzid)
{
FILE* fp = popen("getprop persist.sys.timezone", "r");
if (fp)
{
tzid = winpr_read_unix_timezone_identifier_from_file(fp);
pclose(fp);
}
}
return tzid;
}
#endif
static char* winpr_get_unix_timezone_identifier_from_file(void)
{
#if defined(ANDROID)
return winpr_get_android_timezone_identifier();
#else
FILE* fp = NULL;
char* tzid = NULL;
#if !defined(WINPR_TIMEZONE_FILE)
#error \
"Please define WINPR_TIMEZONE_FILE with the path to your timezone file (e.g. /etc/timezone or similar)"
#else
fp = winpr_fopen(WINPR_TIMEZONE_FILE, "r");
#endif
if (NULL == fp)
return NULL;
tzid = winpr_read_unix_timezone_identifier_from_file(fp);
(void)fclose(fp);
if (tzid != NULL)
WLog_DBG(TAG, "tzid: %s", tzid);
return tzid;
#endif
}
static char* winpr_time_zone_from_env(void)
{
LPCSTR tz = "TZ";
char* tzid = NULL;
DWORD nSize = GetEnvironmentVariableA(tz, NULL, 0);
if (nSize > 0)
{
tzid = (char*)calloc(nSize, sizeof(char));
if (!tzid)
goto fail;
if (!GetEnvironmentVariableA(tz, tzid, nSize))
goto fail;
else if (tzid[0] == ':')
{
/* Remove leading colon, see tzset(3) */
memmove(tzid, tzid + 1, nSize - sizeof(char));
}
}
return tzid;
fail:
free(tzid);
return NULL;
}
static char* winpr_translate_time_zone(const char* tzid)
{
const char* zipath = "/usr/share/zoneinfo/";
char* buf = NULL;
const char* links[] = { buf };
if (!tzid)
return NULL;
if (tzid[0] == '/')
{
/* Full path given in TZ */
links[0] = tzid;
}
else
{
size_t bsize = 0;
winpr_asprintf(&buf, &bsize, "%s%s", zipath, tzid);
links[0] = buf;
}
char* ntzid = winpr_get_timezone_from_link(links, 1);
free(buf);
return ntzid;
}
static char* winpr_guess_time_zone(void)
{
char* tzid = winpr_time_zone_from_env();
if (tzid)
goto end;
tzid = winpr_get_unix_timezone_identifier_from_file();
if (tzid)
goto end;
tzid = winpr_get_timezone_from_link(NULL, 0);
if (tzid)
goto end;
end:
{
char* ntzid = winpr_translate_time_zone(tzid);
if (ntzid)
{
free(tzid);
return ntzid;
}
return tzid;
}
}
static SYSTEMTIME tm2systemtime(const struct tm* t)
{
SYSTEMTIME st = { 0 };
if (t)
{
st.wYear = (WORD)1900 + t->tm_year;
st.wMonth = (WORD)t->tm_mon + 1;
st.wDay = (WORD)t->tm_mday;
st.wDayOfWeek = (WORD)t->tm_wday;
st.wHour = (WORD)t->tm_hour;
st.wMinute = (WORD)t->tm_min;
st.wSecond = (WORD)t->tm_sec;
st.wMilliseconds = 0;
}
return st;
}
static struct tm systemtime2tm(const SYSTEMTIME* st)
{
struct tm t = { 0 };
if (st)
{
if (st->wYear >= 1900)
t.tm_year = st->wYear - 1900;
if (st->wMonth > 0)
t.tm_mon = st->wMonth - 1;
t.tm_mday = st->wDay;
t.tm_wday = st->wDayOfWeek;
t.tm_hour = st->wHour;
t.tm_min = st->wMinute;
t.tm_sec = st->wSecond;
}
return t;
}
static LONG get_gmtoff_min(const struct tm* t)
{
WINPR_ASSERT(t);
return -(LONG)(t->tm_gmtoff / 60l);
}
static struct tm next_day(const struct tm* start)
{
struct tm cur = *start;
cur.tm_hour = 0;
cur.tm_min = 0;
cur.tm_sec = 0;
cur.tm_isdst = -1;
cur.tm_mday++;
const time_t t = mktime(&cur);
localtime_r(&t, &cur);
return cur;
}
static struct tm adjust_time(const struct tm* start, int hour, int minute)
{
struct tm cur = *start;
cur.tm_hour = hour;
cur.tm_min = minute;
cur.tm_sec = 0;
cur.tm_isdst = -1;
const time_t t = mktime(&cur);
localtime_r(&t, &cur);
return cur;
}
/* [MS-RDPBCGR] 2.2.1.11.1.1.1.1.1 System Time (TS_SYSTEMTIME) */
static WORD get_transition_weekday_occurrence(const SYSTEMTIME* st)
{
WORD count = 0;
struct tm start = systemtime2tm(st);
WORD last = 0;
struct tm next = start;
next.tm_mday = 1;
next.tm_isdst = -1;
do
{
const time_t t = mktime(&next);
next.tm_mday++;
struct tm cur = { 0 };
localtime_r(&t, &cur);
if (cur.tm_mon + 1 != st->wMonth)
break;
if (cur.tm_wday == st->wDayOfWeek)
{
if (cur.tm_mday <= st->wDay)
count++;
last++;
}
} while (TRUE);
if (count == last)
count = 5;
return count;
}
static SYSTEMTIME tm2transitiontime(const struct tm* cur)
{
SYSTEMTIME t = tm2systemtime(cur);
if (cur)
{
t.wDay = get_transition_weekday_occurrence(&t);
t.wYear = 0;
}
return t;
}
static SYSTEMTIME get_transition_time(const struct tm* start, BOOL toDst)
{
BOOL toggled = FALSE;
struct tm first = adjust_time(start, 0, 0);
for (int hour = 0; hour < 24; hour++)
{
struct tm cur = adjust_time(start, hour, 0);
if (cur.tm_isdst != first.tm_isdst)
toggled = TRUE;
if (toggled)
{
if (toDst && (cur.tm_isdst > 0))
return tm2transitiontime(&cur);
else if (!toDst && (cur.tm_isdst == 0))
return tm2transitiontime(&cur);
}
}
return tm2transitiontime(start);
}
static BOOL get_transition_date(const struct tm* start, BOOL toDst, SYSTEMTIME* pdate)
{
WINPR_ASSERT(start);
WINPR_ASSERT(pdate);
*pdate = tm2transitiontime(NULL);
if (start->tm_isdst < 0)
return FALSE;
BOOL val = start->tm_isdst > 0; // the year starts with DST or not
BOOL toggled = FALSE;
struct tm cur = *start;
struct tm last = cur;
for (int day = 1; day <= 365; day++)
{
last = cur;
cur = next_day(&cur);
const BOOL curDst = (cur.tm_isdst > 0);
if ((val != curDst) && !toggled)
toggled = TRUE;
if (toggled)
{
if (toDst && curDst)
{
*pdate = get_transition_time(&last, toDst);
return TRUE;
}
if (!toDst && !curDst)
{
*pdate = get_transition_time(&last, toDst);
return TRUE;
}
}
}
return FALSE;
}
static LONG get_bias(const struct tm* start, BOOL dstBias)
{
if ((start->tm_isdst > 0) && dstBias)
return get_gmtoff_min(start);
if ((start->tm_isdst == 0) && !dstBias)
return get_gmtoff_min(start);
if (start->tm_isdst < 0)
return get_gmtoff_min(start);
struct tm cur = *start;
for (int day = 1; day <= 365; day++)
{
cur = next_day(&cur);
if ((cur.tm_isdst > 0) && dstBias)
return get_gmtoff_min(&cur);
else if ((cur.tm_isdst == 0) && !dstBias)
return get_gmtoff_min(&cur);
}
return 0;
}
static BOOL map_iana_id(const char* iana, LPDYNAMIC_TIME_ZONE_INFORMATION tz)
{
const char* winId = TimeZoneIanaToWindows(iana, TIME_ZONE_NAME_ID);
const char* winStd = TimeZoneIanaToWindows(iana, TIME_ZONE_NAME_STANDARD);
const char* winDst = TimeZoneIanaToWindows(iana, TIME_ZONE_NAME_DAYLIGHT);
if (winStd)
ConvertUtf8ToWChar(winStd, tz->StandardName, ARRAYSIZE(tz->StandardName));
if (winDst)
ConvertUtf8ToWChar(winDst, tz->DaylightName, ARRAYSIZE(tz->DaylightName));
if (winId)
ConvertUtf8ToWChar(winId, tz->TimeZoneKeyName, ARRAYSIZE(tz->TimeZoneKeyName));
return winId != NULL;
}
static const char* weekday2str(WORD wDayOfWeek)
{
switch (wDayOfWeek)
{
case 0:
return "SUNDAY";
case 1:
return "MONDAY";
case 2:
return "TUESDAY";
case 3:
return "WEDNESDAY";
case 4:
return "THURSDAY";
case 5:
return "FRIDAY";
case 6:
return "SATURDAY";
default:
return "DAY-OF-MAGIC";
}
}
static char* systemtime2str(const SYSTEMTIME* t, char* buffer, size_t len)
{
const SYSTEMTIME empty = { 0 };
if (memcmp(t, &empty, sizeof(SYSTEMTIME)) == 0)
(void)_snprintf(buffer, len, "{ not set }");
else
{
(void)_snprintf(buffer, len,
"{ %" PRIu16 "-%" PRIu16 "-%" PRIu16 " [%s] %" PRIu16 ":%" PRIu16
":%" PRIu16 ".%" PRIu16 "}",
t->wYear, t->wMonth, t->wDay, weekday2str(t->wDayOfWeek), t->wHour,
t->wMinute, t->wSecond, t->wMilliseconds);
}
return buffer;
}
static void log_print(wLog* log, DWORD level, const char* file, const char* fkt, size_t line, ...)
{
if (!WLog_IsLevelActive(log, level))
return;
va_list ap;
va_start(ap, line);
WLog_PrintMessageVA(log, WLOG_MESSAGE_TEXT, level, line, file, fkt, ap);
va_end(ap);
}
#define log_timezone(tzif, result) log_timezone_((tzif), (result), __FILE__, __func__, __LINE__)
static void log_timezone_(const DYNAMIC_TIME_ZONE_INFORMATION* tzif, DWORD result, const char* file,
const char* fkt, size_t line)
{
WINPR_ASSERT(tzif);
char buffer[130] = { 0 };
DWORD level = WLOG_TRACE;
wLog* log = WLog_Get(TAG);
log_print(log, level, file, fkt, line, "DYNAMIC_TIME_ZONE_INFORMATION {");
log_print(log, level, file, fkt, line, " Bias=%" PRIu32, tzif->Bias);
ConvertWCharNToUtf8(tzif->StandardName, ARRAYSIZE(tzif->StandardName), buffer,
ARRAYSIZE(buffer));
log_print(log, level, file, fkt, line, " StandardName=%s", buffer);
log_print(log, level, file, fkt, line, " StandardDate=%s",
systemtime2str(&tzif->StandardDate, buffer, sizeof(buffer)));
log_print(log, level, file, fkt, line, " StandardBias=%" PRIu32, tzif->StandardBias);
ConvertWCharNToUtf8(tzif->DaylightName, ARRAYSIZE(tzif->DaylightName), buffer,
ARRAYSIZE(buffer));
log_print(log, level, file, fkt, line, " DaylightName=%s", buffer);
log_print(log, level, file, fkt, line, " DaylightDate=%s",
systemtime2str(&tzif->DaylightDate, buffer, sizeof(buffer)));
log_print(log, level, file, fkt, line, " DaylightBias=%" PRIu32, tzif->DaylightBias);
ConvertWCharNToUtf8(tzif->TimeZoneKeyName, ARRAYSIZE(tzif->TimeZoneKeyName), buffer,
ARRAYSIZE(buffer));
log_print(log, level, file, fkt, line, " TimeZoneKeyName=%s", buffer);
log_print(log, level, file, fkt, line, " DynamicDaylightTimeDisabled=DST-%s",
tzif->DynamicDaylightTimeDisabled ? "disabled" : "enabled");
switch (result)
{
case TIME_ZONE_ID_DAYLIGHT:
log_print(log, level, file, fkt, line, " DaylightDate in use");
break;
case TIME_ZONE_ID_STANDARD:
log_print(log, level, file, fkt, line, " StandardDate in use");
break;
default:
log_print(log, level, file, fkt, line, " UnknownDate in use");
break;
}
log_print(log, level, file, fkt, line, "}");
}
DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation)
{
DYNAMIC_TIME_ZONE_INFORMATION dyn = { 0 };
DWORD rc = GetDynamicTimeZoneInformation(&dyn);
lpTimeZoneInformation->Bias = dyn.Bias;
lpTimeZoneInformation->DaylightBias = dyn.DaylightBias;
lpTimeZoneInformation->DaylightDate = dyn.DaylightDate;
lpTimeZoneInformation->StandardBias = dyn.StandardBias;
lpTimeZoneInformation->StandardDate = dyn.StandardDate;
memcpy(lpTimeZoneInformation->StandardName, dyn.StandardName,
sizeof(lpTimeZoneInformation->StandardName));
memcpy(lpTimeZoneInformation->DaylightName, dyn.DaylightName,
sizeof(lpTimeZoneInformation->DaylightName));
return rc;
}
BOOL SetTimeZoneInformation(const TIME_ZONE_INFORMATION* lpTimeZoneInformation)
{
WINPR_UNUSED(lpTimeZoneInformation);
return FALSE;
}
BOOL SystemTimeToFileTime(const SYSTEMTIME* lpSystemTime, LPFILETIME lpFileTime)
{
WINPR_UNUSED(lpSystemTime);
WINPR_UNUSED(lpFileTime);
return FALSE;
}
BOOL FileTimeToSystemTime(const FILETIME* lpFileTime, LPSYSTEMTIME lpSystemTime)
{
WINPR_UNUSED(lpFileTime);
WINPR_UNUSED(lpSystemTime);
return FALSE;
}
BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION lpTimeZone,
LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime)
{
WINPR_UNUSED(lpTimeZone);
WINPR_UNUSED(lpUniversalTime);
WINPR_UNUSED(lpLocalTime);
return FALSE;
}
BOOL TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
LPSYSTEMTIME lpLocalTime, LPSYSTEMTIME lpUniversalTime)
{
WINPR_UNUSED(lpTimeZoneInformation);
WINPR_UNUSED(lpLocalTime);
WINPR_UNUSED(lpUniversalTime);
return FALSE;
}
#endif
/*
* GetDynamicTimeZoneInformation is provided by the SDK if _WIN32_WINNT >= 0x0600 in SDKs above 7.1A
* and incorrectly if _WIN32_WINNT >= 0x0501 in older SDKs
*/
#if !defined(_WIN32) || \
(defined(_WIN32) && (defined(NTDDI_WIN8) && _WIN32_WINNT < 0x0600 || \
!defined(NTDDI_WIN8) && _WIN32_WINNT < 0x0501)) /* Windows Vista */
typedef enum
{
HAVE_TRANSITION_DATES = 0,
HAVE_NO_STANDARD_TRANSITION_DATE = 1,
HAVE_NO_DAYLIGHT_TRANSITION_DATE = 2
} dyn_transition_result;
static int dynamic_time_zone_from_localtime(const struct tm* local_time,
PDYNAMIC_TIME_ZONE_INFORMATION tz)
{
WINPR_ASSERT(local_time);
WINPR_ASSERT(tz);
int rc = HAVE_TRANSITION_DATES;
tz->Bias = get_bias(local_time, FALSE);
if (local_time->tm_isdst >= 0)
{
/* DST bias is the difference between standard time and DST in minutes */
const LONG d = get_bias(local_time, TRUE);
tz->DaylightBias = -1 * labs(tz->Bias - d);
if (!get_transition_date(local_time, FALSE, &tz->StandardDate))
rc |= HAVE_NO_STANDARD_TRANSITION_DATE;
if (!get_transition_date(local_time, TRUE, &tz->DaylightDate))
rc |= HAVE_NO_DAYLIGHT_TRANSITION_DATE;
}
return rc;
}
DWORD GetDynamicTimeZoneInformation(PDYNAMIC_TIME_ZONE_INFORMATION tz)
{
BOOL doesNotHaveStandardDate = FALSE;
BOOL doesNotHaveDaylightDate = FALSE;
const char** list = NULL;
char* tzid = NULL;
const char* defaultName = "Client Local Time";
DWORD res = TIME_ZONE_ID_UNKNOWN;
const DYNAMIC_TIME_ZONE_INFORMATION empty = { 0 };
WINPR_ASSERT(tz);
*tz = empty;
ConvertUtf8ToWChar(defaultName, tz->StandardName, ARRAYSIZE(tz->StandardName));
const time_t t = time(NULL);
struct tm tres = { 0 };
struct tm* local_time = localtime_r(&t, &tres);
if (!local_time)
goto out_error;
tz->Bias = get_bias(local_time, FALSE);
if (local_time->tm_isdst >= 0)
{
const int rc = dynamic_time_zone_from_localtime(local_time, tz);
if (rc & HAVE_NO_STANDARD_TRANSITION_DATE)
doesNotHaveStandardDate = TRUE;
if (rc & HAVE_NO_DAYLIGHT_TRANSITION_DATE)
doesNotHaveDaylightDate = TRUE;
}
tzid = winpr_guess_time_zone();
if (!map_iana_id(tzid, tz))
{
const size_t len = TimeZoneIanaAbbrevGet(local_time->tm_zone, NULL, 0);
list = calloc(len, sizeof(char*));
if (!list)
goto out_error;
const size_t size = TimeZoneIanaAbbrevGet(local_time->tm_zone, list, len);
for (size_t x = 0; x < size; x++)
{
const char* id = list[x];
if (map_iana_id(id, tz))
{
res = (local_time->tm_isdst) ? TIME_ZONE_ID_DAYLIGHT : TIME_ZONE_ID_STANDARD;
break;
}
}
}
else
res = (local_time->tm_isdst) ? TIME_ZONE_ID_DAYLIGHT : TIME_ZONE_ID_STANDARD;
if (doesNotHaveDaylightDate)
tz->DaylightBias = 0;
if (doesNotHaveStandardDate)
tz->StandardBias = 0;
out_error:
free(tzid);
free(list);
log_timezone(tz, res);
return res;
}
BOOL SetDynamicTimeZoneInformation(const DYNAMIC_TIME_ZONE_INFORMATION* lpTimeZoneInformation)
{
WINPR_UNUSED(lpTimeZoneInformation);
return FALSE;
}
BOOL GetTimeZoneInformationForYear(USHORT wYear, PDYNAMIC_TIME_ZONE_INFORMATION pdtzi,
LPTIME_ZONE_INFORMATION ptzi)
{
WINPR_UNUSED(wYear);
WINPR_UNUSED(pdtzi);
WINPR_UNUSED(ptzi);
return FALSE;
}
#endif
#if !defined(_WIN32) || (defined(_WIN32) && (_WIN32_WINNT < 0x0601)) /* Windows 7 */
BOOL SystemTimeToTzSpecificLocalTimeEx(const DYNAMIC_TIME_ZONE_INFORMATION* lpTimeZoneInformation,
const SYSTEMTIME* lpUniversalTime, LPSYSTEMTIME lpLocalTime)
{
WINPR_UNUSED(lpTimeZoneInformation);
WINPR_UNUSED(lpUniversalTime);
WINPR_UNUSED(lpLocalTime);
return FALSE;
}
BOOL TzSpecificLocalTimeToSystemTimeEx(const DYNAMIC_TIME_ZONE_INFORMATION* lpTimeZoneInformation,
const SYSTEMTIME* lpLocalTime, LPSYSTEMTIME lpUniversalTime)
{
WINPR_UNUSED(lpTimeZoneInformation);
WINPR_UNUSED(lpLocalTime);
WINPR_UNUSED(lpUniversalTime);
return FALSE;
}
#endif
#if !defined(_WIN32)
DWORD EnumDynamicTimeZoneInformation(const DWORD dwIndex,
PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation)
{
if (!lpTimeZoneInformation)
return ERROR_INVALID_PARAMETER;
const DYNAMIC_TIME_ZONE_INFORMATION empty = { 0 };
*lpTimeZoneInformation = empty;
const TimeZoneNameMapEntry* entry = TimeZoneGetAt(dwIndex);
if (!entry)
return ERROR_NO_MORE_ITEMS;
if (entry->DaylightName)
ConvertUtf8ToWChar(entry->DaylightName, lpTimeZoneInformation->DaylightName,
ARRAYSIZE(lpTimeZoneInformation->DaylightName));
if (entry->StandardName)
ConvertUtf8ToWChar(entry->StandardName, lpTimeZoneInformation->StandardName,
ARRAYSIZE(lpTimeZoneInformation->StandardName));
if (entry->Id)
ConvertUtf8ToWChar(entry->Id, lpTimeZoneInformation->TimeZoneKeyName,
ARRAYSIZE(lpTimeZoneInformation->TimeZoneKeyName));
const time_t t = time(NULL);
struct tm tres = { 0 };
const char* tz = getenv("TZ");
char* tzcopy = NULL;
if (tz)
{
size_t tzianalen = 0;
winpr_asprintf(&tzcopy, &tzianalen, "TZ=%s", tz);
}
char* tziana = NULL;
{
size_t tzianalen = 0;
winpr_asprintf(&tziana, &tzianalen, "TZ=%s", entry->Iana);
}
if (tziana)
putenv(tziana);
tzset();
struct tm* local_time = localtime_r(&t, &tres);
free(tziana);
if (tzcopy)
putenv(tzcopy);
else
unsetenv("TZ");
free(tzcopy);
if (local_time)
dynamic_time_zone_from_localtime(local_time, lpTimeZoneInformation);
return ERROR_SUCCESS;
}
DWORD GetDynamicTimeZoneInformationEffectiveYears(
const PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation, LPDWORD FirstYear, LPDWORD LastYear)
{
WINPR_UNUSED(lpTimeZoneInformation);
WINPR_UNUSED(FirstYear);
WINPR_UNUSED(LastYear);
return ERROR_FILE_NOT_FOUND;
}
#elif _WIN32_WINNT < 0x0602 /* Windows 8 */
DWORD EnumDynamicTimeZoneInformation(const DWORD dwIndex,
PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation)
{
WINPR_UNUSED(dwIndex);
WINPR_UNUSED(lpTimeZoneInformation);
return ERROR_NO_MORE_ITEMS;
}
DWORD GetDynamicTimeZoneInformationEffectiveYears(
const PDYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation, LPDWORD FirstYear, LPDWORD LastYear)
{
WINPR_UNUSED(lpTimeZoneInformation);
WINPR_UNUSED(FirstYear);
WINPR_UNUSED(LastYear);
return ERROR_FILE_NOT_FOUND;
}
#endif