qtimezoneprivate_win.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2013 John Layt <jlayt@kde.org>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include "qtimezone.h"
#include "qtimezoneprivate_p.h"
 
#include "qdatetime.h"
#include "qdebug.h"
#include <private/qnumeric_p.h>
#include <private/wcharhelpers_win_p.h>
 
#include <algorithm>
#include <optional>
 
#include <private/qwinregistry_p.h>
 
QT_REQUIRE_CONFIG(timezone_locale);
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
/*
    Private
 
    Windows system implementation
*/
 
#define MAX_KEY_LENGTH 255
 
// MSDN home page for Time support
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms724962%28v=vs.85%29.aspx
 
// For Windows XP and later refer to MSDN docs on TIME_ZONE_INFORMATION structure
// http://msdn.microsoft.com/en-gb/library/windows/desktop/ms725481%28v=vs.85%29.aspx
 
// Vista introduced support for historic data, see MSDN docs on DYNAMIC_TIME_ZONE_INFORMATION
// http://msdn.microsoft.com/en-gb/library/windows/desktop/ms724253%28v=vs.85%29.aspx
static const wchar_t tzRegPath[] = LR"(SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones)";
static const wchar_t currTzRegPath[] = LR"(SYSTEM\CurrentControlSet\Control\TimeZoneInformation)";
 
constexpr qint64 MSECS_PER_DAY = 86400000LL;
constexpr qint64 JULIAN_DAY_FOR_EPOCH = 2440588LL; // result of julianDayFromDate(1970, 1, 1)
 
/* Ignore any claims of DST before 1900.
 
   Daylight-Saving time adjustments were first proposed in 1895 (George Vernon
   Hudson in New Zealand) and 1905 (William Willett in the UK) and first adopted
   in 1908 (one town in Ontario, Canada) and 1916 (Germany).  Since MS's data
   tends to pretend the rules in force in 1970ish (or later) had always been in
   effect, which presents difficulties for the code that selects correct data
   (for a time close to the earliest we can represent), always ignore any claim
   a first rule may make of DST starting any time before 1900.
 
   For southern-hemisphere zones, this implies that a rule claiming 1900 started
   in DST is overruled to merely start DST later in 1900, having spent the whole
   part of 1900 prior to that in standard time. This erases 1900's earlier
   transition out of daylight-saving time so as to prevent a fake change of
   offset at the start of the year, since 1899 shall be treated as observing
   standard time throughout.
 
   In the unlikely event of MS supplying a change in standard time before 1900,
   however, that should be faithfully represented. If that ever happens, trust
   that MS gets the start year of any subsequend DST right.
 
   See:
   * https://www.timeanddate.com/time/dst/history.html
   * https://en.wikipedia.org/wiki/Daylight_saving_time#History
*/
constexpr int FIRST_DST_YEAR = 1900;
 
// Copied from MSDN, see above for link
typedef struct _REG_TZI_FORMAT
{
    LONG Bias;
    LONG StandardBias;
    LONG DaylightBias;
    SYSTEMTIME StandardDate;
    SYSTEMTIME DaylightDate;
} REG_TZI_FORMAT;
 
