Sync usage with man page.

[netbsd-mini2440.git] / external / bsd / ntp / dist / ntpd / refclock_acts.c

/*      $NetBSD: refclock_acts.c,v 1.5 2007/01/06 19:45:23 kardel Exp $ */

/*
 * 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) || defined(CLOCK_PTBACTS))

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

/*
 * 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. For reasons
 * unrelated to this driver, the data set ready (DSR) control line
 * should not be set when this driver is first started.
 *
 * The calling program is initiated by setting fudge flag1, either
 * manually or automatically. When flag1 is set, the calling program
 * dials the first number in the phone command of the configuration
 * file. If that call fails, the calling program dials the second number
 * and so on. The number is specified by the Hayes ATDT prefix followed
 * by the number itself, including the prefix and long-distance digits
 * and delay code, if necessary. The flag1 is reset and the calling
 * program terminated if (a) a valid clock update has been determined,
 * (b) no more numbers remain in the list, (c) a device fault or timeout
 * occurs or (d) fudge flag1 is reset manually.
 *
 * 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        no modem; port is directly connected to device
 * flag4        not used
 *
 * time1        offset adjustment (s)
 *
 * Ordinarily, the serial port is connected to a modem; however, it can
 * be connected directly to a device or another computer for testing and
 * calibration. In this case set fudge flag3 and the driver will send a
 * single character 'T' at each poll event. In principle, fudge flag2
 * enables port locking, allowing the modem to be shared when not in use
 * by this driver. At least on Solaris with the current NTP I/O
 * routines, this results only in lots of ugly error messages.
 */
/*
 * 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.
 *
 * 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        B9600   /* uart speed (9600 baud) */
#define PRECISION       (-10)   /* precision assumed (about 1 ms) */
#define LOCKFILE        "/var/spool/locks/LCK..cua%d"
#define DESCRIPTION     "Automated Computer Time Service" /* WRU */
#define REFID           "NONE"  /* default reference ID */
#define MSGCNT          20      /* max message count */
#define SMAX            256     /* max clockstats line length */
#define MAXPHONE        10      /* max number of phone numbers */

/*
 * Calling program modes
 */
#define MODE_AUTO       0       /* automatic mode */
#define MODE_BACKUP     1       /* backup mode */
#define MODE_MANUAL     2       /* manual mode */

/*
 * Service identifiers.
 */
#define REFACTS         "NIST"  /* NIST reference ID */
#define LENACTS         50      /* NIST format */
#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
 */
#define MODEM_SETUP     "ATB1&C0&D2E0L1M1Q0V1\r" /* modem setup */
#define MODEM_HANGUP    "ATH\r" /* modem disconnect */

/*
 * Timeouts (all in seconds)
 */
#define SETUP           3       /* setup timeout */
#define DTR             1       /* DTR timeout */
#define ANSWER          60      /* answer timeout */
#define CONNECT         20      /* first valid message timeout */
#define TIMECODE        30      /* all valid messages timeout */

/*
 * State machine codes
 */
#define S_IDLE          0       /* wait for poll */
#define S_OK            1       /* wait for modem setup */
#define S_DTR           2       /* wait for modem DTR */
#define S_CONNECT       3       /* wait for answer*/
#define S_FIRST         4       /* wait for first valid message */
#define S_MSG           5       /* wait for all messages */
#define S_CLOSE         6       /* wait after sending disconnect */

/*
 * 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;        /* buffer pointer */
};

