/*

 * refclock_arc - clock driver for ARCRON MSF/DCF/WWVB receivers

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "ntp_types.h"

#if defined(REFCLOCK) && defined(CLOCK_ARCRON_MSF)

static const char arc_version[] = { "V1.3 2003/02/21" };

/* define PRE_NTP420 for compatibility to previous versions of NTP (at least

   to 4.1.0 */

#undef PRE_NTP420

#ifndef ARCRON_NOT_KEEN

#define ARCRON_KEEN 1 /* Be keen, and trusting of the clock, if defined. */

#endif

#ifndef ARCRON_NOT_MULTIPLE_SAMPLES

#define ARCRON_MULTIPLE_SAMPLES 1 /* Use all timestamp bytes as samples. */

#endif

#ifndef ARCRON_NOT_LEAPSECOND_KEEN

#ifndef ARCRON_LEAPSECOND_KEEN

#undef ARCRON_LEAPSECOND_KEEN /* Respond quickly to leap seconds: doesn't work yet. */

#endif

#endif

/*

Code by Derek Mulcahy, <derek@toybox.demon.co.uk>, 1997.

Modifications by Damon Hart-Davis, <d@hd.org>, 1997.

Modifications by Paul Alfille, <palfille@partners.org>, 2003.

Modifications by Christopher Price, <cprice@cs-home.com>, 2003.

Modifications by Nigel Roles <nigel@9fs.org>, 2003.

THIS CODE IS SUPPLIED AS IS, WITH NO WARRANTY OF ANY KIND.  USE AT

YOUR OWN RISK.

Orginally developed and used with ntp3-5.85 by Derek Mulcahy.

Built against ntp3-5.90 on Solaris 2.5 using gcc 2.7.2.

This code may be freely copied and used and incorporated in other

systems providing the disclaimer and notice of authorship are

reproduced.

-------------------------------------------------------------------------------

Nigel's notes:

1) Called tcgetattr() before modifying, so that fields correctly initialised

   for all operating systems

2) Altered parsing of timestamp line so that it copes with fields which are

   not always ASCII digits (e.g. status field when battery low)

-------------------------------------------------------------------------------

Christopher's notes:

MAJOR CHANGES SINCE V1.2 

========================

 1) Applied patch by Andrey Bray <abuse@madhouse.demon.co.uk>

    2001-02-17 comp.protocols.time.ntp

 2) Added WWVB support via clock mode command, localtime/UTC time configured

    via flag1=(0=UTC, 1=localtime)

 3) Added ignore resync request via flag2=(0=resync, 1=ignore resync)

 4) Added simplified conversion from localtime to UTC with dst/bst translation

 5) Added average signal quality poll

 6) Fixed a badformat error when no code is available due to stripping 

    \n & \r's 

 7) Fixed a badformat error when clearing lencode & memset a_lastcode in poll

    routine

 8) Lots of code cleanup, including standardized DEBUG macros and removal 

    of unused code 

-------------------------------------------------------------------------------

Author's original note:

I enclose my ntp driver for the Galleon Systems Arc MSF receiver.

It works (after a fashion) on both Solaris-1 and Solaris-2.

I am currently using ntp3-5.85.  I have been running the code for

about 7 months without any problems.  Even coped with the change to BST!

I had to do some funky things to read from the clock because it uses the

power from the receive lines to drive the transmit lines.  This makes the

code look a bit stupid but it works.  I also had to put in some delays to

allow for the turnaround time from receive to transmit.  These delays

are between characters when requesting a time stamp so that shouldn't affect

the results too drastically.

...

The bottom line is that it works but could easily be improved.  You are

free to do what you will with the code.  I haven't been able to determine

how good the clock is.  I think that this requires a known good clock

to compare it against.

-------------------------------------------------------------------------------

Damon's notes for adjustments:

MAJOR CHANGES SINCE V1.0

========================

 1) Removal of pollcnt variable that made the clock go permanently

    off-line once two time polls failed to gain responses.

 2) Avoiding (at least on Solaris-2) terminal becoming the controlling

    terminal of the process when we do a low-level open().

 3) Additional logic (conditional on ARCRON_LEAPSECOND_KEEN being

    defined) to try to resync quickly after a potential leap-second

    insertion or deletion.

 4) Code significantly slimmer at run-time than V1.0.

GENERAL

=======

 1) The C preprocessor symbol to have the clock built has been changed

    from ARC to ARCRON_MSF to CLOCK_ARCRON_MSF to minimise the

    possiblity of clashes with other symbols in the future.

 2) PRECISION should be -4/-5 (63ms/31ms) for the following reasons:

     a) The ARC documentation claims the internal clock is (only)

  accurate to about 20ms relative to Rugby (plus there must be

  noticable drift and delay in the ms range due to transmission

  delays and changing atmospheric effects).  This clock is not

  designed for ms accuracy as NTP has spoilt us all to expect.

     b) The clock oscillator looks like a simple uncompensated quartz

  crystal of the sort used in digital watches (ie 32768Hz) which

  can have large temperature coefficients and drifts; it is not

  clear if this oscillator is properly disciplined to the MSF

  transmission, but as the default is to resync only once per

  *day*, we can imagine that it is not, and is free-running.  We

  can minimise drift by resyncing more often (at the cost of

  reduced battery life), but drift/wander may still be

  significant.

     c) Note that the bit time of 3.3ms adds to the potential error in

  the the clock timestamp, since the bit clock of the serial link

  may effectively be free-running with respect to the host clock

  and the MSF clock.  Actually, the error is probably 1/16th of

  the above, since the input data is probably sampled at at least

  16x the bit rate.

    By keeping the clock marked as not very precise, it will have a

    fairly large dispersion, and thus will tend to be used as a

    `backup' time source and sanity checker, which this clock is

    probably ideal for.  For an isolated network without other time

    sources, this clock can probably be expected to provide *much*

    better than 1s accuracy, which will be fine.

    By default, PRECISION is set to -4, but experience, especially at a

    particular geographic location with a particular clock, may allow

    this to be altered to -5.  (Note that skews of +/- 10ms are to be

    expected from the clock from time-to-time.)  This improvement of

    reported precision can be instigated by setting flag3 to 1, though

    the PRECISION will revert to the normal value while the clock

    signal quality is unknown whatever the flag3 setting.

    IN ANY CASE, BE SURE TO SET AN APPROPRIATE FUDGE FACTOR TO REMOVE

    ANY RESIDUAL SKEW, eg:

  server 127.127.27.0 # ARCRON MSF radio clock unit 0.

  # Fudge timestamps by about 20ms.

  fudge 127.127.27.0 time1 0.020

    You will need to observe your system's behaviour, assuming you have

    some other NTP source to compare it with, to work out what the

    fudge factor should be.  For my Sun SS1 running SunOS 4.1.3_U1 with

    my MSF clock with my distance from the MSF transmitter, +20ms

    seemed about right, after some observation.

 3) REFID has been made "MSFa" to reflect the MSF time source and the

    ARCRON receiver.

 4) DEFAULT_RESYNC_TIME is the time in seconds (by default) before

    forcing a resync since the last attempt.  This is picked to give a

    little less than an hour between resyncs and to try to avoid

    clashing with any regular event at a regular time-past-the-hour

    which might cause systematic errors.

    The INITIAL_RESYNC_DELAY is to avoid bothering the clock and

    running down its batteries unnecesarily if ntpd is going to crash

    or be killed or reconfigured quickly.  If ARCRON_KEEN is defined

    then this period is long enough for (with normal polling rates)

    enough time samples to have been taken to allow ntpd to sync to

    the clock before the interruption for the clock to resync to MSF.

    This avoids ntpd syncing to another peer first and then

    almost immediately hopping to the MSF clock.

    The RETRY_RESYNC_TIME is used before rescheduling a resync after a

    resync failed to reveal a statisfatory signal quality (too low or

    unknown).

 5) The clock seems quite jittery, so I have increased the

    median-filter size from the typical (previous) value of 3.  I

    discard up to half the results in the filter.  It looks like maybe

    1 sample in 10 or so (maybe less) is a spike, so allow the median

    filter to discard at least 10% of its entries or 1 entry, whichever

    is greater.

 6) Sleeping *before* each character sent to the unit to allow required

    inter-character time but without introducting jitter and delay in

    handling the response if possible.

 7) If the flag ARCRON_KEEN is defined, take time samples whenever

    possible, even while resyncing, etc.  We rely, in this case, on the

    clock always giving us a reasonable time or else telling us in the

    status byte at the end of the timestamp that it failed to sync to

    MSF---thus we should never end up syncing to completely the wrong

    time.

 8) If the flag ARCRON_OWN_FILTER is defined, use own versions of

    refclock median-filter routines to get round small bug in 3-5.90

    code which does not return the median offset. XXX Removed this

    bit due NTP Version 4 upgrade - dlm.

 9) We would appear to have a year-2000 problem with this clock since

    it returns only the two least-significant digits of the year.  But

    ntpd ignores the year and uses the local-system year instead, so

    this is in fact not a problem.  Nevertheless, we attempt to do a

    sensible thing with the dates, wrapping them into a 100-year

    window.

 10)Logs stats information that can be used by Derek's Tcl/Tk utility

    to show the status of the clock.

 11)The clock documentation insists that the number of bits per

    character to be sent to the clock, and sent by it, is 11, including

    one start bit and two stop bits.  The data format is either 7+even

    or 8+none.

TO-DO LIST

==========

  * Eliminate use of scanf(), and maybe sprintf().

  * Allow user setting of resync interval to trade battery life for

    accuracy; maybe could be done via fudge factor or unit number.

  * Possibly note the time since the last resync of the MSF clock to

    MSF as the age of the last reference timestamp, ie trust the

    clock's oscillator not very much...

  * Add very slow auto-adjustment up to a value of +/- time2 to correct

    for long-term errors in the clock value (time2 defaults to 0 so the

    correction would be disabled by default).

  * Consider trying to use the tty_clk/ppsclock support.

  * Possibly use average or maximum signal quality reported during

    resync, rather than just the last one, which may be atypical.

*/

