/*

 * refclock_acts - clock driver for the NIST/USNO/PTB/NPL Computer Time

 *  Services

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#if defined(REFCLOCK) && defined(CLOCK_ACTS)

#include "ntpd.h"

#include "ntp_io.h"

#include "ntp_unixtime.h"

#include "ntp_refclock.h"

#include "ntp_stdlib.h"

#include "ntp_control.h"

#include <stdio.h>

#include <ctype.h>

#ifdef HAVE_SYS_IOCTL_H

# include <sys/ioctl.h>

#endif /* HAVE_SYS_IOCTL_H */

#ifdef SYS_WINNT

#undef write  /* ports/winnt/include/config.h: #define write _write */

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

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

#endif

/*

 * This driver supports the US (NIST, USNO) and European (PTB, NPL,

 * etc.) modem time services, as well as Spectracom GPS and WWVB

 * receivers connected via a modem. The driver periodically dials a

 * number from a telephone list, receives the timecode data and

 * calculates the local clock correction. It is designed primarily for

 * use as backup when neither a radio clock nor connectivity to Internet

 * time servers is available.

 *

 * This driver requires a modem with a Hayes-compatible command set and

 * control over the modem data terminal ready (DTR) control line. The

 * modem setup string is hard-coded in the driver and may require

 * changes for nonstandard modems or special circumstances.

 *

 * When enabled, the calling program dials the first number in the

 * phones file. If that call fails, it dials the second number and

 * so on. The phone number is specified by the Hayes ATDT prefix

 * followed by the number itself, including the long-distance prefix

 * and delay code, if necessary. The calling program is enabled

 * when (a) fudge flag1 is set by ntpdc, (b) at each poll interval

 * when no other synchronization sources are present, and (c) at each

 * poll interval whether or not other synchronization sources are 

 * present. The calling program disconnects if (a) the called party

 * is busy or does not answer, (b) the called party disconnects

 * before a sufficient nuimber of timecodes have been received. 

 *

 * The driver is transparent to each of the modem time services and

 * Spectracom radios. It selects the parsing algorithm depending on the

 * message length. There is some hazard should the message be corrupted.

 * However, the data format is checked carefully and only if all checks

 * succeed is the message accepted. Corrupted lines are discarded

 * without complaint.

 *

 * Fudge controls

 *

 * flag1  force a call in manual mode

 * flag2  enable port locking (not verified)

 * flag3  not used

 * flag4  not used

 *

 * time1  offset adjustment (s)

 *

 * Ordinarily, the serial port is connected to a modem and the phones

 * list is defined. If no phones list is defined, the port can be 

 * connected directly to a device or another computer. In this case the

 * driver will send a single character 'T' at each poll event. If

 * fudge flag2 is enabled, port locking allows the modem to be shared

 * when not in use by this driver.

 */

/*

 * National Institute of Science and Technology (NIST)

 *

 * Phone: (303) 494-4774 (Boulder, CO); (808) 335-4721 (Hawaii)

 *

 * Data Format

 *

 * National Institute of Standards and Technology

 * Telephone Time Service, Generator 3B

 * Enter question mark "?" for HELP

 *                         D  L D

 *  MJD  YR MO DA H  M  S  ST S UT1 msADV        <OTM>

 * 47999 90-04-18 21:39:15 50 0 +.1 045.0 UTC(NIST) *<CR><LF>

 * ...

 *

 * MJD, DST, DUT1 and UTC are not used by this driver. The "*" or "#" is

 * the on-time markers echoed by the driver and used by NIST to measure

 * and correct for the propagation delay. Note: the ACTS timecode has

 * recently been changed to eliminate the * on-time indicator. The

 * reason for this and the long term implications are not clear.

 *

 * US Naval Observatory (USNO)

 *

 * Phone: (202) 762-1594 (Washington, DC); (719) 567-6742 (Boulder, CO)

 *

 * Data Format (two lines, repeating at one-second intervals)

 *

 * jjjjj nnn hhmmss UTC<CR><LF>

 * *<CR><LF>

 *

 * jjjjj  modified Julian day number (not used)

 * nnn    day of year

 * hhmmss second of day

 * *    on-time marker for previous timecode

 * ...

 *

 * USNO does not correct for the propagation delay. A fudge time1 of

 * about .06 s is advisable.

 *

 * European Services (PTB, NPL, etc.)

 *

 * PTB: +49 531 512038 (Germany)

 * NPL: 0906 851 6333 (UK only)

 *

 * Data format (see the documentation for phone numbers and formats.)

 *

 * 1995-01-23 20:58:51 MEZ  10402303260219950123195849740+40000500<CR><LF>

 *

 * Spectracom GPS and WWVB Receivers

 *

 * If a modem is connected to a Spectracom receiver, this driver will

 * call it up and retrieve the time in one of two formats. As this

 * driver does not send anything, the radio will have to either be

 * configured in continuous mode or be polled by another local driver.

 */

