/*

 * ntp_timer.c - event timer support routines

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include "ntp_machine.h"

#include "ntpd.h"

#include "ntp_stdlib.h"

#include "ntp_calendar.h"

#include "ntp_leapsec.h"

#if defined(HAVE_IO_COMPLETION_PORT)

# include "ntp_iocompletionport.h"

# include "ntp_timer.h"

#endif

#include <stdio.h>

#include <signal.h>

#ifdef HAVE_SYS_SIGNAL_H

# include <sys/signal.h>

#endif

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

#ifdef KERNEL_PLL

#include "ntp_syscall.h"

#endif /* KERNEL_PLL */

#ifdef AUTOKEY

#include <openssl/rand.h>

#endif  /* AUTOKEY */

/* TC_ERR represents the timer_create() error return value. */

#ifdef SYS_VXWORKS

#define TC_ERR  ERROR

#else

#define TC_ERR  (-1)

#endif

static void check_leapsec(u_int32, const time_t*, int/*BOOL*/);

/*

 * These routines provide support for the event timer.  The timer is

 * implemented by an interrupt routine which sets a flag once every

 * second, and a timer routine which is called when the mainline code

 * gets around to seeing the flag.  The timer routine dispatches the

 * clock adjustment code if its time has come, then searches the timer

 * queue for expiries which are dispatched to the transmit procedure.

 * Finally, we call the hourly procedure to do cleanup and print a

 * message.

 */

volatile int interface_interval;     /* init_io() sets def. 300s */

/*

 * Initializing flag.  All async routines watch this and only do their

 * thing when it is clear.

 */

int initializing;

/*

 * Alarm flag. The mainline code imports this.

 */

volatile int alarm_flag;

/*

 * The counters and timeouts

 */

static  u_long interface_timer; /* interface update timer */

static  u_long adjust_timer;  /* second timer */

static  u_long stats_timer; /* stats timer */

static  u_long leapf_timer; /* Report leapfile problems once/day */

static  u_long huffpuff_timer;  /* huff-n'-puff timer */

static  u_long worker_idle_timer;/* next check for idle intres */

u_long  leapsec;          /* seconds to next leap (proximity class) */

int     leapdif;                /* TAI difference step at next leap second*/

u_long  orphwait;     /* orphan wait time */

#ifdef AUTOKEY

static  u_long revoke_timer;  /* keys revoke timer */

static  u_long keys_timer;  /* session key timer */

u_char  sys_revoke = KEY_REVOKE; /* keys revoke timeout (log2 s) */

u_char  sys_automax = NTP_AUTOMAX; /* key list timeout (log2 s) */

#endif  /* AUTOKEY */

/*

 * Statistics counter for the interested.

 */

volatile u_long alarm_overflow;

u_long current_time;    /* seconds since startup */

/*

 * Stats.  Number of overflows and number of calls to transmit().

 */

u_long timer_timereset;

u_long timer_overflows;

u_long timer_xmtcalls;

#if defined(VMS)

static int vmstimer[2];   /* time for next timer AST */

static int vmsinc[2];   /* timer increment */

#endif /* VMS */

#ifdef SYS_WINNT

HANDLE WaitableTimerHandle;

#else

static  RETSIGTYPE alarming (int);

#endif /* SYS_WINNT */

#if !defined(VMS)

# if !defined SYS_WINNT || defined(SYS_CYGWIN32)

#  ifdef HAVE_TIMER_CREATE

static timer_t timer_id;

typedef struct itimerspec intervaltimer;

#   define  itv_frac  tv_nsec

#  else

typedef struct itimerval intervaltimer;

#   define  itv_frac  tv_usec

#  endif

intervaltimer itimer;

# endif

#endif

#if !defined(SYS_WINNT) && !defined(VMS)

void  set_timer_or_die(const intervaltimer *);

#endif

#if !defined(SYS_WINNT) && !defined(VMS)

void

set_timer_or_die(

  const intervaltimer * ptimer

  )

{

  const char *  setfunc;

  int   rc;

# ifdef HAVE_TIMER_CREATE

  setfunc = "timer_settime";

  rc = timer_settime(timer_id, 0, &itimer, NULL);

# else

  setfunc = "setitimer";

  rc = setitimer(ITIMER_REAL, &itimer, NULL);

# endif

  if (-1 == rc) {

    msyslog(LOG_ERR, "interval timer %s failed, %m",

      setfunc);

    exit(1);

  }

}