/* Notes for HKW Elektronik GmBH Radio clock driver */

/* Author Lyndon David, Sentinet Ltd, Feb 1997      */

/* These notes seem also to apply usefully to the ARCRON clock. */

/* The HKW clock module is a radio receiver tuned into the Rugby */

/* MSF time signal tranmitted on 60 kHz. The clock module connects */

/* to the computer via a serial line and transmits the time encoded */

/* in 15 bytes at 300 baud 7 bits two stop bits even parity */

/* Clock communications, from the datasheet */

/* All characters sent to the clock are echoed back to the controlling */

/* device. */

/* Transmit time/date information */

/* syntax ASCII o<cr> */

/* Character o may be replaced if neccesary by a character whose code */

/* contains the lowest four bits f(hex) eg */

/* syntax binary: xxxx1111 00001101 */

/* DHD note:

You have to wait for character echo + 10ms before sending next character.

*/

/* The clock replies to this command with a sequence of 15 characters */

/* which contain the complete time and a final <cr> making 16 characters */

/* in total. */

/* The RC computer clock will not reply immediately to this command because */

/* the start bit edge of the first reply character marks the beginning of */

/* the second. So the RC Computer Clock will reply to this command at the */

/* start of the next second */

/* The characters have the following meaning */

/* 1. hours tens   */

