1  // Copyright (c) 2009-2010 Satoshi Nakamoto
  2  // Copyright (c) 2009-present The Bitcoin Core developers
  3  // Distributed under the MIT software license, see the accompanying
  4  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  5  
  6  #include <util/time.h>
  7  
  8  #include <tinyformat.h>
  9  #include <util/check.h>
 10  #include <util/strencodings.h>
 11  
 12  #include <array>
 13  #include <atomic>
 14  #include <chrono>
 15  #include <compare>
 16  #include <optional>
 17  #include <string>
 18  #include <string_view>
 19  #include <thread>
 20  
 21  #ifdef WIN32
 22  #include <winsock2.h>
 23  #else
 24  #include <sys/time.h>
 25  #endif
 26  
 27  static constexpr std::array<std::string_view, 7> weekdays{"Thu", "Fri", "Sat", "Sun", "Mon", "Tue", "Wed"}; // 1970-01-01 was a Thursday.
 28  static constexpr std::array<std::string_view, 12> months{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 29  
 30  void UninterruptibleSleep(const std::chrono::microseconds& n) { std::this_thread::sleep_for(n); }
 31  
 32  static std::atomic<std::chrono::seconds> g_mock_time{}; //!< For testing
 33  std::atomic<bool> g_used_system_time{false};
 34  static std::atomic<MockableSteadyClock::mock_time_point::duration> g_mock_steady_time{}; //!< For testing
 35  
 36  static_assert(NodeClock::epoch.time_since_epoch().count() == 0);
 37  
 38  NodeClock::time_point NodeClock::now() noexcept
 39  {
 40      const auto mocktime{g_mock_time.load(std::memory_order_relaxed)};
 41      if (!mocktime.count()) {
 42          g_used_system_time = true;
 43      }
 44      const auto ret{
 45          mocktime.count() ?
 46              mocktime :
 47              std::chrono::system_clock::now().time_since_epoch()};
 48      assert(ret > 0s);
 49      return time_point{ret};
 50  };
 51  
 52  void SetMockTime(int64_t nMockTimeIn) { SetMockTime(std::chrono::seconds{nMockTimeIn}); }
 53  void SetMockTime(std::chrono::time_point<NodeClock, std::chrono::seconds> mock) { SetMockTime(mock.time_since_epoch()); }
 54  void SetMockTime(std::chrono::seconds mock_time_in)
 55  {
 56      Assert(mock_time_in >= 0s);
 57      g_mock_time.store(mock_time_in, std::memory_order_relaxed);
 58  }
 59  
 60  std::chrono::seconds GetMockTime()
 61  {
 62      return g_mock_time.load(std::memory_order_relaxed);
 63  }
 64  
 65  MockableSteadyClock::time_point MockableSteadyClock::now() noexcept
 66  {
 67      const auto mocktime{g_mock_steady_time.load(std::memory_order_relaxed)};
 68      if (!mocktime.count()) {
 69          g_used_system_time = true;
 70      }
 71      const auto ret{
 72          mocktime.count() ?
 73              mocktime :
 74              std::chrono::steady_clock::now().time_since_epoch()};
 75      return time_point{ret};
 76  };
 77  
 78  void MockableSteadyClock::SetMockTime(mock_time_point::duration mock_time_in)
 79  {
 80      Assert(mock_time_in >= 0s);
 81      g_mock_steady_time.store(mock_time_in, std::memory_order_relaxed);
 82  }
 83  
 84  void MockableSteadyClock::ClearMockTime()
 85  {
 86      g_mock_steady_time.store(0ms, std::memory_order_relaxed);
 87  }
 88  
 89  int64_t GetTime() { return GetTime<std::chrono::seconds>().count(); }
 90  
 91  std::string FormatISO8601DateTime(int64_t nTime)
 92  {
 93      const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}};
 94      const auto days{std::chrono::floor<std::chrono::days>(secs)};
 95      const std::chrono::year_month_day ymd{days};
 96      const std::chrono::hh_mm_ss hms{secs - days};
 97      return strprintf("%04i-%02u-%02uT%02i:%02i:%02iZ", signed{ymd.year()}, unsigned{ymd.month()}, unsigned{ymd.day()}, hms.hours().count(), hms.minutes().count(), hms.seconds().count());
 98  }
 99  