/*

 * Interface definitions

 */

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

#define SPEED232  B19200  /* uart speed (19200 bps) */

#define PRECISION (-10)  /* precision assumed (about 1 ms) */

#define LOCKFILE  "/var/spool/lock/LCK..cua%d"

#define DESCRIPTION "Automated Computer Time Service" /* WRU */

#define REFID   "NONE"  /* default reference ID */

#define MSGCNT    20  /* max message count */

#define MAXPHONE  10  /* max number of phone numbers */

/*

 * Calling program modes (mode)

 */

#define MODE_BACKUP 0  /* backup mode */

#define MODE_AUTO 1  /* automatic mode */

#define MODE_MANUAL 2  /* manual mode */

/*

 * Service identifiers (message length)

 */

#define REFACTS   "NIST"  /* NIST reference ID */

#define LENACTS   50  /* NIST format A */

#define REFUSNO   "USNO"  /* USNO reference ID */

#define LENUSNO   20  /* USNO */

#define REFPTB    "PTB\0"  /* PTB/NPL reference ID */

#define LENPTB    78  /* PTB/NPL format */

#define REFWWVB   "WWVB"  /* WWVB reference ID */

#define LENWWVB0  22  /* WWVB format 0 */

#define LENWWVB2  24  /* WWVB format 2 */

#define LF    0x0a  /* ASCII LF */

/*

 * Modem setup strings. These may have to be changed for

 * some modems.

 *

 * AT command prefix

 * B1 US answer tone

 * &C0  disable carrier detect

 * &D2  hang up and return to command mode on DTR transition

 * E0 modem command echo disabled

 * L1 set modem speaker volume to low level

 * M1 speaker enabled until carrier detect

 * Q0 return result codes

 * V1 return result codes as English words

 * Y1 enable long-space disconnect

 */

const char def_modem_setup[] = "ATB1&C0&D2E0L1M1Q0V1Y1";

const char *modem_setup = def_modem_setup; 

/*

 * Timeouts (all in seconds)

 */

#define SETUP   3  /* setup timeout */

#define REDIAL    30  /* redial timeout */

#define ANSWER    60  /* answer timeout */

#define TIMECODE  60  /* message timeout */

#define MAXCODE   20  /* max timecodes */

/*

 * State machine codes

 */

typedef enum {

  S_IDLE,     /* wait for poll */

  S_SETUP,    /* send modem setup */

  S_CONNECT,    /* wait for answer */

  S_MSG     /* wait for timecode */

} teModemState;

/*

 * Unit control structure

 */

struct actsunit {

  int unit;   /* unit number */

  int state;    /* the first one was Delaware */

  int timer;    /* timeout counter */

  int retry;    /* retry index */

  int msgcnt;   /* count of messages received */

  l_fp  tstamp;   /* on-time timestamp */

  char  *bufptr;  /* next incoming char stored here */

  char  buf[BMAX];  /* bufptr roams within buf[] */

};

