fc::detail::ntp_impl Class Reference

Collaboration diagram for fc::detail::ntp_impl:

Public Member Functions
	ntp_impl ()
	~ntp_impl ()
fc::time_point	ntp_timestamp_to_fc_time_point (uint64_t ntp_timestamp_net_order)
uint64_t	fc_time_point_to_ntp_timestamp (const fc::time_point &fc_timestamp)
void	request_now ()
void	request_time_task ()
void	start_read_loop ()
void	read_loop ()
void	reschedule ()

Public Attributes
fc::thread	_ntp_thread
std::vector< std::pair< std::string, uint16_t > >	_ntp_hosts
future< void >	_read_loop_done
udp_socket	_sock
uint32_t	_request_interval_sec
uint32_t	_retry_failed_request_interval_sec
fc::time_point	_last_valid_ntp_reply_received_time
std::atomic_bool	_last_ntp_delta_initialized
std::atomic< int64_t >	_last_ntp_delta_microseconds
future< void >	_request_time_task_done
std::shared_ptr< scheduled_task_impl< void > >	_scheduled_request_time

Detailed Description

Definition at line 18 of file ntp.cpp.

Constructor & Destructor Documentation

ntp_impl()

fc::detail::ntp_impl::ntp_impl ( )

inline

Definition at line 37 of file ntp.cpp.

                 :
      _ntp_thread("ntp"),
      _request_interval_sec( 60*60 /* 1 hr */),
      _retry_failed_request_interval_sec(60 * 5),
      _last_ntp_delta_microseconds(0)
      {
        _last_ntp_delta_initialized = false;
        _ntp_hosts.push_back( std::make_pair( "pool.ntp.org",123 ) );
      }

~ntp_impl()

fc::detail::ntp_impl::~ntp_impl ( )

inline

Definition at line 47 of file ntp.cpp.

      {
         _sock.close();
         if( _scheduled_request_time ) {
            _scheduled_request_time->cancel();
            _scheduled_request_time->get_future().wait();
            _scheduled_request_time.reset();
         }
      }

Here is the call graph for this function:

Member Function Documentation

fc_time_point_to_ntp_timestamp()

uint64_t fc::detail::ntp_impl::fc_time_point_to_ntp_timestamp ( const fc::time_point & fc_timestamp )

inline