/* 2. hours units  */

/* 3. minutes tens */

/* 4. minutes units */

/* 5. seconds tens  */

/* 6. seconds units */

/* 7. day of week 1-monday 7-sunday */

/* 8. day of month tens */

/* 9. day of month units */

/* 10. month tens */

/* 11. month units */

/* 12. year tens */

/* 13. year units */

/* 14. BST/UTC status */

/*  bit 7 parity */

/*  bit 6 always 0 */

/*  bit 5 always 1 */

/*  bit 4 always 1 */

/*  bit 3 always 0 */

/*  bit 2 =1 if UTC is in effect, complementary to the BST bit */

/*  bit 1 =1 if BST is in effect, according to the BST bit     */

/*  bit 0 BST/UTC change impending bit=1 in case of change impending */

/* 15. status */

/*  bit 7 parity */

/*  bit 6 always 0 */

/*  bit 5 always 1 */

/*  bit 4 always 1 */

/*  bit 3 =1 if low battery is detected */

/*  bit 2 =1 if the very last reception attempt failed and a valid */

/*    time information already exists (bit0=1) */

/*    =0 if the last reception attempt was successful */

/*  bit 1 =1 if at least one reception since 2:30 am was successful */

/*    =0 if no reception attempt since 2:30 am was successful */

/*  bit 0 =1 if the RC Computer Clock contains valid time information */

/*    This bit is zero after reset and one after the first */

/*    successful reception attempt */

/* DHD note:

Also note g<cr> command which confirms that a resync is in progress, and

if so what signal quality (0--5) is available.

Also note h<cr> command which starts a resync to MSF signal.

*/

#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>

