xref: /freebsd/contrib/ntp/ntpd/ntp_timer.c (revision 4436b51dff5736e74da464946049ea6899a88938) 
1 /*
2  * ntp_timer.c - event timer support routines
3  */
4 #ifdef HAVE_CONFIG_H
5 # include <config.h>
6 #endif
7 
8 #include "ntp_machine.h"
9 #include "ntpd.h"
10 #include "ntp_stdlib.h"
11 #include "ntp_calendar.h"
12 #include "ntp_leapsec.h"
13 
14 #if defined(HAVE_IO_COMPLETION_PORT)
15 # include "ntp_iocompletionport.h"
16 # include "ntp_timer.h"
17 #endif
18 
19 #include <stdio.h>
20 #include <signal.h>
21 #ifdef HAVE_SYS_SIGNAL_H
22 # include <sys/signal.h>
23 #endif
24 #ifdef HAVE_UNISTD_H
25 # include <unistd.h>
26 #endif
27 
28 #ifdef KERNEL_PLL
29 #include "ntp_syscall.h"
30 #endif /* KERNEL_PLL */
31 
32 #ifdef AUTOKEY
33 #include <openssl/rand.h>
34 #endif	/* AUTOKEY */
35 
36 
37 /* TC_ERR represents the timer_create() error return value. */
38 #ifdef SYS_VXWORKS
39 #define	TC_ERR	ERROR
40 #else
41 #define	TC_ERR	(-1)
42 #endif
43 
44 
45 static void check_leapsec(u_int32, const time_t*, int/*BOOL*/);
46 
47 /*
48  * These routines provide support for the event timer.  The timer is
49  * implemented by an interrupt routine which sets a flag once every
50  * second, and a timer routine which is called when the mainline code
51  * gets around to seeing the flag.  The timer routine dispatches the
52  * clock adjustment code if its time has come, then searches the timer
53  * queue for expiries which are dispatched to the transmit procedure.
54  * Finally, we call the hourly procedure to do cleanup and print a
55  * message.
56  */
57 volatile int interface_interval;     /* init_io() sets def. 300s */
58 
59 /*
60  * Alarm flag. The mainline code imports this.
61  */
62 volatile int alarm_flag;
63 
64 /*
65  * The counters and timeouts
66  */
67 static  u_long interface_timer;	/* interface update timer */
68 static	u_long adjust_timer;	/* second timer */
69 static	u_long stats_timer;	/* stats timer */
70 static	u_long leapf_timer;	/* Report leapfile problems once/day */
71 static	u_long huffpuff_timer;	/* huff-n'-puff timer */
72 static	u_long worker_idle_timer;/* next check for idle intres */
73 u_long	leapsec;	        /* seconds to next leap (proximity class) */
74 int     leapdif;                /* TAI difference step at next leap second*/
75 u_long	orphwait; 		/* orphan wait time */
76 #ifdef AUTOKEY
77 static	u_long revoke_timer;	/* keys revoke timer */
78 static	u_long keys_timer;	/* session key timer */
79 u_long	sys_revoke = KEY_REVOKE; /* keys revoke timeout (log2 s) */
80 u_long	sys_automax = NTP_AUTOMAX; /* key list timeout (log2 s) */
81 #endif	/* AUTOKEY */
82 
83 /*
84  * Statistics counter for the interested.
85  */
86 volatile u_long alarm_overflow;
87 
88 u_long current_time;		/* seconds since startup */
89 
90 /*
91  * Stats.  Number of overflows and number of calls to transmit().
92  */
93 u_long timer_timereset;
94 u_long timer_overflows;
95 u_long timer_xmtcalls;
96 
97 #if defined(VMS)
98 static int vmstimer[2]; 	/* time for next timer AST */
99 static int vmsinc[2];		/* timer increment */
100 #endif /* VMS */
101 
102 #ifdef SYS_WINNT
103 HANDLE WaitableTimerHandle;
104 #else
105 static	RETSIGTYPE alarming (int);
106 #endif /* SYS_WINNT */
107 
108 #if !defined(VMS)
109 # if !defined SYS_WINNT || defined(SYS_CYGWIN32)
110 #  ifdef HAVE_TIMER_CREATE
111 static timer_t timer_id;
112 typedef struct itimerspec intervaltimer;
113 #   define	itv_frac	tv_nsec
114 #  else
115 typedef struct itimerval intervaltimer;
116 #   define	itv_frac	tv_usec
117 #  endif
118 intervaltimer itimer;
119 # endif
120 #endif
121 
122 #if !defined(SYS_WINNT) && !defined(VMS)
123 void	set_timer_or_die(const intervaltimer *);
124 #endif
125 
126 
127 #if !defined(SYS_WINNT) && !defined(VMS)
128 void
129 set_timer_or_die(
130 	const intervaltimer *	ptimer
131 	)
132 {
133 	const char *	setfunc;
134 	int		rc;
135 
136 # ifdef HAVE_TIMER_CREATE
137 	setfunc = "timer_settime";
138 	rc = timer_settime(timer_id, 0, &itimer, NULL);
139 # else
140 	setfunc = "setitimer";
141 	rc = setitimer(ITIMER_REAL, &itimer, NULL);
142 # endif
143 	if (-1 == rc) {
144 		msyslog(LOG_ERR, "interval timer %s failed, %m",
145 			setfunc);
146 		exit(1);
147 	}
148 }
149 #endif	/* !SYS_WINNT && !VMS */
150 
151 
152 /*
153  * reinit_timer - reinitialize interval timer after a clock step.
154  */
155 void
156 reinit_timer(void)
157 {
158 #if !defined(SYS_WINNT) && !defined(VMS)
159 	ZERO(itimer);
160 # ifdef HAVE_TIMER_CREATE
161 	timer_gettime(timer_id, &itimer);
162 # else
163 	getitimer(ITIMER_REAL, &itimer);
164 # endif
165 	if (itimer.it_value.tv_sec < 0 ||
166 	    itimer.it_value.tv_sec > (1 << EVENT_TIMEOUT))
167 		itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
168 	if (itimer.it_value.itv_frac < 0)
169 		itimer.it_value.itv_frac = 0;
170 	if (0 == itimer.it_value.tv_sec &&
171 	    0 == itimer.it_value.itv_frac)
172 		itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
173 	itimer.it_interval.tv_sec = (1 << EVENT_TIMEOUT);
174 	itimer.it_interval.itv_frac = 0;
175 	set_timer_or_die(&itimer);
176 # endif /* VMS */
177 }
178 
179 
180 /*
181  * init_timer - initialize the timer data structures
182  */
183 void
184 init_timer(void)
185 {
186 	/*
187 	 * Initialize...
188 	 */
189 	alarm_flag = FALSE;
190 	alarm_overflow = 0;
191 	adjust_timer = 1;
192 	stats_timer = SECSPERHR;
193 	leapf_timer = SECSPERDAY;
194 	huffpuff_timer = 0;
195 	interface_timer = 0;
196 	current_time = 0;
197 	timer_overflows = 0;
198 	timer_xmtcalls = 0;
199 	timer_timereset = 0;
200 
201 #ifndef SYS_WINNT
202 	/*
203 	 * Set up the alarm interrupt.	The first comes 2**EVENT_TIMEOUT
204 	 * seconds from now and they continue on every 2**EVENT_TIMEOUT
205 	 * seconds.
206 	 */
207 # ifndef VMS
208 #  ifdef HAVE_TIMER_CREATE
209 	if (TC_ERR == timer_create(CLOCK_REALTIME, NULL, &timer_id)) {
210 		msyslog(LOG_ERR, "timer_create failed, %m");
211 		exit(1);
212 	}
213 #  endif
214 	signal_no_reset(SIGALRM, alarming);
215 	itimer.it_interval.tv_sec =
216 		itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
217 	itimer.it_interval.itv_frac = itimer.it_value.itv_frac = 0;
218 	set_timer_or_die(&itimer);
219 # else	/* VMS follows */
220 	vmsinc[0] = 10000000;		/* 1 sec */
221 	vmsinc[1] = 0;
222 	lib$emul(&(1<<EVENT_TIMEOUT), &vmsinc, &0, &vmsinc);
223 
224 	sys$gettim(&vmstimer);	/* that's "now" as abstime */
225 
226 	lib$addx(&vmsinc, &vmstimer, &vmstimer);
227 	sys$setimr(0, &vmstimer, alarming, alarming, 0);
228 # endif	/* VMS */
229 #else	/* SYS_WINNT follows */
230 	/*
231 	 * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
232 	 * Under Windows/NT,
233 	 */
234 
235 	WaitableTimerHandle = CreateWaitableTimer(NULL, FALSE, NULL);
236 	if (WaitableTimerHandle == NULL) {
237 		msyslog(LOG_ERR, "CreateWaitableTimer failed: %m");
238 		exit(1);
239 	}
240 	else {
241 		DWORD		Period;
242 		LARGE_INTEGER	DueTime;
243 		BOOL		rc;
244 
245 		Period = (1 << EVENT_TIMEOUT) * 1000;
246 		DueTime.QuadPart = Period * 10000i64;
247 		rc = SetWaitableTimer(WaitableTimerHandle, &DueTime,
248 				      Period, NULL, NULL, FALSE);
249 		if (!rc) {
250 			msyslog(LOG_ERR, "SetWaitableTimer failed: %m");
251 			exit(1);
252 		}
253 	}
254 
255 #endif	/* SYS_WINNT */
256 }
257 
258 
259 /*
260  * intres_timeout_req(s) is invoked in the parent to schedule an idle
261  * timeout to fire in s seconds, if not reset earlier by a call to
262  * intres_timeout_req(0), which clears any pending timeout.  When the
263  * timeout expires, worker_idle_timer_fired() is invoked (again, in the
264  * parent).
265  *
266  * sntp and ntpd each provide implementations adapted to their timers.
267  */
268 void
269 intres_timeout_req(
270 	u_int	seconds		/* 0 cancels */
271 	)
272 {
273 	if (0 == seconds) {
274 		worker_idle_timer = 0;
275 		return;
276 	}
277 	worker_idle_timer = current_time + seconds;
278 }
279 
280 
281 /*
282  * timer - event timer
283  */
284 void
285 timer(void)
286 {
287 	struct peer *	p;
288 	struct peer *	next_peer;
289 	l_fp		now;
290 	time_t          tnow;
291 
292 	/*
293 	 * The basic timerevent is one second.  This is used to adjust the
294 	 * system clock in time and frequency, implement the kiss-o'-death
295 	 * function and the association polling function.
296 	 */
297 	current_time++;
298 	if (adjust_timer <= current_time) {
299 		adjust_timer += 1;
300 		adj_host_clock();
301 #ifdef REFCLOCK
302 		for (p = peer_list; p != NULL; p = next_peer) {
303 			next_peer = p->p_link;
304 			if (FLAG_REFCLOCK & p->flags)
305 				refclock_timer(p);
306 		}
307 #endif /* REFCLOCK */
308 	}
309 
310 	/*
311 	 * Now dispatch any peers whose event timer has expired. Be
312 	 * careful here, since the peer structure might go away as the
313 	 * result of the call.
314 	 */
315 	for (p = peer_list; p != NULL; p = next_peer) {
316 		next_peer = p->p_link;
317 
318 		/*
319 		 * Restrain the non-burst packet rate not more
320 		 * than one packet every 16 seconds. This is
321 		 * usually tripped using iburst and minpoll of
322 		 * 128 s or less.
323 		 */
324 		if (p->throttle > 0)
325 			p->throttle--;
326 		if (p->nextdate <= current_time) {
327 #ifdef REFCLOCK
328 			if (FLAG_REFCLOCK & p->flags)
329 				refclock_transmit(p);
330 			else
331 #endif	/* REFCLOCK */
332 				transmit(p);
333 		}
334 	}
335 
336 	/*
337 	 * Orphan mode is active when enabled and when no servers less
338 	 * than the orphan stratum are available. A server with no other
339 	 * synchronization source is an orphan. It shows offset zero and
340 	 * reference ID the loopback address.
341 	 */
342 	if (sys_orphan < STRATUM_UNSPEC && sys_peer == NULL &&
343 	    current_time > orphwait) {
344 		if (sys_leap == LEAP_NOTINSYNC) {
345 			set_sys_leap(LEAP_NOWARNING);
346 #ifdef AUTOKEY
347 			if (crypto_flags)
348 				crypto_update();
349 #endif	/* AUTOKEY */
350 		}
351 		sys_stratum = (u_char)sys_orphan;
352 		if (sys_stratum > 1)
353 			sys_refid = htonl(LOOPBACKADR);
354 		else
355 			memcpy(&sys_refid, "LOOP", 4);
356 		sys_offset = 0;
357 		sys_rootdelay = 0;
358 		sys_rootdisp = 0;
359 	}
360 
361 	get_systime(&now);
362 	time(&tnow);
363 
364 	/*
365 	 * Leapseconds. Get time and defer to worker if either something
366 	 * is imminent or every 8th second.
367 	 */
368 	if (leapsec > LSPROX_NOWARN || 0 == (current_time & 7))
369 		check_leapsec(now.l_ui, &tnow,
370                                 (sys_leap == LEAP_NOTINSYNC));
371         if (sys_leap != LEAP_NOTINSYNC) {
372                 if (leapsec >= LSPROX_ANNOUNCE && leapdif) {
373 		        if (leapdif > 0)
374 			        set_sys_leap(LEAP_ADDSECOND);
375 		        else
376 			        set_sys_leap(LEAP_DELSECOND);
377                 } else {
378                         set_sys_leap(LEAP_NOWARNING);
379                 }
380 	}
381 
382 	/*
383 	 * Update huff-n'-puff filter.
384 	 */
385 	if (huffpuff_timer <= current_time) {
386 		huffpuff_timer += HUFFPUFF;
387 		huffpuff();
388 	}
389 
390 #ifdef AUTOKEY
391 	/*
392 	 * Garbage collect expired keys.
393 	 */
394 	if (keys_timer <= current_time) {
395 		keys_timer += 1 << sys_automax;
396 		auth_agekeys();
397 	}
398 
399 	/*
400 	 * Generate new private value. This causes all associations
401 	 * to regenerate cookies.
402 	 */
403 	if (revoke_timer && revoke_timer <= current_time) {
404 		revoke_timer += 1 << sys_revoke;
405 		RAND_bytes((u_char *)&sys_private, 4);
406 	}
407 #endif	/* AUTOKEY */
408 
409 	/*
410 	 * Interface update timer
411 	 */
412 	if (interface_interval && interface_timer <= current_time) {
413 		timer_interfacetimeout(current_time +
414 		    interface_interval);
415 		DPRINTF(2, ("timer: interface update\n"));
416 		interface_update(NULL, NULL);
417 	}
418 
419 	if (worker_idle_timer && worker_idle_timer <= current_time)
420 		worker_idle_timer_fired();
421 
422 	/*
423 	 * Finally, write hourly stats and do the hourly
424 	 * and daily leapfile checks.
425 	 */
426 	if (stats_timer <= current_time) {
427 		stats_timer += SECSPERHR;
428 		write_stats();
429 		if (leapf_timer <= current_time) {
430 			leapf_timer += SECSPERDAY;
431 			check_leap_file(TRUE, now.l_ui, &tnow);
432 		} else {
433 			check_leap_file(FALSE, now.l_ui, &tnow);
434 		}
435 	}
436 }
437 
438 
439 #ifndef SYS_WINNT
440 /*
441  * alarming - tell the world we've been alarmed
442  */
443 static RETSIGTYPE
444 alarming(
445 	int sig
446 	)
447 {
448 # ifdef DEBUG
449 	const char *msg = "alarming: initializing TRUE\n";
450 # endif
451 
452 	if (!initializing) {
453 		if (alarm_flag) {
454 			alarm_overflow++;
455 # ifdef DEBUG
456 			msg = "alarming: overflow\n";
457 # endif
458 		} else {
459 # ifndef VMS
460 			alarm_flag++;
461 # else
462 			/* VMS AST routine, increment is no good */
463 			alarm_flag = 1;
464 # endif
465 # ifdef DEBUG
466 			msg = "alarming: normal\n";
467 # endif
468 		}
469 	}
470 # ifdef VMS
471 	lib$addx(&vmsinc, &vmstimer, &vmstimer);
472 	sys$setimr(0, &vmstimer, alarming, alarming, 0);
473 # endif
474 # ifdef DEBUG
475 	if (debug >= 4)
476 		(void)(-1 == write(1, msg, strlen(msg)));
477 # endif
478 }
479 #endif /* SYS_WINNT */
480 
481 
482 void
483 timer_interfacetimeout(u_long timeout)
484 {
485 	interface_timer = timeout;
486 }
487 
488 
489 /*
490  * timer_clr_stats - clear timer module stat counters
491  */
492 void
493 timer_clr_stats(void)
494 {
495 	timer_overflows = 0;
496 	timer_xmtcalls = 0;
497 	timer_timereset = current_time;
498 }
499 
500 
501 static void
502 check_leap_sec_in_progress( const leap_result_t *lsdata ) {
503 	int prv_leap_sec_in_progress = leap_sec_in_progress;
504 	leap_sec_in_progress = lsdata->tai_diff && (lsdata->ddist < 3);
505 
506 	/* if changed we may have to update the leap status sent to clients */
507 	if (leap_sec_in_progress != prv_leap_sec_in_progress)
508 		set_sys_leap(sys_leap);
509 }
510 
511 
512 static void
513 check_leapsec(
514 	u_int32        now  ,
515 	const time_t * tpiv ,
516         int/*BOOL*/    reset)
517 {
518 	static const char leapmsg_p_step[] =
519 	    "Positive leap second, stepped backward.";
520 	static const char leapmsg_p_slew[] =
521 	    "Positive leap second, no step correction. "
522 	    "System clock will be inaccurate for a long time.";
523 
524 	static const char leapmsg_n_step[] =
525 	    "Negative leap second, stepped forward.";
526 	static const char leapmsg_n_slew[] =
527 	    "Negative leap second, no step correction. "
528 	    "System clock will be inaccurate for a long time.";
529 
530 	leap_result_t lsdata;
531 	u_int32       lsprox;
532 #ifdef AUTOKEY
533 	int/*BOOL*/   update_autokey = FALSE;
534 #endif
535 
536 #ifndef SYS_WINNT  /* WinNT port has its own leap second handling */
537 # ifdef KERNEL_PLL
538 	leapsec_electric(pll_control && kern_enable);
539 # else
540 	leapsec_electric(0);
541 # endif
542 #endif
543 #ifdef LEAP_SMEAR
544 	leap_smear.enabled = leap_smear_intv != 0;
545 #endif
546 	if (reset)	{
547 		lsprox = LSPROX_NOWARN;
548 		leapsec_reset_frame();
549 		memset(&lsdata, 0, sizeof(lsdata));
550 	} else {
551 	  int fired = leapsec_query(&lsdata, now, tpiv);
552 
553 	  DPRINTF(1, ("*** leapsec_query: fired %i, now %u (0x%08X), tai_diff %i, ddist %u\n",
554 		  fired, now, now, lsdata.tai_diff, lsdata.ddist));
555 
556 #ifdef LEAP_SMEAR
557 	  leap_smear.in_progress = 0;
558 	  leap_smear.doffset = 0.0;
559 
560 	  if (leap_smear.enabled) {
561 		if (lsdata.tai_diff) {
562 			if (leap_smear.interval == 0) {
563 				leap_smear.interval = leap_smear_intv;
564 				leap_smear.intv_end = lsdata.ttime.Q_s;
565 				leap_smear.intv_start = leap_smear.intv_end - leap_smear.interval;
566 				DPRINTF(1, ("*** leapsec_query: setting leap_smear interval %li, begin %.0f, end %.0f\n",
567 					leap_smear.interval, leap_smear.intv_start, leap_smear.intv_end));
568 			}
569 		}
570 		else {
571 			if (leap_smear.interval)
572 				DPRINTF(1, ("*** leapsec_query: clearing leap_smear interval\n"));
573 			leap_smear.interval = 0;
574 		}
575 
576 		if (leap_smear.interval) {
577 			double dtemp = now;
578 			if (dtemp >= leap_smear.intv_start && dtemp <= leap_smear.intv_end) {
579 				double leap_smear_time = dtemp - leap_smear.intv_start;
580 				/*
581 				 * For now we just do a linear interpolation over the smear interval
582 				 */
583 #if 0
584 				// linear interpolation
585 				leap_smear.doffset = -(leap_smear_time * lsdata.tai_diff / leap_smear.interval);
586 #else
587 				// Google approach: lie(t) = (1.0 - cos(pi * t / w)) / 2.0
588 				leap_smear.doffset = -((double) lsdata.tai_diff - cos( M_PI * leap_smear_time / leap_smear.interval)) / 2.0;
589 #endif
590 				/*
591 				 * TODO see if we're inside an inserted leap second, so we need to compute
592 				 * leap_smear.doffset = 1.0 - leap_smear.doffset
593 				 */
594 				leap_smear.in_progress = 1;
595 #if 0 && defined( DEBUG )
596 				msyslog(LOG_NOTICE, "*** leapsec_query: [%.0f:%.0f] (%li), now %u (%.0f), smear offset %.6f ms\n",
597 					leap_smear.intv_start, leap_smear.intv_end, leap_smear.interval,
598 					now, leap_smear_time, leap_smear.doffset);
599 #else
600 				DPRINTF(1, ("*** leapsec_query: [%.0f:%.0f] (%li), now %u (%.0f), smear offset %.6f ms\n",
601 					leap_smear.intv_start, leap_smear.intv_end, leap_smear.interval,
602 					now, leap_smear_time, leap_smear.doffset));
603 #endif
604 
605 			}
606 		}
607 	  }
608 	  else
609 		leap_smear.interval = 0;
610 
611 	  /*
612 	   * Update the current leap smear offset, eventually 0.0 if outside smear interval.
613 	   */
614 	  DTOLFP(leap_smear.doffset, &leap_smear.offset);
615 
616 #endif	/* LEAP_SMEAR */
617 
618 	  if (fired) {
619 		/* Full hit. Eventually step the clock, but always
620 		 * announce the leap event has happened.
621 		 */
622 		const char *leapmsg = NULL;
623 		if (lsdata.warped < 0) {
624 			if (clock_max_back > 0.0 &&
625 			    clock_max_back < fabs(lsdata.warped)) {
626 				step_systime(lsdata.warped);
627 				leapmsg = leapmsg_p_step;
628 			} else {
629 				leapmsg = leapmsg_p_slew;
630 			}
631 		} else 	if (lsdata.warped > 0) {
632 			if (clock_max_fwd > 0.0 &&
633 			    clock_max_fwd < fabs(lsdata.warped)) {
634 				step_systime(lsdata.warped);
635 				leapmsg = leapmsg_n_step;
636 			} else {
637 				leapmsg = leapmsg_n_slew;
638 			}
639 		}
640 		if (leapmsg)
641 			msyslog(LOG_NOTICE, "%s", leapmsg);
642 		report_event(EVNT_LEAP, NULL, NULL);
643 #ifdef AUTOKEY
644 		update_autokey = TRUE;
645 #endif
646 		lsprox  = LSPROX_NOWARN;
647 		leapsec = LSPROX_NOWARN;
648 		sys_tai = lsdata.tai_offs;
649 	  } else {
650 #ifdef AUTOKEY
651 		update_autokey = (sys_tai != lsdata.tai_offs);
652 #endif
653 		lsprox  = lsdata.proximity;
654 		sys_tai = lsdata.tai_offs;
655 	  }
656 	}
657 
658 	/* We guard against panic alarming during the red alert phase.
659 	 * Strange and evil things might happen if we go from stone cold
660 	 * to piping hot in one step. If things are already that wobbly,
661 	 * we let the normal clock correction take over, even if a jump
662 	 * is involved.
663          * Also make sure the alarming events are edge-triggered, that is,
664          * ceated only when the threshold is crossed.
665          */
666 	if (  (leapsec > 0 || lsprox < LSPROX_ALERT)
667 	    && leapsec < lsprox                     ) {
668 		if (  leapsec < LSPROX_SCHEDULE
669                    && lsprox >= LSPROX_SCHEDULE) {
670 			if (lsdata.dynamic)
671 				report_event(PEVNT_ARMED, sys_peer, NULL);
672 			else
673 				report_event(EVNT_ARMED, NULL, NULL);
674 		}
675 		leapsec = lsprox;
676 	}
677 	if (leapsec > lsprox) {
678 		if (  leapsec >= LSPROX_SCHEDULE
679                    && lsprox   < LSPROX_SCHEDULE) {
680 			report_event(EVNT_DISARMED, NULL, NULL);
681 		}
682 		leapsec = lsprox;
683 	}
684 
685 	if (leapsec >= LSPROX_SCHEDULE)
686 		leapdif = lsdata.tai_diff;
687 	else
688 		leapdif = 0;
689 
690 	check_leap_sec_in_progress(&lsdata);
691 
692 #ifdef AUTOKEY
693 	if (update_autokey)
694 		crypto_update_taichange();
695 #endif
696 }
697