#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_unixtime.h"
#include "ntp_filegen.h"
#include "ntp_if.h"
#include "ntp_stdlib.h"
#include "ntp_assert.h"
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#ifdef HAVE_IEEEFP_H
# include <ieeefp.h>
#endif
#ifdef HAVE_MATH_H
# include <math.h>
#endif
#ifdef DOSYNCTODR
# if !defined(VMS)
# include <sys/resource.h>
# endif
#endif
#if defined(VMS)
# include <descrip.h>
#endif
#include <vproc.h>
#include <sys/mman.h>
#include <signal.h>
#define MAX_TAI 100
#define L_DAY 86400UL
#define L_YEAR (L_DAY * 365)
#define L_LYEAR (L_YEAR + L_DAY)
#define L_4YEAR (L_LYEAR + 3 * L_YEAR)
#define L_CENT (L_4YEAR * 25)
static char *key_file_name;
char *leapseconds_file_name;
char *stats_drift_file;
static char *stats_temp_file;
double wander_resid;
double wander_threshold = 1e-7;
int drift_file_sw;
static int drift_exists;
#ifndef NTP_VAR
# ifndef SYS_WINNT
# define NTP_VAR "/var/NTP/"
# else
# define NTP_VAR "c:\\var\\ntp\\"
# endif
#endif
#ifndef MAXPATHLEN
# define MAXPATHLEN 256
#endif
#ifdef DEBUG_TIMING
static FILEGEN timingstats;
#endif
#ifdef OPENSSL
static FILEGEN cryptostats;
#endif
static char statsdir[MAXPATHLEN] = NTP_VAR;
static FILEGEN peerstats;
static FILEGEN loopstats;
static FILEGEN clockstats;
static FILEGEN rawstats;
static FILEGEN sysstats;
static FILEGEN protostats;
int stats_control;
double old_drift = 1e9;
static double prev_drift_comp;
static int leap_file(FILE *);
static void record_sys_stats(void);
#ifdef DEBUG
void uninit_util(void);
#endif
#ifdef DEBUG
void
uninit_util(void)
{
#if defined(_MSC_VER) && defined (_DEBUG)
_CrtCheckMemory();
#endif
if (stats_drift_file) {
free(stats_drift_file);
free(stats_temp_file);
stats_drift_file = NULL;
stats_temp_file = NULL;
}
if (key_file_name) {
free(key_file_name);
key_file_name = NULL;
}
filegen_unregister("peerstats");
filegen_unregister("loopstats");
filegen_unregister("clockstats");
filegen_unregister("rawstats");
filegen_unregister("sysstats");
filegen_unregister("protostats");
#ifdef OPENSSL
filegen_unregister("cryptostats");
#endif
#ifdef DEBUG_TIMING
filegen_unregister("timingstats");
#endif
#if defined(_MSC_VER) && defined (_DEBUG)
_CrtCheckMemory();
#endif
}
#endif
void
init_util(void)
{
stats_drift_file = NULL;
stats_temp_file = NULL;
key_file_name = NULL;
filegen_register(statsdir, "peerstats", &peerstats);
filegen_register(statsdir, "loopstats", &loopstats);
filegen_register(statsdir, "clockstats", &clockstats);
filegen_register(statsdir, "rawstats", &rawstats);
filegen_register(statsdir, "sysstats", &sysstats);
filegen_register(statsdir, "protostats", &protostats);
#ifdef OPENSSL
filegen_register(statsdir, "cryptostats", &cryptostats);
#endif
#ifdef DEBUG_TIMING
filegen_register(statsdir, "timingstats", &timingstats);
#endif
#ifdef DEBUG
atexit(uninit_util);
#endif
}
#include <mach/mach_port.h>
#include <mach/mach_interface.h>
#include <mach/mach_init.h>
#include <IOKit/pwr_mgt/IOPMLib.h>
#include <IOKit/pwr_mgt/IOPM.h>
static io_connect_t getFB(void) {
static io_connect_t fb;
if (!fb) {
fb = IOPMFindPowerManagement(kIOMasterPortDefault);
}
return fb;
}
static unsigned long energy_saving(void) {
IOReturn err;
unsigned long min = 99;
io_connect_t fb = getFB();
if (fb) {
err = IOPMGetAggressiveness( fb, kPMMinutesToSleep, &min);
if (err == kIOReturnSuccess) {
if (min > 0) {
return min;
} else {
err = IOPMGetAggressiveness( fb, kPMMinutesToSpinDown, &min);
if (err == kIOReturnSuccess) {
return min;
}
}
}
}
return 0;
}
int
save_drift_file(
)
{
FILE *fp;
int rc = true;
#if !TARGET_OS_EMBEDDED
vproc_transaction_t vt;
#endif
static off_t stats_size = 0;
sigset_t sigterm, oset;
sigemptyset(&sigterm);
sigaddset(&sigterm, SIGTERM);
sigprocmask(SIG_BLOCK, &sigterm, &oset);
#if !TARGET_OS_EMBEDDED
vt = vproc_transaction_begin(NULL);
#endif
if (stats_drift_file != 0 && (!drift_exists || !energy_saving())) {
if ((fp = fopen(stats_temp_file, "w")) == NULL) {
msyslog(LOG_ERR, "can't open %s: %m",
stats_temp_file);
rc = false;
goto done;
}
stats_size = fprintf(fp, "%.3f\n", drift_comp * 1e6);
(void)fclose(fp);
#ifdef SYS_WINNT
(void) _unlink(stats_drift_file);
#endif
#ifndef NO_RENAME
(void) rename(stats_temp_file, stats_drift_file);
#else
if ((fp = fopen(stats_drift_file, "w")) == NULL) {
msyslog(LOG_ERR, "can't open %s: %m",
stats_drift_file);
rc = false;
}
#endif
drift_exists++;
#if defined(VMS)
{
$DESCRIPTOR(oldvers,";-1");
struct dsc$descriptor driftdsc = {
strlen(stats_drift_file),0,0,stats_drift_file };
while(lib$delete_file(&oldvers,&driftdsc) & 1) ;
}
#endif
} else {
static void *mmap_addr;
if (mmap_addr == 0) {
int fd = open(stats_drift_file, O_RDWR);
if (fd >= 0) {
mmap_addr = mmap(0, getpagesize(), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, fd, 0);
if (mmap_addr == MAP_FAILED) {
msyslog(LOG_ERR, "can't mmap %s: %m", stats_drift_file);
mmap_addr = 0;
rc = false;
}
close(fd);
} else {
msyslog(LOG_ERR, "can't open %s: %m", stats_drift_file);
rc = false;
}
} else {
off_t n = snprintf(mmap_addr, getpagesize(), "%.3f\n", drift_comp * 1e6);
if (n != stats_size) {
truncate(stats_drift_file, n);
stats_size = n;
}
}
}
done:
#if !TARGET_OS_EMBEDDED
vproc_transaction_end(NULL, vt);
#endif
sigprocmask(SIG_SETMASK, &oset, NULL);
return rc;
}
void
write_stats(void)
{
double ftemp;
#ifdef DOSYNCTODR
struct timeval tv;
#if !defined(VMS)
int prio_set;
#endif
#ifdef HAVE_GETCLOCK
struct timespec ts;
#endif
int o_prio;
#if !defined(VMS)
errno = 0;
prio_set = 0;
o_prio = getpriority(PRIO_PROCESS,0);
if ((errno == 0) && (setpriority(PRIO_PROCESS,0,-20) == 0))
prio_set = 1;
#endif
#ifdef HAVE_GETCLOCK
(void) getclock(TIMEOFDAY, &ts);
tv.tv_sec = ts.tv_sec;
tv.tv_usec = ts.tv_nsec / 1000;
#else
GETTIMEOFDAY(&tv,(struct timezone *)NULL);
#endif
if (ntp_set_tod(&tv,(struct timezone *)NULL) != 0)
msyslog(LOG_ERR, "can't sync battery time: %m");
#if !defined(VMS)
if (prio_set)
setpriority(PRIO_PROCESS, 0, o_prio);
#endif
#endif
record_sys_stats();
ftemp = fabs(prev_drift_comp - drift_comp);
prev_drift_comp = drift_comp;
if (ftemp > clock_phi)
return;
if (stats_drift_file != 0 && drift_file_sw) {
drift_file_sw = FALSE;
wander_resid *= 0.5;
#ifdef DEBUG
if (debug)
printf("write_stats: wander %.6lf thresh %.6lf, freq %.6lf\n",
clock_stability * 1e6, wander_resid * 1e6,
drift_comp * 1e6);
#endif
if (sys_leap != LEAP_NOTINSYNC && clock_stability >
wander_resid) {
wander_resid = wander_threshold;
save_drift_file();
#ifdef SYS_WINNT
if (_unlink(stats_drift_file))
msyslog(LOG_WARNING,
"Unable to remove prior drift file %s, %m",
stats_drift_file);
#endif
#if defined(VMS)
{
$DESCRIPTOR(oldvers,";-1");
struct dsc$descriptor driftdsc = {
strlen(stats_drift_file), 0, 0,
stats_drift_file };
while(lib$delete_file(&oldvers,
&driftdsc) & 1);
}
#endif
} else {
}
}
}
void
stats_config(
int item,
const char *invalue
)
{
FILE *fp;
const char *value;
int len;
char tbuf[80];
char str1[20], str2[20];
#ifdef SYS_WINNT
char newvalue[MAX_PATH], parameter[MAX_PATH];
if (!ExpandEnvironmentStrings(invalue, newvalue, MAX_PATH)) {
switch(item) {
case STATS_FREQ_FILE:
strcpy(parameter,"STATS_FREQ_FILE");
break;
case STATS_LEAP_FILE:
strcpy(parameter,"STATS_LEAP_FILE");
break;
case STATS_STATSDIR:
strcpy(parameter,"STATS_STATSDIR");
break;
case STATS_PID_FILE:
strcpy(parameter,"STATS_PID_FILE");
break;
default:
strcpy(parameter,"UNKNOWN");
break;
}
value = invalue;
msyslog(LOG_ERR,
"ExpandEnvironmentStrings(%s) failed: %m\n",
parameter);
} else {
value = newvalue;
}
#else
value = invalue;
#endif
switch(item) {
case STATS_FREQ_FILE:
if (!value || (len = strlen(value)) == 0)
break;
stats_drift_file = erealloc(stats_drift_file, len + 1);
stats_temp_file = erealloc(stats_temp_file,
len + sizeof(".TEMP"));
memmove(stats_drift_file, value, (unsigned)(len+1));
memmove(stats_temp_file, value, (unsigned)len);
memmove(stats_temp_file + len,
#if !defined(VMS)
".TEMP", sizeof(".TEMP"));
#else
"-TEMP", sizeof("-TEMP"));
#endif
if ((fp = fopen(stats_drift_file, "r")) == NULL)
break;
if (fscanf(fp, "%lf", &old_drift) != 1) {
msyslog(LOG_ERR,
"format error frequency file %s",
stats_drift_file);
fclose(fp);
break;
}
fclose(fp);
drift_exists++;
old_drift /= 1e6;
prev_drift_comp = old_drift;
break;
case STATS_STATSDIR:
if (strlen(value) >= sizeof(statsdir)) {
msyslog(LOG_ERR,
"statsdir too long (>%d, sigh)",
(int)sizeof(statsdir) - 1);
} else {
l_fp now;
int add_dir_sep;
int value_l = strlen(value);
if (value_l == 0)
add_dir_sep = 0;
else
add_dir_sep = (DIR_SEP !=
value[value_l - 1]);
if (add_dir_sep)
snprintf(statsdir, sizeof(statsdir),
"%s%c", value, DIR_SEP);
else
snprintf(statsdir, sizeof(statsdir),
"%s", value);
get_systime(&now);
if(peerstats.prefix == &statsdir[0] &&
peerstats.fp != NULL) {
fclose(peerstats.fp);
peerstats.fp = NULL;
filegen_setup(&peerstats, now.l_ui);
}
if(loopstats.prefix == &statsdir[0] &&
loopstats.fp != NULL) {
fclose(loopstats.fp);
loopstats.fp = NULL;
filegen_setup(&loopstats, now.l_ui);
}
if(clockstats.prefix == &statsdir[0] &&
clockstats.fp != NULL) {
fclose(clockstats.fp);
clockstats.fp = NULL;
filegen_setup(&clockstats, now.l_ui);
}
if(rawstats.prefix == &statsdir[0] &&
rawstats.fp != NULL) {
fclose(rawstats.fp);
rawstats.fp = NULL;
filegen_setup(&rawstats, now.l_ui);
}
if(sysstats.prefix == &statsdir[0] &&
sysstats.fp != NULL) {
fclose(sysstats.fp);
sysstats.fp = NULL;
filegen_setup(&sysstats, now.l_ui);
}
if(protostats.prefix == &statsdir[0] &&
protostats.fp != NULL) {
fclose(protostats.fp);
protostats.fp = NULL;
filegen_setup(&protostats, now.l_ui);
}
#ifdef OPENSSL
if(cryptostats.prefix == &statsdir[0] &&
cryptostats.fp != NULL) {
fclose(cryptostats.fp);
cryptostats.fp = NULL;
filegen_setup(&cryptostats, now.l_ui);
}
#endif
#ifdef DEBUG_TIMING
if(timingstats.prefix == &statsdir[0] &&
timingstats.fp != NULL) {
fclose(timingstats.fp);
timingstats.fp = NULL;
filegen_setup(&timingstats, now.l_ui);
}
#endif
}
break;
case STATS_PID_FILE:
if ((fp = fopen(value, "w")) == NULL) {
msyslog(LOG_ERR, "pid file %s: %m",
value);
break;
}
fprintf(fp, "%d", (int)getpid());
fclose(fp);;
break;
case STATS_LEAP_FILE:
if ((fp = fopen(value, "r")) == NULL) {
msyslog(LOG_ERR, "leapseconds file %s: %m",
value);
break;
}
if (leap_file(fp) < 0) {
msyslog(LOG_ERR,
"format error leapseconds file %s",
value);
} else {
strcpy(str1, fstostr(leap_sec));
strcpy(str2, fstostr(leap_expire));
snprintf(tbuf, sizeof(tbuf),
"%d leap %s expire %s", leap_tai, str1,
str2);
report_event(EVNT_TAI, NULL, tbuf);
}
fclose(fp);
break;
default:
break;
}
}
void
record_peer_stats(
sockaddr_u *addr,
int status,
double offset,
double delay,
double dispersion,
double jitter
)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&peerstats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (peerstats.fp != NULL) {
fprintf(peerstats.fp,
"%lu %s %s %x %.9f %.9f %.9f %.9f\n", day,
ulfptoa(&now, 3), stoa(addr), status, offset,
delay, dispersion, jitter);
fflush(peerstats.fp);
}
}
void
record_loop_stats(
double offset,
double freq,
double jitter,
double wander,
int spoll
)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&loopstats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (loopstats.fp != NULL) {
fprintf(loopstats.fp, "%lu %s %.9f %.3f %.9f %.6f %d\n",
day, ulfptoa(&now, 3), offset, freq * 1e6, jitter,
wander * 1e6, spoll);
fflush(loopstats.fp);
}
}
void
record_clock_stats(
sockaddr_u *addr,
const char *text
)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&clockstats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (clockstats.fp != NULL) {
fprintf(clockstats.fp, "%lu %s %s %s\n", day,
ulfptoa(&now, 3), stoa(addr), text);
fflush(clockstats.fp);
}
}
void
record_raw_stats(
sockaddr_u *srcadr,
sockaddr_u *dstadr,
l_fp *t1,
l_fp *t2,
l_fp *t3,
l_fp *t4
)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&rawstats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (rawstats.fp != NULL) {
fprintf(rawstats.fp, "%lu %s %s %s %s %s %s %s\n", day,
ulfptoa(&now, 3), stoa(srcadr), dstadr ?
stoa(dstadr) : "-", ulfptoa(t1, 9), ulfptoa(t2, 9),
ulfptoa(t3, 9), ulfptoa(t4, 9));
fflush(rawstats.fp);
}
}
void
record_sys_stats(void)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&sysstats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (sysstats.fp != NULL) {
fprintf(sysstats.fp,
"%lu %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
day, ulfptoa(&now, 3), current_time - sys_stattime,
sys_received, sys_processed, sys_newversion,
sys_oldversion, sys_restricted, sys_badlength,
sys_badauth, sys_declined, sys_limitrejected,
sys_kodsent);
fflush(sysstats.fp);
proto_clr_stats();
}
}
void
record_proto_stats(
char *str
)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&protostats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (protostats.fp != NULL) {
fprintf(protostats.fp, "%lu %s %s\n", day,
ulfptoa(&now, 3), str);
fflush(protostats.fp);
}
}
#ifdef OPENSSL
void
record_crypto_stats(
sockaddr_u *addr,
const char *text
)
{
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&cryptostats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (cryptostats.fp != NULL) {
if (addr == NULL)
fprintf(cryptostats.fp, "%lu %s 0.0.0.0 %s\n",
day, ulfptoa(&now, 3), text);
else
fprintf(cryptostats.fp, "%lu %s %s %s\n",
day, ulfptoa(&now, 3), stoa(addr), text);
fflush(cryptostats.fp);
}
}
#endif
#ifdef DEBUG_TIMING
void
record_timing_stats(
const char *text
)
{
static unsigned int flshcnt;
l_fp now;
u_long day;
if (!stats_control)
return;
get_systime(&now);
filegen_setup(&timingstats, now.l_ui);
day = now.l_ui / 86400 + MJD_1900;
now.l_ui %= 86400;
if (timingstats.fp != NULL) {
fprintf(timingstats.fp, "%lu %s %s\n", day, lfptoa(&now,
3), text);
if (++flshcnt % 100 == 0)
fflush(timingstats.fp);
}
}
#endif
static int
leap_file(
FILE *fp
)
{
char buf[NTP_MAXSTRLEN];
u_long leap;
u_long expire;
int offset;
int i;
offset = 0;
leap = 0;
expire = 0;
i = 10;
while (fgets(buf, NTP_MAXSTRLEN - 1, fp) != NULL) {
if (strlen(buf) < 1)
continue;
if (buf[0] == '#') {
if (strlen(buf) < 3)
continue;
if (buf[1] == '@' || buf[1] == '$') {
if (sscanf(&buf[2], "%lu", &expire) !=
1)
return (-1);
continue;
}
}
if (sscanf(buf, "%lu %d", &leap, &offset) == 2) {
if (i++ != offset)
return (-1);
}
}
if (i == 10)
return (-1);
leap_tai = offset;
leap_sec = leap;
leap_expire = expire;
return (0);
}
u_long
leap_month(
u_long sec
)
{
u_long ltemp;
u_long *ptr;
u_long year[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,
31};
u_long lyear[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30,
31};
ltemp = sec;
while (ltemp >= L_CENT)
ltemp -= L_CENT;
while (ltemp >= L_4YEAR)
ltemp -= L_4YEAR;
if (ltemp < L_LYEAR) {
ptr = lyear;
} else {
ptr = year;
ltemp -= L_LYEAR;
while (ltemp >= L_YEAR)
ltemp -= L_YEAR;
}
while (ltemp >= *ptr * L_DAY)
ltemp -= *ptr++ * L_DAY;
return (*ptr * L_DAY - ltemp - L_DAY);
}
void
getauthkeys(
const char *keyfile
)
{
int len;
len = strlen(keyfile);
if (!len)
return;
#ifndef SYS_WINNT
key_file_name = erealloc(key_file_name, len + 1);
memmove(key_file_name, keyfile, len + 1);
#else
key_file_name = erealloc(key_file_name, _MAX_PATH);
if (len + 1 > _MAX_PATH)
return;
if (!ExpandEnvironmentStrings(keyfile, key_file_name,
_MAX_PATH)) {
msyslog(LOG_ERR,
"ExpandEnvironmentStrings(KEY_FILE) failed: %m");
strncpy(key_file_name, keyfile, _MAX_PATH);
}
#endif
authreadkeys(key_file_name);
}
void
rereadkeys(void)
{
if (NULL != key_file_name)
authreadkeys(key_file_name);
}
u_short
sock_hash(
sockaddr_u *addr
)
{
u_int hashVal;
u_int j;
size_t len;
u_char *pch;
hashVal = 0;
len = 0;
pch = (u_char *)&AF(addr);
hashVal = 37 * hashVal + *pch;
if (sizeof(AF(addr)) > 1) {
pch++;
hashVal = 37 * hashVal + *pch;
}
switch(AF(addr)) {
case AF_INET:
pch = (u_char *)&SOCK_ADDR4(addr);
len = sizeof(SOCK_ADDR4(addr));
break;
case AF_INET6:
pch = (u_char *)&SOCK_ADDR6(addr);
len = sizeof(SOCK_ADDR6(addr));
break;
}
for (j = 0; j < len ; j++)
hashVal = 37 * hashVal + pch[j];
hashVal = hashVal & NTP_HASH_MASK;
return (u_short)hashVal;
}
#if notyet
void
ntp_exit(int retval)
{
msyslog(LOG_ERR, "EXITING with return code %d", retval);
exit(retval);
}
#endif
char * fstostr(
time_t ntp_stamp
)
{
static char str[20];
struct tm * tm;
time_t unix_stamp;
unix_stamp = ntp_stamp - JAN_1970;
tm = gmtime(&unix_stamp);
if (NULL != tm)
snprintf(str, sizeof(str),
"%04d%02d%02d%02d%02d",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min);
else
strcpy(str, "gmtime() error");
return str;
}
#define kMaxUUIDLen 37
int awoke(void)
{
static char sleepwakeuuid[kMaxUUIDLen];
int rc = 0;
io_service_t service = IORegistryEntryFromPath(kIOMasterPortDefault,
kIOPowerPlane ":/IOPowerConnection/IOPMrootDomain");
CFStringRef uuidString = IORegistryEntryCreateCFProperty(
service,
CFSTR(kIOPMSleepWakeUUIDKey),
kCFAllocatorDefault, 0);
if (uuidString) {
char newuuid[kMaxUUIDLen];
CFStringGetCString(uuidString, newuuid, sizeof(newuuid),
kCFStringEncodingUTF8);
rc = strncasecmp(newuuid, sleepwakeuuid, sizeof(newuuid));
if (rc) {
strlcpy(sleepwakeuuid, newuuid, sizeof(sleepwakeuuid));
}
CFRelease(uuidString);
}
IOObjectRelease(service);
return rc;
}