#if defined(HAVE_BSD_TTYS)

#include <sgtty.h>

#endif /* HAVE_BSD_TTYS */

#if defined(HAVE_SYSV_TTYS)

#include <termio.h>

#endif /* HAVE_SYSV_TTYS */

#if defined(HAVE_TERMIOS)

#include <termios.h>

#endif

/*

 * This driver supports the ARCRON MSF/DCF/WWVB Radio Controlled Clock

 */

/*

 * Interface definitions

 */

#define DEVICE    "/dev/arc%d"  /* Device name and unit. */

#define SPEED   B300    /* UART speed (300 baud) */

#define PRECISION (-4)    /* Precision  (~63 ms). */

#define HIGHPRECISION (-5)    /* If things are going well... */

#define REFID   "MSFa"    /* Reference ID. */

#define REFID_MSF "MSF"    /* Reference ID. */

#define REFID_DCF77 "DCF"    /* Reference ID. */

#define REFID_WWVB  "WWVB"    /* Reference ID. */

#define DESCRIPTION "ARCRON MSF/DCF/WWVB Receiver"

#ifdef PRE_NTP420

#define MODE ttlmax

#else

#define MODE ttl

#endif

#define LENARC    16    /* Format `o' timecode length. */

#define BITSPERCHAR 11    /* Bits per character. */

#define BITTIME   0x0DA740E /* Time for 1 bit at 300bps. */

#define CHARTIME10  0x8888888 /* Time for 10-bit char at 300bps. */

#define CHARTIME11  0x962FC96 /* Time for 11-bit char at 300bps. */

#define CHARTIME      /* Time for char at 300bps. */ \

( (BITSPERCHAR == 11) ? CHARTIME11 : ( (BITSPERCHAR == 10) ? CHARTIME10 : \

               (BITSPERCHAR * BITTIME) ) )

     /* Allow for UART to accept char half-way through final stop bit. */

#define INITIALOFFSET ((u_int32)(-BITTIME/2))

     /*

    charoffsets[x] is the time after the start of the second that byte

    x (with the first byte being byte 1) is received by the UART,

    assuming that the initial edge of the start bit of the first byte

    is on-time.  The values are represented as the fractional part of

    an l_fp.

    We store enough values to have the offset of each byte including

    the trailing \r, on the assumption that the bytes follow one

    another without gaps.

    */

     static const u_int32 charoffsets[LENARC+1] = {

#if BITSPERCHAR == 11 /* Usual case. */

       /* Offsets computed as accurately as possible... */

       0,

       INITIALOFFSET + 0x0962fc96, /*  1 chars,  11 bits */

       INITIALOFFSET + 0x12c5f92c, /*  2 chars,  22 bits */

       INITIALOFFSET + 0x1c28f5c3, /*  3 chars,  33 bits */

       INITIALOFFSET + 0x258bf259, /*  4 chars,  44 bits */

       INITIALOFFSET + 0x2eeeeeef, /*  5 chars,  55 bits */

       INITIALOFFSET + 0x3851eb85, /*  6 chars,  66 bits */

       INITIALOFFSET + 0x41b4e81b, /*  7 chars,  77 bits */

       INITIALOFFSET + 0x4b17e4b1, /*  8 chars,  88 bits */

       INITIALOFFSET + 0x547ae148, /*  9 chars,  99 bits */

       INITIALOFFSET + 0x5dddddde, /* 10 chars, 110 bits */

       INITIALOFFSET + 0x6740da74, /* 11 chars, 121 bits */

       INITIALOFFSET + 0x70a3d70a, /* 12 chars, 132 bits */

       INITIALOFFSET + 0x7a06d3a0, /* 13 chars, 143 bits */

       INITIALOFFSET + 0x8369d037, /* 14 chars, 154 bits */

       INITIALOFFSET + 0x8ccccccd, /* 15 chars, 165 bits */

       INITIALOFFSET + 0x962fc963  /* 16 chars, 176 bits */

#else

       /* Offsets computed with a small rounding error... */

       0,

       INITIALOFFSET +  1 * CHARTIME,

       INITIALOFFSET +  2 * CHARTIME,

       INITIALOFFSET +  3 * CHARTIME,

       INITIALOFFSET +  4 * CHARTIME,

       INITIALOFFSET +  5 * CHARTIME,

       INITIALOFFSET +  6 * CHARTIME,

       INITIALOFFSET +  7 * CHARTIME,

       INITIALOFFSET +  8 * CHARTIME,

       INITIALOFFSET +  9 * CHARTIME,

       INITIALOFFSET + 10 * CHARTIME,

       INITIALOFFSET + 11 * CHARTIME,

       INITIALOFFSET + 12 * CHARTIME,

       INITIALOFFSET + 13 * CHARTIME,

       INITIALOFFSET + 14 * CHARTIME,

       INITIALOFFSET + 15 * CHARTIME,

       INITIALOFFSET + 16 * CHARTIME

#endif

     };

