`std::chrono::time_zone::get_info` throws an exception saying: The operation completed successfully

[cppdev123]

Originally asked at : https://stackoverflow.com/questions/73668044/msvc-stdchronotime-zoneget-info-throws-an-exception-saying-the-operation

I was trying to convert utc time returned from std::chrono::system_clock to local time before displaying it using std::format but I got a surprising exception from std::chrono::time_zone::to_local and its what message says: The operation completed successfully. What a surprise ! I looked into this method and it called std::chrono::time_zone::get_info on the passed time parameter and did a simple conversion so I tested std::chrono::time_zone::get_info separately and it was the source of this exception. I don't know is it a bug in the implementation or my code is buggy ?

Here is a simple code which throws this error:

           try
            {
                const std::chrono::time_zone* current_z = std::chrono::current_zone();
                std::cout << "current timezone name: " << current_z->name() << "\n";
                auto sys_time = std::chrono::system_clock::now();
                std::cout << "current system time: " << sys_time << "\n";
                auto sys_info = current_z->get_info(sys_time); // throws exception what(): The operation completed successfully.
                std::cout << "sys_info: offset: " << sys_info.offset << ", abbrev" << sys_info.abbrev << "\n";
                //auto local_time = current_z->to_local(sys_time); // throws exception since it calls get_info
                //std::cout << "current local time: " << local_time << "\n";
            }
            catch (const std::exception& ex)
            {
                std::cout << "caught exception: " << ex.what();
            }

After looking at std::chrono::time_zone::get_info source code it will invoke this method: std::chrono::time_zone::_Get_info and its source:

        template <class _Duration>
        _NODISCARD sys_info _Get_info(const _Duration& _Dur) const {
            using _Internal_duration = duration<__std_tzdb_epoch_milli, milli>;
            const auto _Internal_dur = _CHRONO duration_cast<_Internal_duration>(_Dur);
            const unique_ptr<__std_tzdb_sys_info, _Tzdb_deleter<__std_tzdb_sys_info>> _Info{
                __std_tzdb_get_sys_info(_Name.c_str(), _Name.length(), _Internal_dur.count())};
            if (_Info == nullptr) {
                _Xbad_alloc();
            } else if (_Info->_Err == __std_tzdb_error::_Win_error) {
                _XGetLastError();
            } else if (_Info->_Err == __std_tzdb_error::_Icu_error) {
                _Xruntime_error("Internal error loading IANA database information");
            }

            constexpr auto _Min_internal =
                _CHRONO duration_cast<_Internal_duration>(_Min_seconds.time_since_epoch()).count();
            constexpr auto _Max_internal =
                _CHRONO duration_cast<_Internal_duration>(_Max_seconds.time_since_epoch()).count();
            const auto _Begin =
                _Info->_Begin <= _Min_internal
                    ? _Min_seconds
                    : sys_seconds{_CHRONO duration_cast<sys_seconds::duration>(_Internal_duration{_Info->_Begin})};
            const auto _End =
                _Info->_End >= _Max_internal
                    ? _Max_seconds
                    : sys_seconds{_CHRONO duration_cast<sys_seconds::duration>(_Internal_duration{_Info->_End})};
            return {.begin = _Begin,
                .end       = _End,
                .offset    = _CHRONO duration_cast<seconds>(_Internal_duration{_Info->_Offset}),
                .save      = _CHRONO duration_cast<minutes>(_Internal_duration{_Info->_Save}),
                .abbrev    = _Info->_Abbrev};
        }

After stepping with the debugger (although debugging this header is hard) the _Info pointer returned by __std_tzdb_get_sys_info is not nullptr but its _Err is set to 1 which equals __std_tzdb_error::_Win_error so _XGetLastError is called to throw an exception with the error code from GetLastError and it will return 0 indicating no error code so an exception is thrown indicating that no error has happened !

I examined __std_tzdb_get_sys_info body in tzdb.cpp and found that only _Acquire_icu_functions may cause error __std_tzdb_error::_Win_error but it is also called by __std_tzdb_get_current_zone which is called by current_zone without failure !

[fsb4000]

#include <chrono>
#include <iostream>