/*
 * 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 *);
static  void    acts_timecode   (struct peer *, char *);
static  void    acts_poll       (int, struct peer *);
static  void    acts_timeout    (struct peer *);
static  void    acts_disc       (struct peer *);
static  void    acts_timer      (int, 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;

        /*
         * Allocate and initialize unit structure
         */
        up = emalloc(sizeof(struct actsunit));
        memset(up, 0, sizeof(struct actsunit));
        up->unit = unit;
        pp = peer->procptr;
        pp->unitptr = (caddr_t)up;
        pp->io.clock_recv = acts_receive;
        pp->io.srcclock = (caddr_t)peer;
        pp->io.datalen = 0;

        /*
         * Initialize miscellaneous variables
         */
        peer->precision = PRECISION;
        pp->clockdesc = DESCRIPTION;
        memcpy((char *)&pp->refid, REFID, 4);
        peer->sstclktype = CTL_SST_TS_TELEPHONE;
        up->bufptr = pp->a_lastcode;
        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 = (struct actsunit *)pp->unitptr;
        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[BMAX];
        char    *tptr;

        /*
         * 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 = (struct peer *)rbufp->recv_srcclock;
        pp = peer->procptr;
        up = (struct actsunit *)pp->unitptr;
        pp->lencode = refclock_gtraw(rbufp, tbuf, BMAX - (up->bufptr -
            pp->a_lastcode), &pp->lastrec);
        for (tptr = tbuf; *tptr != '\0'; tptr++) {
                if (*tptr == LF) {
                        if (up->bufptr == pp->a_lastcode) {
                                up->tstamp = pp->lastrec;
                                continue;

                        } else {
                                *up->bufptr = '\0';
                                acts_message(peer);
                                up->bufptr = pp->a_lastcode;
                        }
                } else if (!iscntrl((unsigned char)*tptr)) {
                        *up->bufptr++ = *tptr;
                        if (*tptr == '*' || *tptr == '#') {
                                up->tstamp = pp->lastrec;
                                write(pp->io.fd, tptr, 1);
                        }
                }
        }
}


/*
 * acts_message - process message
 */
void
acts_message(
        struct peer *peer
        )
{
        struct actsunit *up;
        struct refclockproc *pp;
        int     dtr = TIOCM_DTR;
        char    tbuf[SMAX];
#ifdef DEBUG
        u_int   modem;
#endif

        /*
         * What to do depends on the state and the first token in the
         * message.      */
        pp = peer->procptr;
        up = (struct actsunit *)pp->unitptr;
#ifdef DEBUG
        ioctl(pp->io.fd, TIOCMGET, (char *)&modem);
        snprintf(tbuf, sizeof(tbuf), "acts: %04x (%d %d) %zu %s", modem,
            up->state, up->timer, strlen(pp->a_lastcode),
            pp->a_lastcode);
        if (debug)
                printf("%s\n", tbuf);
#endif

        /*
         * Extract the first token in the line. A NO token sends the
         * message to the clockstats.
         */
        strncpy(tbuf, pp->a_lastcode, SMAX);
        strtok(tbuf, " ");
        if (strcmp(tbuf, "NO") == 0) {
                report_event(PEVNT_CLOCK, peer, pp->a_lastcode);
                return;
        }
        switch(up->state) {

        /*
         * We are waiting for the OK response to the modem setup
         * command. When this happens, raise DTR and dial the number
         * followed by \r.
         */
        case S_OK:
                if (strcmp(tbuf, "OK") != 0) {
                        msyslog(LOG_ERR, "acts: setup error %s",
                            pp->a_lastcode);
                        acts_disc(peer);
                        return;
                }
                ioctl(pp->io.fd, TIOCMBIS, (char *)&dtr);
                up->state = S_DTR;
                up->timer = DTR;
                return;

        /*
         * We are waiting for the call to be answered. All we care about
         * here is token CONNECT. Send the message to the clockstats.
         */
        case S_CONNECT:
                report_event(PEVNT_CLOCK, peer, pp->a_lastcode);
                if (strcmp(tbuf, "CONNECT") != 0) {
                        acts_disc(peer);
                        return;
                }
                up->state = S_FIRST;
                up->timer = CONNECT;
                return;

        /*
         * We are waiting for a timecode. Pass it to the parser.
         */
        case S_FIRST:
        case S_MSG:
                acts_timecode(peer, pp->a_lastcode);
                break;
        }
}

/*
 * acts_timecode - identify the service and parse the timecode message
 */
