/*

  chronyd/chronyc - Programs for keeping computer clocks accurate.

 **********************************************************************

 * Copyright (C) Richard P. Curnow  1997-2003

 * Copyright (C) Miroslav Lichvar  2009-2016, 2018

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of version 2 of the GNU General Public License as

 * published by the Free Software Foundation.

 * 

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 * 

 **********************************************************************

  =======================================================================

  Command and monitoring module in the main program

  */

#include "config.h"

#include "sysincl.h"

#include "cmdmon.h"

#include "candm.h"

#include "sched.h"

#include "util.h"

#include "logging.h"

#include "keys.h"

#include "ntp_sources.h"

#include "ntp_core.h"

#include "smooth.h"

#include "sources.h"

#include "sourcestats.h"

#include "reference.h"

#include "manual.h"

#include "memory.h"

#include "local.h"

#include "addrfilt.h"

#include "conf.h"

#include "rtc.h"

#include "pktlength.h"

#include "clientlog.h"

#include "refclock.h"

/* ================================================== */

union sockaddr_all {

  struct sockaddr_in in4;

#ifdef FEAT_IPV6

  struct sockaddr_in6 in6;

#endif

  struct sockaddr_un un;

  struct sockaddr sa;

};

/* File descriptors for command and monitoring sockets */

static int sock_fdu;

static int sock_fd4;

#ifdef FEAT_IPV6

static int sock_fd6;

#endif

/* Flag indicating whether this module has been initialised or not */

static int initialised = 0;

/* ================================================== */

/* Array of permission levels for command types */

static const char permissions[] = {

  PERMIT_OPEN, /* NULL */

  PERMIT_AUTH, /* ONLINE */

  PERMIT_AUTH, /* OFFLINE */

  PERMIT_AUTH, /* BURST */

  PERMIT_AUTH, /* MODIFY_MINPOLL */

  PERMIT_AUTH, /* MODIFY_MAXPOLL */

  PERMIT_AUTH, /* DUMP */

  PERMIT_AUTH, /* MODIFY_MAXDELAY */

  PERMIT_AUTH, /* MODIFY_MAXDELAYRATIO */

  PERMIT_AUTH, /* MODIFY_MAXUPDATESKEW */

  PERMIT_OPEN, /* LOGON */

  PERMIT_AUTH, /* SETTIME */

  PERMIT_AUTH, /* LOCAL */

  PERMIT_AUTH, /* MANUAL */

  PERMIT_OPEN, /* N_SOURCES */

  PERMIT_OPEN, /* SOURCE_DATA */

  PERMIT_AUTH, /* REKEY */

  PERMIT_AUTH, /* ALLOW */

  PERMIT_AUTH, /* ALLOWALL */

  PERMIT_AUTH, /* DENY */

  PERMIT_AUTH, /* DENYALL */

  PERMIT_AUTH, /* CMDALLOW */

  PERMIT_AUTH, /* CMDALLOWALL */

  PERMIT_AUTH, /* CMDDENY */

  PERMIT_AUTH, /* CMDDENYALL */

  PERMIT_AUTH, /* ACCHECK */

  PERMIT_AUTH, /* CMDACCHECK */

  PERMIT_AUTH, /* ADD_SERVER */

  PERMIT_AUTH, /* ADD_PEER */

  PERMIT_AUTH, /* DEL_SOURCE */

  PERMIT_AUTH, /* WRITERTC */

  PERMIT_AUTH, /* DFREQ */

  PERMIT_AUTH, /* DOFFSET */

  PERMIT_OPEN, /* TRACKING */

  PERMIT_OPEN, /* SOURCESTATS */

  PERMIT_OPEN, /* RTCREPORT */

  PERMIT_AUTH, /* TRIMRTC */

  PERMIT_AUTH, /* CYCLELOGS */

  PERMIT_AUTH, /* SUBNETS_ACCESSED */

  PERMIT_AUTH, /* CLIENT_ACCESSES (by subnet) */

  PERMIT_AUTH, /* CLIENT_ACCESSES_BY_INDEX */

  PERMIT_OPEN, /* MANUAL_LIST */

  PERMIT_AUTH, /* MANUAL_DELETE */

  PERMIT_AUTH, /* MAKESTEP */

  PERMIT_OPEN, /* ACTIVITY */

  PERMIT_AUTH, /* MODIFY_MINSTRATUM */

  PERMIT_AUTH, /* MODIFY_POLLTARGET */

  PERMIT_AUTH, /* MODIFY_MAXDELAYDEVRATIO */

  PERMIT_AUTH, /* RESELECT */

  PERMIT_AUTH, /* RESELECTDISTANCE */

  PERMIT_AUTH, /* MODIFY_MAKESTEP */

  PERMIT_OPEN, /* SMOOTHING */

  PERMIT_AUTH, /* SMOOTHTIME */

  PERMIT_AUTH, /* REFRESH */

  PERMIT_AUTH, /* SERVER_STATS */

  PERMIT_AUTH, /* CLIENT_ACCESSES_BY_INDEX2 */

  PERMIT_AUTH, /* LOCAL2 */

  PERMIT_AUTH, /* NTP_DATA */

  PERMIT_AUTH, /* ADD_SERVER2 */

  PERMIT_AUTH, /* ADD_PEER2 */

  PERMIT_AUTH, /* ADD_SERVER3 */

  PERMIT_AUTH, /* ADD_PEER3 */

  PERMIT_AUTH, /* SHUTDOWN */

  PERMIT_AUTH, /* ONOFFLINE */

};