int main() {
    try
    {
        const std::chrono::time_zone* current_z = std::chrono::current_zone();
        std::cout << "current timezone name: " << current_z->name() << "\n";
        auto sys_time = std::chrono::system_clock::now();
        std::cout << "current system time: " << sys_time << "\n";
        auto sys_info = current_z->get_info(sys_time); // throws exception what(): The operation completed successfully.
        std::cout << "sys_info: offset: " << sys_info.offset << ", abbrev" << sys_info.abbrev << "\n";
        auto local_time = current_z->to_local(sys_time); // throws exception since it calls get_info
        std::cout << "current local time: " << local_time << "\n";
    }
    catch (const std::exception& ex)
    {
        std::cout << "caught exception: " << ex.what();
    }
}

$ cl /std:c++latest /EHsc /W4 /WX /nologo main.cpp
$ main.exe
current timezone name: Asia/Barnaul
current system time: 2022-09-12 15:34:21.5789916
sys_info: offset: 25200s, abbrevGMT+7
current local time: 2022-09-12 22:34:21.5789916

It works fine on my machine, I can't reproduce. (I tried both: console and Visual Studio 2022 IDE release and debug builds)

[cppdev123]

I don't have Visual Studio 2022
I'm using Visual Studio 2019 16.11.18 and on Windows 10 19042.1466

[fsb4000]

I'm using Visual Studio 2022 17.4 Preview 1 and Windows 10 19044.1889

I don't have installed Visual Studio 2019...
I will install it tomorrow if no one tests today.

[fsb4000]

Casey said that it works with VS 2019 and Windows 11

[fsb4000]

VS 2019 and Windows 10, still works for me.

[CaseyCarter]

@PUBG-hacks we're having a hard time reproducing this. Does the complete program that Igor provided in #3097 (comment) reproduce the bug for you when compiled with cl /std:c++latest /EHsc /W4 /WX? If not, could you provide a complete program and command line that does reliably reproduce the bug for you?

[cppdev123]

@CaseyCarter yes the output is

current timezone name: Africa/Cairo
current system time: 2022-09-13 21:03:09.2953996
caught exception: The operation completed successfully.

Can I set breakpoints inside tzdb.cpp somehow to see where exactly it fails in debug build ?

[StephanTLavavej]

Yes, you can definitely step into tzdb.cpp (this will be easier when building in debug mode than in release mode). You may need to disable the "Just My Code" setting in VS.

Win10 19042 was 20H2, while @fsb4000's Win10 19044 is 21H2 and @CaseyCarter's Win11 22621 is 22H2. I'm not aware of any ICU updates between these versions, but this code is dependent on ICU provided by Windows, and it seems notable that the only repro is occurring on the oldest OS.

[lone-wolf-akela]

Yes, you can definitely step into tzdb.cpp (this will be easier when building in debug mode than in release mode). You may need to disable the "Just My Code" setting in VS.

Win10 19042 was 20H2, while @fsb4000's Win10 19044 is 21H2 and @CaseyCarter's Win11 22621 is 22H2. I'm not aware of any ICU updates between these versions, but this code is dependent on ICU provided by Windows, and it seems notable that the only repro is occurring on the oldest OS.

I compile @fsb4000's code on windows 11 with VS 2022 17.4.0 preview 1.0, and run the compiled exe on a win10 19042.631(20H2), and cannot reproduce the problem. I don't have VS2019 and haven't installed VS in my win10 virtual machine though.

[cppdev123]

This is what I found so far:

The failure point in __std_tzdb_get_sys_info is due to _Allocate_wide_to_narrow and it seems to happen only when passing non ascii string (at least Arabic in my case) :