#endif  /* !SYS_WINNT && !VMS */

/*

 * reinit_timer - reinitialize interval timer after a clock step.

 */

void

reinit_timer(void)

{

#if !defined(SYS_WINNT) && !defined(VMS)

  ZERO(itimer);

# ifdef HAVE_TIMER_CREATE

  timer_gettime(timer_id, &itimer);

# else

  getitimer(ITIMER_REAL, &itimer);

# endif

  if (itimer.it_value.tv_sec < 0 ||

      itimer.it_value.tv_sec > (1 << EVENT_TIMEOUT))

    itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);

  if (itimer.it_value.itv_frac < 0)

    itimer.it_value.itv_frac = 0;

  if (0 == itimer.it_value.tv_sec &&

      0 == itimer.it_value.itv_frac)

    itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);

  itimer.it_interval.tv_sec = (1 << EVENT_TIMEOUT);

  itimer.it_interval.itv_frac = 0;

  set_timer_or_die(&itimer);

# endif /* VMS */

}

/*

 * init_timer - initialize the timer data structures

 */

void

init_timer(void)

{

  /*

   * Initialize...

   */

  alarm_flag = FALSE;

  alarm_overflow = 0;

  adjust_timer = 1;

  stats_timer = SECSPERHR;

  leapf_timer = SECSPERDAY;

  huffpuff_timer = 0;

  interface_timer = 0;

  current_time = 0;

  timer_overflows = 0;

  timer_xmtcalls = 0;

  timer_timereset = 0;

#ifndef SYS_WINNT

  /*

   * Set up the alarm interrupt.  The first comes 2**EVENT_TIMEOUT

   * seconds from now and they continue on every 2**EVENT_TIMEOUT

   * seconds.

   */

# ifndef VMS

#  ifdef HAVE_TIMER_CREATE

  if (TC_ERR == timer_create(CLOCK_REALTIME, NULL, &timer_id)) {

    msyslog(LOG_ERR, "timer_create failed, %m");

    exit(1);

  }

#  endif

  signal_no_reset(SIGALRM, alarming);

  itimer.it_interval.tv_sec =

    itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);

  itimer.it_interval.itv_frac = itimer.it_value.itv_frac = 0;

  set_timer_or_die(&itimer);

# else  /* VMS follows */

  vmsinc[0] = 10000000;   /* 1 sec */

  vmsinc[1] = 0;

  lib$emul(&(1<<EVENT_TIMEOUT), &vmsinc, &0, &vmsinc);

  sys$gettim(&vmstimer);  /* that's "now" as abstime */

  lib$addx(&vmsinc, &vmstimer, &vmstimer);

  sys$setimr(0, &vmstimer, alarming, alarming, 0);

# endif /* VMS */

#else /* SYS_WINNT follows */

  /*

   * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds

   * Under Windows/NT,

   */

  WaitableTimerHandle = CreateWaitableTimer(NULL, FALSE, NULL);

  if (WaitableTimerHandle == NULL) {

    msyslog(LOG_ERR, "CreateWaitableTimer failed: %m");

    exit(1);

  }

  else {

    DWORD   Period;

    LARGE_INTEGER DueTime;

    BOOL    rc;

    Period = (1 << EVENT_TIMEOUT) * 1000;

    DueTime.QuadPart = Period * 10000i64;

    rc = SetWaitableTimer(WaitableTimerHandle, &DueTime,

              Period, NULL, NULL, FALSE);

    if (!rc) {

      msyslog(LOG_ERR, "SetWaitableTimer failed: %m");

      exit(1);

    }

  }

#endif  /* SYS_WINNT */

}

/*

 * intres_timeout_req(s) is invoked in the parent to schedule an idle

 * timeout to fire in s seconds, if not reset earlier by a call to

 * intres_timeout_req(0), which clears any pending timeout.  When the

 * timeout expires, worker_idle_timer_fired() is invoked (again, in the

 * parent).

 *

 * sntp and ntpd each provide implementations adapted to their timers.

 */

void

intres_timeout_req(

  u_int seconds   /* 0 cancels */

  )

{

#if defined(HAVE_DROPROOT) && defined(NEED_EARLY_FORK)

  if (droproot) {

    worker_idle_timer = 0;

    return;

  }

#endif

  if (0 == seconds) {

    worker_idle_timer = 0;

    return;

  }

  worker_idle_timer = current_time + seconds;

}

