mirror of https://github.com/PurpleI2P/i2pd.git
I2P: End-to-End encrypted and anonymous Internet
https://i2pd.website/
259 lines
6.2 KiB
259 lines
6.2 KiB
/* |
|
* Copyright (c) 2013-2022, The PurpleI2P Project |
|
* |
|
* This file is part of Purple i2pd project and licensed under BSD3 |
|
* |
|
* See full license text in LICENSE file at top of project tree |
|
*/ |
|
|
|
#include <time.h> |
|
#include <stdio.h> |
|
#include <inttypes.h> |
|
#include <string.h> |
|
#include <chrono> |
|
#include <future> |
|
#include <boost/asio.hpp> |
|
#include <boost/algorithm/string.hpp> |
|
#include "Config.h" |
|
#include "Log.h" |
|
#include "RouterContext.h" |
|
#include "I2PEndian.h" |
|
#include "Timestamp.h" |
|
#include "util.h" |
|
|
|
#ifdef _WIN32 |
|
#ifndef _WIN64 |
|
#define _USE_32BIT_TIME_T |
|
#endif |
|
#endif |
|
|
|
namespace i2p |
|
{ |
|
namespace util |
|
{ |
|
static uint64_t GetLocalMillisecondsSinceEpoch () |
|
{ |
|
return std::chrono::duration_cast<std::chrono::milliseconds>( |
|
std::chrono::system_clock::now().time_since_epoch()).count (); |
|
} |
|
|
|
static uint64_t GetLocalSecondsSinceEpoch () |
|
{ |
|
return std::chrono::duration_cast<std::chrono::seconds>( |
|
std::chrono::system_clock::now().time_since_epoch()).count (); |
|
} |
|
|
|
static uint32_t GetLocalMinutesSinceEpoch () |
|
{ |
|
return std::chrono::duration_cast<std::chrono::minutes>( |
|
std::chrono::system_clock::now().time_since_epoch()).count (); |
|
} |
|
|
|
static uint32_t GetLocalHoursSinceEpoch () |
|
{ |
|
return std::chrono::duration_cast<std::chrono::hours>( |
|
std::chrono::system_clock::now().time_since_epoch()).count (); |
|
} |
|
|
|
static int64_t g_TimeOffset = 0; // in seconds |
|
|
|
static void SyncTimeWithNTP (const std::string& address) |
|
{ |
|
LogPrint (eLogInfo, "Timestamp: NTP request to ", address); |
|
boost::asio::io_service service; |
|
boost::system::error_code ec; |
|
auto it = boost::asio::ip::udp::resolver (service).resolve ( |
|
boost::asio::ip::udp::resolver::query (address, "ntp"), ec); |
|
if (!ec) |
|
{ |
|
bool found = false; |
|
boost::asio::ip::udp::resolver::iterator end; |
|
boost::asio::ip::udp::endpoint ep; |
|
while (it != end) |
|
{ |
|
ep = *it; |
|
if (!ep.address ().is_unspecified ()) |
|
{ |
|
if (ep.address ().is_v4 ()) |
|
{ |
|
if (i2p::context.SupportsV4 ()) found = true; |
|
} |
|
else if (ep.address ().is_v6 ()) |
|
{ |
|
if (i2p::util::net::IsYggdrasilAddress (ep.address ())) |
|
{ |
|
if (i2p::context.SupportsMesh ()) found = true; |
|
} |
|
else if (i2p::context.SupportsV6 ()) found = true; |
|
} |
|
} |
|
if (found) break; |
|
it++; |
|
} |
|
if (!found) |
|
{ |
|
LogPrint (eLogError, "Timestamp: can't find compatible address for ", address); |
|
return; |
|
} |
|
|
|
boost::asio::ip::udp::socket socket (service); |
|
socket.open (ep.protocol (), ec); |
|
if (!ec) |
|
{ |
|
uint8_t buf[48];// 48 bytes NTP request/response |
|
memset (buf, 0, 48); |
|
htobe32buf (buf, (3 << 27) | (3 << 24)); // RFC 4330 |
|
size_t len = 0; |
|
try |
|
{ |
|
socket.send_to (boost::asio::buffer (buf, 48), ep); |
|
int i = 0; |
|
while (!socket.available() && i < 10) // 10 seconds max |
|
{ |
|
std::this_thread::sleep_for (std::chrono::seconds(1)); |
|
i++; |
|
} |
|
if (socket.available ()) |
|
len = socket.receive_from (boost::asio::buffer (buf, 48), ep); |
|
} |
|
catch (std::exception& e) |
|
{ |
|
LogPrint (eLogError, "Timestamp: NTP error: ", e.what ()); |
|
} |
|
if (len >= 8) |
|
{ |
|
auto ourTs = GetLocalSecondsSinceEpoch (); |
|
uint32_t ts = bufbe32toh (buf + 32); |
|
if (ts > 2208988800U) ts -= 2208988800U; // 1/1/1970 from 1/1/1900 |
|
g_TimeOffset = ts - ourTs; |
|
LogPrint (eLogInfo, "Timestamp: ", address, " time offset from system time is ", g_TimeOffset, " seconds"); |
|
} |
|
} |
|
else |
|
LogPrint (eLogError, "Timestamp: Couldn't open UDP socket"); |
|
} |
|
else |
|
LogPrint (eLogError, "Timestamp: Couldn't resolve address ", address); |
|
} |
|
|
|
NTPTimeSync::NTPTimeSync (): m_IsRunning (false), m_Timer (m_Service) |
|
{ |
|
i2p::config::GetOption("nettime.ntpsyncinterval", m_SyncInterval); |
|
std::string ntpservers; i2p::config::GetOption("nettime.ntpservers", ntpservers); |
|
boost::split (m_NTPServersList, ntpservers, boost::is_any_of(","), boost::token_compress_on); |
|
} |
|
|
|
NTPTimeSync::~NTPTimeSync () |
|
{ |
|
Stop (); |
|
} |
|
|
|
void NTPTimeSync::Start() |
|
{ |
|
if (m_NTPServersList.size () > 0) |
|
{ |
|
m_IsRunning = true; |
|
LogPrint(eLogInfo, "Timestamp: NTP time sync starting"); |
|
m_Service.post (std::bind (&NTPTimeSync::Sync, this)); |
|
m_Thread.reset (new std::thread (std::bind (&NTPTimeSync::Run, this))); |
|
} |
|
else |
|
LogPrint (eLogWarning, "Timestamp: No NTP server found"); |
|
} |
|
|
|
void NTPTimeSync::Stop () |
|
{ |
|
if (m_IsRunning) |
|
{ |
|
LogPrint(eLogInfo, "Timestamp: NTP time sync stopping"); |
|
m_IsRunning = false; |
|
m_Timer.cancel (); |
|
m_Service.stop (); |
|
if (m_Thread) |
|
{ |
|
m_Thread->join (); |
|
m_Thread.reset (nullptr); |
|
} |
|
} |
|
} |
|
|
|
void NTPTimeSync::Run () |
|
{ |
|
i2p::util::SetThreadName("Timesync"); |
|
|
|
while (m_IsRunning) |
|
{ |
|
try |
|
{ |
|
m_Service.run (); |
|
} |
|
catch (std::exception& ex) |
|
{ |
|
LogPrint (eLogError, "Timestamp: NTP time sync exception: ", ex.what ()); |
|
} |
|
} |
|
} |
|
|
|
void NTPTimeSync::Sync () |
|
{ |
|
if (m_NTPServersList.size () > 0) |
|
SyncTimeWithNTP (m_NTPServersList[rand () % m_NTPServersList.size ()]); |
|
else |
|
m_IsRunning = false; |
|
|
|
if (m_IsRunning) |
|
{ |
|
m_Timer.expires_from_now (boost::posix_time::hours (m_SyncInterval)); |
|
m_Timer.async_wait ([this](const boost::system::error_code& ecode) |
|
{ |
|
if (ecode != boost::asio::error::operation_aborted) |
|
Sync (); |
|
}); |
|
} |
|
} |
|
|
|
uint64_t GetMillisecondsSinceEpoch () |
|
{ |
|
return GetLocalMillisecondsSinceEpoch () + g_TimeOffset*1000; |
|
} |
|
|
|
uint64_t GetSecondsSinceEpoch () |
|
{ |
|
return GetLocalSecondsSinceEpoch () + g_TimeOffset; |
|
} |
|
|
|
uint32_t GetMinutesSinceEpoch () |
|
{ |
|
return GetLocalMinutesSinceEpoch () + g_TimeOffset/60; |
|
} |
|
|
|
uint32_t GetHoursSinceEpoch () |
|
{ |
|
return GetLocalHoursSinceEpoch () + g_TimeOffset/3600; |
|
} |
|
|
|
void GetCurrentDate (char * date) |
|
{ |
|
GetDateString (GetSecondsSinceEpoch (), date); |
|
} |
|
|
|
void GetDateString (uint64_t timestamp, char * date) |
|
{ |
|
using clock = std::chrono::system_clock; |
|
auto t = clock::to_time_t (clock::time_point (std::chrono::seconds(timestamp))); |
|
struct tm tm; |
|
#ifdef _WIN32 |
|
gmtime_s(&tm, &t); |
|
sprintf_s(date, 9, "%04i%02i%02i", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); |
|
#else |
|
gmtime_r(&t, &tm); |
|
sprintf(date, "%04i%02i%02i", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); |
|
#endif |
|
} |
|
|
|
void AdjustTimeOffset (int64_t offset) |
|
{ |
|
g_TimeOffset += offset; |
|
} |
|
} |
|
}
|
|
|