_NODISCARD __std_tzdb_sys_info* __stdcall __std_tzdb_get_sys_info(
    const char* _Tz, const size_t _Tz_len, __std_tzdb_epoch_milli _Sys) noexcept {
    // On exit---
    //    _Info == nullptr          --> bad_alloc
    //    _Info->_Err == _Win_error --> failed, call GetLastError()
    //    _Info->_Err == _Icu_error --> runtime_error interacting with ICU
#pragma warning(push)
#pragma warning(disable : 28182) // TRANSITION, VSO-1558277: Dereferencing NULL pointer.
    _STD unique_ptr<__std_tzdb_sys_info, _STD _Tzdb_deleter<__std_tzdb_sys_info>> _Info{
        new (_STD nothrow) __std_tzdb_sys_info{}};
#pragma warning(pop)
    if (_Info == nullptr) {
        return nullptr;
    }

    if (_Acquire_icu_functions() < _Icu_api_level::_Has_icu_addresses) {
        return _Report_error(_Info, __std_tzdb_error::_Win_error);
    }

    const auto _Cal = _Get_cal(_Tz, _Tz_len, _Info->_Err);
    if (_Cal == nullptr) {
        return _Propagate_error(_Info);
    }

    UErrorCode _UErr{};
    __icu_ucal_setMillis(_Cal.get(), _Sys, &_UErr);
    if (U_FAILURE(_UErr)) {
        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
    }

    const auto _Is_daylight = __icu_ucal_inDaylightTime(_Cal.get(), &_UErr);
    if (U_FAILURE(_UErr)) {
        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
    }

    _Info->_Save = _Is_daylight ? __icu_ucal_get(_Cal.get(), UCalendarDateFields::UCAL_DST_OFFSET, &_UErr) : 0;
    if (U_FAILURE(_UErr)) {
        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
    }

    _Info->_Offset = __icu_ucal_get(_Cal.get(), UCalendarDateFields::UCAL_ZONE_OFFSET, &_UErr) + _Info->_Save;
    if (U_FAILURE(_UErr)) {
        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
    }

    UDate _Transition{};
    _Info->_Begin = __icu_ucal_getTimeZoneTransitionDate(_Cal.get(),
                        UTimeZoneTransitionType::UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE, &_Transition, &_UErr)
                      ? _Transition
                      : U_DATE_MIN;
    if (U_FAILURE(_UErr)) {
        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
    }

    _Info->_End = __icu_ucal_getTimeZoneTransitionDate(
                      _Cal.get(), UTimeZoneTransitionType::UCAL_TZ_TRANSITION_NEXT, &_Transition, &_UErr)
                    ? _Transition
                    : U_DATE_MAX;
    if (U_FAILURE(_UErr)) {
        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
    }

    int32_t _Abbrev_len{};
    const auto _Abbrev = _Get_timezone_short_id(_Cal.get(), _Is_daylight, _Abbrev_len, _Info->_Err);
    if (_Abbrev == nullptr) {
        return _Propagate_error(_Info);
    }
    // the next line fails and _Allocate_wide_to_narrow set _Err to _Win_error
    // _Abbrev points to : "غرينتش+2" which means in abbreviated English "GMT+2" and len is 8
    _Info->_Abbrev = _Allocate_wide_to_narrow(_Abbrev.get(), _Abbrev_len, _Info->_Err);
    if (_Info->_Abbrev == nullptr) {
        
        return _Propagate_error(_Info);
    }

    return _Info.release();
}

The failure point in _Allocate_wide_to_narrow is as follows:

_NODISCARD const char* _Allocate_wide_to_narrow(
        const char16_t* const _Input, const int _Input_len, __std_tzdb_error& _Err) noexcept {
        const auto _Code_page      = __std_fs_code_page();
        const auto _Input_as_wchar = reinterpret_cast<const wchar_t*>(_Input);
        // the next line fails with _Count_result : len = 0, and _Err = 1113 aka ERROR_NO_UNICODE_TRANSLATION
       // _Code_page is Acp aka 0 and _Input_as_wchar is "غرينتش+2" and _Input_len is 8
        const auto _Count_result = __std_fs_convert_wide_to_narrow(_Code_page, _Input_as_wchar, _Input_len, nullptr, 0);
        if (_Count_result._Err != __std_win_error::_Success) {
            // Here _Err is set to _Win_error but no winapi function actually failed
            _Err = __std_tzdb_error::_Win_error;
            return nullptr;
        }

        _STD unique_ptr<char[]> _Data{new (_STD nothrow) char[_Count_result._Len + 1]};
        if (_Data == nullptr) {
            return nullptr;
        }

        _Data[_Count_result._Len] = '\0';

        const auto _Result =
            __std_fs_convert_wide_to_narrow(_Code_page, _Input_as_wchar, _Input_len, _Data.get(), _Count_result._Len);
        if (_Result._Err != __std_win_error::_Success) {
            _Err = __std_tzdb_error::_Win_error;
            return nullptr;
        }

        return _Data.release();
}