/* ================================================== */

/* This authorisation table is used for checking whether particular

   machines are allowed to make command and monitoring requests. */

static ADF_AuthTable access_auth_table;

/* ================================================== */

/* Forward prototypes */

static void read_from_cmd_socket(int sock_fd, int event, void *anything);

/* ================================================== */

static int

prepare_socket(int family, int port_number)

{

  int sock_fd;

  socklen_t my_addr_len;

  union sockaddr_all my_addr;

  IPAddr bind_address;

  int on_off = 1;

  sock_fd = socket(family, SOCK_DGRAM, 0);

  if (sock_fd < 0) {

    LOG(LOGS_ERR, "Could not open %s command socket : %s",

        UTI_SockaddrFamilyToString(family), strerror(errno));

    return -1;

  }

  /* Close on exec */

  UTI_FdSetCloexec(sock_fd);

  if (family != AF_UNIX) {

    /* Allow reuse of port number */

    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on_off, sizeof(on_off)) < 0) {

      LOG(LOGS_ERR, "Could not set reuseaddr socket options");

      /* Don't quit - we might survive anyway */

    }

#ifdef IP_FREEBIND

    /* Allow binding to address that doesn't exist yet */

    if (setsockopt(sock_fd, IPPROTO_IP, IP_FREEBIND, (char *)&on_off, sizeof(on_off)) < 0) {

      LOG(LOGS_ERR, "Could not set free bind socket option");

    }

#endif

#ifdef FEAT_IPV6

    if (family == AF_INET6) {

#ifdef IPV6_V6ONLY

      /* Receive IPv6 packets only */

      if (setsockopt(sock_fd, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&on_off, sizeof(on_off)) < 0) {

        LOG(LOGS_ERR, "Could not request IPV6_V6ONLY socket option");

      }

#endif

    }

