ntp_util.c revision 290001 
1/*
2 * ntp_util.c - stuff I didn't have any other place for
3 */
4#ifdef HAVE_CONFIG_H
5# include <config.h>
6#endif
7
8#include "ntpd.h"
9#include "ntp_unixtime.h"
10#include "ntp_filegen.h"
11#include "ntp_if.h"
12#include "ntp_stdlib.h"
13#include "ntp_assert.h"
14#include "ntp_calendar.h"
15#include "ntp_leapsec.h"
16#include "lib_strbuf.h"
17
18#include <stdio.h>
19#include <ctype.h>
20#include <sys/types.h>
21#ifdef HAVE_SYS_IOCTL_H
22# include <sys/ioctl.h>
23#endif
24#ifdef HAVE_UNISTD_H
25# include <unistd.h>
26#endif
27#include <sys/stat.h>
28
29#ifdef HAVE_IEEEFP_H
30# include <ieeefp.h>
31#endif
32#ifdef HAVE_MATH_H
33# include <math.h>
34#endif
35
36#if defined(VMS)
37# include <descrip.h>
38#endif /* VMS */
39
40/*
41 * Defines used by the leapseconds stuff
42 */
43#define	MAX_TAI	100			/* max TAI offset (s) */
44#define	L_DAY	86400UL			/* seconds per day */
45#define	L_YEAR	(L_DAY * 365)		/* days per year */
46#define	L_LYEAR	(L_YEAR + L_DAY)	/* days per leap year */
47#define	L_4YEAR	(L_LYEAR + 3 * L_YEAR)	/* days per leap cycle */
48#define	L_CENT	(L_4YEAR * 25)		/* days per century */
49
50/*
51 * This contains odds and ends, including the hourly stats, various
52 * configuration items, leapseconds stuff, etc.
53 */
54/*
55 * File names
56 */
57static	char *key_file_name;		/* keys file name */
58static char	  *leapfile_name;		/* leapseconds file name */
59static struct stat leapfile_stat;	/* leapseconds file stat() buffer */
60static int /*BOOL*/have_leapfile = FALSE;
61char	*stats_drift_file;		/* frequency file name */
62static	char *stats_temp_file;		/* temp frequency file name */
63static double wander_resid;		/* last frequency update */
64double	wander_threshold = 1e-7;	/* initial frequency threshold */
65
66/*
67 * Statistics file stuff
68 */
69#ifndef NTP_VAR
70# ifndef SYS_WINNT
71#  define NTP_VAR "/var/NTP/"		/* NOTE the trailing '/' */
72# else
73#  define NTP_VAR "c:\\var\\ntp\\"	/* NOTE the trailing '\\' */
74# endif /* SYS_WINNT */
75#endif
76
77
78char statsdir[MAXFILENAME] = NTP_VAR;
79static FILEGEN peerstats;
80static FILEGEN loopstats;
81static FILEGEN clockstats;
82static FILEGEN rawstats;
83static FILEGEN sysstats;
84static FILEGEN protostats;
85static FILEGEN cryptostats;
86static FILEGEN timingstats;
87
88/*
89 * This controls whether stats are written to the fileset. Provided
90 * so that ntpdc can turn off stats when the file system fills up.
91 */
92int stats_control;
93
94/*
95 * Last frequency written to file.
96 */
97static double prev_drift_comp;		/* last frequency update */
98
99/*
100 * Function prototypes
101 */
102static	void	record_sys_stats(void);
103	void	ntpd_time_stepped(void);
104static  void	check_leap_expiration(int, uint32_t, const time_t*);
105
106/*
107 * Prototypes
108 */
109#ifdef DEBUG
110void	uninit_util(void);
111#endif
112
113/*
114 * uninit_util - free memory allocated by init_util
115 */
116#ifdef DEBUG
117void
118uninit_util(void)
119{
120#if defined(_MSC_VER) && defined (_DEBUG)
121	_CrtCheckMemory();
122#endif
123	if (stats_drift_file) {
124		free(stats_drift_file);
125		free(stats_temp_file);
126		stats_drift_file = NULL;
127		stats_temp_file = NULL;
128	}
129	if (key_file_name) {
130		free(key_file_name);
131		key_file_name = NULL;
132	}
133	filegen_unregister("peerstats");
134	filegen_unregister("loopstats");
135	filegen_unregister("clockstats");
136	filegen_unregister("rawstats");
137	filegen_unregister("sysstats");
138	filegen_unregister("protostats");
139#ifdef AUTOKEY
140	filegen_unregister("cryptostats");
141#endif	/* AUTOKEY */
142#ifdef DEBUG_TIMING
143	filegen_unregister("timingstats");
144#endif	/* DEBUG_TIMING */
145
146#if defined(_MSC_VER) && defined (_DEBUG)
147	_CrtCheckMemory();
148#endif
149}
150#endif /* DEBUG */
151
152
153/*
154 * init_util - initialize the util module of ntpd
155 */
156void
157init_util(void)
158{
159	filegen_register(statsdir, "peerstats",	  &peerstats);
160	filegen_register(statsdir, "loopstats",	  &loopstats);
161	filegen_register(statsdir, "clockstats",  &clockstats);
162	filegen_register(statsdir, "rawstats",	  &rawstats);
163	filegen_register(statsdir, "sysstats",	  &sysstats);
164	filegen_register(statsdir, "protostats",  &protostats);
165	filegen_register(statsdir, "cryptostats", &cryptostats);
166	filegen_register(statsdir, "timingstats", &timingstats);
167	/*
168	 * register with libntp ntp_set_tod() to call us back
169	 * when time is stepped.
170	 */
171	step_callback = &ntpd_time_stepped;
172#ifdef DEBUG
173	atexit(&uninit_util);
174#endif /* DEBUG */
175}
176
177
178/*
179 * hourly_stats - print some interesting stats
180 */
181void
182write_stats(void)
183{
184	FILE	*fp;
185#ifdef DOSYNCTODR
186	struct timeval tv;
187#if !defined(VMS)
188	int	prio_set;
189#endif
190#ifdef HAVE_GETCLOCK
191	struct timespec ts;
192#endif
193	int	o_prio;
194
195	/*
196	 * Sometimes having a Sun can be a drag.
197	 *
198	 * The kernel variable dosynctodr controls whether the system's
199	 * soft clock is kept in sync with the battery clock. If it
200	 * is zero, then the soft clock is not synced, and the battery
201	 * clock is simply left to rot. That means that when the system
202	 * reboots, the battery clock (which has probably gone wacky)
203	 * sets the soft clock. That means ntpd starts off with a very
204	 * confused idea of what time it is. It then takes a large
205	 * amount of time to figure out just how wacky the battery clock
206	 * has made things drift, etc, etc. The solution is to make the
207	 * battery clock sync up to system time. The way to do THAT is
208	 * to simply set the time of day to the current time of day, but
209	 * as quickly as possible. This may, or may not be a sensible
210	 * thing to do.
211	 *
212	 * CAVEAT: settimeofday() steps the sun clock by about 800 us,
213	 *	   so setting DOSYNCTODR seems a bad idea in the
214	 *	   case of us resolution
215	 */
216
217#if !defined(VMS)
218	/*
219	 * (prr) getpriority returns -1 on error, but -1 is also a valid
220	 * return value (!), so instead we have to zero errno before the
221	 * call and check it for non-zero afterwards.
222	 */
223	errno = 0;
224	prio_set = 0;
225	o_prio = getpriority(PRIO_PROCESS,0); /* Save setting */
226
227	/*
228	 * (prr) if getpriority succeeded, call setpriority to raise
229	 * scheduling priority as high as possible.  If that succeeds
230	 * as well, set the prio_set flag so we remember to reset
231	 * priority to its previous value below.  Note that on Solaris
232	 * 2.6 (and beyond?), both getpriority and setpriority will fail
233	 * with ESRCH, because sched_setscheduler (called from main) put
234	 * us in the real-time scheduling class which setpriority
235	 * doesn't know about. Being in the real-time class is better
236	 * than anything setpriority can do, anyhow, so this error is
237	 * silently ignored.
238	 */
239	if ((errno == 0) && (setpriority(PRIO_PROCESS,0,-20) == 0))
240		prio_set = 1;	/* overdrive */
241#endif /* VMS */
242#ifdef HAVE_GETCLOCK
243	(void) getclock(TIMEOFDAY, &ts);
244	tv.tv_sec = ts.tv_sec;
245	tv.tv_usec = ts.tv_nsec / 1000;
246#else /*  not HAVE_GETCLOCK */
247	GETTIMEOFDAY(&tv,(struct timezone *)NULL);
248#endif /* not HAVE_GETCLOCK */
249	if (ntp_set_tod(&tv,(struct timezone *)NULL) != 0)
250		msyslog(LOG_ERR, "can't sync battery time: %m");
251#if !defined(VMS)
252	if (prio_set)
253		setpriority(PRIO_PROCESS, 0, o_prio); /* downshift */
254#endif /* VMS */
255#endif /* DOSYNCTODR */
256	record_sys_stats();
257	if (stats_drift_file != 0) {
258
259		/*
260		 * When the frequency file is written, initialize the
261		 * prev_drift_comp and wander_resid. Thereafter,
262		 * reduce the wander_resid by half each hour. When
263		 * the difference between the prev_drift_comp and
264		 * drift_comp is less than the wander_resid, update
265		 * the frequncy file. This minimizes the file writes to
266		 * nonvolaile storage.
267		 */
268#ifdef DEBUG
269		if (debug)
270			printf("write_stats: frequency %.6lf thresh %.6lf, freq %.6lf\n",
271			    (prev_drift_comp - drift_comp) * 1e6, wander_resid *
272			    1e6, drift_comp * 1e6);
273#endif
274		if (fabs(prev_drift_comp - drift_comp) < wander_resid) {
275			wander_resid *= 0.5;
276			return;
277		}
278		prev_drift_comp = drift_comp;
279		wander_resid = wander_threshold;
280		if ((fp = fopen(stats_temp_file, "w")) == NULL) {
281			msyslog(LOG_ERR, "frequency file %s: %m",
282			    stats_temp_file);
283			return;
284		}
285		fprintf(fp, "%.3f\n", drift_comp * 1e6);
286		(void)fclose(fp);
287		/* atomic */
288#ifdef SYS_WINNT
289		if (_unlink(stats_drift_file)) /* rename semantics differ under NT */
290			msyslog(LOG_WARNING,
291				"Unable to remove prior drift file %s, %m",
292				stats_drift_file);
293#endif /* SYS_WINNT */
294
295#ifndef NO_RENAME
296		if (rename(stats_temp_file, stats_drift_file))
297			msyslog(LOG_WARNING,
298				"Unable to rename temp drift file %s to %s, %m",
299				stats_temp_file, stats_drift_file);
300#else
301		/* we have no rename NFS of ftp in use */
302		if ((fp = fopen(stats_drift_file, "w")) ==
303		    NULL) {
304			msyslog(LOG_ERR,
305			    "frequency file %s: %m",
306			    stats_drift_file);
307			return;
308		}
309#endif
310
311#if defined(VMS)
312		/* PURGE */
313		{
314			$DESCRIPTOR(oldvers,";-1");
315			struct dsc$descriptor driftdsc = {
316				strlen(stats_drift_file), 0, 0,
317				    stats_drift_file };
318			while(lib$delete_file(&oldvers,
319			    &driftdsc) & 1);
320		}
321#endif
322	}
323}
324
325
326/*
327 * stats_config - configure the stats operation
328 */
329void
330stats_config(
331	int item,
332	const char *invalue	/* only one type so far */
333	)
334{
335	FILE	*fp;
336	const char *value;
337	int	len;
338	double	old_drift;
339	l_fp	now;
340	time_t  ttnow;
341#ifndef VMS
342	const char temp_ext[] = ".TEMP";
343#else
344	const char temp_ext[] = "-TEMP";
345#endif
346
347	/*
348	 * Expand environment strings under Windows NT, since the
349	 * command interpreter doesn't do this, the program must.
350	 */
351#ifdef SYS_WINNT
352	char newvalue[MAX_PATH], parameter[MAX_PATH];
353
354	if (!ExpandEnvironmentStrings(invalue, newvalue, MAX_PATH)) {
355		switch (item) {
356		case STATS_FREQ_FILE:
357			strlcpy(parameter, "STATS_FREQ_FILE",
358				sizeof(parameter));
359			break;
360
361		case STATS_LEAP_FILE:
362			strlcpy(parameter, "STATS_LEAP_FILE",
363				sizeof(parameter));
364			break;
365
366		case STATS_STATSDIR:
367			strlcpy(parameter, "STATS_STATSDIR",
368				sizeof(parameter));
369			break;
370
371		case STATS_PID_FILE:
372			strlcpy(parameter, "STATS_PID_FILE",
373				sizeof(parameter));
374			break;
375
376		default:
377			strlcpy(parameter, "UNKNOWN",
378				sizeof(parameter));
379			break;
380		}
381		value = invalue;
382		msyslog(LOG_ERR,
383			"ExpandEnvironmentStrings(%s) failed: %m\n",
384			parameter);
385	} else {
386		value = newvalue;
387	}
388#else
389	value = invalue;
390#endif /* SYS_WINNT */
391
392	switch (item) {
393
394	/*
395	 * Open and read frequency file.
396	 */
397	case STATS_FREQ_FILE:
398		if (!value || (len = strlen(value)) == 0)
399			break;
400
401		stats_drift_file = erealloc(stats_drift_file, len + 1);
402		stats_temp_file = erealloc(stats_temp_file,
403		    len + sizeof(".TEMP"));
404		memcpy(stats_drift_file, value, (size_t)(len+1));
405		memcpy(stats_temp_file, value, (size_t)len);
406		memcpy(stats_temp_file + len, temp_ext, sizeof(temp_ext));
407
408		/*
409		 * Open drift file and read frequency. If the file is
410		 * missing or contains errors, tell the loop to reset.
411		 */
412		if ((fp = fopen(stats_drift_file, "r")) == NULL)
413			break;
414
415		if (fscanf(fp, "%lf", &old_drift) != 1) {
416			msyslog(LOG_ERR,
417				"format error frequency file %s",
418				stats_drift_file);
419			fclose(fp);
420			break;
421
422		}
423		fclose(fp);
424		loop_config(LOOP_FREQ, old_drift);
425		prev_drift_comp = drift_comp;
426		break;
427
428	/*
429	 * Specify statistics directory.
430	 */
431	case STATS_STATSDIR:
432
433		/* - 1 since value may be missing the DIR_SEP. */
434		if (strlen(value) >= sizeof(statsdir) - 1) {
435			msyslog(LOG_ERR,
436			    "statsdir too long (>%d, sigh)",
437			    (int)sizeof(statsdir) - 2);
438		} else {
439			int add_dir_sep;
440			int value_l;
441
442			/* Add a DIR_SEP unless we already have one. */
443			value_l = strlen(value);
444			if (0 == value_l)
445				add_dir_sep = FALSE;
446			else
447				add_dir_sep = (DIR_SEP !=
448				    value[value_l - 1]);
449
450			if (add_dir_sep)
451				snprintf(statsdir, sizeof(statsdir),
452				    "%s%c", value, DIR_SEP);
453			else
454				snprintf(statsdir, sizeof(statsdir),
455				    "%s", value);
456			filegen_statsdir();
457		}
458		break;
459
460	/*
461	 * Open pid file.
462	 */
463	case STATS_PID_FILE:
464		if ((fp = fopen(value, "w")) == NULL) {
465			msyslog(LOG_ERR, "pid file %s: %m",
466			    value);
467			break;
468		}
469		fprintf(fp, "%d", (int)getpid());
470		fclose(fp);
471		break;
472
473	/*
474	 * Read leapseconds file.
475	 *
476	 * Note: Currently a leap file without SHA1 signature is
477	 * accepted, but if there is a signature line, the signature
478	 * must be valid or the file is rejected.
479	 */
480	case STATS_LEAP_FILE:
481		if (!value || (len = strlen(value)) == 0)
482			break;
483
484		leapfile_name = erealloc(leapfile_name, len + 1);
485		memcpy(leapfile_name, value, len + 1);
486
487		if (leapsec_load_file(
488			    leapfile_name, &leapfile_stat, TRUE, TRUE))
489		{
490			leap_signature_t lsig;
491
492			get_systime(&now);
493			time(&ttnow);
494			leapsec_getsig(&lsig);
495			mprintf_event(EVNT_TAI, NULL,
496				      "%d leap %s %s %s",
497				      lsig.taiof,
498				      fstostr(lsig.ttime),
499				      leapsec_expired(now.l_ui, NULL)
500					  ? "expired"
501					  : "expires",
502				      fstostr(lsig.etime));
503
504			have_leapfile = TRUE;
505
506			/* force an immediate daily expiration check of
507			 * the leap seconds table
508			 */
509			check_leap_expiration(TRUE, now.l_ui, &ttnow);
510		}
511		break;
512
513	default:
514		/* oh well */
515		break;
516	}
517}
518
519
520/*
521 * record_peer_stats - write peer statistics to file
522 *
523 * file format:
524 * day (MJD)
525 * time (s past UTC midnight)
526 * IP address
527 * status word (hex)
528 * offset
529 * delay
530 * dispersion
531 * jitter
532*/
533void
534record_peer_stats(
535	sockaddr_u *addr,
536	int	status,
537	double	offset,		/* offset */
538	double	delay,		/* delay */
539	double	dispersion,	/* dispersion */
540	double	jitter		/* jitter */
541	)
542{
543	l_fp	now;
544	u_long	day;
545
546	if (!stats_control)
547		return;
548
549	get_systime(&now);
550	filegen_setup(&peerstats, now.l_ui);
551	day = now.l_ui / 86400 + MJD_1900;
552	now.l_ui %= 86400;
553	if (peerstats.fp != NULL) {
554		fprintf(peerstats.fp,
555		    "%lu %s %s %x %.9f %.9f %.9f %.9f\n", day,
556		    ulfptoa(&now, 3), stoa(addr), status, offset,
557		    delay, dispersion, jitter);
558		fflush(peerstats.fp);
559	}
560}
561
562
563/*
564 * record_loop_stats - write loop filter statistics to file
565 *
566 * file format:
567 * day (MJD)
568 * time (s past midnight)
569 * offset
570 * frequency (PPM)
571 * jitter
572 * wnder (PPM)
573 * time constant (log2)
574 */
575void
576record_loop_stats(
577	double	offset,		/* offset */
578	double	freq,		/* frequency (PPM) */
579	double	jitter,		/* jitter */
580	double	wander,		/* wander (PPM) */
581	int spoll
582	)
583{
584	l_fp	now;
585	u_long	day;
586
587	if (!stats_control)
588		return;
589
590	get_systime(&now);
591	filegen_setup(&loopstats, now.l_ui);
592	day = now.l_ui / 86400 + MJD_1900;
593	now.l_ui %= 86400;
594	if (loopstats.fp != NULL) {
595		fprintf(loopstats.fp, "%lu %s %.9f %.3f %.9f %.6f %d\n",
596		    day, ulfptoa(&now, 3), offset, freq * 1e6, jitter,
597		    wander * 1e6, spoll);
598		fflush(loopstats.fp);
599	}
600}
601
602
603/*
604 * record_clock_stats - write clock statistics to file
605 *
606 * file format:
607 * day (MJD)
608 * time (s past midnight)
609 * IP address
610 * text message
611 */
612void
613record_clock_stats(
614	sockaddr_u *addr,
615	const char *text	/* timecode string */
616	)
617{
618	l_fp	now;
619	u_long	day;
620
621	if (!stats_control)
622		return;
623
624	get_systime(&now);
625	filegen_setup(&clockstats, now.l_ui);
626	day = now.l_ui / 86400 + MJD_1900;
627	now.l_ui %= 86400;
628	if (clockstats.fp != NULL) {
629		fprintf(clockstats.fp, "%lu %s %s %s\n", day,
630		    ulfptoa(&now, 3), stoa(addr), text);
631		fflush(clockstats.fp);
632	}
633}
634
635
636/*
637 * mprintf_clock_stats - write clock statistics to file with
638 *			msnprintf-style formatting.
639 */
640int
641mprintf_clock_stats(
642	sockaddr_u *addr,
643	const char *fmt,
644	...
645	)
646{
647	va_list	ap;
648	int	rc;
649	char	msg[512];
650
651	va_start(ap, fmt);
652	rc = mvsnprintf(msg, sizeof(msg), fmt, ap);
653	va_end(ap);
654	if (stats_control)
655		record_clock_stats(addr, msg);
656
657	return rc;
658}
659
660/*
661 * record_raw_stats - write raw timestamps to file
662 *
663 * file format
664 * day (MJD)
665 * time (s past midnight)
666 * peer ip address
667 * IP address
668 * t1 t2 t3 t4 timestamps
669 */
670void
671record_raw_stats(
672	sockaddr_u *srcadr,
673	sockaddr_u *dstadr,
674	l_fp	*t1,		/* originate timestamp */
675	l_fp	*t2,		/* receive timestamp */
676	l_fp	*t3,		/* transmit timestamp */
677	l_fp	*t4,		/* destination timestamp */
678	int	leap,
679	int	version,
680	int	mode,
681	int	stratum,
682	int	ppoll,
683	int	precision,
684	double	root_delay,	/* seconds */
685	double	root_dispersion,/* seconds */
686	u_int32	refid
687	)
688{
689	l_fp	now;
690	u_long	day;
691
692	if (!stats_control)
693		return;
694
695	get_systime(&now);
696	filegen_setup(&rawstats, now.l_ui);
697	day = now.l_ui / 86400 + MJD_1900;
698	now.l_ui %= 86400;
699	if (rawstats.fp != NULL) {
700		fprintf(rawstats.fp, "%lu %s %s %s %s %s %s %s %d %d %d %d %d %d %.6f %.6f %s\n",
701		    day, ulfptoa(&now, 3),
702		    stoa(srcadr), dstadr ?  stoa(dstadr) : "-",
703		    ulfptoa(t1, 9), ulfptoa(t2, 9),
704		    ulfptoa(t3, 9), ulfptoa(t4, 9),
705		    leap, version, mode, stratum, ppoll, precision,
706		    root_delay, root_dispersion, refid_str(refid, stratum));
707		fflush(rawstats.fp);
708	}
709}
710
711
712/*
713 * record_sys_stats - write system statistics to file
714 *
715 * file format
716 * day (MJD)
717 * time (s past midnight)
718 * time since reset
719 * packets recieved
720 * packets for this host
721 * current version
722 * old version
723 * access denied
724 * bad length or format
725 * bad authentication
726 * declined
727 * rate exceeded
728 * KoD sent
729 */
730void
731record_sys_stats(void)
732{
733	l_fp	now;
734	u_long	day;
735
736	if (!stats_control)
737		return;
738
739	get_systime(&now);
740	filegen_setup(&sysstats, now.l_ui);
741	day = now.l_ui / 86400 + MJD_1900;
742	now.l_ui %= 86400;
743	if (sysstats.fp != NULL) {
744		fprintf(sysstats.fp,
745		    "%lu %s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
746		    day, ulfptoa(&now, 3), current_time - sys_stattime,
747		    sys_received, sys_processed, sys_newversion,
748		    sys_oldversion, sys_restricted, sys_badlength,
749		    sys_badauth, sys_declined, sys_limitrejected,
750		    sys_kodsent);
751		fflush(sysstats.fp);
752		proto_clr_stats();
753	}
754}
755
756
757/*
758 * record_proto_stats - write system statistics to file
759 *
760 * file format
761 * day (MJD)
762 * time (s past midnight)
763 * text message
764 */
765void
766record_proto_stats(
767	char	*str		/* text string */
768	)
769{
770	l_fp	now;
771	u_long	day;
772
773	if (!stats_control)
774		return;
775
776	get_systime(&now);
777	filegen_setup(&protostats, now.l_ui);
778	day = now.l_ui / 86400 + MJD_1900;
779	now.l_ui %= 86400;
780	if (protostats.fp != NULL) {
781		fprintf(protostats.fp, "%lu %s %s\n", day,
782		    ulfptoa(&now, 3), str);
783		fflush(protostats.fp);
784	}
785}
786
787
788#ifdef AUTOKEY
789/*
790 * record_crypto_stats - write crypto statistics to file
791 *
792 * file format:
793 * day (mjd)
794 * time (s past midnight)
795 * peer ip address
796 * text message
797 */
798void
799record_crypto_stats(
800	sockaddr_u *addr,
801	const char *text	/* text message */
802	)
803{
804	l_fp	now;
805	u_long	day;
806
807	if (!stats_control)
808		return;
809
810	get_systime(&now);
811	filegen_setup(&cryptostats, now.l_ui);
812	day = now.l_ui / 86400 + MJD_1900;
813	now.l_ui %= 86400;
814	if (cryptostats.fp != NULL) {
815		if (addr == NULL)
816			fprintf(cryptostats.fp, "%lu %s 0.0.0.0 %s\n",
817			    day, ulfptoa(&now, 3), text);
818		else
819			fprintf(cryptostats.fp, "%lu %s %s %s\n",
820			    day, ulfptoa(&now, 3), stoa(addr), text);
821		fflush(cryptostats.fp);
822	}
823}
824#endif	/* AUTOKEY */
825
826
827#ifdef DEBUG_TIMING
828/*
829 * record_timing_stats - write timing statistics to file
830 *
831 * file format:
832 * day (mjd)
833 * time (s past midnight)
834 * text message
835 */
836void
837record_timing_stats(
838	const char *text	/* text message */
839	)
840{
841	static unsigned int flshcnt;
842	l_fp	now;
843	u_long	day;
844
845	if (!stats_control)
846		return;
847
848	get_systime(&now);
849	filegen_setup(&timingstats, now.l_ui);
850	day = now.l_ui / 86400 + MJD_1900;
851	now.l_ui %= 86400;
852	if (timingstats.fp != NULL) {
853		fprintf(timingstats.fp, "%lu %s %s\n", day, lfptoa(&now,
854		    3), text);
855		if (++flshcnt % 100 == 0)
856			fflush(timingstats.fp);
857	}
858}
859#endif
860
861
862/*
863 * check_leap_file - See if the leapseconds file has been updated.
864 *
865 * Returns: n/a
866 *
867 * Note: This loads a new leapfile on the fly. Currently a leap file
868 * without SHA1 signature is accepted, but if there is a signature line,
869 * the signature must be valid or the file is rejected.
870 */
871void
872check_leap_file(
873	int           is_daily_check,
874	uint32_t      ntptime       ,
875	const time_t *systime
876	)
877{
878	/* just do nothing if there is no leap file */
879	if ( ! (leapfile_name && *leapfile_name))
880		return;
881
882	/* try to load leapfile, force it if no leapfile loaded yet */
883	if (leapsec_load_file(
884		    leapfile_name, &leapfile_stat,
885		    !have_leapfile, is_daily_check))
886		have_leapfile = TRUE;
887	else if (!have_leapfile)
888		return;
889
890	check_leap_expiration(is_daily_check, ntptime, systime);
891}
892
893/*
894 * check expiration of a loaded leap table
895 */
896static void
897check_leap_expiration(
898	int           is_daily_check,
899	uint32_t      ntptime       ,
900	const time_t *systime
901	)
902{
903	static const char * const logPrefix = "leapsecond file";
904	int  rc;
905
906	/* test the expiration of the leap data and log with proper
907	 * level and frequency (once/hour or once/day, depending on the
908	 * state.
909	 */
910	rc = leapsec_daystolive(ntptime, systime);
911	if (rc == 0) {
912		msyslog(LOG_WARNING,
913			"%s ('%s'): will expire in less than one day",
914			logPrefix, leapfile_name);
915	} else if (is_daily_check && rc < 28) {
916		if (rc < 0)
917			msyslog(LOG_ERR,
918				"%s ('%s'): expired less than %d day%s ago",
919				logPrefix, leapfile_name, -rc, (rc == -1 ? "" : "s"));
920		else
921			msyslog(LOG_WARNING,
922				"%s ('%s'): will expire in less than %d days",
923				logPrefix, leapfile_name, 1+rc);
924	}
925}
926
927
928/*
929 * getauthkeys - read the authentication keys from the specified file
930 */
931void
932getauthkeys(
933	const char *keyfile
934	)
935{
936	int len;
937
938	len = strlen(keyfile);
939	if (!len)
940		return;
941
942#ifndef SYS_WINNT
943	key_file_name = erealloc(key_file_name, len + 1);
944	memcpy(key_file_name, keyfile, len + 1);
945#else
946	key_file_name = erealloc(key_file_name, _MAX_PATH);
947	if (len + 1 > _MAX_PATH)
948		return;
949	if (!ExpandEnvironmentStrings(keyfile, key_file_name,
950				      _MAX_PATH)) {
951		msyslog(LOG_ERR,
952			"ExpandEnvironmentStrings(KEY_FILE) failed: %m");
953		strlcpy(key_file_name, keyfile, _MAX_PATH);
954	}
955	key_file_name = erealloc(key_file_name,
956				 1 + strlen(key_file_name));
957#endif /* SYS_WINNT */
958
959	authreadkeys(key_file_name);
960}
961
962
963/*
964 * rereadkeys - read the authentication key file over again.
965 */
966void
967rereadkeys(void)
968{
969	if (NULL != key_file_name)
970		authreadkeys(key_file_name);
971}
972
973
974#if notyet
975/*
976 * ntp_exit - document explicitly that ntpd has exited
977 */
978void
979ntp_exit(int retval)
980{
981	msyslog(LOG_ERR, "EXITING with return code %d", retval);
982	exit(retval);
983}
984#endif
985
986/*
987 * fstostr - prettyprint NTP seconds
988 */
989char * fstostr(
990	time_t	ntp_stamp
991	)
992{
993	char *		buf;
994	struct calendar tm;
995
996	LIB_GETBUF(buf);
997	if (ntpcal_ntp_to_date(&tm, (u_int32)ntp_stamp, NULL) < 0)
998		snprintf(buf, LIB_BUFLENGTH, "ntpcal_ntp_to_date: %ld: range error",
999			 (long)ntp_stamp);
1000	else
1001		snprintf(buf, LIB_BUFLENGTH, "%04d%02d%02d%02d%02d",
1002			 tm.year, tm.month, tm.monthday,
1003			 tm.hour, tm.minute);
1004	return buf;
1005}
1006
1007
1008/*
1009 * ntpd_time_stepped is called back by step_systime(), allowing ntpd
1010 * to do any one-time processing necessitated by the step.
1011 */
1012void
1013ntpd_time_stepped(void)
1014{
1015	u_int saved_mon_enabled;
1016
1017	/*
1018	 * flush the monitor MRU list which contains l_fp timestamps
1019	 * which should not be compared across the step.
1020	 */
1021	if (MON_OFF != mon_enabled) {
1022		saved_mon_enabled = mon_enabled;
1023		mon_stop(MON_OFF);
1024		mon_start(saved_mon_enabled);
1025	}
1026
1027	/* inform interpolating Windows code to allow time to go back */
1028#ifdef SYS_WINNT
1029	win_time_stepped();
1030#endif
1031}
1032