/*

 * Function prototypes

 */

static  int acts_start  (int, struct peer *);

static  void  acts_shutdown (int, struct peer *);

static  void  acts_receive  (struct recvbuf *);

static  void  acts_message  (struct peer *, const char *);

static  void  acts_timecode (struct peer *, const char *);

static  void  acts_poll (int, struct peer *);

static  void  acts_timeout  (struct peer *, teModemState);

static  void  acts_timer  (int, struct peer *);

static  void  acts_close  (struct peer *);

/*

 * Transfer vector (conditional structure name)

 */

struct refclock refclock_acts = {

  acts_start,   /* start up driver */

  acts_shutdown,    /* shut down driver */

  acts_poll,    /* transmit poll message */

  noentry,    /* not used */

  noentry,    /* not used */

  noentry,    /* not used */

  acts_timer    /* housekeeping timer */

};

/*

 * Initialize data for processing

 */

static int

acts_start(

  int unit,

  struct peer *peer

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  const char *setup;

  /*

   * Allocate and initialize unit structure

   */

  up = emalloc_zero(sizeof(struct actsunit));

  up->unit = unit;

  pp = peer->procptr;

  pp->unitptr = up;

  pp->io.clock_recv = acts_receive;

  pp->io.srcclock = peer;

  pp->io.datalen = 0;

  pp->io.fd = -1;

  /*

   * Initialize miscellaneous variables

   */

  peer->precision = PRECISION;

  pp->clockdesc = DESCRIPTION;

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

  peer->sstclktype = CTL_SST_TS_TELEPHONE;

  up->bufptr = up->buf;

  if (def_modem_setup == modem_setup) {

    setup = get_ext_sys_var("modemsetup");

    if (setup != NULL)

      modem_setup = estrdup(setup);

  }

  return (1);

}

/*

 * acts_shutdown - shut down the clock

 */

static void

acts_shutdown(

  int unit,

  struct peer *peer

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  /*

   * Warning: do this only when a call is not in progress.

   */

  pp = peer->procptr;

  up = pp->unitptr;

  acts_close(peer);

  free(up);

}

/*

 * acts_receive - receive data from the serial interface

 */

static void

acts_receive(

  struct recvbuf *rbufp

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  struct peer *peer;

  char  tbuf[sizeof(up->buf)];

  char *  tptr;

  int octets;

  /*

   * Initialize pointers and read the timecode and timestamp. Note

   * we are in raw mode and victim of whatever the terminal

   * interface kicks up; so, we have to reassemble messages from

   * arbitrary fragments. Capture the timecode at the beginning of

   * the message and at the '*' and '#' on-time characters.

   */

  peer = rbufp->recv_peer;

  pp = peer->procptr;

  up = pp->unitptr;

  octets = sizeof(up->buf) - (up->bufptr - up->buf);

  refclock_gtraw(rbufp, tbuf, octets, &pp->lastrec);

  for (tptr = tbuf; *tptr != '\0'; tptr++) {

    if (*tptr == LF) {

      if (up->bufptr == up->buf) {

        up->tstamp = pp->lastrec;

        continue;

      } else {

        *up->bufptr = '\0';

        up->bufptr = up->buf;

        acts_message(peer, up->buf);

      }

    } else if (!iscntrl((unsigned char)*tptr)) {

      *up->bufptr++ = *tptr;

      if (*tptr == '*' || *tptr == '#') {

        up->tstamp = pp->lastrec;

        if (write(pp->io.fd, tptr, 1) < 0)

          msyslog(LOG_ERR, "acts: write echo fails %m");

      }

    }

  }

}

/*

 * acts_message - process message

 */

void