/*

 * timer - event timer

 */

void

timer(void)

{

  struct peer * p;

  struct peer * next_peer;

  l_fp    now;

  time_t          tnow;

  /*

   * The basic timerevent is one second.  This is used to adjust the

   * system clock in time and frequency, implement the kiss-o'-death

   * function and the association polling function.

   */

  current_time++;

  if (adjust_timer <= current_time) {

    adjust_timer += 1;

    adj_host_clock();

#ifdef REFCLOCK

    for (p = peer_list; p != NULL; p = next_peer) {

      next_peer = p->p_link;

      if (FLAG_REFCLOCK & p->flags)

        refclock_timer(p);

    }

#endif /* REFCLOCK */

  }

  /*

   * Now dispatch any peers whose event timer has expired. Be

   * careful here, since the peer structure might go away as the

   * result of the call.

   */

  for (p = peer_list; p != NULL; p = next_peer) {

    next_peer = p->p_link;

    /*

     * Restrain the non-burst packet rate not more

     * than one packet every 16 seconds. This is

     * usually tripped using iburst and minpoll of

     * 128 s or less.

     */

    if (p->throttle > 0)

      p->throttle--;

    if (p->nextdate <= current_time) {

#ifdef REFCLOCK

      if (FLAG_REFCLOCK & p->flags)

        refclock_transmit(p);

      else

#endif  /* REFCLOCK */

        transmit(p);

    }

  }

  /*

   * Orphan mode is active when enabled and when no servers less

   * than the orphan stratum are available. A server with no other

   * synchronization source is an orphan. It shows offset zero and

   * reference ID the loopback address.

   */

  if (sys_orphan < STRATUM_UNSPEC && sys_peer == NULL &&

      current_time > orphwait) {

    if (sys_leap == LEAP_NOTINSYNC) {

      set_sys_leap(LEAP_NOWARNING);

#ifdef AUTOKEY

      if (crypto_flags)

        crypto_update();

#endif  /* AUTOKEY */

    }

    sys_stratum = (u_char)sys_orphan;

    if (sys_stratum > 1)

      sys_refid = htonl(LOOPBACKADR);

    else

      memcpy(&sys_refid, "LOOP", 4);

    sys_offset = 0;

    sys_rootdelay = 0;

    sys_rootdisp = 0;

  }

  get_systime(&now);

  time(&tnow);

  /*

   * Leapseconds. Get time and defer to worker if either something

   * is imminent or every 8th second.

   */

  if (leapsec > LSPROX_NOWARN || 0 == (current_time & 7))

    check_leapsec(now.l_ui, &tnow,

                                (sys_leap == LEAP_NOTINSYNC));

        if (sys_leap != LEAP_NOTINSYNC) {

                if (leapsec >= LSPROX_ANNOUNCE && leapdif) {

            if (leapdif > 0)

              set_sys_leap(LEAP_ADDSECOND);

            else

              set_sys_leap(LEAP_DELSECOND);

                } else {

                        set_sys_leap(LEAP_NOWARNING);

                }

  }

  /*

   * Update huff-n'-puff filter.

   */

  if (huffpuff_timer <= current_time) {

    huffpuff_timer += HUFFPUFF;

    huffpuff();

  }

#ifdef AUTOKEY

  /*

   * Garbage collect expired keys.

   */

  if (keys_timer <= current_time) {

    keys_timer += (1UL << sys_automax);

    auth_agekeys();

  }

  /*

   * Generate new private value. This causes all associations

   * to regenerate cookies.

   */

  if (revoke_timer && revoke_timer <= current_time) {

    revoke_timer += (1UL << sys_revoke);

    RAND_bytes((u_char *)&sys_private, 4);

  }

#endif  /* AUTOKEY */

  /*

   * Interface update timer

   */

  if (interface_interval && interface_timer <= current_time) {

    timer_interfacetimeout(current_time +

        interface_interval);

    DPRINTF(2, ("timer: interface update\n"));

    interface_update(NULL, NULL);

  }

  if (worker_idle_timer && worker_idle_timer <= current_time)

    worker_idle_timer_fired();

  /*

   * Finally, write hourly stats and do the hourly

   * and daily leapfile checks.

   */

  if (stats_timer <= current_time) {

    stats_timer += SECSPERHR;

    write_stats();

    if (leapf_timer <= current_time) {

      leapf_timer += SECSPERDAY;

      check_leap_file(TRUE, now.l_ui, &tnow);

    } else {

      check_leap_file(FALSE, now.l_ui, &tnow);

    }

  }

}

