/*

 * refclock_dumbclock - clock driver for a unknown time distribution system

 * that only provides hh:mm:ss (in local time, yet!).

 */

/*

 * Must interpolate back to local time.  Very annoying.

 */

#define GET_LOCALTIME

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#if defined(REFCLOCK) && defined(CLOCK_DUMBCLOCK)

#include "ntpd.h"

#include "ntp_io.h"

#include "ntp_refclock.h"

#include "ntp_calendar.h"

#include "ntp_stdlib.h"

#include <stdio.h>

#include <ctype.h>

#ifdef SYS_WINNT

extern int async_write(int, const void *, unsigned int);

#undef write

#define write(fd, data, octets) async_write(fd, data, octets)

#endif

/*

 * This driver supports a generic dumb clock that only outputs hh:mm:ss,

 * in local time, no less.

 *

 * Input format:

 *

 *  hh:mm:ss   <cr>

 *

 * hh:mm:ss -- what you'd expect, with a 24 hour clock.  (Heck, that's the only

 * way it could get stupider.)  We take time on the <cr>.

 *

 * The original source of this module was the WWVB module.

 */

/*

 * Interface definitions

 */

#define DEVICE    "/dev/dumbclock%d" /* device name and unit */

#define SPEED232  B9600  /* uart speed (9600 baud) */

#define PRECISION (-13)  /* precision assumed (about 100 us) */

#define REFID   "dumbclock"  /* reference ID */

#define DESCRIPTION "Dumb clock" /* WRU */

/*

 * Insanity check.  Since the time is local, we need to make sure that during midnight

 * transitions, we can convert back to Unix time.  If the conversion results in some number

 * worse than this number of seconds away, assume the next day and retry.

 */

#define INSANE_SECONDS 3600

/*

 * Dumb clock control structure

 */

struct dumbclock_unit {

  u_char    tcswitch; /* timecode switch */

  l_fp    laststamp;  /* last receive timestamp */

  u_char    lasthour; /* last hour (for monitor) */

  u_char    linect; /* count ignored lines (for monitor */

  struct tm ymd;    /* struct tm for y/m/d only */

};

/*

 * Function prototypes

 */

static  int dumbclock_start   (int, struct peer *);

static  void  dumbclock_shutdown  (int, struct peer *);

static  void  dumbclock_receive (struct recvbuf *);

#if 0

static  void  dumbclock_poll    (int, struct peer *);

#endif

/*

 * Transfer vector

 */

struct  refclock refclock_dumbclock = {

  dumbclock_start,         /* start up driver */

  dumbclock_shutdown,        /* shut down driver */

  noentry,           /* poll the driver -- a nice fabrication */

  noentry,           /* not used */

  noentry,           /* not used */

  noentry,           /* not used */

  NOFLAGS            /* not used */

};

/*

 * dumbclock_start - open the devices and initialize data for processing

 */

static int

dumbclock_start(

  int unit,

  struct peer *peer

  )

{

  register struct dumbclock_unit *up;

  struct refclockproc *pp;

  int fd;

  char device[20];

  struct tm *tm_time_p;

  time_t     now;

  /*

   * Open serial port. Don't bother with CLK line discipline, since

   * it's not available.

   */

  snprintf(device, sizeof(device), DEVICE, unit);

#ifdef DEBUG

  if (debug)

    printf ("starting Dumbclock with device %s\n",device);

#endif

  fd = refclock_open(device, SPEED232, 0);

  if (fd <= 0)

    return (0);

  /*

   * Allocate and initialize unit structure

   */

  up = emalloc_zero(sizeof(*up));

  pp = peer->procptr;

  pp->unitptr = up;

  pp->io.clock_recv = dumbclock_receive;

  pp->io.srcclock = peer;

  pp->io.datalen = 0;

  pp->io.fd = fd;

  if (!io_addclock(&pp->io)) {

    close(fd);

    pp->io.fd = -1;

    free(up);

    pp->unitptr = NULL;

    return (0);

  }

  time(&now);

#ifdef GET_LOCALTIME

  tm_time_p = localtime(&now);

#else

  tm_time_p = gmtime(&now);

#endif

  if (tm_time_p)

    up->ymd = *tm_time_p;

  else

    return 0;

  /*

   * Initialize miscellaneous variables

   */

  peer->precision = PRECISION;

  pp->clockdesc = DESCRIPTION;

  memcpy((char *)&pp->refid, REFID, 4);

  return (1);

}

/*

 * dumbclock_shutdown - shut down the clock

 */

static void

dumbclock_shutdown(

  int unit,

  struct peer *peer

  )

{

  register struct dumbclock_unit *up;

  struct refclockproc *pp;

  pp = peer->procptr;

  up = pp->unitptr;

  if (-1 != pp->io.fd)

    io_closeclock(&pp->io);

  if (NULL != up)

    free(up);

}

/*

 * dumbclock_receive - receive data from the serial interface

 */

static void

dumbclock_receive(

  struct recvbuf *rbufp

  )