Definition at line 67 of file ntp.cpp.

      {
        uint64_t microseconds_since_epoch = (uint64_t)fc_timestamp.time_since_epoch().count();
        uint32_t seconds_since_epoch = (uint32_t)(microseconds_since_epoch / 1000000);
        uint32_t seconds_since_1900 = seconds_since_epoch + 2208988800;
        uint32_t microseconds = microseconds_since_epoch % 1000000;
        uint32_t fractional_seconds = (uint32_t)((((uint64_t)microseconds << 32) + (uint64_t(1) << 31)) / 1000000);
        uint64_t ntp_timestamp_net_order = ((uint64_t)seconds_since_1900 << 32) + fractional_seconds;
        return bswap_64(ntp_timestamp_net_order);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

ntp_timestamp_to_fc_time_point()

fc::time_point fc::detail::ntp_impl::ntp_timestamp_to_fc_time_point ( uint64_t ntp_timestamp_net_order )

inline

Definition at line 57 of file ntp.cpp.

      {
        uint64_t ntp_timestamp_host = bswap_64(ntp_timestamp_net_order);
        uint32_t fractional_seconds = ntp_timestamp_host & 0xffffffff;
        uint32_t microseconds = (uint32_t)((((uint64_t)fractional_seconds * 1000000) + (uint64_t(1) << 31)) >> 32);
        uint32_t seconds_since_1900 = ntp_timestamp_host >> 32;
        uint32_t seconds_since_epoch = seconds_since_1900 - 2208988800;
        return fc::time_point() + fc::seconds(seconds_since_epoch) + fc::microseconds(microseconds);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

read_loop()

void fc::detail::ntp_impl::read_loop ( )

inline

Definition at line 137 of file ntp.cpp.

      {
        FC_ASSERT(_ntp_thread.is_current());
 
        uint32_t receive_buffer_size = sizeof(uint64_t) * 1024;
        std::shared_ptr<char> receive_buffer(new char[receive_buffer_size], [](char* p){ delete[] p; });
        uint64_t* recv_buf = (uint64_t*)receive_buffer.get();
 
        // if you start the read while loop here, the recieve_from call will throw "invalid argument" on win32,
        // so instead we start the loop after making our first request
        _sock.open();
        _request_time_task_done = fc::async( [&](){ request_time_task(); } );
 
        while( true )
        {
          fc::ip::endpoint from;
          try
          {
            _sock.receive_from( receive_buffer, receive_buffer_size, from );
          //  wlog("received ntp reply from ${from}",("from",from) );
          } FC_RETHROW_EXCEPTIONS(error, "Error reading from NTP socket");
 
          fc::time_point receive_time = fc::time_point::now();
          fc::time_point origin_time = ntp_timestamp_to_fc_time_point(recv_buf[3]);
          fc::time_point server_receive_time = ntp_timestamp_to_fc_time_point(recv_buf[4]);
          fc::time_point server_transmit_time = ntp_timestamp_to_fc_time_point(recv_buf[5]);
 
          fc::microseconds offset(((server_receive_time - origin_time) +
                                   (server_transmit_time - receive_time)).count() / 2);
          fc::microseconds round_trip_delay((receive_time - origin_time) -
                                            (server_transmit_time - server_receive_time));
          //wlog("origin_time = ${origin_time}, server_receive_time = ${server_receive_time}, server_transmit_time = ${server_transmit_time}, receive_time = ${receive_time}",
          //     ("origin_time", origin_time)("server_receive_time", server_receive_time)("server_transmit_time", server_transmit_time)("receive_time", receive_time));
          // wlog("ntp offset: ${offset}, round_trip_delay ${delay}", ("offset", offset)("delay", round_trip_delay));
 
          //if the reply we just received has occurred more than a second after our last time request (it was more than a second ago since our last request)
          if( round_trip_delay > fc::microseconds(300000) )
          {
            wlog("received stale ntp reply requested at ${request_time}, send a new time request", ("request_time", origin_time));
            request_now(); //request another reply and ignore this one
          }
          else //we think we have a timely reply, process it
          {
            if( offset < fc::seconds(60*60*24) && offset > fc::seconds(-60*60*24) )
            {
              _last_ntp_delta_microseconds = offset.count();
              _last_ntp_delta_initialized = true;
              fc::microseconds ntp_delta_time = fc::microseconds(_last_ntp_delta_microseconds);
              _last_valid_ntp_reply_received_time = receive_time;
              wlog("ntp_delta_time updated to ${delta_time} us", ("delta_time",ntp_delta_time) );
            }
            else
              elog( "NTP time and local time vary by more than a day! ntp:${ntp_time} local:${local}",
                   ("ntp_time", receive_time + offset)("local", fc::time_point::now()) );
          }
        }
        wlog("exiting ntp read_loop");
      } //end read_loop()

Here is the call graph for this function:

Here is the caller graph for this function:

request_now()

void fc::detail::ntp_impl::request_now ( )

inline

Definition at line 78 of file ntp.cpp.

      {
        FC_ASSERT(_ntp_thread.is_current());
        for( auto item : _ntp_hosts )
        {
          try
          {
            wlog( "resolving... ${r}", ("r", item) );
            auto eps = resolve( item.first, item.second );
            for( auto ep : eps )
            {
              wlog( "sending request to ${ep}", ("ep",ep) );
              std::shared_ptr<char> send_buffer(new char[48], [](char* p){ delete[] p; });
              std::array<unsigned char, 48> packet_to_send { {010,0,0,0,0,0,0,0,0} };
              memcpy(send_buffer.get(), packet_to_send.data(), packet_to_send.size());
              uint64_t* send_buf_as_64_array = (uint64_t*)send_buffer.get();
              send_buf_as_64_array[5] = fc_time_point_to_ntp_timestamp(fc::time_point::now()); // 5 = Transmit Timestamp
              _sock.send_to(send_buffer, packet_to_send.size(), ep);
              break;
            }
          }
          catch (const fc::canceled_exception&)
          {
            throw;
          }
          catch ( const std::bad_alloc& ) 
          {
            throw;
          } 
          catch ( const boost::interprocess::bad_alloc& ) 
          {
            throw;
          } 
          // this could fail to resolve but we want to go on to other hosts..
          catch ( const fc::exception& e )
          {
            elog( "${e}", ("e",e.to_detail_string() ) );
          }
          catch ( const std::exception& e )
          {
            elog( "${e}", ("e",e.what() ) );
          }
        }
      } // request_now

Here is the call graph for this function:

Here is the caller graph for this function:

request_time_task()

void fc::detail::ntp_impl::request_time_task ( )

inline

Definition at line 127 of file ntp.cpp.

      {
         request_now();
      } // request_loop

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule()

void fc::detail::ntp_impl::reschedule ( )

inline

Definition at line 196 of file ntp.cpp.

                        {
          if( _scheduled_request_time )
             _scheduled_request_time->cancel();
 
          _scheduled_request_time = _ntp_thread.schedule(
            [&](){
               request_now();
               reschedule();
            },
          fc::time_point::now() + fc::seconds(_request_interval_sec) );
      }

Here is the call graph for this function:

Here is the caller graph for this function:

start_read_loop()

void fc::detail::ntp_impl::start_read_loop ( )

inline

Definition at line 132 of file ntp.cpp.

      {
        _read_loop_done = _ntp_thread.async( [this](){ read_loop(); } );
      }

Here is the call graph for this function:

Member Data Documentation

_last_ntp_delta_initialized

std::atomic_bool fc::detail::ntp_impl::_last_ntp_delta_initialized

Definition at line 30 of file ntp.cpp.

_last_ntp_delta_microseconds

std::atomic<int64_t> fc::detail::ntp_impl::_last_ntp_delta_microseconds

Definition at line 31 of file ntp.cpp.

_last_valid_ntp_reply_received_time

fc::time_point fc::detail::ntp_impl::_last_valid_ntp_reply_received_time

Definition at line 28 of file ntp.cpp.

_ntp_hosts

std::vector< std::pair< std::string, uint16_t> > fc::detail::ntp_impl::_ntp_hosts

Definition at line 23 of file ntp.cpp.

_ntp_thread

fc::thread fc::detail::ntp_impl::_ntp_thread

vector < host, port >

Definition at line 22 of file ntp.cpp.

_read_loop_done

future<void> fc::detail::ntp_impl::_read_loop_done

Definition at line 24 of file ntp.cpp.

_request_interval_sec

uint32_t fc::detail::ntp_impl::_request_interval_sec

Definition at line 26 of file ntp.cpp.

_request_time_task_done

future<void> fc::detail::ntp_impl::_request_time_task_done

Definition at line 33 of file ntp.cpp.

_retry_failed_request_interval_sec

uint32_t fc::detail::ntp_impl::_retry_failed_request_interval_sec

Definition at line 27 of file ntp.cpp.

_scheduled_request_time

std::shared_ptr<scheduled_task_impl<void> > fc::detail::ntp_impl::_scheduled_request_time

Definition at line 35 of file ntp.cpp.

_sock

udp_socket fc::detail::ntp_impl::_sock

Definition at line 25 of file ntp.cpp.

---

The documentation for this class was generated from the following file:

• libraries/fc/src/network/ntp.cpp