#endif

  }

  memset(&my_addr, 0, sizeof (my_addr));

  switch (family) {

    case AF_INET:

      my_addr_len = sizeof (my_addr.in4);

      my_addr.in4.sin_family = family;

      my_addr.in4.sin_port = htons((unsigned short)port_number);

      CNF_GetBindCommandAddress(IPADDR_INET4, &bind_address);

      if (bind_address.family == IPADDR_INET4)

        my_addr.in4.sin_addr.s_addr = htonl(bind_address.addr.in4);

      else

        my_addr.in4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

      break;

#ifdef FEAT_IPV6

    case AF_INET6:

      my_addr_len = sizeof (my_addr.in6);

      my_addr.in6.sin6_family = family;

      my_addr.in6.sin6_port = htons((unsigned short)port_number);

      CNF_GetBindCommandAddress(IPADDR_INET6, &bind_address);

      if (bind_address.family == IPADDR_INET6)

        memcpy(my_addr.in6.sin6_addr.s6_addr, bind_address.addr.in6,

            sizeof (my_addr.in6.sin6_addr.s6_addr));

      else

        my_addr.in6.sin6_addr = in6addr_loopback;

      break;

#endif

    case AF_UNIX:

      my_addr_len = sizeof (my_addr.un);

      my_addr.un.sun_family = family;

      if (snprintf(my_addr.un.sun_path, sizeof (my_addr.un.sun_path), "%s",

                   CNF_GetBindCommandPath()) >= sizeof (my_addr.un.sun_path))

        LOG_FATAL("Unix socket path too long");

      unlink(my_addr.un.sun_path);

      break;

    default:

      assert(0);

  }

  if (bind(sock_fd, &my_addr.sa, my_addr_len) < 0) {

    LOG(LOGS_ERR, "Could not bind %s command socket : %s",

        UTI_SockaddrFamilyToString(family), strerror(errno));

    close(sock_fd);

    return -1;

  }

  /* Register handler for read events on the socket */

  SCH_AddFileHandler(sock_fd, SCH_FILE_INPUT, read_from_cmd_socket, NULL);

  return sock_fd;

}

/* ================================================== */

static void

do_size_checks(void)

{

  int i, request_length, padding_length, reply_length;

  CMD_Request request;

  CMD_Reply reply;

  assert(offsetof(CMD_Request, data) == 20);

  assert(offsetof(CMD_Reply, data) == 28);

  for (i = 0; i < N_REQUEST_TYPES; i++) {

    request.version = PROTO_VERSION_NUMBER;

    request.command = htons(i);

    request_length = PKL_CommandLength(&request);

    padding_length = PKL_CommandPaddingLength(&request);

    if (padding_length > MAX_PADDING_LENGTH || padding_length > request_length ||

        request_length > sizeof (CMD_Request) ||

        (request_length && request_length < offsetof(CMD_Request, data)))

      assert(0);

  }

  for (i = 1; i < N_REPLY_TYPES; i++) {

    reply.reply = htons(i);

    reply.status = STT_SUCCESS;

    reply_length = PKL_ReplyLength(&reply);

    if ((reply_length && reply_length < offsetof(CMD_Reply, data)) ||

        reply_length > sizeof (CMD_Reply))

      assert(0);

  }

}

/* ================================================== */

void

CAM_Initialise(int family)

{

  int port_number;

  assert(!initialised);

  assert(sizeof (permissions) / sizeof (permissions[0]) == N_REQUEST_TYPES);

  do_size_checks();

  initialised = 1;

  sock_fdu = -1;

  port_number = CNF_GetCommandPort();

  if (port_number && (family == IPADDR_UNSPEC || family == IPADDR_INET4))

    sock_fd4 = prepare_socket(AF_INET, port_number);

  else

    sock_fd4 = -1;

#ifdef FEAT_IPV6

  if (port_number && (family == IPADDR_UNSPEC || family == IPADDR_INET6))

    sock_fd6 = prepare_socket(AF_INET6, port_number);

  else

    sock_fd6 = -1;

#endif

  if (port_number && sock_fd4 < 0

#ifdef FEAT_IPV6

      && sock_fd6 < 0

#endif

      ) {

    LOG_FATAL("Could not open any command socket");

  }

  access_auth_table = ADF_CreateTable();

}

/* ================================================== */

void

CAM_Finalise(void)

{

  if (sock_fdu >= 0) {

    SCH_RemoveFileHandler(sock_fdu);

    close(sock_fdu);

    unlink(CNF_GetBindCommandPath());

  }

  sock_fdu = -1;

  if (sock_fd4 >= 0) {

    SCH_RemoveFileHandler(sock_fd4);

    close(sock_fd4);

  }

  sock_fd4 = -1;

#ifdef FEAT_IPV6

  if (sock_fd6 >= 0) {

    SCH_RemoveFileHandler(sock_fd6);

    close(sock_fd6);

  }

  sock_fd6 = -1;

#endif

  ADF_DestroyTable(access_auth_table);

  initialised = 0;

}