void
acts_timecode(
        struct peer *peer,      /* peer structure pointer */
        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 */

        u_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 = (struct actsunit *)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: "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;
                }

                /*
                 * Wait until ACTS has calculated the roundtrip delay.
                 * We don't need to do anything, as ACTS adjusts the
                 * on-time epoch.
                 */
                if (flag != '#')
                        return;

                pp->day = ymd2yd(pp->year, month, day);
                pp->leap = LEAP_NOWARNING;
                if (leap == 1)
                        pp->leap = LEAP_ADDSECOND;
                else if (pp->leap == 2)
                        pp->leap = LEAP_DELSECOND;
                memcpy(&pp->refid, REFACTS, 4);
                if (up->msgcnt == 0)
                        record_clock_stats(&peer->srcadr, str);
                up->msgcnt++;
                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);
                if (up->msgcnt == 0)
                        record_clock_stats(&peer->srcadr, str);
                up->msgcnt++;
                return;

        /*
         * 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);
                if (up->msgcnt == 0)
                        record_clock_stats(&peer->srcadr, str);
                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);
                if (up->msgcnt == 0)
                        record_clock_stats(&peer->srcadr, str);
                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);
                if (up->msgcnt == 0)
                        record_clock_stats(&peer->srcadr, str);
                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 (!refclock_process(pp)) {
                refclock_report(peer, CEVNT_BADTIME);
                return;
        }
        pp->lastref = pp->lastrec;
        if (up->state != S_MSG) {
                up->state = S_MSG;
                up->timer = TIMECODE;
        }
}


/*
 * 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 = (struct actsunit *)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:
                /* fall through */
                break;

        /*
         * In automatic mode the calling program runs continuously at
         * intervals determined by the poll event or specified timeout.
         */
        case MODE_AUTO:
                pp->sloppyclockflag |= CLK_FLAG1;
                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)
                        pp->sloppyclockflag |= CLK_FLAG1;
                break;
        }
}


/*
 * 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 in S_IDLE state, force a
         * timeout.
         */
        pp = peer->procptr;
        up = (struct actsunit *)pp->unitptr;
        if (pp->sloppyclockflag & CLK_FLAG1 && up->state == S_IDLE) {
                acts_timeout(peer);
                return;
        }
        if (up->timer == 0)
                return;

        up->timer--;
        if (up->timer == 0)
                acts_timeout(peer);
}


/*
 * acts_timeout - called on timeout
 */
