i2pd/libi2pd/Timestamp.cpp

/*
* Copyright (c) 2013-2024, 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;
	}

	uint64_t GetMonotonicMicroseconds()
	{
		return std::chrono::duration_cast<std::chrono::microseconds>(
			std::chrono::steady_clock::now().time_since_epoch()).count();
	}

	uint64_t GetMonotonicMilliseconds()
	{
		return std::chrono::duration_cast<std::chrono::milliseconds>(
			std::chrono::steady_clock::now().time_since_epoch()).count();
	}

	uint64_t GetMonotonicSeconds ()
	{
		return std::chrono::duration_cast<std::chrono::seconds>(
			std::chrono::steady_clock::now().time_since_epoch()).count();
	}	
	
	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;
	}
}
}