acts_message(

  struct peer *peer,

  const char *msg

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  char  tbuf[BMAX];

  int   dtr = TIOCM_DTR;

  DPRINTF(1, ("acts: %d %s\n", (int)strlen(msg), msg));

  /*

   * What to do depends on the state and the first token in the

   * message.

   */

  pp = peer->procptr;

  up = pp->unitptr;

  /*

   * Extract the first token in the line.

   */

  strlcpy(tbuf, msg, sizeof(tbuf));

  strtok(tbuf, " ");

  switch (up->state) {

  /*

   * We are waiting for the OK response to the modem setup

   * command. When this happens, dial the number followed.

   * If anything other than OK is received, just ignore it

   * and wait for timeoue.

   */

  case S_SETUP:

    if (strcmp(tbuf, "OK") != 0) {

      /*

       * We disable echo with MODEM_SETUP's E0 but

       * if the modem was previously E1, we will

       * see MODEM_SETUP echoed before the OK/ERROR.

       * Ignore it.

       */

      if (!strcmp(tbuf, modem_setup))

        return;

      break;

    }

    mprintf_event(PEVNT_CLOCK, peer, "DIAL #%d %s",

            up->retry, sys_phone[up->retry]);

    if (ioctl(pp->io.fd, TIOCMBIS, &dtr) < 0)

      msyslog(LOG_ERR, "acts: ioctl(TIOCMBIS) failed: %m");

    if (write(pp->io.fd, sys_phone[up->retry],

        strlen(sys_phone[up->retry])) < 0)

      msyslog(LOG_ERR, "acts: write DIAL fails %m");

    write(pp->io.fd, "\r", 1);

    up->retry++;

    up->state = S_CONNECT;

    up->timer = ANSWER;

    return;

  /*

   * We are waiting for the CONNECT response to the dial

   * command. When this happens, listen for timecodes. If

   * somthing other than CONNECT is received, like BUSY

   * or NO CARRIER, abort the call.

   */

  case S_CONNECT:

    if (strcmp(tbuf, "CONNECT") != 0)

      break;

    report_event(PEVNT_CLOCK, peer, msg);

    up->state = S_MSG;

    up->timer = TIMECODE;

    return;

  /*

   * We are waiting for a timecode response. Pass it to

   * the parser. If NO CARRIER is received, save the

   * messages and abort the call.

   */

  case S_MSG:

    if (strcmp(tbuf, "NO") == 0)

      report_event(PEVNT_CLOCK, peer, msg);

    if (up->msgcnt < MAXCODE)

      acts_timecode(peer, msg);

    else

      acts_timeout(peer, S_MSG);

    return;

  }

  /*

   * Other response. Tell us about it.

   */

  report_event(PEVNT_CLOCK, peer, msg);

  acts_close(peer);

}

/*

 * acts_timeout - called on timeout

 */

static void

