2597 lines
73 KiB
C
2597 lines
73 KiB
C
/*
|
|
$Header: /cvs/src/chrony/client.c,v 1.68 2003/09/22 21:22:30 richard Exp $
|
|
|
|
=======================================================================
|
|
|
|
chronyd/chronyc - Programs for keeping computer clocks accurate.
|
|
|
|
**********************************************************************
|
|
* Copyright (C) Richard P. Curnow 1997-2003
|
|
*
|
|
* 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.,
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
|
*
|
|
**********************************************************************
|
|
|
|
=======================================================================
|
|
|
|
Command line client for configuring the daemon and obtaining status
|
|
from it whilst running.
|
|
*/
|
|
|
|
#include "sysincl.h"
|
|
|
|
#include "candm.h"
|
|
#include "nameserv.h"
|
|
#include "md5.h"
|
|
#include "version.h"
|
|
#include "getdate.h"
|
|
#include "cmdparse.h"
|
|
#include "pktlength.h"
|
|
#include "memory.h"
|
|
|
|
#ifdef FEAT_READLINE
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
#endif
|
|
|
|
/* ================================================== */
|
|
|
|
static int sock_fd;
|
|
struct sockaddr_in his_addr;
|
|
|
|
static int on_terminal = 0;
|
|
|
|
static int no_dns = 0;
|
|
|
|
/* ================================================== */
|
|
/* Forward prototypes */
|
|
|
|
static void process_cmd_manual_list(const char *line);
|
|
static void process_cmd_manual_delete(const char *line);
|
|
|
|
/* ================================================== */
|
|
/* Ought to extract some code from util.c to make
|
|
a new set of utilities that can be linked into either
|
|
the daemon or the client. */
|
|
|
|
static char *
|
|
time_to_log_form(time_t t)
|
|
{
|
|
struct tm stm;
|
|
static char buffer[64];
|
|
static const char *months[] = {"Jan", "Feb", "Mar", "Apr",
|
|
"May", "Jun", "Jul", "Aug",
|
|
"Sep", "Oct", "Nov", "Dec"};
|
|
|
|
|
|
stm = *gmtime(&t);
|
|
snprintf(buffer, sizeof(buffer),
|
|
"%2d%s%02d %02d:%02d:%02d",
|
|
stm.tm_mday, months[stm.tm_mon], stm.tm_year % 100,
|
|
stm.tm_hour, stm.tm_min, stm.tm_sec);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static char *
|
|
UTI_IPToDottedQuad(unsigned long ip)
|
|
{
|
|
unsigned long a, b, c, d;
|
|
static char result[64];
|
|
a = (ip>>24) & 0xff;
|
|
b = (ip>>16) & 0xff;
|
|
c = (ip>> 8) & 0xff;
|
|
d = (ip>> 0) & 0xff;
|
|
snprintf(result, sizeof(result), "%ld.%ld.%ld.%ld", a, b, c, d);
|
|
return result;
|
|
}
|
|
|
|
/* ================================================== */
|
|
/* Read a single line of commands from standard input. Eventually we
|
|
might want to use the GNU readline library. */
|
|
|
|
static char *
|
|
read_line(void)
|
|
{
|
|
static char line[2048];
|
|
static const char *prompt = "chronyc> ";
|
|
|
|
if (on_terminal) {
|
|
#ifdef FEAT_READLINE
|
|
char *cmd;
|
|
|
|
/* save line only if not empty */
|
|
cmd = readline(prompt);
|
|
if( cmd == NULL ) return( NULL );
|
|
|
|
/* user pressed return */
|
|
if( *cmd != '\0' ) {
|
|
strncpy(line, cmd, sizeof(line) - 1);
|
|
line[sizeof(line) - 1] = '\0';
|
|
add_history(cmd);
|
|
/* free the buffer allocated by readline */
|
|
free(cmd);
|
|
} else {
|
|
/* simulate the user has entered an empty line */
|
|
*line = '\0';
|
|
}
|
|
return( line );
|
|
#else
|
|
printf(prompt);
|
|
#endif
|
|
}
|
|
if (fgets(line, sizeof(line), stdin)) {
|
|
return line;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static unsigned long
|
|
get_address(const char *hostname)
|
|
{
|
|
char *address0;
|
|
struct hostent *host;
|
|
unsigned long result;
|
|
|
|
/* Note, this call could block for a while */
|
|
host = gethostbyname(hostname);
|
|
if (host == NULL) {
|
|
fprintf(stderr, "Could not get IP address for %s\n", hostname);
|
|
exit(1);
|
|
} else {
|
|
address0 = host->h_addr_list[0];
|
|
result = ((((unsigned long) address0[0]) << 24) |
|
|
(((unsigned long) address0[1]) << 16) |
|
|
(((unsigned long) address0[2]) << 8) |
|
|
(((unsigned long) address0[3])));
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
/* Initialise the socket used to talk to the daemon */
|
|
|
|
static void
|
|
open_io(const char *hostname, int port)
|
|
{
|
|
struct sockaddr_in my_addr;
|
|
|
|
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (sock_fd < 0) {
|
|
perror("Can't create socket");
|
|
exit(1);
|
|
}
|
|
|
|
my_addr.sin_family = AF_INET;
|
|
my_addr.sin_port = htons(INADDR_ANY);
|
|
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
|
if(bind(sock_fd, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0) {
|
|
perror("Can't bind socket");
|
|
exit(1);
|
|
}
|
|
|
|
/* Build the socket address structure for sending packets */
|
|
his_addr.sin_family = AF_INET;
|
|
his_addr.sin_addr.s_addr = htonl(get_address(hostname));
|
|
|
|
/* Eventually the port number needs to be a command line param */
|
|
his_addr.sin_port = htons(port);
|
|
|
|
return;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
close_io(void)
|
|
{
|
|
|
|
close(sock_fd);
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
read_mask_address(char *line, unsigned long *mask, unsigned long *address)
|
|
{
|
|
unsigned int ma, mb, mc, md, aa, ab, ac, ad;
|
|
int ok = 0;
|
|
char *p;
|
|
|
|
p = line;
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
if (!*p) {
|
|
*mask = *address = 0;
|
|
ok = 1;
|
|
} else {
|
|
|
|
if (sscanf(line, "%u.%u.%u.%u/%u.%u.%u.%u",
|
|
&ma, &mb, &mc, &md,
|
|
&aa, &ab, &ac, &ad) != 8) {
|
|
fprintf(stderr, "Invalid syntax for mask/address\n");
|
|
ok = 0;
|
|
} else {
|
|
*mask = (ma << 24) | (mb << 16) | (mc << 8) | md;
|
|
*address = (aa << 24) | (ab << 16) | (ac << 8) | ad;
|
|
ok = 1;
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_offline(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long mask, address;
|
|
int ok;
|
|
|
|
if (read_mask_address(line, &mask, &address)) {
|
|
msg->data.offline.mask = htonl(mask);
|
|
msg->data.offline.address = htonl(address);
|
|
msg->command = htons(REQ_OFFLINE);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
|
|
static int
|
|
process_cmd_online(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long mask, address;
|
|
int ok;
|
|
|
|
if (read_mask_address(line, &mask, &address)) {
|
|
msg->data.online.mask = htonl(mask);
|
|
msg->data.online.address = htonl(address);
|
|
msg->command = htons(REQ_ONLINE);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
read_address_integer(char *line, unsigned long *address, int *value)
|
|
{
|
|
char hostname[2048];
|
|
int ok = 0;
|
|
|
|
if (sscanf(line, "%2047s %d", hostname, value) != 2) {
|
|
fprintf(stderr, "Invalid syntax for address value\n");
|
|
ok = 0;
|
|
} else {
|
|
*address = DNS_Name2IPAddress(hostname);
|
|
if (*address == DNS_Failed_Address) {
|
|
fprintf(stderr, "Could not get address for hostname\n");
|
|
ok = 0;
|
|
} else {
|
|
ok = 1;
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
read_address_double(char *line, unsigned long *address, double *value)
|
|
{
|
|
char hostname[2048];
|
|
int ok = 0;
|
|
|
|
if (sscanf(line, "%2047s %lf", hostname, value) != 2) {
|
|
fprintf(stderr, "Invalid syntax for address value\n");
|
|
ok = 0;
|
|
} else {
|
|
*address = DNS_Name2IPAddress(hostname);
|
|
if (*address == DNS_Failed_Address) {
|
|
fprintf(stderr, "Could not get address for hostname\n");
|
|
ok = 0;
|
|
} else {
|
|
ok = 1;
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_minpoll(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long address;
|
|
int minpoll;
|
|
int ok;
|
|
|
|
if (read_address_integer(line, &address, &minpoll)) {
|
|
msg->data.modify_minpoll.address = htonl(address);
|
|
msg->data.modify_minpoll.new_minpoll = htonl(minpoll);
|
|
msg->command = htons(REQ_MODIFY_MINPOLL);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_maxpoll(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long address;
|
|
int maxpoll;
|
|
int ok;
|
|
|
|
if (read_address_integer(line, &address, &maxpoll)) {
|
|
msg->data.modify_maxpoll.address = htonl(address);
|
|
msg->data.modify_maxpoll.new_maxpoll = htonl(maxpoll);
|
|
msg->command = htons(REQ_MODIFY_MAXPOLL);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_maxdelay(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long address;
|
|
double max_delay;
|
|
int ok;
|
|
|
|
if (read_address_double(line, &address, &max_delay)) {
|
|
msg->data.modify_maxdelay.address = htonl(address);
|
|
msg->data.modify_maxdelay.new_max_delay = REAL2WIRE(max_delay);
|
|
msg->command = htons(REQ_MODIFY_MAXDELAY);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_maxdelayratio(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long address;
|
|
double max_delay_ratio;
|
|
int ok;
|
|
|
|
if (read_address_double(line, &address, &max_delay_ratio)) {
|
|
msg->data.modify_maxdelayratio.address = htonl(address);
|
|
msg->data.modify_maxdelayratio.new_max_delay_ratio = REAL2WIRE(max_delay_ratio);
|
|
msg->command = htons(REQ_MODIFY_MAXDELAYRATIO);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_maxupdateskew(CMD_Request *msg, char *line)
|
|
{
|
|
int ok;
|
|
double new_max_update_skew;
|
|
|
|
if (sscanf(line, "%lf", &new_max_update_skew) == 1) {
|
|
msg->data.modify_maxupdateskew.new_max_update_skew = REAL2WIRE(new_max_update_skew);
|
|
msg->command = htons(REQ_MODIFY_MAXUPDATESKEW);
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_dump(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_DUMP);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_writertc(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_WRITERTC);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_trimrtc(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_TRIMRTC);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_cyclelogs(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_CYCLELOGS);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_burst(CMD_Request *msg, char *line)
|
|
{
|
|
int ok;
|
|
int n_good_samples, n_total_samples;
|
|
unsigned int ma, mb, mc, md, aa, ab, ac, ad;
|
|
int n_parsed;
|
|
|
|
n_parsed = sscanf(line, "%d/%d %u.%u.%u.%u/%u.%u.%u.%u",
|
|
&n_good_samples,
|
|
&n_total_samples,
|
|
&ma, &mb, &mc, &md,
|
|
&aa, &ab, &ac, &ad);
|
|
|
|
msg->command = htons(REQ_BURST);
|
|
msg->data.burst.n_good_samples = ntohl(n_good_samples);
|
|
msg->data.burst.n_total_samples = ntohl(n_total_samples);
|
|
|
|
if (n_parsed == 10) {
|
|
msg->data.burst.mask = htonl((ma << 24) | (mb << 16) | (mc << 8) | md);
|
|
msg->data.burst.address = htonl((aa << 24) | (ab << 16) | (ac << 8) | ad);
|
|
ok = 1;
|
|
} else if (n_parsed == 2) {
|
|
msg->data.burst.mask = 0;
|
|
msg->data.burst.address = 0;
|
|
ok = 1;
|
|
} else {
|
|
ok = 0;
|
|
fprintf(stderr, "Invalid syntax for burst command\n");
|
|
}
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_local(CMD_Request *msg, const char *line)
|
|
{
|
|
const char *p;
|
|
int stratum;
|
|
|
|
p = line;
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
|
|
if (!*p) {
|
|
return 0;
|
|
} else if (!strncmp(p, "off", 3)) {
|
|
msg->data.local.on_off = htonl(0);
|
|
} else if (sscanf(p, "stratum%d", &stratum) == 1) {
|
|
msg->data.local.on_off = htonl(1);
|
|
msg->data.local.stratum = htonl(stratum);
|
|
} else {
|
|
fprintf(stderr, "Invalid syntax for local command\n");
|
|
return 0;
|
|
}
|
|
|
|
msg->command = htons(REQ_LOCAL);
|
|
return 1;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_manual(CMD_Request *msg, const char *line)
|
|
{
|
|
const char *p;
|
|
|
|
p = line;
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
|
|
if (!*p) {
|
|
return 0;
|
|
} else if (!strncmp(p, "off", 3)) {
|
|
msg->data.manual.option = htonl(0);
|
|
} else if (!strncmp(p, "on", 2)) {
|
|
msg->data.manual.option = htonl(1);
|
|
} else if (!strncmp(p, "reset", 5)) {
|
|
msg->data.manual.option = htonl(2);
|
|
} else if (!strncmp(p, "list", 4)) {
|
|
process_cmd_manual_list(p);
|
|
return 0;
|
|
} else if (!strncmp(p, "delete", 6)) {
|
|
process_cmd_manual_delete(p+6);
|
|
return 0;
|
|
} else {
|
|
return 0;
|
|
}
|
|
msg->command = htons(REQ_MANUAL);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
parse_allow_deny(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long a, b, c, d, n, ip;
|
|
char *p, *q;
|
|
|
|
p = line;
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
if (!*p) {
|
|
/* blank line - applies to all addresses */
|
|
msg->data.allow_deny.ip = htonl(0);
|
|
msg->data.allow_deny.subnet_bits = htonl(0);
|
|
} else {
|
|
char *slashpos;
|
|
slashpos = strchr(p, '/');
|
|
if (slashpos) *slashpos = 0;
|
|
|
|
n = sscanf(p, "%lu.%lu.%lu.%lu", &a, &b, &c, &d);
|
|
|
|
if (n == 0) {
|
|
/* Try to parse as the name of a machine */
|
|
q = p;
|
|
while (*q) {
|
|
if (*q == '\n') *q = 0;
|
|
q++;
|
|
}
|
|
ip = DNS_Name2IPAddress(p);
|
|
if (ip == DNS_Failed_Address) {
|
|
fprintf(stderr, "Could not read address\n");
|
|
return 0;
|
|
} else {
|
|
msg->data.allow_deny.ip = htonl(ip);
|
|
msg->data.allow_deny.subnet_bits = htonl(32);
|
|
}
|
|
} else {
|
|
|
|
a &= 0xff;
|
|
b &= 0xff;
|
|
c &= 0xff;
|
|
d &= 0xff;
|
|
|
|
switch (n) {
|
|
case 1:
|
|
msg->data.allow_deny.ip = htonl((a<<24));
|
|
msg->data.allow_deny.subnet_bits = htonl(8);
|
|
break;
|
|
case 2:
|
|
msg->data.allow_deny.ip = htonl((a<<24) | (b<<16));
|
|
msg->data.allow_deny.subnet_bits = htonl(16);
|
|
break;
|
|
case 3:
|
|
msg->data.allow_deny.ip = htonl((a<<24) | (b<<16) | (c<<8));
|
|
msg->data.allow_deny.subnet_bits = htonl(24);
|
|
break;
|
|
case 4:
|
|
msg->data.allow_deny.ip = htonl((a<<24) | (b<<16) | (c<<8) | d);
|
|
msg->data.allow_deny.subnet_bits = htonl(32);
|
|
break;
|
|
default:
|
|
assert(0);
|
|
|
|
}
|
|
|
|
if (slashpos) {
|
|
int specified_subnet_bits, n;
|
|
n = sscanf(slashpos+1, "%d", &specified_subnet_bits);
|
|
if (n == 1) {
|
|
msg->data.allow_deny.subnet_bits = htonl(specified_subnet_bits);
|
|
} else {
|
|
fprintf(stderr, "Warning: badly formatted subnet size, using %ld\n", (long) ntohl(msg->data.allow_deny.subnet_bits));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_allow(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_ALLOW);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_allowall(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_ALLOWALL);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_deny(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_DENY);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_denyall(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_DENYALL);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_cmdallow(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_CMDALLOW);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_cmdallowall(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_CMDALLOWALL);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_cmddeny(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_CMDDENY);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_cmddenyall(CMD_Request *msg, char *line)
|
|
{
|
|
int status;
|
|
msg->command = htons(REQ_CMDDENYALL);
|
|
status = parse_allow_deny(msg, line);
|
|
return status;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
accheck_getaddr(char *line, unsigned long *addr)
|
|
{
|
|
unsigned long a, b, c, d, ip;
|
|
char *p, *q;
|
|
p = line;
|
|
while (*p && isspace(*p)) p++;
|
|
if (!*p) {
|
|
return 0;
|
|
} else {
|
|
if (sscanf(p, "%lu.%lu.%lu.%lu", &a, &b, &c, &d) == 4) {
|
|
*addr = (a<<24) | (b<<16) | (c<<8) | d;
|
|
return 1;
|
|
} else {
|
|
q = p;
|
|
while (*q) {
|
|
if (*q == '\n') *q = 0;
|
|
q++;
|
|
}
|
|
ip = DNS_Name2IPAddress(p);
|
|
if (ip == DNS_Failed_Address) {
|
|
return 0;
|
|
} else {
|
|
*addr = ip;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_accheck(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long ip;
|
|
msg->command = htons(REQ_ACCHECK);
|
|
if (accheck_getaddr(line, &ip)) {
|
|
msg->data.ac_check.ip = htonl(ip);
|
|
return 1;
|
|
} else {
|
|
fprintf(stderr, "Could not read address\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_cmdaccheck(CMD_Request *msg, char *line)
|
|
{
|
|
unsigned long ip;
|
|
msg->command = htons(REQ_CMDACCHECK);
|
|
if (accheck_getaddr(line, &ip)) {
|
|
msg->data.ac_check.ip = htonl(ip);
|
|
return 1;
|
|
} else {
|
|
fprintf(stderr, "Could not read address\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_dfreq(CMD_Request *msg, char *line)
|
|
{
|
|
double dfreq;
|
|
msg->command = htons(REQ_DFREQ);
|
|
if (sscanf(line, "%lf", &dfreq) == 1) {
|
|
msg->data.dfreq.dfreq = REAL2WIRE(dfreq);
|
|
} else {
|
|
msg->data.dfreq.dfreq = REAL2WIRE(0.0);
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
cvt_to_sec_usec(double x, long *sec, long *usec) {
|
|
long s, us;
|
|
s = (long) x;
|
|
us = (long)(0.5 + 1.0e6 * (x - (double) s));
|
|
while (us >= 1000000) {
|
|
us -= 1000000;
|
|
s += 1;
|
|
}
|
|
while (us < 0) {
|
|
us += 1000000;
|
|
s -= 1;
|
|
}
|
|
|
|
*sec = s;
|
|
*usec = us;
|
|
return;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_doffset(CMD_Request *msg, char *line)
|
|
{
|
|
double doffset;
|
|
long sec, usec;
|
|
msg->command = htons(REQ_DOFFSET);
|
|
if (sscanf(line, "%lf", &doffset) == 1) {
|
|
cvt_to_sec_usec(doffset, &sec, &usec);
|
|
msg->data.doffset.sec = htonl(sec);
|
|
msg->data.doffset.usec = htonl(usec);
|
|
} else {
|
|
msg->data.doffset.sec = htonl(0);
|
|
msg->data.doffset.usec = htonl(0);
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_add_server_or_peer(CMD_Request *msg, char *line)
|
|
{
|
|
CPS_NTP_Source data;
|
|
CPS_Status status;
|
|
int result = 0;
|
|
|
|
status = CPS_ParseNTPSourceAdd(line, &data);
|
|
switch (status) {
|
|
case CPS_Success:
|
|
msg->data.ntp_source.port = htonl((unsigned long) data.port);
|
|
msg->data.ntp_source.ip_addr = htonl(data.ip_addr);
|
|
msg->data.ntp_source.minpoll = htonl(data.params.minpoll);
|
|
msg->data.ntp_source.maxpoll = htonl(data.params.maxpoll);
|
|
msg->data.ntp_source.presend_minpoll = htonl(data.params.presend_minpoll);
|
|
msg->data.ntp_source.online = htonl(data.params.online);
|
|
msg->data.ntp_source.auto_offline = htonl(data.params.auto_offline);
|
|
msg->data.ntp_source.authkey = htonl(data.params.authkey);
|
|
msg->data.ntp_source.max_delay = REAL2WIRE(data.params.max_delay);
|
|
msg->data.ntp_source.max_delay_ratio = REAL2WIRE(data.params.max_delay_ratio);
|
|
result = 1;
|
|
|
|
break;
|
|
case CPS_BadOption:
|
|
fprintf(stderr, "Unrecognized subcommand\n");
|
|
break;
|
|
case CPS_BadHost:
|
|
fprintf(stderr, "Invalid host/IP address\n");
|
|
break;
|
|
case CPS_BadPort:
|
|
fprintf(stderr, "Unreadable port number\n");
|
|
break;
|
|
case CPS_BadMinpoll:
|
|
fprintf(stderr, "Unreadable minpoll value\n");
|
|
break;
|
|
case CPS_BadMaxpoll:
|
|
fprintf(stderr, "Unreadable maxpoll value\n");
|
|
break;
|
|
case CPS_BadPresend:
|
|
fprintf(stderr, "Unreadable presend value\n");
|
|
break;
|
|
case CPS_BadMaxdelayratio:
|
|
fprintf(stderr, "Unreadable max delay ratio value\n");
|
|
break;
|
|
case CPS_BadMaxdelay:
|
|
fprintf(stderr, "Unreadable max delay value\n");
|
|
break;
|
|
case CPS_BadKey:
|
|
fprintf(stderr, "Unreadable key value\n");
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_add_server(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_ADD_SERVER);
|
|
return process_cmd_add_server_or_peer(msg, line);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_add_peer(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_ADD_PEER);
|
|
return process_cmd_add_server_or_peer(msg, line);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_delete(CMD_Request *msg, char *line)
|
|
{
|
|
char hostname[2048];
|
|
int ok = 0;
|
|
unsigned long address = 0UL;
|
|
|
|
msg->command = htons(REQ_DEL_SOURCE);
|
|
|
|
if (sscanf(line, "%2047s", hostname) != 1) {
|
|
fprintf(stderr, "Invalid syntax for address\n");
|
|
ok = 0;
|
|
} else {
|
|
address = DNS_Name2IPAddress(hostname);
|
|
if (address == DNS_Failed_Address) {
|
|
fprintf(stderr, "Could not get address for hostname\n");
|
|
ok = 0;
|
|
} else {
|
|
ok = 1;
|
|
}
|
|
}
|
|
|
|
msg->data.del_source.ip_addr = htonl(address);
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int password_seen = 0;
|
|
static MD5_CTX md5_after_just_password;
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_cmd_password(CMD_Request *msg, char *line)
|
|
{
|
|
char *p, *q;
|
|
char *password;
|
|
struct timezone tz;
|
|
|
|
p = line;
|
|
while (*p && isspace((unsigned char)*p))
|
|
p++;
|
|
|
|
/* Get rid of trailing newline */
|
|
for (q=p; *q; q++) {
|
|
if (isspace((unsigned char)*q)) *q = 0;
|
|
}
|
|
|
|
if (*p) {
|
|
password = p;
|
|
} else {
|
|
/* blank line, prompt for password */
|
|
password = getpass("Password: ");
|
|
}
|
|
|
|
if (!*password) {
|
|
password_seen = 0;
|
|
} else {
|
|
password_seen = 1;
|
|
}
|
|
|
|
/* Generate MD5 initial context */
|
|
MD5Init(&md5_after_just_password);
|
|
MD5Update(&md5_after_just_password, (unsigned char *) password, strlen(password));
|
|
|
|
/* Blank the password for security */
|
|
for (p = password; *p; p++) {
|
|
*p = 0;
|
|
}
|
|
|
|
if (gettimeofday(&msg->data.logon.ts, &tz) < 0) {
|
|
printf("500 - Could not read time of day\n");
|
|
return 0;
|
|
} else {
|
|
msg->command = htons(REQ_LOGON); /* Just force a round trip so that we get tokens etc */
|
|
msg->data.logon.ts.tv_sec = htonl(msg->data.logon.ts.tv_sec);
|
|
msg->data.logon.ts.tv_usec = htonl(msg->data.logon.ts.tv_usec);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
generate_auth(CMD_Request *msg)
|
|
{
|
|
MD5_CTX ctx;
|
|
int pkt_len;
|
|
|
|
pkt_len = PKL_CommandLength(msg);
|
|
ctx = md5_after_just_password;
|
|
MD5Update(&ctx, (unsigned char *) msg, offsetof(CMD_Request, auth));
|
|
if (pkt_len > offsetof(CMD_Request, data)) {
|
|
MD5Update(&ctx, (unsigned char *) &(msg->data), pkt_len - offsetof(CMD_Request, data));
|
|
}
|
|
MD5Final(&ctx);
|
|
memcpy(&(msg->auth), &ctx.digest, 16);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
check_reply_auth(CMD_Reply *msg)
|
|
{
|
|
int pkt_len;
|
|
MD5_CTX ctx;
|
|
|
|
pkt_len = PKL_ReplyLength(msg);
|
|
ctx = md5_after_just_password;
|
|
MD5Update(&ctx, (unsigned char *) msg, offsetof(CMD_Request, auth));
|
|
if (pkt_len > offsetof(CMD_Reply, data)) {
|
|
MD5Update(&ctx, (unsigned char *) &(msg->data), pkt_len - offsetof(CMD_Reply, data));
|
|
}
|
|
MD5Final(&ctx);
|
|
|
|
if (!memcmp((void *) &ctx.digest, (void *) &(msg->auth), 16)) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
give_help(void)
|
|
{
|
|
printf("205 - Help follows\n");
|
|
printf("accheck <address> : Check whether NTP access is allowed to <address>\n");
|
|
printf("activity : Check how many NTP sources are online/offline\n");
|
|
printf("allow [<subnet-addr>] : Allow NTP access to that subnet as a default\n");
|
|
printf("allow all [<subnet-addr>] : Allow NTP access to that subnet and all children\n");
|
|
printf("burst <n-good>/<n-max> [<mask>/<masked-address>] : Start a rapid set of measurements\n");
|
|
printf("clients : Report on clients that have accessed the server\n");
|
|
printf("cmdaccheck <address> : Check whether command access is allowed to <address>\n");
|
|
printf("cmdallow [<subnet-addr>] : Allow command access to that subnet as a default\n");
|
|
printf("cmdallow all [<subnet-addr>] : Allow command access to that subnet and all children\n");
|
|
printf("cmddeny [<subnet-addr>] : Deny command access to that subnet as a default\n");
|
|
printf("cmddeny all [<subnet-addr>] : Deny command access to that subnet and all children\n");
|
|
printf("cyclelogs : Close and re-open logs files\n");
|
|
printf("deny [<subnet-addr>] : Deny NTP access to that subnet as a default\n");
|
|
printf("deny all [<subnet-addr>] : Deny NTP access to that subnet and all children\n");
|
|
printf("dump : Dump all measurements to save files\n");
|
|
printf("exit : Leave the program\n");
|
|
printf("help : Generate this help\n");
|
|
printf("local off : Disable server capability for unsynchronised clock\n");
|
|
printf("local stratum <stratum> : Enable server capability for unsynchronised clock\n");
|
|
printf("makestep : Jump the time to remove any correction being slewed\n");
|
|
printf("manual off|on|reset : Disable/enable/reset settime command and statistics\n");
|
|
printf("manual list : Show previous settime entries\n");
|
|
printf("minpoll <address> <new-minpoll> : Modify minimum polling interval of source\n");
|
|
printf("maxdelay <address> <new-max-delay> : Modify maximum round-trip valid sample delay for source\n");
|
|
printf("maxdelayratio <address> <new-max-ratio> : Modify max round-trip delay ratio for source\n");
|
|
printf("maxpoll <address> <new-minpoll> : Modify maximum polling interval of source\n");
|
|
printf("maxupdateskew <new-max-skew> : Modify maximum skew for a clock frequency update to be made\n");
|
|
printf("offline [<mask>/<masked-address>] : Set sources in subnet to offline status\n");
|
|
printf("online [<mask>/<masked-address>] : Set sources in subnet to online status\n");
|
|
printf("password [<new-password>] : Set command authentication password\n");
|
|
printf("quit : Leave the program\n");
|
|
printf("rtcdata : Print current RTC performance parameters\n");
|
|
printf("settime <date/time (e.g. Nov 21, 1997 16:30:05 or 16:30:05)> : Manually set the daemon time\n");
|
|
printf("sources [-v] : Display information about current sources\n");
|
|
printf("sourcestats [-v] : Display estimation information about current sources\n");
|
|
printf("tracking : Display system time information\n");
|
|
printf("trimrtc : Correct RTC relative to system clock\n");
|
|
printf("writertc : Save RTC parameters to file\n");
|
|
printf(".\n");
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static unsigned long sequence = 0;
|
|
static unsigned long utoken = 0;
|
|
static unsigned long token = 0;
|
|
|
|
#define MAX_ATTEMPTS 5
|
|
|
|
|
|
/* This is the core protocol module. Complete particular fields in
|
|
the outgoing packet, send it, wait for a response, handle retries,
|
|
etc. Returns a Boolean indicating whether the protocol was
|
|
successful or not.*/
|
|
|
|
static int
|
|
submit_request(CMD_Request *request, CMD_Reply *reply, int *reply_auth_ok)
|
|
{
|
|
unsigned long tx_sequence;
|
|
socklen_t where_from_len;
|
|
struct sockaddr_in where_from;
|
|
int bad_length, bad_sender, bad_sequence, bad_header;
|
|
int select_status;
|
|
int recvfrom_status;
|
|
int read_length;
|
|
int expected_length;
|
|
int command_length;
|
|
struct timeval timeout;
|
|
int timeout_seconds;
|
|
int n_attempts;
|
|
fd_set rdfd, wrfd, exfd;
|
|
|
|
request->version = PROTO_VERSION_NUMBER;
|
|
request->pkt_type = PKT_TYPE_CMD_REQUEST;
|
|
request->res1 = 0;
|
|
request->res2 = 0;
|
|
tx_sequence = sequence++;
|
|
request->sequence = htonl(tx_sequence);
|
|
request->attempt = 0;
|
|
request->utoken = htonl(utoken);
|
|
request->token = htonl(token);
|
|
|
|
|
|
timeout_seconds = 120;
|
|
|
|
n_attempts = 0;
|
|
|
|
do {
|
|
|
|
/* Decide whether to authenticate */
|
|
if (password_seen) {
|
|
if (!utoken || (request->command == htons(REQ_LOGON))) {
|
|
/* Otherwise, the daemon won't bother authenticating our
|
|
packet and we won't get a token back */
|
|
request->utoken = htonl(SPECIAL_UTOKEN);
|
|
}
|
|
generate_auth(request);
|
|
}
|
|
|
|
command_length = PKL_CommandLength(request);
|
|
#if 0
|
|
printf("Sent command length=%d bytes\n", command_length);
|
|
#endif
|
|
|
|
if (sendto(sock_fd, (void *) request, command_length, 0,
|
|
(struct sockaddr *) &his_addr, sizeof(his_addr)) < 0) {
|
|
|
|
|
|
#if 0
|
|
perror("Could not send packet");
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/* Increment this for next time */
|
|
++ request->attempt;
|
|
|
|
timeout.tv_sec = timeout_seconds;
|
|
timeout.tv_usec = 0;
|
|
|
|
timeout_seconds += 1;
|
|
FD_ZERO(&rdfd);
|
|
FD_ZERO(&wrfd);
|
|
FD_ZERO(&exfd);
|
|
|
|
FD_SET(sock_fd, &rdfd);
|
|
|
|
select_status = select(sock_fd + 1, &rdfd, &wrfd, &exfd, &timeout);
|
|
|
|
if (select_status < 0) {
|
|
#if 0
|
|
perror("Select returned negative status");
|
|
#endif
|
|
} else if (select_status == 0) {
|
|
/* Timeout must have elapsed, try a resend? */
|
|
n_attempts ++;
|
|
if (n_attempts == MAX_ATTEMPTS) {
|
|
return 0;
|
|
}
|
|
|
|
/* Back to top of loop to do resend */
|
|
continue;
|
|
|
|
} else {
|
|
|
|
where_from_len = sizeof(where_from);
|
|
recvfrom_status = recvfrom(sock_fd, (void *) reply, sizeof(CMD_Reply), 0,
|
|
(struct sockaddr *) &where_from, &where_from_len);
|
|
|
|
|
|
#if 0
|
|
printf("Received packet, status=%d\n", recvfrom_status);
|
|
#endif
|
|
|
|
if (recvfrom_status < 0) {
|
|
/* If we get connrefused here, it suggests the sendto is
|
|
going to a dead port - but only if the daemon machine is
|
|
running Linux (Solaris doesn't return anything) */
|
|
n_attempts++;
|
|
if (n_attempts == MAX_ATTEMPTS) {
|
|
return 0;
|
|
}
|
|
} else {
|
|
|
|
read_length = recvfrom_status;
|
|
expected_length = PKL_ReplyLength(reply);
|
|
|
|
bad_length = (read_length != expected_length);
|
|
bad_sender = ((where_from.sin_addr.s_addr != his_addr.sin_addr.s_addr) ||
|
|
(where_from.sin_port != his_addr.sin_port));
|
|
|
|
if (!bad_length) {
|
|
bad_sequence = (ntohl(reply->sequence) != tx_sequence);
|
|
} else {
|
|
bad_sequence = 0;
|
|
}
|
|
|
|
if (bad_length || bad_sender || bad_sequence) {
|
|
n_attempts++;
|
|
if (n_attempts == MAX_ATTEMPTS) {
|
|
return 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
bad_header = ((reply->version != PROTO_VERSION_NUMBER) ||
|
|
(reply->pkt_type != PKT_TYPE_CMD_REPLY) ||
|
|
(reply->res1 != 0) ||
|
|
(reply->res2 != 0));
|
|
|
|
if (bad_header) {
|
|
n_attempts++;
|
|
if (n_attempts == MAX_ATTEMPTS) {
|
|
return 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* Good packet received, print out results */
|
|
#if 0
|
|
printf("Reply cmd=%d reply=%d stat=%d num=%d tot=%d seq=%d utok=%08lx tok=%d\n",
|
|
ntohs(reply->command), ntohs(reply->reply),
|
|
ntohs(reply->status), ntohs(reply->number),
|
|
ntohs(reply->total),
|
|
ntohl(reply->sequence),
|
|
ntohl(reply->utoken),
|
|
ntohl(reply->token));
|
|
#endif
|
|
|
|
if (password_seen) {
|
|
*reply_auth_ok = check_reply_auth(reply);
|
|
} else {
|
|
/* Assume in this case that the reply is always considered
|
|
to be authentic */
|
|
*reply_auth_ok = 1;
|
|
}
|
|
|
|
utoken = ntohl(reply->utoken);
|
|
|
|
if (*reply_auth_ok) {
|
|
/* If we're in authenticated mode, only acquire the utoken
|
|
and new token values if the reply authenticated properly.
|
|
This protects against forged packets with bogus tokens
|
|
in. We won't accept a repeat of an old message with a
|
|
stale token in it, due to bad_sequence processing
|
|
earlier. */
|
|
utoken = ntohl(reply->utoken);
|
|
token = ntohl(reply->token);
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
}
|
|
} while (1);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
print_seconds(unsigned long s)
|
|
{
|
|
unsigned long d;
|
|
if (s <= 1024) {
|
|
printf("%4ld", s);
|
|
} else if (s < 36000) {
|
|
printf("%3ldm", s / 60);
|
|
} else if (s < 345600) {
|
|
printf("%3ldh", s / 3600);
|
|
} else {
|
|
d = s / 86400;
|
|
if (d > 999) {
|
|
printf("%3ldy", d / 365);
|
|
} else {
|
|
printf("%3ldd", d);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
print_microseconds(unsigned long us)
|
|
{
|
|
if (us <= 9999) {
|
|
printf("%4ldus", us);
|
|
} else if (us <= 9999999) {
|
|
printf("%4ldms", us / 1000);
|
|
} else if (us <= 999999999) {
|
|
printf("%3ld.%01lds", us / 1000000, (us/100000) % 10);
|
|
} else {
|
|
printf("%5lds", us / 1000000);
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
print_signed_microseconds(long us)
|
|
{
|
|
long x = abs(us);
|
|
if (x <= 9999) {
|
|
printf("%+5ldus", us);
|
|
} else if (x <= 9999999) {
|
|
printf("%+5ldms", us / 1000);
|
|
} else {
|
|
printf("%+6lds", us / 1000000);
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
check_for_verbose_flag(char *line)
|
|
{
|
|
char *p = line;
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
if (!strncmp(p, "-v", 2)) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_sources(char *line)
|
|
{
|
|
int submit_ok;
|
|
int auth_ok;
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int n_sources, i;
|
|
int verbose = 0;
|
|
|
|
long orig_latest_meas, latest_meas, est_offset;
|
|
unsigned long ip_addr;
|
|
unsigned long latest_meas_err, est_offset_err;
|
|
unsigned long latest_meas_ago;
|
|
unsigned short poll, stratum;
|
|
unsigned short state, mode;
|
|
double resid_freq, resid_skew;
|
|
const char *dns_lookup;
|
|
char hostname_buf[32];
|
|
unsigned short status;
|
|
|
|
/* Check whether to output verbose headers */
|
|
verbose = check_for_verbose_flag(line);
|
|
|
|
request.command = htons(REQ_N_SOURCES);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_INVALID:
|
|
printf("502 Invalid command\n");
|
|
return;
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
n_sources = ntohl(reply.data.n_sources.n_sources);
|
|
printf("210 Number of sources = %d\n", n_sources);
|
|
if (verbose) {
|
|
printf("\n");
|
|
printf(" .-- Source mode '^' = server, '=' = peer, '#' = local clock.\n");
|
|
printf(" / .- Source state '*' = current synced, '+' = OK for sync, '?' = unreachable,\n");
|
|
printf("| / 'x' = time may be in error, '~' = time is too variable.\n");
|
|
printf("|| .- xxxx [ yyyy ] +/- zzzz\n");
|
|
printf("|| / xxxx = adjusted offset,\n");
|
|
printf("|| Log2(Polling interval) -. | yyyy = measured offset,\n");
|
|
printf("|| \\ | zzzz = estimated error.\n");
|
|
printf("|| | | \n");
|
|
}
|
|
|
|
printf("MS Name/IP address Stratum Poll LastRx Last sample\n");
|
|
printf("============================================================================\n");
|
|
|
|
/* "MS NNNNNNNNNNNNNNNNNNNNNNNNN SS PP RRRR SSSSSSS[SSSSSSS] +/- SSSSSS" */
|
|
|
|
for (i=0; i<n_sources; i++) {
|
|
request.command = htons(REQ_SOURCE_DATA);
|
|
request.data.source_data.index = htonl(i);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
if (ntohs(reply.status) == STT_SUCCESS) {
|
|
ip_addr = ntohl(reply.data.source_data.ip_addr);
|
|
poll = ntohs(reply.data.source_data.poll);
|
|
stratum = ntohs(reply.data.source_data.stratum);
|
|
state = ntohs(reply.data.source_data.state);
|
|
mode = ntohs(reply.data.source_data.mode);
|
|
latest_meas_ago = ntohl(reply.data.source_data.since_sample);
|
|
orig_latest_meas = ntohl(reply.data.source_data.orig_latest_meas);
|
|
latest_meas = ntohl(reply.data.source_data.latest_meas);
|
|
latest_meas_err = ntohl(reply.data.source_data.latest_meas_err);
|
|
est_offset = ntohl(reply.data.source_data.est_offset);
|
|
est_offset_err = ntohl(reply.data.source_data.est_offset_err);
|
|
resid_freq = (double) ((long) ntohl(reply.data.source_data.resid_freq)) * 1.0e-3;
|
|
resid_skew = (double) (ntohl(reply.data.source_data.resid_skew)) * 1.0e-3;
|
|
|
|
hostname_buf[25] = 0;
|
|
if (no_dns) {
|
|
snprintf(hostname_buf, sizeof(hostname_buf), "%s", UTI_IPToDottedQuad(ip_addr));
|
|
} else {
|
|
dns_lookup = DNS_IPAddress2Name(ip_addr);
|
|
strncpy(hostname_buf, dns_lookup, 25);
|
|
}
|
|
|
|
switch (mode) {
|
|
case RPY_SD_MD_CLIENT:
|
|
printf("^"); break;
|
|
case RPY_SD_MD_PEER:
|
|
printf("="); break;
|
|
case RPY_SD_MD_REF:
|
|
printf("#"); break;
|
|
}
|
|
switch (state) {
|
|
case RPY_SD_ST_SYNC:
|
|
printf("*"); break;
|
|
case RPY_SD_ST_UNREACH:
|
|
printf("?"); break;
|
|
case RPY_SD_ST_FALSETICKER:
|
|
printf("x"); break;
|
|
case RPY_SD_ST_JITTERY:
|
|
printf("~"); break;
|
|
case RPY_SD_ST_OTHER:
|
|
printf("+"); break;
|
|
}
|
|
|
|
printf(" %-25s %2d %2d ", hostname_buf, stratum, poll);
|
|
print_seconds(latest_meas_ago);
|
|
printf(" ");
|
|
print_signed_microseconds(latest_meas);
|
|
printf("[");
|
|
print_signed_microseconds(orig_latest_meas);
|
|
printf("]");
|
|
printf(" +/- ");
|
|
print_microseconds(latest_meas_err);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
printf("506 Cannot talk to daemon\n");
|
|
}
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_sourcestats(char *line)
|
|
{
|
|
int submit_ok;
|
|
int auth_ok;
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int n_sources, i;
|
|
int verbose = 0;
|
|
|
|
const char *dns_lookup;
|
|
char hostname_buf[32];
|
|
unsigned long n_samples, n_runs, span_seconds;
|
|
double resid_freq_ppm, skew_ppm;
|
|
unsigned long sd_us;
|
|
unsigned long ip_addr;
|
|
unsigned short status;
|
|
|
|
verbose = check_for_verbose_flag(line);
|
|
|
|
request.command = htons(REQ_N_SOURCES);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_INVALID:
|
|
printf("502 Invalid command\n");
|
|
return;
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
n_sources = ntohl(reply.data.n_sources.n_sources);
|
|
printf("210 Number of sources = %d\n", n_sources);
|
|
if (verbose) {
|
|
printf(" .- Number of sample points in measurement set.\n");
|
|
printf(" / .- Number of residual runs with same sign.\n");
|
|
printf(" | / .- Length of measurement set (time).\n");
|
|
printf(" | | / .- Est. clock freq error (ppm).\n");
|
|
printf(" | | | / .- Est error in freq.\n");
|
|
printf(" | | | | / .- On the\n");
|
|
printf(" | | | | | / samples.\n");
|
|
printf(" | | | | | |\n");
|
|
}
|
|
|
|
printf("Name/IP Address NP NR Span Frequency Freq Skew Std Dev\n");
|
|
printf("========================================================================\n");
|
|
|
|
/* NNNNNNNNNNNNNNNNNNNNNNNNN NP NR SSSS FFFFFFFFFF SSSSSSSSSS SSSSSSS */
|
|
|
|
for (i=0; i<n_sources; i++) {
|
|
request.command = htons(REQ_SOURCESTATS);
|
|
request.data.source_data.index = htonl(i);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
if (ntohs(reply.status) == STT_SUCCESS) {
|
|
|
|
ip_addr = ntohl(reply.data.sourcestats.ip_addr);
|
|
n_samples = ntohl(reply.data.sourcestats.n_samples);
|
|
n_runs = ntohl(reply.data.sourcestats.n_runs);
|
|
span_seconds = ntohl(reply.data.sourcestats.span_seconds);
|
|
resid_freq_ppm = WIRE2REAL(reply.data.sourcestats.resid_freq_ppm);
|
|
skew_ppm = WIRE2REAL(reply.data.sourcestats.skew_ppm);
|
|
sd_us = ntohl(reply.data.sourcestats.sd_us);
|
|
|
|
hostname_buf[25] = 0;
|
|
if (no_dns) {
|
|
snprintf(hostname_buf, sizeof(hostname_buf), "%s", UTI_IPToDottedQuad(ip_addr));
|
|
} else {
|
|
dns_lookup = DNS_IPAddress2Name(ip_addr);
|
|
strncpy(hostname_buf, dns_lookup, 25);
|
|
}
|
|
|
|
printf("%-25s %2lu %2lu ", hostname_buf, n_samples, n_runs);
|
|
print_seconds(span_seconds);
|
|
printf(" %10.3f %10.3f ", resid_freq_ppm, skew_ppm);
|
|
print_microseconds(sd_us);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
printf("506 Cannot talk to daemon\n");
|
|
}
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_tracking(char *line)
|
|
{
|
|
int status;
|
|
int submit_ok;
|
|
int auth_ok;
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
unsigned long ref_id;
|
|
struct timeval ref_time;
|
|
struct tm ref_time_tm;
|
|
unsigned long a, b, c, d;
|
|
struct timeval correction_tv;
|
|
double correction;
|
|
double freq_ppm;
|
|
double resid_freq_ppm;
|
|
double skew_ppm;
|
|
double root_delay;
|
|
double root_dispersion;
|
|
|
|
request.command = htons(REQ_TRACKING);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_INVALID:
|
|
printf("502 Invalid command\n");
|
|
return;
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ref_id = ntohl(reply.data.tracking.ref_id);
|
|
a = (ref_id >> 24);
|
|
b = (ref_id >> 16) & 0xff;
|
|
c = (ref_id >> 8) & 0xff;
|
|
d = (ref_id) & 0xff;
|
|
printf("Reference ID : %lu.%lu.%lu.%lu (%s)\n",
|
|
a, b, c, d,
|
|
(no_dns) ? UTI_IPToDottedQuad(ref_id) : DNS_IPAddress2Name(ref_id));
|
|
printf("Stratum : %lu\n", (unsigned long) ntohl(reply.data.tracking.stratum));
|
|
ref_time.tv_sec = ntohl(reply.data.tracking.ref_time_s);
|
|
ref_time.tv_usec = ntohl(reply.data.tracking.ref_time_us);
|
|
ref_time_tm = *gmtime((time_t *)&ref_time.tv_sec);
|
|
printf("Ref time (UTC) : %s", asctime(&ref_time_tm));
|
|
correction_tv.tv_sec = (int32_t)ntohl(reply.data.tracking.current_correction_s);
|
|
correction_tv.tv_usec = ntohl(reply.data.tracking.current_correction_us);
|
|
correction = (double) correction_tv.tv_sec + 1.0e-6 * correction_tv.tv_usec;
|
|
printf("System time : %.6f seconds %s of NTP time\n", fabs(correction),
|
|
(correction > 0.0) ? "slow" : "fast");
|
|
freq_ppm = WIRE2REAL(reply.data.tracking.freq_ppm);
|
|
resid_freq_ppm = WIRE2REAL(reply.data.tracking.resid_freq_ppm);
|
|
skew_ppm = WIRE2REAL(reply.data.tracking.skew_ppm);
|
|
root_delay = WIRE2REAL(reply.data.tracking.root_delay);
|
|
root_dispersion = WIRE2REAL(reply.data.tracking.root_dispersion);
|
|
printf("Frequency : %.3f ppm %s\n", fabs(freq_ppm), (freq_ppm < 0.0) ? "slow" : "fast");
|
|
printf("Residual freq : %.3f ppm\n", resid_freq_ppm);
|
|
printf("Skew : %.3f ppm\n", skew_ppm);
|
|
printf("Root delay : %.6f seconds\n", root_delay);
|
|
printf("Root dispersion : %.6f seconds\n", root_dispersion);
|
|
} else {
|
|
printf("506 Cannot talk to daemon\n");
|
|
}
|
|
}
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_rtcreport(char *line)
|
|
{
|
|
int status;
|
|
int submit_ok;
|
|
int auth_ok;
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
time_t ref_time;
|
|
struct tm ref_time_tm;
|
|
unsigned short n_samples;
|
|
unsigned short n_runs;
|
|
unsigned long span_seconds;
|
|
double coef_seconds_fast;
|
|
double coef_gain_rate_ppm;
|
|
|
|
request.command = htons(REQ_RTCREPORT);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_INVALID:
|
|
printf("502 Invalid command\n");
|
|
return;
|
|
break;
|
|
case STT_NORTC:
|
|
printf("513 No RTC driver\n");
|
|
return;
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
ref_time = (time_t) ntohl(reply.data.rtc.ref_time);
|
|
ref_time_tm = *gmtime(&ref_time);
|
|
n_samples = ntohs(reply.data.rtc.n_samples);
|
|
n_runs = ntohs(reply.data.rtc.n_runs);
|
|
span_seconds = ntohl(reply.data.rtc.span_seconds);
|
|
coef_seconds_fast = WIRE2REAL(reply.data.rtc.rtc_seconds_fast);
|
|
coef_gain_rate_ppm = WIRE2REAL(reply.data.rtc.rtc_gain_rate_ppm);
|
|
printf("RTC ref time (UTC) : %s", asctime(&ref_time_tm));
|
|
printf("Number of samples : %d\n", n_samples);
|
|
printf("Number of runs : %d\n", n_runs);
|
|
printf("Sample span period : ");
|
|
print_seconds(span_seconds);
|
|
printf("\n");
|
|
printf("RTC is fast by : %12.6f seconds\n", coef_seconds_fast);
|
|
printf("RTC gains time at : %9.3f ppm\n", coef_gain_rate_ppm);
|
|
} else {
|
|
printf("506 Cannot talk to daemon\n");
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
#if 0
|
|
|
|
/* This is a previous attempt at implementing the clients command. It
|
|
could be re-instated sometime as a way of looking at all clients in a
|
|
particular subnet. The problem with it is that is requires at least 5
|
|
round trips to the server even if the server only has one client to
|
|
report. */
|
|
|
|
typedef struct XSubnetToDo {
|
|
struct XSubnetToDo *next;
|
|
unsigned long ip;
|
|
unsigned long bits;
|
|
} SubnetToDo;
|
|
|
|
static void
|
|
process_cmd_clients(char *line)
|
|
{
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
SubnetToDo *head, *todo, *tail, *p, *next_node, *new_node;
|
|
int submit_ok, auth_ok;
|
|
int status;
|
|
int i, j, nets_looked_up, clients_looked_up;
|
|
int word;
|
|
unsigned long mask;
|
|
unsigned long ip, bits;
|
|
unsigned long client_hits;
|
|
unsigned long peer_hits;
|
|
unsigned long cmd_hits_auth;
|
|
unsigned long cmd_hits_normal;
|
|
unsigned long cmd_hits_bad;
|
|
unsigned long last_ntp_hit_ago;
|
|
unsigned long last_cmd_hit_ago;
|
|
char hostname_buf[32];
|
|
const char *dns_lookup;
|
|
|
|
int n_replies;
|
|
|
|
head = todo = MallocNew(SubnetToDo);
|
|
todo->next = NULL;
|
|
/* Set up initial query = root subnet */
|
|
todo->ip = 0;
|
|
todo->bits = 0;
|
|
tail = todo;
|
|
|
|
do {
|
|
|
|
request.command = htons(REQ_SUBNETS_ACCESSED);
|
|
/* Build list of subnets to examine */
|
|
i=0;
|
|
p=todo;
|
|
while((i < MAX_SUBNETS_ACCESSED) &&
|
|
p &&
|
|
(p->bits < 32)) {
|
|
|
|
request.data.subnets_accessed.subnets[i].ip = htonl(p->ip);
|
|
request.data.subnets_accessed.subnets[i].bits_specd = htonl(p->bits);
|
|
p = p->next;
|
|
i++;
|
|
}
|
|
|
|
nets_looked_up = i;
|
|
|
|
if (nets_looked_up == 0) {
|
|
/* No subnets need examining */
|
|
break;
|
|
}
|
|
|
|
request.data.subnets_accessed.n_subnets = htonl(nets_looked_up);
|
|
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
n_replies = ntohl(reply.data.subnets_accessed.n_subnets);
|
|
for (j=0; j<n_replies; j++) {
|
|
ip = ntohl(reply.data.subnets_accessed.subnets[j].ip);
|
|
bits = ntohl(reply.data.subnets_accessed.subnets[j].bits_specd);
|
|
for (i=0; i<256; i++) {
|
|
word = i/32;
|
|
mask = 1UL << (i%32);
|
|
if (ntohl(reply.data.subnets_accessed.subnets[j].bitmap[word]) & mask) {
|
|
/* Add this subnet to the todo list */
|
|
new_node = MallocNew(SubnetToDo);
|
|
new_node->next = NULL;
|
|
new_node->bits = bits + 8;
|
|
new_node->ip = ip | (i << (24 - bits));
|
|
tail->next = new_node;
|
|
tail = new_node;
|
|
#if 0
|
|
printf("%08lx %2d %3d %08lx\n", ip, bits, i, new_node->ip);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Skip the todo pointer forwards by the number of nets looked
|
|
up. Can't do this earlier, because we might have to point
|
|
at the next layer of subnets that have only just been
|
|
concatenated to the linked list. */
|
|
for (i=0; i<nets_looked_up; i++) {
|
|
todo = todo->next;
|
|
}
|
|
|
|
break;
|
|
case STT_BADSUBNET:
|
|
/* We should never generate any bad subnet messages */
|
|
assert(0);
|
|
break;
|
|
case STT_INACTIVE:
|
|
printf("519 Client logging is not active in the daemon\n");
|
|
goto cleanup;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
goto cleanup;
|
|
default:
|
|
printf("520 Got unexpected error from daemon\n");
|
|
goto cleanup;
|
|
}
|
|
|
|
} else {
|
|
printf("506 Cannot talk to daemon\n");
|
|
return;
|
|
}
|
|
} while (1); /* keep going until all subnets have been expanded,
|
|
down to single nodes */
|
|
|
|
/* Now the todo list consists of client records */
|
|
request.command = htons(REQ_CLIENT_ACCESSES);
|
|
|
|
#if 0
|
|
printf("%d %d\n", sizeof (RPY_ClientAccesses_Client), offsetof(CMD_Reply, data.client_accesses.clients));
|
|
#endif
|
|
|
|
printf("Hostname Client Peer CmdAuth CmdNorm CmdBad LstN LstC\n"
|
|
"========================= ====== ====== ====== ====== ====== ==== ====\n");
|
|
|
|
do {
|
|
|
|
i = 0;
|
|
p = todo;
|
|
while ((i < MAX_CLIENT_ACCESSES) &&
|
|
p) {
|
|
|
|
request.data.client_accesses.client_ips[i] = htonl(p->ip);
|
|
p = p->next;
|
|
i++;
|
|
}
|
|
|
|
clients_looked_up = i;
|
|
|
|
if (clients_looked_up == 0) {
|
|
/* No more clients to do */
|
|
break;
|
|
}
|
|
|
|
request.data.client_accesses.n_clients = htonl(clients_looked_up);
|
|
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
n_replies = ntohl(reply.data.client_accesses.n_clients);
|
|
for (j=0; j<n_replies; j++) {
|
|
ip = ntohl(reply.data.client_accesses.clients[j].ip);
|
|
if (ip != 0UL) {
|
|
/* ip == 0 implies that the node could not be found in
|
|
the daemon's tables; we shouldn't ever generate this
|
|
case, but ignore it if we do. (In future there might
|
|
be a protocol to reset the client logging; if another
|
|
administrator runs that while we're doing the clients
|
|
command, there will be a race condition that could
|
|
cause this). */
|
|
|
|
client_hits = ntohl(reply.data.client_accesses.clients[j].client_hits);
|
|
peer_hits = ntohl(reply.data.client_accesses.clients[j].peer_hits);
|
|
cmd_hits_auth = ntohl(reply.data.client_accesses.clients[j].cmd_hits_auth);
|
|
cmd_hits_normal = ntohl(reply.data.client_accesses.clients[j].cmd_hits_normal);
|
|
cmd_hits_bad = ntohl(reply.data.client_accesses.clients[j].cmd_hits_bad);
|
|
last_ntp_hit_ago = ntohl(reply.data.client_accesses.clients[j].last_ntp_hit_ago);
|
|
last_cmd_hit_ago = ntohl(reply.data.client_accesses.clients[j].last_cmd_hit_ago);
|
|
|
|
if (no_dns) {
|
|
snprintf(hostname_buf, sizeof(hostname_buf),
|
|
"%s", UTI_IPToDottedQuad(ip));
|
|
} else {
|
|
dns_lookup = DNS_IPAddress2Name(ip);
|
|
hostname_buf[25] = 0;
|
|
strncpy(hostname_buf, dns_lookup, 25);
|
|
}
|
|
printf("%-25s %6d %6d %6d %6d %6d ",
|
|
hostname_buf,
|
|
client_hits, peer_hits,
|
|
cmd_hits_auth, cmd_hits_normal, cmd_hits_bad);
|
|
print_seconds(last_ntp_hit_ago);
|
|
printf(" ");
|
|
print_seconds(last_cmd_hit_ago);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
/* Skip the todo pointer forwards by the number of nets looked
|
|
up. Can't do this earlier, because we might have to point
|
|
at the next layer of subnets that have only just been
|
|
concatenated to the linked list. */
|
|
for (i=0; i<clients_looked_up; i++) {
|
|
todo = todo->next;
|
|
}
|
|
|
|
break;
|
|
|
|
case STT_BADSUBNET:
|
|
/* We should never generate any bad subnet messages */
|
|
assert(0);
|
|
break;
|
|
case STT_INACTIVE:
|
|
printf("519 Client logging is not active in the daemon\n");
|
|
goto cleanup;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
goto cleanup;
|
|
default:
|
|
printf("520 Got unexpected error from daemon\n");
|
|
goto cleanup;
|
|
}
|
|
|
|
}
|
|
|
|
} while (1);
|
|
|
|
cleanup:
|
|
for (p = head; p; ) {
|
|
next_node = p->next;
|
|
Free(p);
|
|
p = next_node;
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* New implementation of clients command */
|
|
|
|
static void
|
|
process_cmd_clients(char *line)
|
|
{
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int submit_ok, auth_ok;
|
|
int status;
|
|
unsigned long next_index;
|
|
int j;
|
|
unsigned long ip;
|
|
unsigned long client_hits;
|
|
unsigned long peer_hits;
|
|
unsigned long cmd_hits_auth;
|
|
unsigned long cmd_hits_normal;
|
|
unsigned long cmd_hits_bad;
|
|
unsigned long last_ntp_hit_ago;
|
|
unsigned long last_cmd_hit_ago;
|
|
char hostname_buf[32];
|
|
const char *dns_lookup;
|
|
|
|
int n_replies;
|
|
int n_indices_in_table;
|
|
|
|
next_index = 0;
|
|
|
|
printf("Hostname Client Peer CmdAuth CmdNorm CmdBad LstN LstC\n"
|
|
"========================= ====== ====== ====== ====== ====== ==== ====\n");
|
|
|
|
do {
|
|
|
|
request.command = htons(REQ_CLIENT_ACCESSES_BY_INDEX);
|
|
request.data.client_accesses_by_index.first_index = htonl(next_index);
|
|
request.data.client_accesses_by_index.n_indices = htonl(MAX_CLIENT_ACCESSES);
|
|
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
n_replies = ntohl(reply.data.client_accesses_by_index.n_clients);
|
|
n_indices_in_table = ntohl(reply.data.client_accesses_by_index.n_indices);
|
|
if (n_replies == 0) {
|
|
goto finished;
|
|
}
|
|
for (j=0; j<n_replies; j++) {
|
|
ip = ntohl(reply.data.client_accesses_by_index.clients[j].ip);
|
|
if (ip != 0UL) {
|
|
/* ip == 0 implies that the node could not be found in
|
|
the daemon's tables; we shouldn't ever generate this
|
|
case, but ignore it if we do. (In future there might
|
|
be a protocol to reset the client logging; if another
|
|
administrator runs that while we're doing the clients
|
|
command, there will be a race condition that could
|
|
cause this). */
|
|
|
|
client_hits = ntohl(reply.data.client_accesses_by_index.clients[j].client_hits);
|
|
peer_hits = ntohl(reply.data.client_accesses_by_index.clients[j].peer_hits);
|
|
cmd_hits_auth = ntohl(reply.data.client_accesses_by_index.clients[j].cmd_hits_auth);
|
|
cmd_hits_normal = ntohl(reply.data.client_accesses_by_index.clients[j].cmd_hits_normal);
|
|
cmd_hits_bad = ntohl(reply.data.client_accesses_by_index.clients[j].cmd_hits_bad);
|
|
last_ntp_hit_ago = ntohl(reply.data.client_accesses_by_index.clients[j].last_ntp_hit_ago);
|
|
last_cmd_hit_ago = ntohl(reply.data.client_accesses_by_index.clients[j].last_cmd_hit_ago);
|
|
|
|
if (no_dns) {
|
|
snprintf(hostname_buf, sizeof(hostname_buf),
|
|
"%s", UTI_IPToDottedQuad(ip));
|
|
} else {
|
|
dns_lookup = DNS_IPAddress2Name(ip);
|
|
hostname_buf[25] = 0;
|
|
strncpy(hostname_buf, dns_lookup, 25);
|
|
}
|
|
printf("%-25s %6ld %6ld %6ld %6ld %6ld ",
|
|
hostname_buf,
|
|
client_hits, peer_hits,
|
|
cmd_hits_auth, cmd_hits_normal, cmd_hits_bad);
|
|
print_seconds(last_ntp_hit_ago);
|
|
printf(" ");
|
|
print_seconds(last_cmd_hit_ago);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
/* Set the next index to probe based on what the server tells us */
|
|
next_index = ntohl(reply.data.client_accesses_by_index.next_index);
|
|
if (next_index >= n_indices_in_table) {
|
|
goto finished;
|
|
}
|
|
|
|
break;
|
|
case STT_BADSUBNET:
|
|
/* We should never generate any bad subnet messages */
|
|
assert(0);
|
|
break;
|
|
case STT_INACTIVE:
|
|
printf("519 Client logging is not active in the daemon\n");
|
|
goto finished;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
goto finished;
|
|
default:
|
|
printf("520 Got unexpected error from daemon\n");
|
|
goto finished;
|
|
}
|
|
|
|
} else {
|
|
printf("506 Cannot talk to daemon\n");
|
|
return;
|
|
}
|
|
} while (1); /* keep going until all subnets have been expanded,
|
|
down to single nodes */
|
|
|
|
finished:
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
/* ================================================== */
|
|
/* Process the manual list command */
|
|
static void
|
|
process_cmd_manual_list(const char *line)
|
|
{
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int submit_ok, auth_ok;
|
|
int status;
|
|
int n_samples;
|
|
RPY_ManualListSample *sample;
|
|
int i;
|
|
time_t when;
|
|
double slewed_offset, orig_offset, residual;
|
|
|
|
request.command = htons(REQ_MANUAL_LIST);
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
n_samples = ntohl(reply.data.manual_list.n_samples);
|
|
printf("210 n_samples = %d\n", n_samples);
|
|
printf("# Date Time(UTC) Slewed Original Residual\n"
|
|
"====================================================\n");
|
|
for (i=0; i<n_samples; i++) {
|
|
sample = &reply.data.manual_list.samples[i];
|
|
when = ntohl(sample->when);
|
|
slewed_offset = WIRE2REAL(sample->slewed_offset);
|
|
orig_offset = WIRE2REAL(sample->orig_offset);
|
|
residual = WIRE2REAL(sample->residual);
|
|
printf("%2d %s %10.2f %10.2f %10.2f\n", i, time_to_log_form(when), slewed_offset, orig_offset, residual);
|
|
}
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
break;
|
|
default:
|
|
printf("520 Got unexpected error from daemon\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_manual_delete(const char *line)
|
|
{
|
|
int index;
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int submit_ok, auth_ok;
|
|
int status;
|
|
|
|
if (sscanf(line, "%d", &index) != 1) {
|
|
fprintf(stderr, "Bad syntax for manual delete command\n");
|
|
return;
|
|
|
|
}
|
|
|
|
request.command = htons(REQ_MANUAL_DELETE);
|
|
request.data.manual_delete.index = htonl(index);
|
|
|
|
submit_ok = submit_request(&request, &reply, &auth_ok);
|
|
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
printf("200 OK\n");
|
|
break;
|
|
case STT_BADSAMPLE:
|
|
printf("516 Sample index out of range\n");
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host\n");
|
|
break;
|
|
default:
|
|
printf("520 Got unexpected error from daemon\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_settime(char *line)
|
|
{
|
|
time_t now, new_time;
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int submit_ok, reply_auth_ok;
|
|
long offset_cs;
|
|
double dfreq_ppm, new_afreq_ppm;
|
|
double offset;
|
|
int status;
|
|
|
|
now = time(NULL);
|
|
new_time = get_date(line, &now);
|
|
|
|
if (new_time == -1) {
|
|
printf("510 - Could not parse date string\n");
|
|
} else {
|
|
request.data.settime.ts.tv_sec = htonl(new_time);
|
|
request.data.settime.ts.tv_usec = htonl(0);
|
|
request.command = htons(REQ_SETTIME);
|
|
submit_ok = submit_request(&request, &reply, &reply_auth_ok);
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
offset_cs = ntohl(reply.data.manual_timestamp.centiseconds);
|
|
offset = 0.01 * (double) offset_cs;
|
|
dfreq_ppm = WIRE2REAL(reply.data.manual_timestamp.dfreq_ppm);
|
|
new_afreq_ppm = WIRE2REAL(reply.data.manual_timestamp.new_afreq_ppm);
|
|
printf("200 OK : Clock was %.2f seconds fast. Frequency change = %.2fppm, new frequency = %.2fppm",
|
|
offset, dfreq_ppm, new_afreq_ppm);
|
|
break;
|
|
case STT_FAILED:
|
|
printf("500 Failure");
|
|
break;
|
|
case STT_UNAUTH:
|
|
printf("501 Not authorised");
|
|
break;
|
|
case STT_INVALID:
|
|
printf("502 Invalid command");
|
|
break;
|
|
case STT_NOTENABLED:
|
|
printf("505 Facility not enabled in daemon");
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host");
|
|
break;
|
|
}
|
|
if (reply_auth_ok) {
|
|
printf("\n");
|
|
} else {
|
|
printf(" --- Reply not authenticated\n");
|
|
}
|
|
} else {
|
|
printf("506 Could not submit settime command\n");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_rekey(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_REKEY);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_makestep(CMD_Request *msg, char *line)
|
|
{
|
|
msg->command = htons(REQ_MAKESTEP);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_cmd_activity(const char *line)
|
|
{
|
|
CMD_Request request;
|
|
CMD_Reply reply;
|
|
int submit_ok, status, reply_auth_ok;
|
|
request.command = htons(REQ_ACTIVITY);
|
|
submit_ok = submit_request(&request, &reply, &reply_auth_ok);
|
|
if (submit_ok) {
|
|
status = ntohs(reply.status);
|
|
switch (status) {
|
|
case STT_SUCCESS:
|
|
printf("200 OK\n"
|
|
"%ld sources online\n"
|
|
"%ld sources offline\n"
|
|
"%ld sources doing burst (return to online)\n"
|
|
"%ld sources doing burst (return to offline)\n",
|
|
(long) ntohl(reply.data.activity.online),
|
|
(long) ntohl(reply.data.activity.offline),
|
|
(long) ntohl(reply.data.activity.burst_online),
|
|
(long) ntohl(reply.data.activity.burst_offline));
|
|
break;
|
|
default:
|
|
printf("Unexpected error returned\n");
|
|
break;
|
|
}
|
|
if (!reply_auth_ok) {
|
|
printf(" --- Reply not authenticated\n");
|
|
}
|
|
} else {
|
|
printf("506 Could not submit activity command\n");
|
|
}
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static int
|
|
process_line(char *line)
|
|
{
|
|
char *p;
|
|
int quit;
|
|
int do_normal_submit;
|
|
CMD_Request tx_message;
|
|
CMD_Reply rx_message;
|
|
int reply_auth_ok, request_submitted_ok;
|
|
|
|
quit = 0;
|
|
|
|
do_normal_submit = 1;
|
|
|
|
/* Check for line being blank */
|
|
p = line;
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
if (!*p) {
|
|
fflush(stderr);
|
|
fflush(stdout);
|
|
return quit;
|
|
};
|
|
|
|
if (!strncmp(p, "offline", 7)) {
|
|
do_normal_submit = process_cmd_offline(&tx_message, p+7);
|
|
} else if (!strncmp(p, "online", 6)) {
|
|
do_normal_submit = process_cmd_online(&tx_message, p+6);
|
|
} else if (!strncmp(p, "burst", 5)) {
|
|
do_normal_submit = process_cmd_burst(&tx_message, p+5);
|
|
} else if (!strncmp(p, "password", 8)) {
|
|
do_normal_submit = process_cmd_password(&tx_message, p+8);
|
|
} else if (!strncmp(p, "minpoll", 7)) {
|
|
do_normal_submit = process_cmd_minpoll(&tx_message, p+7);
|
|
} else if (!strncmp(p, "maxpoll", 7)) {
|
|
do_normal_submit = process_cmd_maxpoll(&tx_message, p+7);
|
|
} else if (!strncmp(p, "dump", 4)) {
|
|
process_cmd_dump(&tx_message, p+4);
|
|
} else if (!strncmp(p, "maxdelayratio", 13)) {
|
|
do_normal_submit = process_cmd_maxdelayratio(&tx_message, p+13);
|
|
} else if (!strncmp(p, "maxdelay", 8)) {
|
|
do_normal_submit = process_cmd_maxdelay(&tx_message, p+8);
|
|
} else if (!strncmp(p, "maxupdateskew", 13)) {
|
|
do_normal_submit = process_cmd_maxupdateskew(&tx_message, p+13);
|
|
} else if (!strncmp(p, "settime", 7)) {
|
|
do_normal_submit = 0;
|
|
process_cmd_settime(p+7);
|
|
} else if (!strncmp(p, "local", 5)) {
|
|
do_normal_submit = process_cmd_local(&tx_message, p+5);
|
|
} else if (!strncmp(p, "manual", 6)) {
|
|
do_normal_submit = process_cmd_manual(&tx_message, p+6);
|
|
} else if (!strncmp(p, "sourcestats", 11)) {
|
|
do_normal_submit = 0;
|
|
process_cmd_sourcestats(p+11);
|
|
} else if (!strncmp(p, "sources", 7)) {
|
|
do_normal_submit = 0;
|
|
process_cmd_sources(p+7);
|
|
} else if (!strncmp(p, "rekey", 5)) {
|
|
process_cmd_rekey(&tx_message, p+5);
|
|
} else if (!strncmp(p, "allow all", 9)) {
|
|
do_normal_submit = process_cmd_allowall(&tx_message, p+9);
|
|
} else if (!strncmp(p, "allow", 5)) {
|
|
do_normal_submit = process_cmd_allow(&tx_message, p+5);
|
|
} else if (!strncmp(p, "deny all", 8)) {
|
|
do_normal_submit = process_cmd_denyall(&tx_message, p+8);
|
|
} else if (!strncmp(p, "deny", 4)) {
|
|
do_normal_submit = process_cmd_deny(&tx_message, p+4);
|
|
} else if (!strncmp(p, "cmdallow all", 12)) {
|
|
do_normal_submit = process_cmd_cmdallowall(&tx_message, p+12);
|
|
} else if (!strncmp(p, "cmdallow", 8)) {
|
|
do_normal_submit = process_cmd_cmdallow(&tx_message, p+8);
|
|
} else if (!strncmp(p, "cmddeny all", 11)) {
|
|
do_normal_submit = process_cmd_cmddenyall(&tx_message, p+11);
|
|
} else if (!strncmp(p, "cmddeny", 7)) {
|
|
do_normal_submit = process_cmd_cmddeny(&tx_message, p+7);
|
|
} else if (!strncmp(p, "accheck", 7)) {
|
|
do_normal_submit = process_cmd_accheck(&tx_message, p+7);
|
|
} else if (!strncmp(p, "cmdaccheck", 10)) {
|
|
do_normal_submit = process_cmd_cmdaccheck(&tx_message, p+10);
|
|
} else if (!strncmp(p, "add server", 10)) {
|
|
do_normal_submit = process_cmd_add_server(&tx_message, p+10);
|
|
} else if (!strncmp(p, "add peer", 8)) {
|
|
do_normal_submit = process_cmd_add_peer(&tx_message, p+8);
|
|
} else if (!strncmp(p, "delete", 6)) {
|
|
do_normal_submit = process_cmd_delete(&tx_message, p+6);
|
|
} else if (!strncmp(p, "writertc", 7)) {
|
|
process_cmd_writertc(&tx_message, p+7);
|
|
} else if (!strncmp(p, "rtcdata", 7)) {
|
|
do_normal_submit = 0;
|
|
process_cmd_rtcreport(p);
|
|
} else if (!strncmp(p, "trimrtc", 7)) {
|
|
process_cmd_trimrtc(&tx_message, p);
|
|
} else if (!strncmp(p, "cyclelogs", 9)) {
|
|
process_cmd_cyclelogs(&tx_message, p);
|
|
} else if (!strncmp(p, "dfreq", 5)) {
|
|
process_cmd_dfreq(&tx_message, p+5);
|
|
} else if (!strncmp(p, "doffset", 7)) {
|
|
process_cmd_doffset(&tx_message, p+7);
|
|
} else if (!strncmp(p, "tracking", 8)) {
|
|
process_cmd_tracking(p+8);
|
|
do_normal_submit = 0;
|
|
} else if (!strncmp(p, "clients", 7)) {
|
|
process_cmd_clients(p+7);
|
|
do_normal_submit = 0;
|
|
} else if (!strncmp(p, "makestep", 8)) {
|
|
process_cmd_makestep(&tx_message, p+8);
|
|
} else if (!strncmp(p, "activity", 8)) {
|
|
process_cmd_activity(p+8);
|
|
do_normal_submit = 0;
|
|
} else if (!strncmp(p, "help", 4)) {
|
|
do_normal_submit = 0;
|
|
give_help();
|
|
} else if (!strncmp(p, "quit", 4)) {
|
|
do_normal_submit = 0;
|
|
quit = 1;
|
|
} else if (!strncmp(p, "exit", 4)) {
|
|
do_normal_submit = 0;
|
|
quit = 1;
|
|
} else {
|
|
fprintf(stderr, "Unrecognized command\n");
|
|
do_normal_submit = 0;
|
|
}
|
|
|
|
if (do_normal_submit) {
|
|
|
|
request_submitted_ok = submit_request(&tx_message, &rx_message, &reply_auth_ok);
|
|
|
|
if (request_submitted_ok) {
|
|
switch(ntohs(rx_message.status)) {
|
|
case STT_SUCCESS:
|
|
printf("200 OK");
|
|
break;
|
|
case STT_FAILED:
|
|
printf("500 Failure");
|
|
break;
|
|
case STT_UNAUTH:
|
|
printf("501 Not authorised");
|
|
break;
|
|
case STT_INVALID:
|
|
printf("502 Invalid command");
|
|
break;
|
|
case STT_NOSUCHSOURCE:
|
|
printf("503 No such source");
|
|
break;
|
|
case STT_INVALIDTS:
|
|
printf("504 Duplicate or stale logon detected");
|
|
break;
|
|
case STT_NOTENABLED:
|
|
printf("505 Facility not enabled in daemon");
|
|
break;
|
|
case STT_BADSUBNET:
|
|
printf("507 Bad subnet");
|
|
break;
|
|
case STT_ACCESSALLOWED:
|
|
printf("208 Access allowed");
|
|
break;
|
|
case STT_ACCESSDENIED:
|
|
printf("209 Access denied");
|
|
break;
|
|
case STT_NOHOSTACCESS:
|
|
printf("510 No command access from this host");
|
|
break;
|
|
case STT_SOURCEALREADYKNOWN:
|
|
printf("511 Source already present");
|
|
break;
|
|
case STT_TOOMANYSOURCES:
|
|
printf("512 Too many sources present");
|
|
break;
|
|
case STT_NORTC:
|
|
printf("513 RTC driver not running");
|
|
break;
|
|
case STT_BADRTCFILE:
|
|
printf("514 Can't write RTC parameters");
|
|
break;
|
|
}
|
|
|
|
if (reply_auth_ok) {
|
|
printf("\n");
|
|
} else {
|
|
printf(" --- Reply not authenticated\n");
|
|
}
|
|
}
|
|
}
|
|
fflush(stderr);
|
|
fflush(stdout);
|
|
return quit;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
process_args(int argc, char **argv)
|
|
{
|
|
int total_length, i;
|
|
char *line;
|
|
|
|
total_length = 0;
|
|
for(i=0; i<argc; i++) {
|
|
total_length += strlen(argv[i]);
|
|
}
|
|
|
|
line = (char *) malloc((2 + total_length) * sizeof(char));
|
|
line[0] = 0;
|
|
for (i=0; i<argc; i++) {
|
|
strcat(line, argv[i]);
|
|
}
|
|
strcat(line, "\n");
|
|
|
|
process_line(line);
|
|
|
|
free(line);
|
|
|
|
return;
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
static void
|
|
display_gpl(void)
|
|
{
|
|
printf("chrony version %s, copyright (C) 1997-2002 Richard P. Curnow\n"
|
|
"chrony comes with ABSOLUTELY NO WARRANTY.\n"
|
|
"This is free software, and you are welcome to redistribute it\n"
|
|
"under certain conditions.\n"
|
|
"See the GNU General Public License version 2 for details.\n\n",
|
|
PROGRAM_VERSION_STRING);
|
|
}
|
|
|
|
/* ================================================== */
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
char *line;
|
|
const char *progname = argv[0];
|
|
const char *hostname = "localhost";
|
|
int quit = 0;
|
|
int port = DEFAULT_CANDM_PORT;
|
|
|
|
/* Parse command line options */
|
|
while (++argv, --argc) {
|
|
if (!strcmp(*argv, "-h")) {
|
|
++argv, --argc;
|
|
if (*argv) {
|
|
hostname = *argv;
|
|
}
|
|
} else if (!strcmp(*argv, "-p")) {
|
|
++argv, --argc;
|
|
if (*argv) {
|
|
port = atoi(*argv);
|
|
}
|
|
} else if (!strcmp(*argv, "-n")) {
|
|
no_dns = 1;
|
|
} else if (!strcmp("-v", *argv) || !strcmp("--version",*argv)) {
|
|
printf("chronyc (chrony) version %s\n", PROGRAM_VERSION_STRING);
|
|
exit(0);
|
|
} else if (!strncmp(*argv, "-", 1)) {
|
|
fprintf(stderr, "Usage : %s [-h <hostname>] [-p <port-number>] [-n] [command]\n", progname);
|
|
exit(1);
|
|
} else {
|
|
break; /* And process remainder of line as a command */
|
|
}
|
|
}
|
|
|
|
if (isatty(0) && isatty(1) && isatty(2)) {
|
|
on_terminal = 1;
|
|
}
|
|
|
|
if (on_terminal && (argc == 0)) {
|
|
display_gpl();
|
|
}
|
|
|
|
open_io(hostname, port);
|
|
|
|
if (argc > 0) {
|
|
process_args(argc, argv);
|
|
} else {
|
|
do {
|
|
line = read_line();
|
|
if (line) {
|
|
quit = process_line(line);
|
|
}else {
|
|
/* supply the final '\n' when user exits via ^D */
|
|
if( on_terminal ) printf("\n");
|
|
}
|
|
} while (line && !quit);
|
|
}
|
|
|
|
close_io();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|