#define DEFAULT_RESYNC_TIME  (57*60)  /* Gap between resync attempts (s). */

#define RETRY_RESYNC_TIME    (27*60)  /* Gap to emergency resync attempt. */

#ifdef ARCRON_KEEN

#define INITIAL_RESYNC_DELAY 500  /* Delay before first resync. */

#else

#define INITIAL_RESYNC_DELAY 50   /* Delay before first resync. */

#endif

     static const int moff[12] =

{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };

/* Flags for a raw open() of the clock serial device. */

#ifdef O_NOCTTY /* Good, we can avoid tty becoming controlling tty. */

#define OPEN_FLAGS (O_RDWR | O_NOCTTY)

#else   /* Oh well, it may not matter... */

#define OPEN_FLAGS (O_RDWR)

#endif

/* Length of queue of command bytes to be sent. */

#define CMDQUEUELEN 4      /* Enough for two cmds + each \r. */

/* Queue tick time; interval in seconds between chars taken off queue. */

/* Must be >= 2 to allow o\r response to come back uninterrupted. */

#define QUEUETICK   2      /* Allow o\r reply to finish. */

/*

 * ARC unit control structure

 */

struct arcunit {

  l_fp lastrec;     /* Time tag for the receive time (system). */

  int status;     /* Clock status. */

  int quality;      /* Quality of reception 0--5 for unit. */

  /* We may also use the values -1 or 6 internally. */

  u_long quality_stamp; /* Next time to reset quality average. */

  u_long next_resync; /* Next resync time (s) compared to current_time. */

  int resyncing;      /* Resync in progress if true. */

  /* In the outgoing queue, cmdqueue[0] is next to be sent. */

  char cmdqueue[CMDQUEUELEN+1]; /* Queue of outgoing commands + \0. */

  u_long saved_flags; /* Saved fudge flags. */

};

#ifdef ARCRON_LEAPSECOND_KEEN

/* The flag `possible_leap' is set non-zero when any MSF unit

       thinks a leap-second may have happened.

       Set whenever we receive a valid time sample in the first hour of

       the first day of the first/seventh months.

       Outside the special hour this value is unconditionally set

       to zero by the receive routine.

       On finding itself in this timeslot, as long as the value is

       non-negative, the receive routine sets it to a positive value to

       indicate a resync to MSF should be performed.

       In the poll routine, if this value is positive and we are not

       already resyncing (eg from a sync that started just before

       midnight), start resyncing and set this value negative to

       indicate that a leap-triggered resync has been started.  Having

       set this negative prevents the receive routine setting it

       positive and thus prevents multiple resyncs during the witching

       hour.

     */

static int possible_leap = 0;       /* No resync required by default. */

#endif

#if 0

static void dummy_event_handler (struct peer *);

static void   arc_event_handler (struct peer *);

#endif /* 0 */

#define QUALITY_UNKNOWN     -1 /* Indicates unknown clock quality. */

#define MIN_CLOCK_QUALITY    0 /* Min quality clock will return. */

#define MIN_CLOCK_QUALITY_OK 3 /* Min quality for OK reception. */

#define MAX_CLOCK_QUALITY    5 /* Max quality clock will return. */

/*

 * Function prototypes

 */

static  int arc_start (int, struct peer *);

static  void  arc_shutdown  (int, struct peer *);

static  void  arc_receive (struct recvbuf *);

static  void  arc_poll  (int, struct peer *);

/*

 * Transfer vector

 */

struct  refclock refclock_arc = {

  arc_start,    /* start up driver */

  arc_shutdown,   /* shut down driver */

  arc_poll,   /* transmit poll message */

  noentry,    /* not used (old arc_control) */

  noentry,    /* initialize driver (not used) */

  noentry,    /* not used (old arc_buginfo) */

  NOFLAGS     /* not used */

};

/* Queue us up for the next tick. */