acts_timeout(

  struct peer *peer,

  teModemState  dstate

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  int fd;

  int rc;

  char  device[20];

  char  lockfile[128], pidbuf[8];

  /*

   * The state machine is driven by messages from the modem,

   * when first started and at timeout.

   */

  pp = peer->procptr;

  up = pp->unitptr;

  switch (dstate) {

  /*

   * System poll event. Lock the modem port, open the device

   * and send the setup command.

   */

  case S_IDLE:

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

      return;   /* port is already open */

    /*

     * Lock the modem port. If busy, retry later. Note: if

     * something fails between here and the close, the lock

     * file may not be removed.

     */

    if (pp->sloppyclockflag & CLK_FLAG2) {

      snprintf(lockfile, sizeof(lockfile), LOCKFILE,

          up->unit);

      fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL,

          0644);

      if (fd < 0) {

        report_event(PEVNT_CLOCK, peer, "acts: port busy");

        return;

      }

      snprintf(pidbuf, sizeof(pidbuf), "%d\n",

          (u_int)getpid());

      if (write(fd, pidbuf, strlen(pidbuf)) < 0)

        msyslog(LOG_ERR, "acts: write lock fails %m");

      close(fd);

    }

    /*

     * Open the device in raw mode and link the I/O.

     */

    snprintf(device, sizeof(device), DEVICE,

        up->unit);

    fd = refclock_open(device, SPEED232, LDISC_ACTS |

        LDISC_RAW | LDISC_REMOTE);

    if (fd < 0) {

      msyslog(LOG_ERR, "acts: open fails %m");

      return;

    }

    pp->io.fd = fd;

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

      msyslog(LOG_ERR, "acts: addclock fails");

      close(fd);

      pp->io.fd = -1;

      return;

    }

    up->msgcnt = 0;

    up->bufptr = up->buf;

    /*

     * If the port is directly connected to the device, skip

     * the modem business and send 'T' for Spectrabum.

     */

    if (sys_phone[up->retry] == NULL) {

      if (write(pp->io.fd, "T", 1) < 0)

        msyslog(LOG_ERR, "acts: write T fails %m");

      up->state = S_MSG;

      up->timer = TIMECODE;

      return;

    }

    /*

     * Initialize the modem. This works with Hayes-

     * compatible modems.

     */

    mprintf_event(PEVNT_CLOCK, peer, "SETUP %s",

            modem_setup);

    rc = write(pp->io.fd, modem_setup, strlen(modem_setup));

    if (rc < 0)

      msyslog(LOG_ERR, "acts: write SETUP fails %m");

    write(pp->io.fd, "\r", 1);

    up->state = S_SETUP;

    up->timer = SETUP;

    return;

  /*

   * In SETUP state the modem did not respond OK to setup string.

   */

  case S_SETUP:

    report_event(PEVNT_CLOCK, peer, "no modem");

    break;

  /*

   * In CONNECT state the call did not complete. Abort the call.

   */

  case S_CONNECT:

    report_event(PEVNT_CLOCK, peer, "no answer");

    break;

  /*

   * In MSG states no further timecodes are expected. If any

   * timecodes have arrived, update the clock. In any case,

   * terminate the call.

   */

  case S_MSG:

    if (up->msgcnt == 0) {

      report_event(PEVNT_CLOCK, peer, "no timecodes");

    } else {

      pp->lastref = pp->lastrec;

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

      refclock_receive(peer);

    }

    break;

  }

  acts_close(peer);

}

/*

 * acts_close - close and prepare for next call.

 *

 * In ClOSE state no further protocol actions are required

 * other than to close and release the device and prepare to

 * dial the next number if necessary.

 */

void

acts_close(

  struct peer *peer

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  char  lockfile[128];

  int dtr;

  pp = peer->procptr;

  up = pp->unitptr;

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

    report_event(PEVNT_CLOCK, peer, "close");

    dtr = TIOCM_DTR;

    if (ioctl(pp->io.fd, TIOCMBIC, &dtr) < 0)

      msyslog(LOG_ERR, "acts: ioctl(TIOCMBIC) failed: %m");

    io_closeclock(&pp->io);

    pp->io.fd = -1;

  }

  if (pp->sloppyclockflag & CLK_FLAG2) {

    snprintf(lockfile, sizeof(lockfile),

        LOCKFILE, up->unit);

    unlink(lockfile);

  }

  if (up->msgcnt == 0 && up->retry > 0) {

    if (sys_phone[up->retry] != NULL) {

      up->state = S_IDLE;

      up->timer = REDIAL;

      return;

    }

  }

  up->state = S_IDLE;

  up->timer = 0;

}

/*

 * acts_poll - called by the transmit routine

 */

static void

acts_poll(

  int unit,

  struct peer *peer

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  /*

   * This routine is called at every system poll. All it does is

   * set flag1 under certain conditions. The real work is done by

   * the timeout routine and state machine.

   */

  pp = peer->procptr;

  up = pp->unitptr;

  switch (peer->ttl) {

  /*

   * In manual mode the calling program is activated by the ntpdc

   * program using the enable flag (fudge flag1), either manually

   * or by a cron job.

   */

  case MODE_MANUAL:

    return;

  /*

   * In automatic mode the calling program runs continuously at

   * intervals determined by the poll event or specified timeout.

   */

  case MODE_AUTO:

    break;

  /*

   * In backup mode the calling program runs continuously as long

   * as either no peers are available or this peer is selected.

   */

  case MODE_BACKUP:

    if (!(sys_peer == NULL || sys_peer == peer))

      return;

    break;

  }

  pp->polls++;

  if (S_IDLE == up->state) {

    up->retry = 0;

    acts_timeout(peer, S_IDLE);

  }

}