static void
acts_timeout(
        struct peer *peer
        )
{
        struct actsunit *up;
        struct refclockproc *pp;
        int     fd;
        char    device[20];
        char    lockfile[128], pidbuf[8];
        char    tbuf[SMAX];

        /*
         * The state machine is driven by messages from the modem, when
         * first stated and at timeout.
         */
        pp = peer->procptr;
        up = (struct actsunit *)pp->unitptr;
        pp->sloppyclockflag &= ~CLK_FLAG1;
        if (sys_phone[up->retry] == NULL && !(pp->sloppyclockflag &
            CLK_FLAG3)) {
                msyslog(LOG_ERR, "acts: no phones");
                return;
        }
        switch(up->state) {

        /*
         * System poll event. Lock the modem port and open the device.
         */
        case S_IDLE:

                /*
                 * 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) {
                                msyslog(LOG_ERR, "acts: port busy");
                                return;
                        }
                        snprintf(pidbuf, sizeof(pidbuf), "%d\n",
                            (u_int)getpid());
                        write(fd, pidbuf, strlen(pidbuf));
                        close(fd);
                }

                /*
                 * Open the device in raw mode and link the I/O.
                 */
                if (!pp->io.fd) {
                        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");
                                return;
                        }
                        pp->io.fd = fd;
                        if (!io_addclock(&pp->io)) {
                                msyslog(LOG_ERR,
                                    "acts: addclock fails");
                                close(fd);
                                pp->io.fd = 0;
                                return;
                        }
                }

                /*
                 * If the port is directly connected to the device, skip
                 * the modem business and send 'T' for Spectrabum.
                 */
                if (pp->sloppyclockflag & CLK_FLAG3) {
                        if (write(pp->io.fd, "T", 1) < 0) {
                                msyslog(LOG_ERR, "acts: write %m");
                                return;
                        }
                        up->state = S_FIRST;
                        up->timer = CONNECT;
                        return;
                }

                /*
                 * Initialize the modem. This works with Hayes commands.
                 */
#ifdef DEBUG
                if (debug)
                        printf("acts: setup %s\n", MODEM_SETUP);
#endif
                if (write(pp->io.fd, MODEM_SETUP, strlen(MODEM_SETUP)) <
                    0) {
                        msyslog(LOG_ERR, "acts: write %m");
                        return;
                }
                up->state = S_OK;
                up->timer = SETUP;
                return;

        /*
         * In OK state the modem did not respond to setup.
         */
        case S_OK:
                msyslog(LOG_ERR, "acts: no modem");
                break;

        /*
         * In DTR state we are waiting for the modem to settle down
         * before hammering it with a dial command.
         */
        case S_DTR:
                snprintf(tbuf, sizeof(tbuf), "DIAL #%d %s", up->retry,
                    sys_phone[up->retry]);
                report_event(PEVNT_CLOCK, peer, tbuf);
#ifdef DEBUG
                if (debug)
                        printf("%s\n", tbuf);
#endif
                write(pp->io.fd, sys_phone[up->retry],
                    strlen(sys_phone[up->retry]));
                write(pp->io.fd, "\r", 1);
                up->state = S_CONNECT;
                up->timer = ANSWER;
                return;

        /*
         * In CONNECT state the call did not complete.
         */
        case S_CONNECT:
                msyslog(LOG_ERR, "acts: no answer");
                break;

        /*
         * In FIRST state no messages were received.
         */
        case S_FIRST:
                msyslog(LOG_ERR, "acts: no messages");
                break;

        /*
         * In CLOSE state hangup is complete. Close the doors and
         * windows and get some air.
         */
        case S_CLOSE:

                /*
                 * Close the device and unlock a shared modem.
                 */
                if (pp->io.fd) {
                        io_closeclock(&pp->io);
                        close(pp->io.fd);
                        if (pp->sloppyclockflag & CLK_FLAG2) {
                                snprintf(lockfile, sizeof(lockfile),
                                    LOCKFILE, up->unit);
                                unlink(lockfile);
                        }
                        pp->io.fd = 0;
                }

                /*
                 * If messages were received, fold the tent and wait for
                 * the next poll. If no messages and there are more
                 * numbers to dial, retry after a short wait.
                 */
                up->bufptr = pp->a_lastcode;
                up->timer = 0;
                up->state = S_IDLE;
                if ( up->msgcnt == 0) {
                        up->retry++;
                        if (sys_phone[up->retry] == NULL)
                                up->retry = 0;
                        else
                                up->timer = SETUP;
                } else {
                        up->retry = 0;
                }
                up->msgcnt = 0;
                return;
        }
        acts_disc(peer);
}


/*
 * acts_disc - disconnect the call and clean the place up.
 */
static void
acts_disc (
        struct peer *peer
        )
{
        struct actsunit *up;
        struct refclockproc *pp;
        int     dtr = TIOCM_DTR;

        /*
         * We get here if the call terminated successfully or if an
         * error occured. If the median filter has something in it,
         * feed the data to the clock filter. If a modem port, drop DTR
         * to force command mode and send modem hangup.
         */
        pp = peer->procptr;
        up = (struct actsunit *)pp->unitptr;
        if (up->msgcnt > 0)
                refclock_receive(peer);
        if (!(pp->sloppyclockflag & CLK_FLAG3)) {
                ioctl(pp->io.fd, TIOCMBIC, (char *)&dtr);
                write(pp->io.fd, MODEM_HANGUP, strlen(MODEM_HANGUP));
        }
        up->timer = SETUP;
        up->state = S_CLOSE;
}
#else
int refclock_acts_bs;
#endif /* REFCLOCK */