ntputil.c

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-2.1-only */
#include <errno.h>
#include <netdb.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
 
#include "ntputil.h"
 
typedef struct _ntp_timestamp_t
{
  uint32_t sec;
  uint32_t frac;
} ntp_timestamp_t;
 
typedef struct _ntp_packet_t
{
  uint8_t li_vn_mode;
  uint8_t stratum;
  uint8_t poll;
  uint8_t precision;
  uint32_t root_delay;
  uint32_t root_dispersion;
  uint32_t ref_id;
  ntp_timestamp_t ref_ts;
  ntp_timestamp_t org_ts;
  ntp_timestamp_t recv_ts;
  ntp_timestamp_t xmit_ts;
} ntp_packet_t;
 
const uint64_t NTPUTIL_TIMESTAMP_DELTA = 2208988800ULL;
const double NTPUTIL_MAX_FRAC_DOUBLE = 4294967295.0L;
const int64_t NTPUTIL_SEC_TO_USEC_MULTIPLIER = 1000000;
const char NTPUTIL_DEFAULT_HNAME[] = "pool.ntp.org";
const uint16_t NTPUTIL_DEFAULT_PORT = 123;
 
uint32_t
_convert_to_host_byte_order (uint32_t in)
{
  return ntohl (in);
}
 
int64_t
ntputil_get_epoch (uint32_t hnums, char **hnames, uint16_t * ports)
{
  struct sockaddr_in serv_addr;
  struct hostent *srv = NULL;
  struct hostent *default_srv = NULL;
  uint16_t port = -1;
  int32_t sockfd = -1;
  uint32_t i;
  int64_t ret;
 
  sockfd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if (sockfd < 0) {
    ret = -1;
    goto ret_normal;
  }
 
  for (i = 0; i < hnums; ++i) {
    srv = gethostbyname (hnames[i]);
    if (srv != NULL) {
      port = ports[i];
      break;
    }
  }
 
  if (srv == NULL) {
    default_srv = gethostbyname (NTPUTIL_DEFAULT_HNAME);
    if (default_srv == NULL) {
      ret = -h_errno;
      goto ret_close_sockfd;
    }
    srv = default_srv;
    port = NTPUTIL_DEFAULT_PORT;
  }
 
  memset (&serv_addr, 0, sizeof (serv_addr));
  serv_addr.sin_family = AF_INET;
  memcpy ((uint8_t *) & serv_addr.sin_addr.s_addr,
      (uint8_t *) srv->h_addr_list[0], (size_t) srv->h_length);
  serv_addr.sin_port = htons (port);
 
  ret = connect (sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr));
  if (ret < 0) {
    ret = -errno;
    goto ret_close_sockfd;
  }
 
  {
    ntp_packet_t packet;
    uint32_t recv_sec;
    uint32_t recv_frac;
    double frac;
    ssize_t n;
 
    memset (&packet, 0, sizeof (packet));
 
    /* li = 0, vn = 3, mode = 3 */
    packet.li_vn_mode = 0x1B;
 
    /* Request */
    n = write (sockfd, &packet, sizeof (packet));
    if (n < 0) {
      ret = -errno;
      goto ret_close_sockfd;
    }
 
    /* Receive */
    n = read (sockfd, &packet, sizeof (packet));
    if (n < 0) {
      ret = -errno;
      goto ret_close_sockfd;
    }
 
    recv_sec = _convert_to_host_byte_order (packet.xmit_ts.sec);
    recv_frac = _convert_to_host_byte_order (packet.xmit_ts.frac);
 
    if (recv_sec <= NTPUTIL_TIMESTAMP_DELTA) {
      ret = -1;
      goto ret_close_sockfd;
    }
 
    ret = (int64_t) (recv_sec - NTPUTIL_TIMESTAMP_DELTA);
    ret *= NTPUTIL_SEC_TO_USEC_MULTIPLIER;
    frac = ((double) recv_frac) / NTPUTIL_MAX_FRAC_DOUBLE;
    frac *= NTPUTIL_SEC_TO_USEC_MULTIPLIER;
 
    ret += (int64_t) frac;
  }
 
ret_close_sockfd:
  close (sockfd);
 
ret_normal:
  return ret;
}