#ifndef SYS_WINNT

/*

 * alarming - tell the world we've been alarmed

 */

static RETSIGTYPE

alarming(

  int sig

  )

{

# ifdef DEBUG

  const char *msg = "alarming: initializing TRUE\n";

# endif

  if (!initializing) {

    if (alarm_flag) {

      alarm_overflow++;

# ifdef DEBUG

      msg = "alarming: overflow\n";

# endif

    } else {

# ifndef VMS

      alarm_flag++;

# else

      /* VMS AST routine, increment is no good */

      alarm_flag = 1;

# endif

# ifdef DEBUG

      msg = "alarming: normal\n";

# endif

    }

  }

# ifdef VMS

  lib$addx(&vmsinc, &vmstimer, &vmstimer);

  sys$setimr(0, &vmstimer, alarming, alarming, 0);

# endif

# ifdef DEBUG

  if (debug >= 4)

    (void)(-1 == write(1, msg, strlen(msg)));

# endif

}

#endif /* SYS_WINNT */

void

timer_interfacetimeout(u_long timeout)

{

  interface_timer = timeout;

}

/*

 * timer_clr_stats - clear timer module stat counters

 */

void

timer_clr_stats(void)

{

  timer_overflows = 0;

  timer_xmtcalls = 0;

  timer_timereset = current_time;

}

static void

check_leap_sec_in_progress( const leap_result_t *lsdata ) {

  int prv_leap_sec_in_progress = leap_sec_in_progress;

  leap_sec_in_progress = lsdata->tai_diff && (lsdata->ddist < 3);

  /* if changed we may have to update the leap status sent to clients */

  if (leap_sec_in_progress != prv_leap_sec_in_progress)

    set_sys_leap(sys_leap);

}

static void

check_leapsec(

  u_int32        now  ,

  const time_t * tpiv ,

        int/*BOOL*/    reset)