#define ENQUEUE(up) \

  do { \

       peer->procptr->nextaction = current_time + QUEUETICK; \

  } while(0)

/* Placeholder event handler---does nothing safely---soaks up loose tick. */

static void

dummy_event_handler(

  struct peer *peer

  )

{

#ifdef DEBUG

  if(debug) { printf("arc: dummy_event_handler() called.\n"); }

#endif

}

/*

Normal event handler.

Take first character off queue and send to clock if not a null.

Shift characters down and put a null on the end.

We assume that there is no parallelism so no race condition, but even

if there is nothing bad will happen except that we might send some bad

data to the clock once in a while.

*/

static void

arc_event_handler(

  struct peer *peer

  )

{

  struct refclockproc *pp = peer->procptr;

  register struct arcunit *up = pp->unitptr;

  int i;

  char c;

#ifdef DEBUG

  if(debug > 2) { printf("arc: arc_event_handler() called.\n"); }

#endif

  c = up->cmdqueue[0];       /* Next char to be sent. */

  /* Shift down characters, shifting trailing \0 in at end. */

  for(i = 0; i < CMDQUEUELEN; ++i)

  { up->cmdqueue[i] = up->cmdqueue[i+1]; }

  /* Don't send '\0' characters. */

  if(c != '\0') {

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

      msyslog(LOG_NOTICE, "ARCRON: write to fd %d failed", pp->io.fd);

    }

#ifdef DEBUG

    else if(debug) { printf("arc: sent `%2.2x', fd %d.\n", c, pp->io.fd); }

#endif

  }

  ENQUEUE(up);

}

/*

 * arc_start - open the devices and initialize data for processing

 */

static int

arc_start(

  int unit,

  struct peer *peer

  )

{

  register struct arcunit *up;

  struct refclockproc *pp;

  int temp_fd;

  int fd;

  char device[20];

#ifdef HAVE_TERMIOS

  struct termios arg;

#endif

  msyslog(LOG_NOTICE, "MSF_ARCRON %s: opening unit %d",

    arc_version, unit);

  DPRINTF(1, ("arc: %s: attempt to open unit %d.\n", arc_version,

    unit));

  /*

   * Open serial port. Use CLK line discipline, if available.

   */

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

  temp_fd = refclock_open(&peer->srcadr, device, SPEED, LDISC_CLK);

  if (temp_fd <= 0)

    return 0;

  DPRINTF(1, ("arc: unit %d using tty_open().\n", unit));

  fd = tty_open(device, OPEN_FLAGS, 0777);

  if (fd < 0) {

    msyslog(LOG_ERR, "MSF_ARCRON(%d): failed second open(%s, 0777): %m.",

      unit, device);

    close(temp_fd);

    return 0;

  }

  close(temp_fd);

  temp_fd = -1;   /* not used after this, at *this* time. */

#ifndef SYS_WINNT

  if (-1 == fcntl(fd, F_SETFL, 0)) /* clear the descriptor flags */

    msyslog(LOG_ERR, "MSF_ARCRON(%d): fcntl(F_SETFL, 0): %m.",

      unit);

#endif

  DPRINTF(1, ("arc: opened RS232 port with file descriptor %d.\n", fd));

#ifdef HAVE_TERMIOS

  if (tcgetattr(fd, &arg) < 0) {

    msyslog(LOG_ERR, "MSF_ARCRON(%d): tcgetattr(%s): %m.",

      unit, device);

    close(fd);

    return 0;

  }

  arg.c_iflag = IGNBRK | ISTRIP;

  arg.c_oflag = 0;

  arg.c_cflag = B300 | CS8 | CREAD | CLOCAL | CSTOPB;

  arg.c_lflag = 0;

  arg.c_cc[VMIN] = 1;

  arg.c_cc[VTIME] = 0;

  if (tcsetattr(fd, TCSANOW, &arg) < 0) {

    msyslog(LOG_ERR, "MSF_ARCRON(%d): tcsetattr(%s): %m.",

      unit, device);

    close(fd);

    return 0;

  }

#else

  msyslog(LOG_ERR, "ARCRON: termios required by this driver");

  (void)close(fd);

  return 0;

#endif

  /* Set structure to all zeros... */

  up = emalloc_zero(sizeof(*up));

  pp = peer->procptr;

  pp->io.clock_recv = arc_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); 

    return(0); 

  }

  pp->unitptr = up;

  /*

   * Initialize miscellaneous variables

   */

  peer->precision = PRECISION;

  peer->stratum = 2;              /* Default to stratum 2 not 0. */

  pp->clockdesc = DESCRIPTION;

  if (peer->MODE > 3) {

    msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d", peer->MODE);

    return 0;

  }