{

  struct dumbclock_unit *up;

  struct refclockproc *pp;

  struct peer *peer;

  l_fp  trtmp;    /* arrival timestamp */

  int hours;    /* hour-of-day */

  int minutes;  /* minutes-past-the-hour */

  int seconds;  /* seconds */

  int temp;   /* int temp */

  int got_good; /* got a good time flag */

  /*

   * Initialize pointers and read the timecode and timestamp

   */

  peer = rbufp->recv_peer;

  pp = peer->procptr;

  up = pp->unitptr;

  temp = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);

  if (temp == 0) {

    if (up->tcswitch == 0) {

      up->tcswitch = 1;

      up->laststamp = trtmp;

    } else

      up->tcswitch = 0;

    return;

  }

  pp->lencode = (u_short)temp;

  pp->lastrec = up->laststamp;

  up->laststamp = trtmp;

  up->tcswitch = 1;

#ifdef DEBUG

  if (debug)

    printf("dumbclock: timecode %d %s\n",

           pp->lencode, pp->a_lastcode);

#endif

  /*

   * We get down to business. Check the timecode format...

   */

  got_good=0;

  if (sscanf(pp->a_lastcode,"%02d:%02d:%02d",

       &hours,&minutes,&seconds) == 3)

  {

      struct tm *gmtp;

      struct tm *lt_p;

      time_t     asserted_time;      /* the SPM time based on the composite time+date */

      struct tm  asserted_tm;      /* the struct tm of the same */

      int        adjyear;

      int        adjmon;

      time_t     reality_delta;

      time_t     now;

      /*

       * Convert to GMT for sites that distribute localtime.  This

       * means we have to figure out what day it is.  Easier said

       * than done...

       */

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

      asserted_tm.tm_year  = up->ymd.tm_year;

      asserted_tm.tm_mon   = up->ymd.tm_mon;

      asserted_tm.tm_mday  = up->ymd.tm_mday;

      asserted_tm.tm_hour  = hours;

      asserted_tm.tm_min   = minutes;

      asserted_tm.tm_sec   = seconds;

      asserted_tm.tm_isdst = -1;

#ifdef GET_LOCALTIME

      asserted_time = mktime (&asserted_tm);

      time(&now);

#else

#include "GMT unsupported for dumbclock!"

#endif

      reality_delta = asserted_time - now;

      /*

       * We assume that if the time is grossly wrong, it's because we got the

       * year/month/day wrong.

       */

      if (reality_delta > INSANE_SECONDS)

      {

    asserted_time -= SECSPERDAY; /* local clock behind real time */

      }

      else if (-reality_delta > INSANE_SECONDS)

      {

    asserted_time += SECSPERDAY; /* local clock ahead of real time */

      }

      lt_p = localtime(&asserted_time);

      if (lt_p)

      {

    up->ymd = *lt_p;

      }

      else

      {

    refclock_report (peer, CEVNT_FAULT);

    return;

      }

      if ((gmtp = gmtime (&asserted_time)) == NULL)

      {

    refclock_report (peer, CEVNT_FAULT);

    return;

      }

      adjyear = gmtp->tm_year+1900;

      adjmon  = gmtp->tm_mon+1;

      pp->day = ymd2yd (adjyear, adjmon, gmtp->tm_mday);

      pp->hour   = gmtp->tm_hour;

      pp->minute = gmtp->tm_min;

      pp->second = gmtp->tm_sec;

#ifdef DEBUG

      if (debug)

    printf ("time is %04d/%02d/%02d %02d:%02d:%02d UTC\n",

      adjyear,adjmon,gmtp->tm_mday,pp->hour,pp->minute,

      pp->second);

#endif

      got_good=1;

  }

  if (!got_good)

  {

      if (up->linect > 0)

        up->linect--;

      else

        refclock_report(peer, CEVNT_BADREPLY);

      return;

  }

  /*

   * Process the new sample in the median filter and determine the

   * timecode timestamp.

   */

  if (!refclock_process(pp)) {

    refclock_report(peer, CEVNT_BADTIME);

    return;

  }

  pp->lastref = pp->lastrec;

  refclock_receive(peer);

  record_clock_stats(&peer->srcadr, pp->a_lastcode);

  up->lasthour = (u_char)pp->hour;

}

#if 0

/*

 * dumbclock_poll - called by the transmit procedure

 */

static void

dumbclock_poll(

  int unit,

  struct peer *peer

  )

{

  register struct dumbclock_unit *up;

  struct refclockproc *pp;

  char pollchar;

  /*

   * Time to poll the clock. The Chrono-log clock is supposed to

   * respond to a 'T' by returning a timecode in the format(s)

   * specified above.  Ours does (can?) not, but this seems to be

   * an installation-specific problem.  This code is dyked out,

   * but may be re-enabled if anyone ever finds a Chrono-log that

   * actually listens to this command.

   */

#if 0

  pp = peer->procptr;

  up = pp->unitptr;

  if (peer->reach == 0)

    refclock_report(peer, CEVNT_TIMEOUT);

  if (up->linect > 0)

    pollchar = 'R';

  else

    pollchar = 'T';

  if (write(pp->io.fd, &pollchar, 1) != 1)

    refclock_report(peer, CEVNT_FAULT);

  else

    pp->polls++;

#endif

}

#endif

#else

int refclock_dumbclock_bs;

#endif  /* defined(REFCLOCK) && defined(CLOCK_DUMBCLOCK) */