namespace {
 
// Fast and reliable conversion from msecs to date for all values
// Adapted from QDateTime msecsToDate
QDate msecsToDate(qint64 msecs)
{
    qint64 jd = JULIAN_DAY_FOR_EPOCH;
    // Corner case: don't use qAbs() because msecs may be numeric_limits<qint64>::min()
    if (msecs >= MSECS_PER_DAY || msecs <= -MSECS_PER_DAY) {
        jd += msecs / MSECS_PER_DAY;
        msecs %= MSECS_PER_DAY;
    }
 
    if (msecs < 0) {
        Q_ASSERT(msecs > -MSECS_PER_DAY);
        --jd;
    }
 
    return QDate::fromJulianDay(jd);
}
 
bool equalSystemtime(const SYSTEMTIME &t1, const SYSTEMTIME &t2)
{
    return (t1.wYear == t2.wYear
            && t1.wMonth == t2.wMonth
            && t1.wDay == t2.wDay
            && t1.wDayOfWeek == t2.wDayOfWeek
            && t1.wHour == t2.wHour
            && t1.wMinute == t2.wMinute
            && t1.wSecond == t2.wSecond
            && t1.wMilliseconds == t2.wMilliseconds);
}
 
bool equalTzi(const TIME_ZONE_INFORMATION &tzi1, const TIME_ZONE_INFORMATION &tzi2)
{
    return(tzi1.Bias == tzi2.Bias
           && tzi1.StandardBias == tzi2.StandardBias
           && equalSystemtime(tzi1.StandardDate, tzi2.StandardDate)
           && wcscmp(tzi1.StandardName, tzi2.StandardName) == 0
           && tzi1.DaylightBias == tzi2.DaylightBias
           && equalSystemtime(tzi1.DaylightDate, tzi2.DaylightDate)
           && wcscmp(tzi1.DaylightName, tzi2.DaylightName) == 0);
}
 
QWinTimeZonePrivate::QWinTransitionRule readRegistryRule(const HKEY &key,
                                                         const wchar_t *value, bool *ok)
{
    *ok = false;
    QWinTimeZonePrivate::QWinTransitionRule rule;
    REG_TZI_FORMAT tzi;
    DWORD tziSize = sizeof(tzi);
    if (RegQueryValueEx(key, value, nullptr, nullptr, reinterpret_cast<BYTE *>(&tzi), &tziSize)
        == ERROR_SUCCESS) {
        Q_ASSERT(tziSize == sizeof(tzi));
        rule.startYear = 0;
        rule.standardTimeBias = tzi.Bias + tzi.StandardBias;
        rule.daylightTimeBias = tzi.Bias + tzi.DaylightBias - rule.standardTimeBias;
        rule.standardTimeRule = tzi.StandardDate;
        rule.daylightTimeRule = tzi.DaylightDate;
        *ok = true;
    }
    return rule;
}
 
TIME_ZONE_INFORMATION getRegistryTzi(const QByteArray &windowsId, bool *ok)
{
    *ok = false;
    TIME_ZONE_INFORMATION tzi;
    REG_TZI_FORMAT regTzi;
    const QString tziKeyPath = QString::fromWCharArray(tzRegPath) + u'\\'
                               + QString::fromUtf8(windowsId);
 
    QWinRegistryKey key(HKEY_LOCAL_MACHINE, tziKeyPath);
    if (key.isValid()) {
        auto regQuery = [&key](const wchar_t *entry, auto buffer, size_t space) {
            std::optional<size_t> res;
            DWORD size = DWORD(space);
            if (RegQueryValueEx(key, entry, nullptr, nullptr,
                                reinterpret_cast<LPBYTE>(buffer), &size) == ERROR_SUCCESS) {
                res = size_t(size);
            }
            return res;
        };
        auto regStrQuery = [&regQuery](const wchar_t *entry, auto buffer, size_t space) {
            // TODO: MS docs say RegGetValue() would be better for string values.
            if (auto res = regQuery(entry, buffer, space); !res)
                buffer[0] = L'\0';
            else if (*res >= space) // ensure '\0' termination, albeit by truncation:
                buffer[space / sizeof(buffer[0]) - 1] = L'\0';
        };
        regStrQuery(L"Dlt", tzi.DaylightName, sizeof(tzi.DaylightName));
        regStrQuery(L"Std", tzi.StandardName, sizeof(tzi.StandardName));
        if (auto res = regQuery(L"TZI", &regTzi, sizeof(regTzi))) {
            Q_ASSERT(*res == sizeof(regTzi));
            tzi.Bias = regTzi.Bias;
            tzi.StandardBias = regTzi.StandardBias;
            tzi.DaylightBias = regTzi.DaylightBias;
            tzi.StandardDate = regTzi.StandardDate;
            tzi.DaylightDate = regTzi.DaylightDate;
            *ok = true;
        }
    }
 
    return tzi;
}
 
bool isSameRule(const QWinTimeZonePrivate::QWinTransitionRule &last,
                       const QWinTimeZonePrivate::QWinTransitionRule &rule)
{
    // In particular, when this is true and either wYear is 0, so is the other;
    // so if one rule is recurrent and they're equal, so is the other.  If
    // either rule *isn't* recurrent, it has non-0 wYear which shall be
    // different from the other's.  Note that we don't compare .startYear, since
    // that will always be different.
    return equalSystemtime(last.standardTimeRule, rule.standardTimeRule)
        && equalSystemtime(last.daylightTimeRule, rule.daylightTimeRule)
        && last.standardTimeBias == rule.standardTimeBias
        && last.daylightTimeBias == rule.daylightTimeBias;
}
 
QList<QByteArray> availableWindowsIds()
{
    static const QList<QByteArray> cache = [] {
        QList<QByteArray> list;
        QWinRegistryKey key(HKEY_LOCAL_MACHINE, tzRegPath);
        if (key.isValid()) {
            DWORD idCount = 0;
            if (RegQueryInfoKey(key, 0, 0, 0, &idCount, 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS
                && idCount > 0) {
                for (DWORD i = 0; i < idCount; ++i) {
                    DWORD maxLen = MAX_KEY_LENGTH;
                    TCHAR buffer[MAX_KEY_LENGTH];
                    if (RegEnumKeyEx(key, i, buffer, &maxLen, 0, 0, 0, 0) == ERROR_SUCCESS)
                        list.append(QString::fromWCharArray(buffer).toUtf8());
                }
            }
        }
        return list;
    }();
    return cache;
}
 
QByteArray windowsSystemZoneId()
{
    // On Vista and later is held in the value TimeZoneKeyName in key currTzRegPath
    const QString id = QWinRegistryKey(HKEY_LOCAL_MACHINE, currTzRegPath)
                       .stringValue(L"TimeZoneKeyName");
    if (!id.isEmpty())
        return id.toUtf8();
 
    // On XP we have to iterate over the zones until we find a match on
    // names/offsets with the current data
    TIME_ZONE_INFORMATION sysTzi;
    if (GetTimeZoneInformation(&sysTzi) != TIME_ZONE_ID_INVALID) {
        bool ok = false;
        const auto winIds = availableWindowsIds();
        for (const QByteArray &winId : winIds) {
            if (equalTzi(getRegistryTzi(winId, &ok), sysTzi) && ok)
                return winId;
        }
    }
 
    // If we can't determine the current ID use UTC
    return QTimeZonePrivate::utcQByteArray();
}
 
QDate calculateTransitionLocalDate(const SYSTEMTIME &rule, int year)
{
    // If month is 0 then there is no date
    if (rule.wMonth == 0)
        return QDate();
 
    // Interpret SYSTEMTIME according to the slightly quirky rules in:
    // https://msdn.microsoft.com/en-us/library/windows/desktop/ms725481(v=vs.85).aspx
    Q_ASSERT(rule.wMonth > 0 && rule.wMonth <= 12);
 
    // If the year is set, the rule gives an absolute date:
    if (rule.wYear)
        return QDate(rule.wYear, rule.wMonth, rule.wDay);
 
    // Otherwise, the rule date is annual and relative:
    Q_ASSERT(rule.wDayOfWeek >= 0 && rule.wDayOfWeek < 7);
    const int dayOfWeek = rule.wDayOfWeek == 0 ? 7 : rule.wDayOfWeek;
    QDate date(year, rule.wMonth, 1);
    Q_ASSERT(date.isValid());
    // How many days before was last dayOfWeek before target month ?
    int adjust = dayOfWeek - date.dayOfWeek(); // -6 <= adjust < 7
    if (adjust >= 0) // Ensure -7 <= adjust < 0:
        adjust -= 7;
    // Normally, wDay is day-within-month; but here it is 1 for the first
    // of the given dayOfWeek in the month, through 4 for the fourth or ...
    adjust += (rule.wDay < 1 ? 1 : rule.wDay > 4 ? 5 : rule.wDay) * 7;
    date = date.addDays(adjust);
    // ... 5 for the last; so back up by weeks to get within the month:
    if (date.month() != rule.wMonth) {
        Q_ASSERT(rule.wDay > 4);
        // (Note that, with adjust < 0, date <= 28th of our target month
        // is guaranteed when wDay <= 4, or after our first -7 here.)
        date = date.addDays(-7);
        Q_ASSERT(date.month() == rule.wMonth);
    }
    return date;
}
 
// Converts a date/time value into msecs, returns true on overflow:
inline bool timeToMSecs(QDate date, QTime time, qint64 *msecs)
{
    qint64 dayms = 0;
    qint64 daySinceEpoch = date.toJulianDay() - JULIAN_DAY_FOR_EPOCH;
    qint64 msInDay = time.msecsSinceStartOfDay();
    if (daySinceEpoch < 0 && msInDay > 0) {
        // In the earliest day with representable parts, take care to not
        // underflow before an addition that would have fixed it.
        ++daySinceEpoch;
        msInDay -= MSECS_PER_DAY;
    }
    return qMulOverflow(daySinceEpoch, std::integral_constant<qint64, MSECS_PER_DAY>(), &dayms)
        || qAddOverflow(dayms, msInDay, msecs);
}
 
qint64 calculateTransitionForYear(const SYSTEMTIME &rule, int year, int bias)
{
    // TODO Consider caching the calculated values - i.e. replace SYSTEMTIME in
    // WinTransitionRule; do this in init() once and store the results.
    Q_ASSERT(year);
    const QDate date = calculateTransitionLocalDate(rule, year);
    const QTime time = QTime(rule.wHour, rule.wMinute, rule.wSecond);
    qint64 msecs = 0;
    if (date.isValid() && time.isValid() && !timeToMSecs(date, time, &msecs)) {
        // If bias pushes us outside the representable range, clip to range
        // (overflow went past the end bias pushed us towards; and
        // invalidMSecs() is a representable value less than minMSecs()):
        return bias && qAddOverflow(msecs, qint64(bias) * 60000, &msecs)
            ? (bias < 0 ? QTimeZonePrivate::minMSecs() : QTimeZonePrivate::maxMSecs())
            : qMax(QTimeZonePrivate::minMSecs(), msecs);
    }
    return QTimeZonePrivate::invalidMSecs();
}
 
// True precisely if transition represents the start of the year.
bool isAtStartOfYear(const SYSTEMTIME &transition, int year)
{
    /*
      Note that, here, wDay identifies an instance of a given day-of-week in the
      month, with 5 meaning last. (December 31st is, incidentally, always the
      fifth instance of its day of the week in its month. But we aren't testing
      that - see below.)
 
      QDate represents Sunday by 7, SYSTEMTIME by 0; so compare day of the week
      by taking difference mod 7.
    */
    return transition.wMonth == 1 && transition.wDay == 1
        && (QDate(year, 1, 1).dayOfWeek() - transition.wDayOfWeek) % 7 == 0
        && transition.wHour == 0 && transition.wMinute == 0 && transition.wSecond == 0;
}
 
struct TransitionTimePair
{
    // Transition times, in ms:
    qint64 std, dst;
    // If either is invalidMSecs(), which shall then be < the other, there is no
    // DST and the other describes a change in actual standard offset.
    bool fakesDst = false;
 
    TransitionTimePair(const QWinTimeZonePrivate::QWinTransitionRule &rule,
                       int year, int oldYearOffset)
        // The local time in Daylight Time of the switch to Standard Time
        : std(calculateTransitionForYear(rule.standardTimeRule, year,
                                         rule.standardTimeBias + rule.daylightTimeBias)),
          // The local time in Standard Time of the switch to Daylight Time
          dst(calculateTransitionForYear(rule.daylightTimeRule, year, rule.standardTimeBias))
    {
        /*
          Check for potential "fake DST", used by MS's APIs because the
          TIME_ZONE_INFORMATION spec either expresses no transitions in the
          year, or expresses a transition of each kind, even if standard time
          did change in a year with no DST.  We've seen year-start fake-DST
          (whose offset matches prior standard offset, in which the previous
          year ended).
 
          It is possible there might also be year-end fake-DST but Bangladesh
          toyed with DST from 2009-06-19 (a Friday) at 23:00 until, according to
          the Olson database, 2009-12-32 24:00; however, MS represents that by
          the last millisecond of the year, technically a millisecond early. (MS
          falsely claims Bhutan did the same.) So we do not attempt to detect an
          end-of-year fake transition; nor is there any reason to suppose MS
          would need to do that, as anything it could implement thereby could
          equally be implemented by a start-of-year fake.
 
          A fake transition at the start of the year tells us what the offset at
          the start of the year is; if this doesn't match the offset in effect
          at the end of the previous year, then it's a real transition. If it
          does match, then we have a fake transition. (A fake transition of one
          kind at the end of the year would be paired with a real transition,
          allegedly of the other kind, part way through the year; that would be
          a transition away from the offset that would nominally be restored by
          the fake so, again, the year would have started with the post-fake
          offset in effect.)
 
          Either the alleged standardTimeRule or the alleged daylightTimeRule
          may be faked; either way, the transition is actually a change to the
          current standard offset; but the unfaked half of the rule contains the
          useful bias data, so we have to go along with its lies. Clients of
          this class should still use DaylightTime and StandardTime as if the
          fake were not a lie, selecting which side of the real transition to
          use the data for, and ruleToData() will take care of extracting the
          right offset based on that, while tagging the resulting Data as
          standard time.
 
          Example: Russia/Moscow
          Format: -bias +( -stdBias, stdDate | -dstBias, dstDate ) notes
          Last year of DST, 2010: 180 +( 0, 0-10-5 3:0 | 60, 0-3-5 2:0 ) normal DST
          Zone change in 2011: 180 +( 0, 0-1-1 0:0 | 60 0-3-5 2:0 ) fake DST at transition
          Fixed standard in 2012: 240 +( 0, 0-0-0 0:0 | 60, 0-0-0 0:0 ) standard time years
          Zone change in 2014: 180 +( 0, 0-10-5 2:0 | 60, 0-1-1 0:0 ) fake DST at year-start
          The last of these is missing on Win7 VMs (too old to know about it).
        */
        if (rule.standardTimeBias + rule.daylightTimeBias == oldYearOffset
            && isAtStartOfYear(rule.daylightTimeRule, year)) {
            dst = QTimeZonePrivate::invalidMSecs();
            fakesDst = true;
        }
        if (rule.standardTimeBias == oldYearOffset
            && isAtStartOfYear(rule.standardTimeRule, year)) {
            Q_ASSERT_X(!fakesDst, "TransitionTimePair",
                       "Year with (DST bias zero and) both transitions fake !");
            std = QTimeZonePrivate::invalidMSecs();
            fakesDst = true;
        }
    }
 
    bool startsInDst() const
    {
        // Year starts in daylightTimeRule iff it has a valid transition out of
        // DST with no earlier valid transition into it.
        return std != QTimeZonePrivate::invalidMSecs()
            && (std < dst || dst == QTimeZonePrivate::invalidMSecs());
    }
 
    // Returns true if (assuming this pair was derived from the first rule, and
    // that has non-zero wMonth values, so is a DST-recurrence or faking it) the
    // given millis, presumed to be in the given year, is before the first
    // transition into DST.
    bool beforeInitialDst(int year, qint64 millis) const
    {
        return !fakesDst && (year == FIRST_DST_YEAR ? millis < dst : year < FIRST_DST_YEAR);
    }
 
    QTimeZonePrivate::Data ruleToData(const QWinTimeZonePrivate::QWinTransitionRule &rule,
                                      const QWinTimeZonePrivate *tzp, bool isDst) const
    {
        const auto type = isDst ? QTimeZone::DaylightTime : QTimeZone::StandardTime;
        auto time = isDst ? dst : std;
        // The isDst we're asked for may be set to the valid one of dst and
        // std, when fake, but not always - so make sure:
        if (fakesDst && time == QTimeZonePrivate::invalidMSecs())
            time = isDst ? std : dst;
        return tzp->ruleToData(rule, time, type, fakesDst);
    }
};
 
int yearEndOffset(const QWinTimeZonePrivate::QWinTransitionRule &rule, int year)
{
    Q_ASSERT(year);
    int offset = rule.standardTimeBias;
    // Only needed to help another TransitionTimePair work out year + 1's start
    // offset; and the oldYearOffset we use only affects an alleged transition
    // at the *start* of this year, so it doesn't matter if we guess wrong here:
    TransitionTimePair pair(rule, year, offset);
    if (pair.dst > pair.std)
        offset += rule.daylightTimeBias;
    return offset;
}
 
QLocale::Territory userTerritory()
{
    const GEOID id = GetUserGeoID(GEOCLASS_NATION);
    wchar_t code[3];
    const int size = GetGeoInfo(id, GEO_ISO2, code, 3, 0);
    return (size == 3) ? QLocalePrivate::codeToTerritory(QStringView(code, size))
                       : QLocale::AnyTerritory;
}
 
// Index of last rule in rules with .startYear <= year, or 0 if all > year.
int ruleIndexForYear(const QList<QWinTimeZonePrivate::QWinTransitionRule> &rules, int year)
{
    Q_ASSERT(!rules.isEmpty()); // Ensured by caller's isValid().
    if (rules.last().startYear <= year)
        return rules.count() - 1;
    // We don't have a rule for before the first, but the first is the best we can offer:
    if (rules.first().startYear > year)
        return 0;
 
    // Otherwise, use binary chop:
    int lo = 0, hi = rules.count();
    // invariant: rules[i].startYear <= year < rules[hi].startYear
    // subject to treating rules[rules.count()] as "off the end of time"
    while (lo + 1 < hi) {
        const int mid = (lo + hi) / 2;
        // lo + 2 <= hi, so lo + 1 <= mid <= hi - 1, so lo < mid < hi
        // In particular, mid < rules.count()
        const int midYear = rules.at(mid).startYear;
        if (midYear > year)
            hi = mid;
        else if (midYear < year)
            lo = mid;
        else // No two rules have the same startYear:
            return mid;
    }
    return lo;
}
 
} // anonymous namespace
 
// Create the system default time zone
QWinTimeZonePrivate::QWinTimeZonePrivate()
                   : QTimeZonePrivate()
{
    init(QByteArray());
}
 
// Create a named time zone
QWinTimeZonePrivate::QWinTimeZonePrivate(const QByteArray &ianaId)
                   : QTimeZonePrivate()
{
    init(ianaId);
}
 
QWinTimeZonePrivate::~QWinTimeZonePrivate()
{
}
 
QWinTimeZonePrivate *QWinTimeZonePrivate::clone() const
{
    return new QWinTimeZonePrivate(*this);
}
 
void QWinTimeZonePrivate::init(const QByteArray &ianaId)
{
    if (ianaId.isEmpty()) {
        m_windowsId = windowsSystemZoneId();
        m_id = systemTimeZoneId();
    } else {
        m_windowsId = ianaIdToWindowsId(ianaId).toByteArray();
        m_id = ianaId;
    }
    const auto initialYear = [](const QWinTransitionRule &rule) {
        // Only applicable to the first rule, and only if not faking DST.
        // The rule starts in FIRST_DST_YEAR if it is a DST recurrence (with
        // non-zero wMonth fields), otherwise read as a constant
        // offset rule dating back to the start of time.
        return (rule.standardTimeRule.wMonth > 0 || rule.daylightTimeRule.wMonth > 0
                ? FIRST_DST_YEAR : int(QDateTime::YearRange::First));
    };
 
    bool badMonth = false; // Only warn once per zone, if at all.
    if (!m_windowsId.isEmpty()) {
        // Open the base TZI for the time zone
        const QString baseKeyPath = QString::fromWCharArray(tzRegPath) + u'\\'
                                   + QString::fromUtf8(m_windowsId);
        QWinRegistryKey baseKey(HKEY_LOCAL_MACHINE, baseKeyPath);
        if (baseKey.isValid()) {
            //  Load the localized names
            m_displayName = baseKey.stringValue(L"Display");
            m_standardName = baseKey.stringValue(L"Std");
            m_daylightName = baseKey.stringValue(L"Dlt");
            // On Vista and later the optional dynamic key holds historic data
            const QString dynamicKeyPath = baseKeyPath + "\\Dynamic DST"_L1;
            QWinRegistryKey dynamicKey(HKEY_LOCAL_MACHINE, dynamicKeyPath);
            if (dynamicKey.isValid()) {
                // See QLocalTime::computeSystemMillisRange():
                constexpr int YearBoundMin = 1970, YearBoundMax = 3000;
                // Find out the start and end years stored, then iterate over them
                const int startYear = dynamicKey.value<int>(L"FirstEntry").value_or(YearBoundMin);
                Q_ASSERT(startYear >= YearBoundMin);
                const int endYear = dynamicKey.value<int>(L"LastEntry").value_or(YearBoundMax);
                Q_ASSERT(endYear <= YearBoundMax);
                for (int year = startYear; year <= endYear; ++year) {
                    bool ruleOk;
                    QWinTransitionRule rule = readRegistryRule(dynamicKey,
                                                               qt_castToWchar(QString::number(year)),
                                                               &ruleOk);
                    if (ruleOk
                        // Don't repeat a recurrent rule:
                        && (m_tranRules.isEmpty()
                            || !isSameRule(m_tranRules.last(), rule))) {
                        if (!badMonth
                            && (rule.standardTimeRule.wMonth == 0)
                            != (rule.daylightTimeRule.wMonth == 0)) {
                            badMonth = true;
                            qWarning("MS registry TZ API violated its wMonth constraint;"
                                     "this may cause mistakes for %s from %d",
                                     ianaId.constData(), year);
                        }
                        const TransitionTimePair pair(rule, year, rule.standardTimeBias);
                        // First rule may be a standard offset change, for which fakesDst is true.
                        rule.startYear
                            = m_tranRules.size() || pair.fakesDst ? year : initialYear(rule);
                        m_tranRules.append(rule);
                    }
                }
            } else {
                // No dynamic data so use the base data
                bool ruleOk;
                QWinTransitionRule rule = readRegistryRule(baseKey, L"TZI", &ruleOk);
                if (ruleOk) {
                    rule.startYear = initialYear(rule);
                    m_tranRules.append(rule);
                }
            }
        }
    }
 
    // If there are no rules then we failed to find a windowsId or any tzi info
    if (m_tranRules.isEmpty()) {
        m_id.clear();
        m_windowsId.clear();
        m_displayName.clear();
    } else if (m_id.isEmpty()) {
        m_id = m_standardName.toUtf8();
    }
}
 
QString QWinTimeZonePrivate::comment() const
{
    return m_displayName;
}
 
QString QWinTimeZonePrivate::displayName(QTimeZone::TimeType timeType,
                                         QTimeZone::NameType nameType,
                                         const QLocale &locale) const
{
    // Registry gave us long names for the system locale:
    if (nameType == QTimeZone::LongName && locale == QLocale::system()) {
        switch (timeType) {
        case  QTimeZone::DaylightTime :
            return m_daylightName;
        case  QTimeZone::GenericTime :
            return m_displayName;
        case  QTimeZone::StandardTime :
            return m_standardName;
        }
    }
    // Fall back to base class for everything else.
    return QTimeZonePrivate::displayName(timeType, nameType, locale);;
}
 
QString QWinTimeZonePrivate::abbreviation(qint64 atMSecsSinceEpoch) const
{
    return data(atMSecsSinceEpoch).abbreviation;
}
 
int QWinTimeZonePrivate::offsetFromUtc(qint64 atMSecsSinceEpoch) const
{
    return data(atMSecsSinceEpoch).offsetFromUtc;
}
 
int QWinTimeZonePrivate::standardTimeOffset(qint64 atMSecsSinceEpoch) const
{
    return data(atMSecsSinceEpoch).standardTimeOffset;
}
 
int QWinTimeZonePrivate::daylightTimeOffset(qint64 atMSecsSinceEpoch) const
{
    return data(atMSecsSinceEpoch).daylightTimeOffset;
}
 
bool QWinTimeZonePrivate::hasDaylightTime() const
{
    // The Windows data doesn't tell us unambiguously about whether a transition
    // is to or from daylight-saving time, so at best we can know whether it has
    // done any transitions. These might be one-off changes to standard time,
    // though. We could perhaps check to see if it's done several transitions,
    // but a zone might have tried DST briefly and changed its mind quickly.
    for (const QWinTransitionRule &rule : m_tranRules) {
        if (rule.standardTimeRule.wMonth > 0 && rule.daylightTimeRule.wMonth > 0)
            return true;
    }
    return false;
}
 
bool QWinTimeZonePrivate::isDaylightTime(qint64 atMSecsSinceEpoch) const
{
    return (data(atMSecsSinceEpoch).daylightTimeOffset != 0);
}
 
QTimeZonePrivate::Data QWinTimeZonePrivate::data(qint64 forMSecsSinceEpoch) const
{
    Q_ASSERT(isValid()); // => !m_tranRules.isEmpty()
    int year = msecsToDate(forMSecsSinceEpoch).year();
    for (int ruleIndex = ruleIndexForYear(m_tranRules, year);
         ruleIndex >= 0; --ruleIndex) {
        const QWinTransitionRule &rule = m_tranRules.at(ruleIndex);
        Q_ASSERT(ruleIndex == 0 || year >= rule.startYear);
        if (year < rule.startYear
            || !(rule.standardTimeRule.wMonth > 0 || rule.daylightTimeRule.wMonth > 0)) {
            // No transition (or before first rule), no DST, use the rule's standard time.
            return ruleToData(rule, forMSecsSinceEpoch, QTimeZone::StandardTime);
        }
 
        int prior = year == 1 ? -1 : year - 1; // No year 0.
        const int endYear = qMax(rule.startYear, prior);
        while (year >= endYear) {
            const int newYearOffset = (prior < rule.startYear && ruleIndex > 0)
                ? yearEndOffset(m_tranRules.at(ruleIndex - 1), prior)
                : yearEndOffset(rule, prior);
            const TransitionTimePair pair(rule, year, newYearOffset);
            bool isDst = false;
            if (ruleIndex == 0 && pair.beforeInitialDst(year, forMSecsSinceEpoch)) {
                // We're before DST first started and have no earlier rule that
                // might give better data on this year, so just extrapolate
                // standard time backwards.
            } else if (pair.std != invalidMSecs() && pair.std <= forMSecsSinceEpoch) {
                isDst = pair.std < pair.dst && pair.dst <= forMSecsSinceEpoch;
            } else if (pair.dst != invalidMSecs() && pair.dst <= forMSecsSinceEpoch) {
                isDst = true;
            } else {
                year = prior; // Try an earlier year for this rule (once).
                prior = year == 1 ? -1 : year - 1; // No year 0.
                continue;
            }
            return ruleToData(rule, forMSecsSinceEpoch,
                              isDst ? QTimeZone::DaylightTime : QTimeZone::StandardTime,
                              pair.fakesDst);
        }
        // We can only fall off the end of that loop if endYear is rule.startYear:
        Q_ASSERT(year < rule.startYear);
        // Fell off start of rule, try previous rule.
    }
    // We don't have relevant data :-(
    return {};
}
 
bool QWinTimeZonePrivate::hasTransitions() const
{
    // NB: this is about the backend capability, not the particular zone.
    return true; // Albeit with caveats, see hasDaylightTime()
}
 
QTimeZonePrivate::Data QWinTimeZonePrivate::nextTransition(qint64 afterMSecsSinceEpoch) const
{
    Q_ASSERT(isValid()); // => !m_tranRules.isEmpty()
    int year = msecsToDate(afterMSecsSinceEpoch).year();
    int newYearOffset = invalidSeconds();
    for (int ruleIndex = ruleIndexForYear(m_tranRules, year);
         ruleIndex < m_tranRules.count(); ++ruleIndex) {
        const QWinTransitionRule &rule = m_tranRules.at(ruleIndex);
        // Does this rule's period include any transition at all ?
        if (rule.standardTimeRule.wMonth > 0 || rule.daylightTimeRule.wMonth > 0) {
            int prior = year == 1 ? -1 : year - 1; // No year 0.
            if (newYearOffset == invalidSeconds()) {
                // First rule tried. (Will revise newYearOffset before any
                // fall-back to a later rule.)
                newYearOffset = (prior < rule.startYear && ruleIndex > 0)
                    ? yearEndOffset(m_tranRules.at(ruleIndex - 1), prior)
                    : yearEndOffset(rule, prior);
            }
            if (year < rule.startYear) {
                // Either before first rule's start, or we fell off the end of
                // the rule for year because afterMSecsSinceEpoch is after any
                // transitions in it. Find first transition in this rule.
                TransitionTimePair pair(rule, rule.startYear, newYearOffset);
                // First transition is to DST precisely if the year started in
                // standard time. If the year is FIRST_DST_YEAR or earlier, it
                // definitely started in standard time.
                return pair.ruleToData(rule, this, !(year > FIRST_DST_YEAR && pair.startsInDst()));
            }
            const int endYear = ruleIndex + 1 < m_tranRules.count()
                ? qMin(m_tranRules.at(ruleIndex + 1).startYear, year + 2) : (year + 2);
            while (year < endYear) {
                const TransitionTimePair pair(rule, year, newYearOffset);
                bool isDst = false;
                Q_ASSERT(invalidMSecs() <= afterMSecsSinceEpoch); // invalid is min qint64
                if (ruleIndex == 0 && pair.beforeInitialDst(year, afterMSecsSinceEpoch)) {
                    // This is an initial recurrence rule, whose startYear
                    // (which we know is <= year) is FIRST_DST_YEAR:
                    Q_ASSERT(year == FIRST_DST_YEAR);
                    // This year's DST transition is the first ever DST
                    // transition, and we're before it. The transition back to
                    // standard time is a lie unless the DST one comes before
                    // it; either way, the DST one is next.
                    isDst = true;
                } else if (pair.std > afterMSecsSinceEpoch) {
                    isDst = pair.std > pair.dst && pair.dst > afterMSecsSinceEpoch;
                } else if (pair.dst > afterMSecsSinceEpoch) {
                    isDst = true;
                } else {
                    newYearOffset = rule.standardTimeBias;
                    if (pair.dst > pair.std)
                        newYearOffset += rule.daylightTimeBias;
                    // Try a later year for this rule (once).
                    prior = year;
                    year = year == -1 ? 1 : year + 1; // No year 0
                    continue;
                }
 
                return pair.ruleToData(rule, this, isDst);
            }
            // Fell off end of rule, try next rule.
        } else {
            // No transition during rule's period. If this is our first rule,
            // record its standard time as newYearOffset for the next rule;
            // otherwise, it should be consistent with what we have.
            if (newYearOffset == invalidSeconds())
                newYearOffset = rule.standardTimeBias;
            else
                Q_ASSERT(newYearOffset == rule.standardTimeBias);
        }
    }
    // Apparently no transition after the given time:
    return {};
}
 
QTimeZonePrivate::Data QWinTimeZonePrivate::previousTransition(qint64 beforeMSecsSinceEpoch) const
{
    Q_ASSERT(isValid()); // => !m_tranRules.isEmpty()
    if (beforeMSecsSinceEpoch <= minMSecs())
        return {};
 
    int year = msecsToDate(beforeMSecsSinceEpoch).year();
    for (int ruleIndex = ruleIndexForYear(m_tranRules, year);
         ruleIndex >= 0; --ruleIndex) {
        const QWinTransitionRule &rule = m_tranRules.at(ruleIndex);
        Q_ASSERT(ruleIndex == 0 || year >= rule.startYear);
        // Does this rule's period include any transition at all ?
        if (year >= rule.startYear
            && (rule.standardTimeRule.wMonth > 0 || rule.daylightTimeRule.wMonth > 0)) {
            int prior = year == 1 ? -1 : year - 1; // No year 0.
            const int endYear = qMax(rule.startYear, prior);
            while (year >= endYear) {
                const int newYearOffset = (prior < rule.startYear && ruleIndex > 0)
                    ? yearEndOffset(m_tranRules.at(ruleIndex - 1), prior)
                    : yearEndOffset(rule, prior);
                const TransitionTimePair pair(rule, year, newYearOffset);
                // A recurrent DST rule, before DST first started, is a lie:
                // fake a first transition at the start of time, as for the
                // other (ruleIndex == 0) case below. Same applies to first
                // instant of DST; there is no prior (real) transition.
                if (ruleIndex == 0 && pair.beforeInitialDst(year, beforeMSecsSinceEpoch - 1))
                    return ruleToData(rule, minMSecs(), QTimeZone::StandardTime, false);
 
                bool isDst = false;
                if (pair.std != invalidMSecs() && pair.std < beforeMSecsSinceEpoch) {
                    isDst = pair.std < pair.dst && pair.dst < beforeMSecsSinceEpoch;
                } else if (pair.dst != invalidMSecs() && pair.dst < beforeMSecsSinceEpoch) {
                    isDst = true;
                } else {
                    year = prior; // Try an earlier year for this rule (once).
                    prior = year == 1 ? -1 : year - 1; // No year 0.
                    continue;
                }
                return pair.ruleToData(rule, this, isDst);
            }
            // Fell off start of rule, try previous rule.
        } else if (ruleIndex == 0) {
            // Describe time before the first transition in terms of a fictional
            // transition at the start of time, so that a scan through all rules
            // *does* see a first rule that supplies the offset for such times:
            return ruleToData(rule, minMSecs(), QTimeZone::StandardTime, false);
        } // else: no transition during rule's period
        if (year >= rule.startYear) {
            year = rule.startYear - 1; // Seek last transition in new rule
            if (!year)
                --year;
        }
    }
    // Apparently no transition before the given time:
    return {};
}
 
QByteArray QWinTimeZonePrivate::systemTimeZoneId() const
{
    const QLocale::Territory territory = userTerritory();
    const QByteArray windowsId = windowsSystemZoneId();
    QByteArrayView ianaId;
    // If we have a real territory, then try get a specific match for that territory
    if (territory != QLocale::AnyTerritory)
        ianaId = windowsIdToDefaultIanaId(windowsId, territory);
    // If we don't have a real territory, or there wasn't a specific match, try the global default
    if (ianaId.isEmpty())
        ianaId = windowsIdToDefaultIanaId(windowsId);
    return ianaId.toByteArray();
}
 
QList<QByteArray> QWinTimeZonePrivate::availableTimeZoneIds() const
{
    static const QList<QByteArray> cache = [] {
        QList<QByteArray> result;
        const auto winIds = availableWindowsIds();
        for (const QByteArray &winId : winIds)
            result += windowsIdToIanaIds(winId);
        return QTimeZonePrivate::uniqueSortedAliasPadded(std::move(result));
    }();
    return cache;
}
 
QTimeZonePrivate::Data QWinTimeZonePrivate::ruleToData(const QWinTransitionRule &rule,
                                                       qint64 atMSecsSinceEpoch,
                                                       QTimeZone::TimeType type,
                                                       bool fakeDst) const
{
    Data tran;
    tran.atMSecsSinceEpoch = atMSecsSinceEpoch;
    tran.standardTimeOffset = rule.standardTimeBias * -60;
    if (fakeDst) {
        tran.daylightTimeOffset = 0;
        // Rule may claim we're in DST when it's actually a standard time change:
        if (type == QTimeZone::DaylightTime)
            tran.standardTimeOffset += rule.daylightTimeBias * -60;
    } else if (type == QTimeZone::DaylightTime) {
        tran.daylightTimeOffset = rule.daylightTimeBias * -60;
    } else {
        tran.daylightTimeOffset = 0;
    }
    tran.offsetFromUtc = tran.standardTimeOffset + tran.daylightTimeOffset;
    tran.abbreviation = localeName(atMSecsSinceEpoch, tran.offsetFromUtc,
                                   type, QTimeZone::ShortName, QLocale::system());
    return tran;
}
 
QT_END_NAMESPACE