#ifdef DEBUG

  if(debug) { printf("arc: mode = %d.\n", peer->MODE); }

#endif

  switch (peer->MODE) {

      case 1:

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

    break;

      case 2:

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

    break;

      case 3:

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

    break;

      default:

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

    break;

  }

  /* Spread out resyncs so that they should remain separated. */

  up->next_resync = current_time + INITIAL_RESYNC_DELAY + (67*unit)%1009;

#if 0 /* Not needed because of zeroing of arcunit structure... */

  up->resyncing = 0;              /* Not resyncing yet. */

  up->saved_flags = 0;            /* Default is all flags off. */

  /* Clear send buffer out... */

  {

    int i;

    for(i = CMDQUEUELEN; i >= 0; --i) { up->cmdqueue[i] = '\0'; }

  }

#endif

#ifdef ARCRON_KEEN

  up->quality = QUALITY_UNKNOWN;  /* Trust the clock immediately. */

#else

  up->quality = MIN_CLOCK_QUALITY;/* Don't trust the clock yet. */

#endif

  peer->procptr->action = arc_event_handler;

  ENQUEUE(up);

  return(1);

}

/*

 * arc_shutdown - shut down the clock

 */

static void

arc_shutdown(

  int unit,

  struct peer *peer

  )

{

  register struct arcunit *up;

  struct refclockproc *pp;

  peer->procptr->action = dummy_event_handler;

  pp = peer->procptr;

  up = pp->unitptr;

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

    io_closeclock(&pp->io);

  if (NULL != up)

    free(up);

}

/*

Compute space left in output buffer.

*/

static int

space_left(

  register struct arcunit *up

  )

{

  int spaceleft;

  /* Compute space left in buffer after any pending output. */

  for(spaceleft = 0; spaceleft < CMDQUEUELEN; ++spaceleft)

  { if(up->cmdqueue[CMDQUEUELEN - 1 - spaceleft] != '\0') { break; } }

  return(spaceleft);

}

/*

Send command by copying into command buffer as far forward as possible,

after any pending output.

Indicate an error by returning 0 if there is not space for the command.

*/

static int

send_slow(

  register struct arcunit *up,

  int fd,

  const char *s

  )

{

  int sl = strlen(s);

  int spaceleft = space_left(up);

#ifdef DEBUG

  if(debug > 1) { printf("arc: spaceleft = %d.\n", spaceleft); }

#endif

  if(spaceleft < sl) { /* Should not normally happen... */

#ifdef DEBUG

    msyslog(LOG_NOTICE, "ARCRON: send-buffer overrun (%d/%d)",

      sl, spaceleft);

#endif

    return(0);      /* FAILED! */

  }

  /* Copy in the command to be sent. */

  while(*s && spaceleft > 0) { up->cmdqueue[CMDQUEUELEN - spaceleft--] = *s++; }

  return(1);

}

static int

get2(char *p, int *val)

{

  if (!isdigit((unsigned char)p[0]) || !isdigit((unsigned char)p[1])) return 0;

  *val = (p[0] - '0') * 10 + p[1] - '0';

  return 1;

}

static int

get1(char *p, int *val)

{

  if (!isdigit((unsigned char)p[0])) return 0;

  *val = p[0] - '0';

  return 1;

}

/* Macro indicating action we will take for different quality values. */

#define quality_action(q) \

(((q) == QUALITY_UNKNOWN) ?         "UNKNOWN, will use clock anyway" : \

 (((q) < MIN_CLOCK_QUALITY_OK) ? "TOO POOR, will not use clock" : \

  "OK, will use clock"))

/*

 * arc_receive - receive data from the serial interface

 */

static void

arc_receive(

  struct recvbuf *rbufp

  )