/* ================================================== */

void

CAM_OpenUnixSocket(void)

{

  /* This is separated from CAM_Initialise() as it needs to be called when

     the process has already dropped the root privileges */

  if (CNF_GetBindCommandPath()[0])

    sock_fdu = prepare_socket(AF_UNIX, 0);

}

/* ================================================== */

static void

transmit_reply(CMD_Reply *msg, union sockaddr_all *where_to)

{

  int status;

  int tx_message_length;

  int sock_fd;

  socklen_t addrlen;

  switch (where_to->sa.sa_family) {

    case AF_INET:

      sock_fd = sock_fd4;

      addrlen = sizeof (where_to->in4);

      break;

#ifdef FEAT_IPV6

    case AF_INET6:

      sock_fd = sock_fd6;

      addrlen = sizeof (where_to->in6);

      break;

#endif

    case AF_UNIX:

      sock_fd = sock_fdu;

      addrlen = sizeof (where_to->un);

      break;

    default:

      assert(0);

  }

  tx_message_length = PKL_ReplyLength(msg);

  status = sendto(sock_fd, (void *) msg, tx_message_length, 0,

                  &where_to->sa, addrlen);

  if (status < 0) {

    DEBUG_LOG("Could not send to %s fd %d : %s",

              UTI_SockaddrToString(&where_to->sa), sock_fd, strerror(errno));

    return;

  }

  DEBUG_LOG("Sent %d bytes to %s fd %d", status,

            UTI_SockaddrToString(&where_to->sa), sock_fd);

}

/* ================================================== */

static void

handle_dump(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  SRC_DumpSources();

}

/* ================================================== */

static void