100  std::string FormatISO8601Date(int64_t nTime)
101  {
102      const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}};
103      const auto days{std::chrono::floor<std::chrono::days>(secs)};
104      const std::chrono::year_month_day ymd{days};
105      return strprintf("%04i-%02u-%02u", signed{ymd.year()}, unsigned{ymd.month()}, unsigned{ymd.day()});
106  }
107  
108  std::optional<int64_t> ParseISO8601DateTime(std::string_view str)
109  {
110      constexpr auto FMT_SIZE{std::string_view{"2000-01-01T01:01:01Z"}.size()};
111      if (str.size() != FMT_SIZE || str[4] != '-' || str[7] != '-' || str[10] != 'T' || str[13] != ':' || str[16] != ':' || str[19] != 'Z') {
112          return {};
113      }
114      const auto year{ToIntegral<uint16_t>(str.substr(0, 4))};
115      const auto month{ToIntegral<uint8_t>(str.substr(5, 2))};
116      const auto day{ToIntegral<uint8_t>(str.substr(8, 2))};
117      const auto hour{ToIntegral<uint8_t>(str.substr(11, 2))};
118      const auto min{ToIntegral<uint8_t>(str.substr(14, 2))};
119      const auto sec{ToIntegral<uint8_t>(str.substr(17, 2))};
120      if (!year || !month || !day || !hour || !min || !sec) {
121          return {};
122      }
123      const std::chrono::year_month_day ymd{std::chrono::year{*year}, std::chrono::month{*month}, std::chrono::day{*day}};
124      if (!ymd.ok()) {
125          return {};
126      }
127      const auto time{std::chrono::hours{*hour} + std::chrono::minutes{*min} + std::chrono::seconds{*sec}};
128      const auto tp{std::chrono::sys_days{ymd} + time};
129      return int64_t{TicksSinceEpoch<std::chrono::seconds>(tp)};
130  }
131  
132  std::string FormatRFC1123DateTime(int64_t time)
133  {
134      if (time < -62167219200 || 253402300799 < time) {
135          // 4-digit year, so only support years 0 to 9999
136          return "";
137      }
138      const std::chrono::sys_seconds secs{std::chrono::seconds{time}};
139      const auto days{std::chrono::floor<std::chrono::days>(secs)};
140      const auto w{days.time_since_epoch().count() % 7}; // will be in the range [-6, 6]
141      std::string_view weekday{weekdays.at(w >= 0 ? w : w + 7)};
142      const std::chrono::year_month_day ymd{days};
143      std::string_view month{months.at(unsigned{ymd.month()} - 1)};
144      const std::chrono::hh_mm_ss hms{secs - days};
145      // examples: Mon, 27 Jul 2009 12:28:53 GMT
146      //           Fri, 31 May 2024 19:18:04 GMT
147      return strprintf("%03s, %02u %03s %04i %02i:%02i:%02i GMT", weekday, unsigned{ymd.day()}, month, signed{ymd.year()}, hms.hours().count(), hms.minutes().count(), hms.seconds().count());
148  }
149  
150  struct timeval MillisToTimeval(int64_t nTimeout)
151  {
152      struct timeval timeout;
153      timeout.tv_sec  = nTimeout / 1000;
154      timeout.tv_usec = (nTimeout % 1000) * 1000;
155      return timeout;
156  }
157  
158  struct timeval MillisToTimeval(std::chrono::milliseconds ms)
159  {
160      return MillisToTimeval(count_milliseconds(ms));
161  }