I set breakpoints inside __std_fs_convert_wide_to_narrow but it is not hit from the call inside tzdb.cpp although it is hit when I call it from my code:

        auto result = __std_fs_convert_wide_to_narrow(__std_code_page::_Acp, L"غرينتش+2", 8, nullptr, 0);
        if (result._Err != __std_win_error::_Success) {
            printf("[!] __std_fs_convert_wide_to_narrow failed ! %d, len: %d\n", (int)result._Err, result._Len);
        }
        else {
            printf("[*] __std_fs_convert_wide_to_narrow succeeded, len: %d\n", result._Len);
        }

and to my surprise it succeeds and prints len = 8 !
the source code of __std_fs_convert_wide_to_narrow is located in filesystem.cpp and it is :

[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow(_In_ const __std_code_page _Code_page,
    _In_reads_(_Input_len) const wchar_t* const _Input_str, _In_ const int _Input_len,
    _Out_writes_opt_(_Output_len) char* const _Output_str, _In_ const int _Output_len) noexcept {
    __std_fs_convert_result _Result;

    if (_Code_page == __std_code_page{CP_UTF8} || _Code_page == __std_code_page{54936}) {
        // For UTF-8 or GB18030, attempt to use WC_ERR_INVALID_CHARS. (These codepages can't use WC_NO_BEST_FIT_CHARS
        // below, and other codepages can't use WC_ERR_INVALID_CHARS.)
        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), WC_ERR_INVALID_CHARS, _Input_str,
            _Input_len, _Output_str, _Output_len, nullptr, nullptr);
    } else { // For other codepages, attempt to use WC_NO_BEST_FIT_CHARS.
             // Codepages that don't support this will activate the ERROR_INVALID_FLAGS fallback below.
        BOOL _Used_default_char = FALSE;

        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), WC_NO_BEST_FIT_CHARS, _Input_str,
            _Input_len, _Output_str, _Output_len, nullptr, &_Used_default_char);

        if (_Used_default_char) { // Report round-tripping failure with ERROR_NO_UNICODE_TRANSLATION,
                                  // "No mapping for the Unicode character exists in the target multi-byte code page."
            return {0, __std_win_error{ERROR_NO_UNICODE_TRANSLATION}};
        }
    }

    _Result._Err = _Result._Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success;

    if (_Result._Err == __std_win_error{ERROR_INVALID_FLAGS}) { // Fall back to a non-strict conversion.
        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), 0, _Input_str, _Input_len,
            _Output_str, _Output_len, nullptr, nullptr);

        _Result._Err = _Result._Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success;
    }

    return _Result;
}

I think the error is coming from this line : return {0, __std_win_error{ERROR_NO_UNICODE_TRANSLATION}}; since ERROR_NO_UNICODE_TRANSLATION is equal to 1113

EDIT: seems that __std_fs_convert_wide_to_narrow is inlined in atomic_wait.dll so it does not hit the breakpoints inside filesystem.cpp
EDIT2: I built with static library /MTd and now the breakpoints inside __std_fs_convert_wide_to_narrow is hit from tzdb.cpp and it fails in this line return {0, __std_win_error{ERROR_NO_UNICODE_TRANSLATION}}; because _Used_default_char is set to 1 by WideCharToMultiByte

[cppdev123]

I think __std_code_page::_Utf8 should be used here because it will suffice for non ascii chars and it will not break ascii because AFAIK utf-8 is compatible with ascii

[strega-nil-ms]

This is really easy to reproduce; compile the following program:

#include <chrono>
#include <iostream>

int main() {
  try
  {
    const std::chrono::time_zone* current_z = std::chrono::current_zone();
    std::cout << "current timezone name: " << current_z->name() << "\n";
    auto sys_time = std::chrono::system_clock::now();
    std::cout << "current system time: " << sys_time << "\n";
    auto sys_info = current_z->get_info(sys_time); // throws exception what(): The operation completed successfully.
    (void)sys_info;
  }
  catch (const std::exception& ex)
  {
      std::cout << "caught exception: " << ex.what();
  }
}

with cl /std:c++20 /EHsc. Then, set your system language to Arabic (you do not need to sign out!), and your active code page to 437.

Finally, run the program:

PS C:\..\nimazzuc\projects\stl-tests> .\gh-3097.exe
current timezone name: America/Los_Angeles
current system time: 2022-09-22 20:46:20.3524622
caught exception: The operation completed successfully.