handle_online(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address, mask;

  UTI_IPNetworkToHost(&rx_message->data.online.mask, &mask);

  UTI_IPNetworkToHost(&rx_message->data.online.address, &address);

  if (!NSR_SetConnectivity(&mask, &address, SRC_ONLINE))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_offline(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address, mask;

  UTI_IPNetworkToHost(&rx_message->data.offline.mask, &mask);

  UTI_IPNetworkToHost(&rx_message->data.offline.address, &address);

  if (!NSR_SetConnectivity(&mask, &address, SRC_OFFLINE))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_onoffline(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address, mask;

  address.family = mask.family = IPADDR_UNSPEC;

  if (!NSR_SetConnectivity(&mask, &address, SRC_MAYBE_ONLINE))

    ;

}

/* ================================================== */

static void

handle_burst(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address, mask;

  UTI_IPNetworkToHost(&rx_message->data.burst.mask, &mask);

  UTI_IPNetworkToHost(&rx_message->data.burst.address, &address);

  if (!NSR_InitiateSampleBurst(ntohl(rx_message->data.burst.n_good_samples),

                               ntohl(rx_message->data.burst.n_total_samples),

                               &mask, &address))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_minpoll(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_minpoll.address, &address);

  if (!NSR_ModifyMinpoll(&address,

                         ntohl(rx_message->data.modify_minpoll.new_minpoll)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_maxpoll(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_minpoll.address, &address);

  if (!NSR_ModifyMaxpoll(&address,

                         ntohl(rx_message->data.modify_minpoll.new_minpoll)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_maxdelay(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_maxdelay.address, &address);

  if (!NSR_ModifyMaxdelay(&address,

        UTI_FloatNetworkToHost(rx_message->data.modify_maxdelay.new_max_delay)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_maxdelayratio(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_maxdelayratio.address, &address);

  if (!NSR_ModifyMaxdelayratio(&address,

        UTI_FloatNetworkToHost(rx_message->data.modify_maxdelayratio.new_max_delay_ratio)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_maxdelaydevratio(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_maxdelaydevratio.address, &address);

  if (!NSR_ModifyMaxdelaydevratio(&address,

        UTI_FloatNetworkToHost(rx_message->data.modify_maxdelaydevratio.new_max_delay_dev_ratio)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_minstratum(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_minpoll.address, &address);

  if (!NSR_ModifyMinstratum(&address,

                            ntohl(rx_message->data.modify_minstratum.new_min_stratum)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_polltarget(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr address;

  UTI_IPNetworkToHost(&rx_message->data.modify_polltarget.address, &address);

  if (!NSR_ModifyPolltarget(&address,

                            ntohl(rx_message->data.modify_polltarget.new_poll_target)))

    tx_message->status = htons(STT_NOSUCHSOURCE);

}

/* ================================================== */

static void

handle_modify_maxupdateskew(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  REF_ModifyMaxupdateskew(UTI_FloatNetworkToHost(rx_message->data.modify_maxupdateskew.new_max_update_skew));

}

/* ================================================== */

static void

handle_modify_makestep(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  REF_ModifyMakestep(ntohl(rx_message->data.modify_makestep.limit),

                     UTI_FloatNetworkToHost(rx_message->data.modify_makestep.threshold));

}

/* ================================================== */

static void

handle_settime(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  struct timespec ts;

  double offset, dfreq_ppm, new_afreq_ppm;

  UTI_TimespecNetworkToHost(&rx_message->data.settime.ts, &ts);

  if (!MNL_IsEnabled()) {

    tx_message->status = htons(STT_NOTENABLED);

  } else if (MNL_AcceptTimestamp(&ts, &offset, &dfreq_ppm, &new_afreq_ppm)) {

    tx_message->reply = htons(RPY_MANUAL_TIMESTAMP2);

    tx_message->data.manual_timestamp.offset = UTI_FloatHostToNetwork(offset);

    tx_message->data.manual_timestamp.dfreq_ppm = UTI_FloatHostToNetwork(dfreq_ppm);

    tx_message->data.manual_timestamp.new_afreq_ppm = UTI_FloatHostToNetwork(new_afreq_ppm);

  } else {

    tx_message->status = htons(STT_FAILED);

  }

}

/* ================================================== */

static void

handle_local(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  if (ntohl(rx_message->data.local.on_off)) {

    REF_EnableLocal(ntohl(rx_message->data.local.stratum),

                    UTI_FloatNetworkToHost(rx_message->data.local.distance),

                    ntohl(rx_message->data.local.orphan));

  } else {

    REF_DisableLocal();

  }

}

/* ================================================== */

static void

handle_manual(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  int option;

  option = ntohl(rx_message->data.manual.option);

  switch (option) {

    case 0:

      MNL_Disable();

      break;

    case 1:

      MNL_Enable();

      break;

    case 2:

      MNL_Reset();

      break;

    default:

      tx_message->status = htons(STT_INVALID);

      break;

  }

}

/* ================================================== */

static void

handle_n_sources(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  int n_sources;

  n_sources = SRC_ReadNumberOfSources();

  tx_message->reply = htons(RPY_N_SOURCES);

  tx_message->data.n_sources.n_sources = htonl(n_sources);

}

/* ================================================== */

static void

handle_source_data(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  RPT_SourceReport report;

  struct timespec now_corr;

  /* Get data */

  SCH_GetLastEventTime(&now_corr, NULL, NULL);

  if (SRC_ReportSource(ntohl(rx_message->data.source_data.index), &report, &now_corr)) {

    switch (SRC_GetType(ntohl(rx_message->data.source_data.index))) {

      case SRC_NTP:

        NSR_ReportSource(&report, &now_corr);

        break;

      case SRC_REFCLOCK:

        RCL_ReportSource(&report, &now_corr);

        break;

    }

    tx_message->reply  = htons(RPY_SOURCE_DATA);

    UTI_IPHostToNetwork(&report.ip_addr, &tx_message->data.source_data.ip_addr);

    tx_message->data.source_data.stratum = htons(report.stratum);

    tx_message->data.source_data.poll    = htons(report.poll);

    switch (report.state) {

      case RPT_SYNC:

        tx_message->data.source_data.state   = htons(RPY_SD_ST_SYNC);

        break;

      case RPT_UNREACH:

        tx_message->data.source_data.state   = htons(RPY_SD_ST_UNREACH);

        break;

      case RPT_FALSETICKER:

        tx_message->data.source_data.state   = htons(RPY_SD_ST_FALSETICKER);

        break;

      case RPT_JITTERY:

        tx_message->data.source_data.state   = htons(RPY_SD_ST_JITTERY);

        break;

      case RPT_CANDIDATE:

        tx_message->data.source_data.state   = htons(RPY_SD_ST_CANDIDATE);

        break;

      case RPT_OUTLIER:

        tx_message->data.source_data.state   = htons(RPY_SD_ST_OUTLIER);

        break;

    }

    switch (report.mode) {

      case RPT_NTP_CLIENT:

        tx_message->data.source_data.mode    = htons(RPY_SD_MD_CLIENT);

        break;

      case RPT_NTP_PEER:

        tx_message->data.source_data.mode    = htons(RPY_SD_MD_PEER);

        break;

      case RPT_LOCAL_REFERENCE:

        tx_message->data.source_data.mode    = htons(RPY_SD_MD_REF);

        break;

    }

    tx_message->data.source_data.flags =

                  htons((report.sel_options & SRC_SELECT_PREFER ? RPY_SD_FLAG_PREFER : 0) |

                        (report.sel_options & SRC_SELECT_NOSELECT ? RPY_SD_FLAG_NOSELECT : 0) |

                        (report.sel_options & SRC_SELECT_TRUST ? RPY_SD_FLAG_TRUST : 0) |

                        (report.sel_options & SRC_SELECT_REQUIRE ? RPY_SD_FLAG_REQUIRE : 0));

    tx_message->data.source_data.reachability = htons(report.reachability);

    tx_message->data.source_data.since_sample = htonl(report.latest_meas_ago);

    tx_message->data.source_data.orig_latest_meas = UTI_FloatHostToNetwork(report.orig_latest_meas);

    tx_message->data.source_data.latest_meas = UTI_FloatHostToNetwork(report.latest_meas);

    tx_message->data.source_data.latest_meas_err = UTI_FloatHostToNetwork(report.latest_meas_err);

  } else {

    tx_message->status = htons(STT_NOSUCHSOURCE);

  }

}

/* ================================================== */

static void

handle_rekey(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  KEY_Reload();

}

/* ================================================== */

static void

handle_allowdeny(CMD_Request *rx_message, CMD_Reply *tx_message, int allow, int all)

{

  IPAddr ip;

  int subnet_bits;

  UTI_IPNetworkToHost(&rx_message->data.allow_deny.ip, &ip);

  subnet_bits = ntohl(rx_message->data.allow_deny.subnet_bits);

  if (!NCR_AddAccessRestriction(&ip, subnet_bits, allow, all))

    tx_message->status = htons(STT_BADSUBNET);

}

/* ================================================== */

static void

handle_cmdallowdeny(CMD_Request *rx_message, CMD_Reply *tx_message, int allow, int all)

{

  IPAddr ip;

  int subnet_bits;

  UTI_IPNetworkToHost(&rx_message->data.allow_deny.ip, &ip);

  subnet_bits = ntohl(rx_message->data.allow_deny.subnet_bits);

  if (!CAM_AddAccessRestriction(&ip, subnet_bits, allow, all))

    tx_message->status = htons(STT_BADSUBNET);

}

/* ================================================== */

static void

handle_accheck(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr ip;

  UTI_IPNetworkToHost(&rx_message->data.ac_check.ip, &ip);

  if (NCR_CheckAccessRestriction(&ip)) {

    tx_message->status = htons(STT_ACCESSALLOWED);

  } else {

    tx_message->status = htons(STT_ACCESSDENIED);

  }

}

/* ================================================== */

static void

handle_cmdaccheck(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  IPAddr ip;

  UTI_IPNetworkToHost(&rx_message->data.ac_check.ip, &ip);

  if (CAM_CheckAccessRestriction(&ip)) {

    tx_message->status = htons(STT_ACCESSALLOWED);

  } else {

    tx_message->status = htons(STT_ACCESSDENIED);

  }

}

/* ================================================== */

static void

handle_add_source(NTP_Source_Type type, CMD_Request *rx_message, CMD_Reply *tx_message)

{

  NTP_Remote_Address rem_addr;

  SourceParameters params;

  NSR_Status status;

  UTI_IPNetworkToHost(&rx_message->data.ntp_source.ip_addr, &rem_addr.ip_addr);

  rem_addr.port = (unsigned short)(ntohl(rx_message->data.ntp_source.port));

  params.minpoll = ntohl(rx_message->data.ntp_source.minpoll);

  params.maxpoll = ntohl(rx_message->data.ntp_source.maxpoll);

  params.presend_minpoll = ntohl(rx_message->data.ntp_source.presend_minpoll);

  params.min_stratum = ntohl(rx_message->data.ntp_source.min_stratum);

  params.poll_target = ntohl(rx_message->data.ntp_source.poll_target);

  params.version = ntohl(rx_message->data.ntp_source.version);

  params.max_sources = ntohl(rx_message->data.ntp_source.max_sources);

  params.min_samples = ntohl(rx_message->data.ntp_source.min_samples);

  params.max_samples = ntohl(rx_message->data.ntp_source.max_samples);

  params.filter_length = ntohl(rx_message->data.ntp_source.filter_length);

  params.authkey = ntohl(rx_message->data.ntp_source.authkey);

  params.max_delay = UTI_FloatNetworkToHost(rx_message->data.ntp_source.max_delay);

  params.max_delay_ratio =

    UTI_FloatNetworkToHost(rx_message->data.ntp_source.max_delay_ratio);

  params.max_delay_dev_ratio =

    UTI_FloatNetworkToHost(rx_message->data.ntp_source.max_delay_dev_ratio);

  params.min_delay = UTI_FloatNetworkToHost(rx_message->data.ntp_source.min_delay);

  params.asymmetry = UTI_FloatNetworkToHost(rx_message->data.ntp_source.asymmetry);

  params.offset = UTI_FloatNetworkToHost(rx_message->data.ntp_source.offset);

  params.connectivity = ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_ONLINE ?

                        SRC_ONLINE : SRC_OFFLINE;

  params.auto_offline = ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_AUTOOFFLINE ? 1 : 0;

  params.iburst = ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_IBURST ? 1 : 0;

  params.interleaved = ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_INTERLEAVED ? 1 : 0;

  params.burst = ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_BURST ? 1 : 0;

  params.sel_options =

    (ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_PREFER ? SRC_SELECT_PREFER : 0) |

    (ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_NOSELECT ? SRC_SELECT_NOSELECT : 0) |

    (ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_TRUST ? SRC_SELECT_TRUST : 0) |

    (ntohl(rx_message->data.ntp_source.flags) & REQ_ADDSRC_REQUIRE ? SRC_SELECT_REQUIRE : 0);

  status = NSR_AddSource(&rem_addr, type, &params);

  switch (status) {

    case NSR_Success:

      break;

    case NSR_AlreadyInUse:

      tx_message->status = htons(STT_SOURCEALREADYKNOWN);

      break;

    case NSR_TooManySources:

      tx_message->status = htons(STT_TOOMANYSOURCES);

      break;

    case NSR_InvalidAF:

      tx_message->status = htons(STT_INVALIDAF);

      break;

    case NSR_NoSuchSource:

      assert(0);

      break;

  }

}

/* ================================================== */

static void

handle_del_source(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  NTP_Remote_Address rem_addr;

  NSR_Status status;

  UTI_IPNetworkToHost(&rx_message->data.del_source.ip_addr, &rem_addr.ip_addr);

  rem_addr.port = 0;

  status = NSR_RemoveSource(&rem_addr);

  switch (status) {

    case NSR_Success:

      break;

    case NSR_NoSuchSource:

      tx_message->status = htons(STT_NOSUCHSOURCE);

      break;

    case NSR_TooManySources:

    case NSR_AlreadyInUse:

    case NSR_InvalidAF:

      assert(0);

      break;

  }

}

/* ================================================== */

static void

handle_writertc(CMD_Request *rx_message, CMD_Reply *tx_message)

{

  switch (RTC_WriteParameters()) {

    case RTC_ST_OK:

      break;

    case RTC_ST_NODRV:

      tx_message->status = htons(STT_NORTC);