ntp_client.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef TIME_SHIELD_HEADER_NTP_NTP_CLIENT_HPP_INCLUDED
#define TIME_SHIELD_HEADER_NTP_NTP_CLIENT_HPP_INCLUDED
 
 
#include <time_shield/core.hpp>
 
#if TIME_SHIELD_ENABLE_NTP_CLIENT
 
#include "detail/ntp_client_core.hpp"
#include "detail/ntp_packet.hpp"
#include "detail/udp_transport.hpp"
 
#if TIME_SHIELD_PLATFORM_WINDOWS
#   include "detail/udp_transport_win.hpp"
#elif TIME_SHIELD_PLATFORM_UNIX
#   include "detail/udp_transport_posix.hpp"
#endif
 
#include <atomic>
#include <cstdint>
#include <string>
 
namespace time_shield {
 
#if TIME_SHIELD_PLATFORM_WINDOWS
    namespace detail { using PlatformUdpTransport = UdpTransportWin; }
#elif TIME_SHIELD_PLATFORM_UNIX
    namespace detail { using PlatformUdpTransport = UdpTransportPosix; }
#endif
 
#if TIME_SHIELD_PLATFORM_WINDOWS || TIME_SHIELD_PLATFORM_UNIX
 
    class NtpClient {
    public:
        NtpClient(std::string server = "pool.ntp.org", int port = 123)
            : m_host(std::move(server))
            , m_port(port)
            , m_offset_us(0)
            , m_delay_us(0)
            , m_stratum(-1)
            , m_is_success(false) {
            now_realtime_us();
        }
 
        bool query() {
            last_error_code_slot() = 0;
 
#if TIME_SHIELD_PLATFORM_WINDOWS
            if (!WsaGuard::instance().success()) {
                last_error_code_slot() = WsaGuard::instance().ret_code();
                m_is_success = false;
                return false;
            }
#endif
 
            detail::PlatformUdpTransport transport;
            detail::NtpClientCore core;
 
            int error_code = 0;
            int64_t offset = 0;
            int64_t delay = 0;
            int stratum = -1;
 
            const bool ok = core.query(
                transport,
                m_host,
                m_port,
                k_default_timeout_ms,
                error_code,
                offset,
                delay,
                stratum
            );
 
            last_error_code_slot() = error_code;
 
            if (!ok) {
                m_delay_us = 0;
                m_stratum = -1;
                m_is_success = false;
                return false;
            }
 
            m_offset_us = offset;
            m_delay_us = delay;
            m_stratum = stratum;
            m_is_success = true;
            return true;
        }
 
        bool success() const noexcept { return m_is_success.load(); }
 
        int64_t offset_us() const noexcept { return m_offset_us; }
 
        int64_t delay_us() const noexcept { return m_delay_us; }
 
        int stratum() const noexcept { return m_stratum; }
 
        int64_t utc_time_us() const noexcept { return now_realtime_us() + m_offset_us.load(); }
 
        int64_t utc_time_ms() const noexcept { return utc_time_us() / 1000; }
 
        time_t utc_time_sec() const noexcept { return static_cast<time_t>(utc_time_us() / 1000000); }
 
        int last_error_code() const noexcept { return last_error_code_slot(); }
 
    private:
        std::string          m_host;
        int                  m_port;
        std::atomic<int64_t> m_offset_us;
        std::atomic<int64_t> m_delay_us;
        std::atomic<int>     m_stratum;
        std::atomic<bool>    m_is_success;
        static const int k_default_timeout_ms = 5000;
 
        static int& last_error_code_slot() noexcept {
            static TIME_SHIELD_THREAD_LOCAL int value = 0;
            return value;
        }
    };
 
#else
 
    class NtpClient {
    public:
        NtpClient() {
            static_assert(sizeof(void*) == 0, "NtpClient is disabled by configuration.");
        }
    };
 
#endif // platform switch
 
} // namespace time_shield
 
#else // TIME_SHIELD_ENABLE_NTP_CLIENT
 
namespace time_shield {
    class NtpClient {
    public:
        NtpClient() {
            static_assert(sizeof(void*) == 0, "NtpClient is disabled by configuration.");
        }
    };
} // namespace time_shield
 
#endif // TIME_SHIELD_ENABLE_NTP_CLIENT
 
#endif // TIME_SHIELD_HEADER_NTP_NTP_CLIENT_HPP_INCLUDED