{

  static int quality_average = 0;

  static int quality_sum = 0;

  static int quality_polls = 0;

  register struct arcunit *up;

  struct refclockproc *pp;

  struct peer *peer;

  char c;

  int i, wday, month, flags, status;

  int arc_last_offset;

    #ifdef DEBUG

  int n;

    #endif

  /*

   * Initialize pointers and read the timecode and timestamp

   */

  peer = rbufp->recv_peer;

  pp = peer->procptr;

  up = pp->unitptr;

  /*

    If the command buffer is empty, and we are resyncing, insert a

    g\r quality request into it to poll for signal quality again.

  */

  if((up->resyncing) && (space_left(up) == CMDQUEUELEN)) {

#ifdef DEBUG

    if(debug > 1) { printf("arc: inserting signal-quality poll.\n"); }

#endif

    send_slow(up, pp->io.fd, "g\r");

  }

  /*

    The `arc_last_offset' is the offset in lastcode[] of the last byte

    received, and which we assume actually received the input

    timestamp.

    (When we get round to using tty_clk and it is available, we

    assume that we will receive the whole timecode with the

    trailing \r, and that that \r will be timestamped.  But this

    assumption also works if receive the characters one-by-one.)

  */

  arc_last_offset = pp->lencode+rbufp->recv_length - 1;

  /*

    We catch a timestamp iff:

    * The command code is `o' for a timestamp.

    * If ARCRON_MULTIPLE_SAMPLES is undefined then we must have

    exactly char in the buffer (the command code) so that we

    only sample the first character of the timecode as our

    `on-time' character.

    * The first character in the buffer is not the echoed `\r'

    from the `o` command (so if we are to timestamp an `\r' it

    must not be first in the receive buffer with lencode==1.

    (Even if we had other characters following it, we probably

    would have a premature timestamp on the '\r'.)

    * We have received at least one character (I cannot imagine

    how it could be otherwise, but anyway...).

  */

  c = rbufp->recv_buffer[0];

  if((pp->a_lastcode[0] == 'o') &&

#ifndef ARCRON_MULTIPLE_SAMPLES

     (pp->lencode == 1) &&

#endif

     ((pp->lencode != 1) || (c != '\r')) &&

     (arc_last_offset >= 1)) {

    /* Note that the timestamp should be corrected if >1 char rcvd. */

    l_fp timestamp;

    timestamp = rbufp->recv_time;

#ifdef DEBUG

    if(debug) { /* Show \r as `R', other non-printing char as `?'. */

      printf("arc: stamp -->%c<-- (%d chars rcvd)\n",

             ((c == '\r') ? 'R' : (isgraph((unsigned char)c) ? c : '?')),

             rbufp->recv_length);

    }

#endif

    /*

      Now correct timestamp by offset of last byte received---we

      subtract from the receive time the delay implied by the

      extra characters received.

      Reject the input if the resulting code is too long, but

      allow for the trailing \r, normally not used but a good

      handle for tty_clk or somesuch kernel timestamper.

    */

    if(arc_last_offset > LENARC) {

#ifdef DEBUG

      if(debug) {

        printf("arc: input code too long (%d cf %d); rejected.\n",

               arc_last_offset, LENARC);

      }

#endif

      pp->lencode = 0;

      refclock_report(peer, CEVNT_BADREPLY);

      return;

    }

    L_SUBUF(&timestamp, charoffsets[arc_last_offset]);

#ifdef DEBUG

    if(debug > 1) {

      printf(

        "arc: %s%d char(s) rcvd, the last for lastcode[%d]; -%sms offset applied.\n",

        ((rbufp->recv_length > 1) ? "*** " : ""),

        rbufp->recv_length,

        arc_last_offset,

        mfptoms((unsigned long)0,

          charoffsets[arc_last_offset],

          1));

    }

#endif

#ifdef ARCRON_MULTIPLE_SAMPLES

    /*

      If taking multiple samples, capture the current adjusted

      sample iff:

      * No timestamp has yet been captured (it is zero), OR

      * This adjusted timestamp is earlier than the one already

      captured, on the grounds that this one suffered less

      delay in being delivered to us and is more accurate.

    */

    if(L_ISZERO(&(up->lastrec)) ||

       L_ISGEQ(&(up->lastrec), &timestamp))

#endif

    {

#ifdef DEBUG

      if(debug > 1) {

        printf("arc: system timestamp captured.\n");

#ifdef ARCRON_MULTIPLE_SAMPLES

        if(!L_ISZERO(&(up->lastrec))) {

          l_fp diff;

          diff = up->lastrec;

          L_SUB(&diff, &timestamp);

          printf("arc: adjusted timestamp by -%sms.\n",

                 mfptoms(diff.l_ui, diff.l_uf, 3));

        }

#endif

      }

#endif

      up->lastrec = timestamp;

    }