/*

 * acts_timer - called at one-second intervals

 */

static void

acts_timer(

  int unit,

  struct peer *peer

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  /*

   * This routine implments a timeout which runs for a programmed

   * interval. The counter is initialized by the state machine and

   * counts down to zero. Upon reaching zero, the state machine is

   * called. If flag1 is set while timer is zero, force a call.

   */

  pp = peer->procptr;

  up = pp->unitptr;

  if (up->timer == 0) {

    if (pp->sloppyclockflag & CLK_FLAG1) {

      pp->sloppyclockflag &= ~CLK_FLAG1;

      acts_timeout(peer, S_IDLE);

    }

  } else {

    up->timer--;

    if (up->timer == 0)

      acts_timeout(peer, up->state);

  }

}

/*

 * acts_timecode - identify the service and parse the timecode message

 */

void

acts_timecode(

  struct peer * peer, /* peer structure pointer */

  const char *  str /* timecode string */

  )

{

  struct actsunit *up;

  struct refclockproc *pp;

  int day;    /* day of the month */

  int month;    /* month of the year */

  u_long  mjd;    /* Modified Julian Day */

  double  dut1;   /* DUT adjustment */

  u_int dst;    /* ACTS daylight/standard time */

  u_int leap;   /* ACTS leap indicator */

  double  msADV;    /* ACTS transmit advance (ms) */

  char  utc[10];  /* ACTS timescale */

  char  flag;   /* ACTS on-time character (* or #) */

  char  synchar;  /* WWVB synchronized indicator */

  char  qualchar; /* WWVB quality indicator */

  char  leapchar; /* WWVB leap indicator */

  char  dstchar;  /* WWVB daylight/savings indicator */

  int tz;   /* WWVB timezone */

  int leapmonth;  /* PTB/NPL month of leap */

  char  leapdir;  /* PTB/NPL leap direction */

  /*

   * The parser selects the modem format based on the message

   * length. Since the data are checked carefully, occasional

   * errors due noise are forgivable.

   */

  pp = peer->procptr;

  up = pp->unitptr;

  pp->nsec = 0;

  switch (strlen(str)) {

  /*

   * For USNO format on-time character '*', which is on a line by

   * itself. Be sure a timecode has been received.

   */

  case 1:

    if (*str == '*' && up->msgcnt > 0) 

      break;

    return;

  /*

   * ACTS format A: "jjjjj yy-mm-dd hh:mm:ss ds l uuu aaaaa

   * UTC(NIST) *".

   */

  case LENACTS:

    if (sscanf(str,

        "%5ld %2d-%2d-%2d %2d:%2d:%2d %2d %1d %3lf %5lf %9s %c",

        &mjd, &pp->year, &month, &day, &pp->hour,

        &pp->minute, &pp->second, &dst, &leap, &dut1,

        &msADV, utc, &flag) != 13) {

      refclock_report(peer, CEVNT_BADREPLY);

      return;

    }

    pp->day = ymd2yd(pp->year, month, day);

    pp->leap = LEAP_NOWARNING;

    if (leap == 1)

      pp->leap = LEAP_ADDSECOND;

    else if (leap == 2)

      pp->leap = LEAP_DELSECOND;

    memcpy(&pp->refid, REFACTS, 4);

    up->msgcnt++;

    if (flag != '#' && up->msgcnt < 10)

      return;

    break;

  /*

   * USNO format: "jjjjj nnn hhmmss UTC"

   */

  case LENUSNO:

    if (sscanf(str, "%5ld %3d %2d%2d%2d %3s",

        &mjd, &pp->day, &pp->hour, &pp->minute,

        &pp->second, utc) != 6) {

      refclock_report(peer, CEVNT_BADREPLY);

      return;

    }

    /*

     * Wait for the on-time character, which follows in a

     * separate message. There is no provision for leap

     * warning.

     */

    pp->leap = LEAP_NOWARNING;

    memcpy(&pp->refid, REFUSNO, 4);

    up->msgcnt++;

    break;

  /*

   * PTB/NPL format: "yyyy-mm-dd hh:mm:ss MEZ" 

   */

  case LENPTB:

    if (sscanf(str,

        "%*4d-%*2d-%*2d %*2d:%*2d:%2d %*5c%*12c%4d%2d%2d%2d%2d%5ld%2lf%c%2d%3lf%*15c%c",

        &pp->second, &pp->year, &month, &day, &pp->hour,

        &pp->minute, &mjd, &dut1, &leapdir, &leapmonth,

        &msADV, &flag) != 12) {

      refclock_report(peer, CEVNT_BADREPLY);

      return;

    }

    pp->leap = LEAP_NOWARNING;

    if (leapmonth == month) {

      if (leapdir == '+')

        pp->leap = LEAP_ADDSECOND;

      else if (leapdir == '-')

        pp->leap = LEAP_DELSECOND;

    }

    pp->day = ymd2yd(pp->year, month, day);

    memcpy(&pp->refid, REFPTB, 4);

    up->msgcnt++;

    break;

  /*

   * WWVB format 0: "I  ddd hh:mm:ss DTZ=nn"

   */

  case LENWWVB0:

    if (sscanf(str, "%c %3d %2d:%2d:%2d %cTZ=%2d",

        &synchar, &pp->day, &pp->hour, &pp->minute,

        &pp->second, &dstchar, &tz) != 7) {

      refclock_report(peer, CEVNT_BADREPLY);

      return;

    }

    pp->leap = LEAP_NOWARNING;

    if (synchar != ' ')

      pp->leap = LEAP_NOTINSYNC;

    memcpy(&pp->refid, REFWWVB, 4);

    up->msgcnt++;

    break;

  /*

   * WWVB format 2: "IQyy ddd hh:mm:ss.mmm LD"

   */

  case LENWWVB2:

    if (sscanf(str, "%c%c%2d %3d %2d:%2d:%2d.%3ld%c%c%c",

        &synchar, &qualchar, &pp->year, &pp->day,

        &pp->hour, &pp->minute, &pp->second, &pp->nsec,

        &dstchar, &leapchar, &dstchar) != 11) {

      refclock_report(peer, CEVNT_BADREPLY);

      return;

    }

    pp->nsec *= 1000000;

    pp->leap = LEAP_NOWARNING;

    if (synchar != ' ')

      pp->leap = LEAP_NOTINSYNC;

    else if (leapchar == 'L')

      pp->leap = LEAP_ADDSECOND;

    memcpy(&pp->refid, REFWWVB, 4);

    up->msgcnt++;

    break;

  /*

   * None of the above. Just forget about it and wait for the next

   * message or timeout.

   */

  default:

    return;

  }

  /*

   * We have a valid timecode. The fudge time1 value is added to

   * each sample by the main line routines. Note that in current

   * telephone networks the propatation time can be different for

   * each call and can reach 200 ms for some calls.

   */

  peer->refid = pp->refid;

  pp->lastrec = up->tstamp;

  if (up->msgcnt == 0)

    return;

  strlcpy(pp->a_lastcode, str, sizeof(pp->a_lastcode));

  pp->lencode = strlen(pp->a_lastcode);

  if (!refclock_process(pp)) {

    refclock_report(peer, CEVNT_BADTIME);

    return;

  }

  pp->lastref = pp->lastrec;

}

#else

int refclock_acts_bs;

#endif /* REFCLOCK */