{

  static const char leapmsg_p_step[] =

      "Positive leap second, stepped backward.";

  static const char leapmsg_p_slew[] =

      "Positive leap second, no step correction. "

      "System clock will be inaccurate for a long time.";

  static const char leapmsg_n_step[] =

      "Negative leap second, stepped forward.";

  static const char leapmsg_n_slew[] =

      "Negative leap second, no step correction. "

      "System clock will be inaccurate for a long time.";

  leap_result_t lsdata;

  u_int32       lsprox;

#ifdef AUTOKEY

  int/*BOOL*/   update_autokey = FALSE;

#endif

#ifndef SYS_WINNT  /* WinNT port has its own leap second handling */

# ifdef KERNEL_PLL

  leapsec_electric(pll_control && kern_enable);

# else

  leapsec_electric(0);

# endif

#endif

#ifdef LEAP_SMEAR

  leap_smear.enabled = leap_smear_intv != 0;

#endif

  if (reset) {

    lsprox = LSPROX_NOWARN;

    leapsec_reset_frame();

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

  } else {

    int fired;

    fired = leapsec_query(&lsdata, now, tpiv);

    DPRINTF(3, ("*** leapsec_query: fired %i, now %u (0x%08X), tai_diff %i, ddist %u\n",

      fired, now, now, lsdata.tai_diff, lsdata.ddist));

#ifdef LEAP_SMEAR

    leap_smear.in_progress = 0;

    leap_smear.doffset = 0.0;

    if (leap_smear.enabled) {

    if (lsdata.tai_diff) {

      if (leap_smear.interval == 0) {

        leap_smear.interval = leap_smear_intv;

        leap_smear.intv_end = lsdata.ttime.Q_s;

        leap_smear.intv_start = leap_smear.intv_end - leap_smear.interval;

        DPRINTF(1, ("*** leapsec_query: setting leap_smear interval %li, begin %.0f, end %.0f\n",

          leap_smear.interval, leap_smear.intv_start, leap_smear.intv_end));

      }

    } else {

      if (leap_smear.interval)

        DPRINTF(1, ("*** leapsec_query: clearing leap_smear interval\n"));

      leap_smear.interval = 0;

    }

    if (leap_smear.interval) {

      double dtemp = now;

      if (dtemp >= leap_smear.intv_start && dtemp <= leap_smear.intv_end) {

        double leap_smear_time = dtemp - leap_smear.intv_start;

        /*

         * For now we just do a linear interpolation over the smear interval

         */

#if 0

        // linear interpolation

        leap_smear.doffset = -(leap_smear_time * lsdata.tai_diff / leap_smear.interval);

#else

        // Google approach: lie(t) = (1.0 - cos(pi * t / w)) / 2.0

        leap_smear.doffset = -((double) lsdata.tai_diff - cos( M_PI * leap_smear_time / leap_smear.interval)) / 2.0;

#endif

        /*

         * TODO see if we're inside an inserted leap second, so we need to compute

         * leap_smear.doffset = 1.0 - leap_smear.doffset

         */

        leap_smear.in_progress = 1;

#if 0 && defined( DEBUG )

        msyslog(LOG_NOTICE, "*** leapsec_query: [%.0f:%.0f] (%li), now %u (%.0f), smear offset %.6f ms\n",

          leap_smear.intv_start, leap_smear.intv_end, leap_smear.interval,

          now, leap_smear_time, leap_smear.doffset);

#else

        DPRINTF(1, ("*** leapsec_query: [%.0f:%.0f] (%li), now %u (%.0f), smear offset %.6f ms\n",

          leap_smear.intv_start, leap_smear.intv_end, leap_smear.interval,

          now, leap_smear_time, leap_smear.doffset));

#endif

      }

    }

    }

    else

    leap_smear.interval = 0;

    /*

     * Update the current leap smear offset, eventually 0.0 if outside smear interval.

     */

    DTOLFP(leap_smear.doffset, &leap_smear.offset);

#endif  /* LEAP_SMEAR */

    if (fired) {

    /* Full hit. Eventually step the clock, but always

     * announce the leap event has happened.

     */

    const char *leapmsg = NULL;

    double      lswarp  = lsdata.warped;

    if (lswarp < 0.0) {

      if (clock_max_back > 0.0 &&

          clock_max_back < -lswarp) {

        step_systime(lswarp);

        leapmsg = leapmsg_p_step;

      } else {

        leapmsg = leapmsg_p_slew;

      }

    } else  if (lswarp > 0.0) {

      if (clock_max_fwd > 0.0 &&

          clock_max_fwd < lswarp) {

        step_systime(lswarp);

        leapmsg = leapmsg_n_step;

      } else {

        leapmsg = leapmsg_n_slew;

      }

    }

    if (leapmsg)

      msyslog(LOG_NOTICE, "%s", leapmsg);

    report_event(EVNT_LEAP, NULL, NULL);

#ifdef AUTOKEY

    update_autokey = TRUE;

#endif

    lsprox  = LSPROX_NOWARN;

    leapsec = LSPROX_NOWARN;

    sys_tai = lsdata.tai_offs;

    } else {

#ifdef AUTOKEY

      update_autokey = (sys_tai != (u_int)lsdata.tai_offs);

#endif

      lsprox  = lsdata.proximity;

      sys_tai = lsdata.tai_offs;

    }

  }

  /* We guard against panic alarming during the red alert phase.

   * Strange and evil things might happen if we go from stone cold

   * to piping hot in one step. If things are already that wobbly,

   * we let the normal clock correction take over, even if a jump

   * is involved.

         * Also make sure the alarming events are edge-triggered, that is,

         * ceated only when the threshold is crossed.

         */

  if (  (leapsec > 0 || lsprox < LSPROX_ALERT)

      && leapsec < lsprox                     ) {

    if (  leapsec < LSPROX_SCHEDULE

                   && lsprox >= LSPROX_SCHEDULE) {

      if (lsdata.dynamic)

        report_event(PEVNT_ARMED, sys_peer, NULL);

      else

        report_event(EVNT_ARMED, NULL, NULL);

    }

    leapsec = lsprox;

  }

  if (leapsec > lsprox) {

    if (  leapsec >= LSPROX_SCHEDULE

                   && lsprox   < LSPROX_SCHEDULE) {

      report_event(EVNT_DISARMED, NULL, NULL);

    }

    leapsec = lsprox;

  }

  if (leapsec >= LSPROX_SCHEDULE)

    leapdif = lsdata.tai_diff;

  else

    leapdif = 0;

  check_leap_sec_in_progress(&lsdata);

#ifdef AUTOKEY

  if (update_autokey)

    crypto_update_taichange();

#endif

}