/* * refclock_acts - clock driver for the NIST/PTB Automated Computer Time * Service aka Amalgamated Containerized Trash Service (ACTS) */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #if defined(REFCLOCK) && (defined(CLOCK_ACTS) || defined(CLOCK_PTBACTS)) #include <stdio.h> #include <ctype.h> #include <sys/time.h> #ifdef HAVE_SYS_IOCTL_H # include <sys/ioctl.h> #endif /* HAVE_SYS_IOCTL_H */ #include "ntpd.h" #include "ntp_io.h" #include "ntp_unixtime.h" #include "ntp_refclock.h" #include "ntp_stdlib.h" #include "ntp_control.h" /* MUST BE AFTER LAST #include <config.h> !!! */ #if defined(CLOCK_ACTS) && defined(CLOCK_PTBACTS) # if defined(KEEPPTBACTS) # undef CLOCK_ACTS # else /* not KEEPPTBACTS */ # undef CLOCK_PTBACTS # endif /* not KEEPPTBACTS */ #endif /* CLOCK_ACTS && CLOCK_PTBACTS */ /* * This driver supports the NIST Automated Computer Time Service (ACTS). * It periodically dials a prespecified telephone number, receives the * NIST timecode data and calculates the local clock correction. It is * designed primarily for use as a backup when neither a radio clock nor * connectivity to Internet time servers is available. For the best * accuracy, the individual telephone line/modem delay needs to be * calibrated using outside sources. * * The ACTS is located at NIST Boulder, CO, telephone 303 494 4774. A * toll call from a residence telephone in Newark, DE, costs between 14 * and 27 cents, depending on time of day, and from a campus telephone * between 3 and 4 cents, although it is not clear what carrier and time * of day discounts apply in this case. The modem dial string will * differ depending on local telephone configuration, etc., and is * specified by the phone command in the configuration file. The * argument to this command is an AT command for a Hayes compatible * modem. * * The accuracy produced by this driver should be in the range of a * millisecond or two, but may need correction due to the delay * characteristics of the individual modem involved. For undetermined * reasons, some modems work with the ACTS echo-delay measurement scheme * and some don't. This driver tries to do the best it can with what it * gets. Initial experiments with a Practical Peripherals 9600SA modem * here in Delaware suggest an accuracy of a millisecond or two can be * achieved without the scheme by using a fudge time1 value of 65.0 ms. * In either case, the dispersion for a single call involving ten * samples is about 1.3 ms. * * The driver can operate in either of three modes, as determined by * the mode parameter in the server configuration command. In mode 0 * (automatic) the driver operates continuously at intervals depending * on the prediction error, as measured by the driver, usually in the * order of several hours. In mode 1 (backup) the driver is enabled in * automatic mode only when no other source of synchronization is * available and when more than MAXOUTAGE (3600 s) have elapsed since * last synchronized by other sources. In mode 2 (manual) the driver * operates only when enabled using a fudge flags switch, as described * below. * * For reliable call management, this driver requires a 1200-bps modem * with a Hayes-compatible command set and control over the modem data * terminal ready (DTR) control line. Present restrictions require the * use of a POSIX-compatible programming interface, although other * interfaces may work as well. The modem setup string is hard-coded in * the driver and may require changes for nonstandard modems or special * circumstances. * * Further information can be found in the README.refclock file in the * ntp - Version 3 distribution. * * Fudge Factors * * Ordinarily, the propagation time correction is computed automatically * by ACTS and the driver. When this is not possible or erratic due to * individual modem characteristics, the fudge flag2 switch should be * set to disable the ACTS echo-delay scheme. In any case, the fudge * time1 parameter can be used to adjust the propagation delay as * required. * * The ACTS call interval is determined in one of three ways. In manual * mode a call is initiated by setting fudge flag1 using ntpdc, either * manually or via a cron job. In AUTO mode this flag is set by the peer * timer, which is controlled by the sys_poll variable in response to * measured errors. In backup mode the driver is ordinarily asleep, but * awakes (in auto mode) if all other synchronization sources are lost. * In either auto or backup modes, the call interval increases as long * as the measured errors do not exceed the value of the fudge time2 * parameter. * * When the fudge flag1 is set, the ACTS calling program is activated. * This program dials each number listed in the phones command of the * configuration file in turn. If a call attempt fails, the next number * in the list is dialed. The fudge flag1 and counter are 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 using * ntpdc. * * In automatic and backup modes, the driver determines the call * interval using a procedure depending on the measured prediction * error and the fudge time2 parameter. If the error exceeds time2 for a * number of times depending on the current interval, the interval is * decreased, but not less than about 1000 s. If the error is less than * time2 for some number of times, the interval is increased, but not * more than about 18 h. With the default value of zero for fudge time2, * the interval will increase from 1000 s to the 4000-8000-s range, in * which the expected accuracy should be in the 1-2-ms range. Setting * fudge time2 to a large value, like 0.1 s, may result in errors of * that order, but increase the call interval to the maximum. The exact * value for each configuration will depend on the modem and operating * system involved, so some experimentation may be necessary. */ /* * DESCRIPTION OF THE AUTOMATED COMPUTER TELEPHONE SERVICE (ACTS) * (reformatted from ACTS on-line computer help information) * * The following is transmitted (at 1200 baud) following completion of * the telephone connection. * * 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) * * 47999 90-04-18 21:39:16 50 0 +.1 045.0 UTC(NIST) * * 47999 90-04-18 21:39:17 50 0 +.1 045.0 UTC(NIST) * * 47999 90-04-18 21:39:18 50 0 +.1 045.0 UTC(NIST) * * 47999 90-04-18 21:39:19 50 0 +.1 037.6 UTC(NIST) # * 47999 90-04-18 21:39:20 50 0 +.1 037.6 UTC(NIST) # * etc..etc...etc....... * * UTC = Universal Time Coordinated, the official world time referred to * the zero meridian. * * DST Daylight savings time characters, valid for the continental * U.S., are set as follows: * * 00 We are on standard time (ST). * 01-49 Now on DST, go to ST when your local time is 2:00 am and * the count is 01. The count is decremented daily at 00 * (UTC). * 50 We are on DST. * 51-99 Now on ST, go to DST when your local time is 2:00 am and * the count is 51. The count is decremented daily at 00 * (UTC). * * The two DST characters provide up to 48 days advance notice of a * change in time. The count remains at 00 or 50 at other times. * * LS Leap second flag is set to "1" to indicate that a leap second is * to be added as 23:59:60 (UTC) on the last day of the current UTC * month. The LS flag will be reset to "0" starting with 23:59:60 * (UTC). The flag will remain on for the entire month before the * second is added. Leap seconds are added as needed at the end of * any month. Usually June and/or December are chosen. * * The leap second flag will be set to a "2" to indicate that a * leap second is to be deleted at 23:59:58--00:00:00 on the last * day of the current month. (This latter provision is included per * international recommendation, however it is not likely to be * required in the near future.) * * DUT1 Approximate difference between earth rotation time (UT1) and * UTC, in steps of 0.1 second: DUT1 = UT1 - UTC. * * MJD Modified Julian Date, often used to tag certain scientific data. * * The full time format is sent at 1200 baud, 8 bit, 1 stop, no parity. * The format at 300 Baud is also 8 bit, 1 stop, no parity. At 300 Baud * the MJD and DUT1 values are deleted and the time is transmitted only * on even seconds. * * Maximum on line time will be 56 seconds. If all lines are busy at any * time, the oldest call will be terminated if it has been on line more * than 28 seconds, otherwise, the call that first reaches 28 seconds * will be terminated. * * Current time is valid at the "on-time" marker (OTM), either "*" or * "#". The nominal on-time marker (*) will be transmitted 45 ms early * to account for the 8 ms required to send 1 character at 1200 Baud, * plus an additional 7 ms for delay from NIST to the user, and * approximately 30 ms "scrambler" delay inherent in 1200 Baud modems. * If the caller echoes all characters, NIST will measure the round trip * delay and advance the on-time marker so that the midpoint of the stop * bit arrives at the user on time. The amount of msADV will reflect the * actual required advance in milliseconds and the OTM will be a "#". * * (The NIST system requires 4 or 5 consecutive delay measurements which * are consistent before switching from "*" to "#". If the user has a * 1200 Baud modem with the same internal delay as that used by NIST, * then the "#" OTM should arrive at the user within +-2 ms of the * correct time. * * However, NIST has studied different brands of 1200 Baud modems and * found internal delays from 24 ms to 40 ms and offsets of the "#" OTM * of +-10 ms. For many computer users, +-10 ms accuracy should be more * than adequate since many computer internal clocks can only be set * with granularity of 20 to 50 ms. In any case, the repeatability of * the offset for the "#" OTM should be within +-2 ms, if the dial-up * path is reciprocal and the user doesn't change the brand or model of * modem used. * * This should be true even if the dial-up path on one day is a land- * line of less than 40 ms (one way) and on the next day is a satellite * link of 260 to 300 ms. In the rare event that the path is one way by * satellite and the other way by land line with a round trip * measurement in the range of 90 to 260 ms, the OTM will remain a "*" * indicating 45 ms advance. * * For user comments write: * NIST-ACTS * Time and Frequency Division * Mail Stop 847 * 325 Broadway * Boulder, CO 80303 * * Software for setting (PC)DOS compatable machines is available on a * 360-kbyte diskette for $35.00 from: NIST Office of Standard Reference * Materials B311-Chemistry Bldg, NIST, Gaithersburg, MD, 20899, (301) * 975-6776 * * PTB timecode service (+49 531 512038) * The Physikalisch-Technische Bundesanstalt (Germany) * also supports a modem time service * as the data formats are very similar this driver can also be compiled for * utilizing the PTB time code service. * * Data format * 0000000000111111111122222222223333333333444444444455555555556666666666777777777 7 * 0123456789012345678901234567890123456789012345678901234567890123456789012345678 9 * 1995-01-23 20:58:51 MEZ 10402303260219950123195849740+40000500 * * A B C D EF G H IJ K L M N O P Q R S T U V W XY Z<CR><LF> * * A year * B month * C day * D hour * E : normally * A for DST to ST switch first hour * B for DST to ST switch second hour if not marked in H * F minute * G second * H timezone * I day of week * J week of year * K day of year * L month for next ST/DST changes * M day * N hour * O UTC year * P UTC month * Q UTC day * R UTC hour * S UTC minute * T modified julian day (MJD) * U DUT1 * V direction and month if leap second * W signal delay (assumed/measured) * X sequence number for additional text line in Y * Y additional text * Z on time marker (* - assumed delay / # measured delay) * <CR>!<LF> ! is second change ! * * This format is also used by the National Physical Laboratory (NPL)'s * TRUETIME service in the UK. In this case the timezone field is * UTC+0 or UTC+1 for standard and daylight saving time. The phone * number for this service (a premium rate number) is 0891 516 333. * It is not clear whether the echo check is implemented. * * For more detail, see http://www.npl.co.uk/npl/cetm/taf/truetime.html. */ /* * Interface definitions */ #define SPEED232 B1200 /* uart speed (1200 cowardly baud) */ #define PRECISION (-10) /* precision assumed (about 1 ms) */ #ifdef CLOCK_ACTS # define REFID "ACTS" /* reference ID */ # define DESCRIPTION "NIST Automated Computer Time Service" /* WRU */ # define LENCODE 50 /* length of valid timecode string */ # define DEVICE "/dev/acts%d" /* device name and unit */ # define REF_ENTRY refclock_acts #else /* not CLOCK_ACTS */ # define REFID "TPTB" /* reference ID */ # define DESCRIPTION "PTB Automated Computer Time Service" # define LENCODE 78 /* length of valid timecode string */ # define DEVICE "/dev/ptb%d" /* device name and unit */ # define REF_ENTRY refclock_ptb #endif /* not CLOCK_ACTS */ #define MODE_AUTO 0 /* automatic mode */ #define MODE_BACKUP 1 /* backup mode */ #define MODE_MANUAL 2 /* manual mode */ #define MSGCNT 10 /* we need this many ACTS messages */ #define SMAX 80 /* max token string length */ #define ACTS_MINPOLL 10 /* log2 min poll interval (1024 s) */ #define ACTS_MAXPOLL 18 /* log2 max poll interval (16384 s) */ #define MAXOUTAGE 3600 /* max before ACTS kicks in (s) */ /* * Modem control strings. These may have to be changed for some modems. * * AT command prefix * B1 initiate call negotiation using Bell 212A * &C1 enable 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 untill carrier detect * Q0 return result codes * V1 return result codes as English words */ #define MODEM_SETUP "ATB1&C1&D2E0L1M1Q0V1" /* modem setup */ #define MODEM_HANGUP "ATH" /* modem disconnect */ /* * Timeouts */ #define IDLE 60 /* idle timeout (s) */ #define WAIT 2 /* wait timeout (s) */ #define ANSWER 30 /* answer timeout (s) */ #define CONNECT 10 /* connect timeout (s) */ #define TIMECODE 15 /* timecode timeout (s) */ /* * Tables to compute the ddd of year form icky dd/mm timecode. Viva la * leap. */ static int day1tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; static int day2tab[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; /* * Unit control structure */ struct actsunit { int pollcnt; /* poll message counter */ int state; /* the first one was Delaware */ int run; /* call program run switch */ int msgcnt; /* count of ACTS messages received */ long redial; /* interval to next automatic call */ double msADV; /* millisecond advance of last message */ }; /* * Function prototypes */ static int acts_start P((int, struct peer *)); static void acts_shutdown P((int, struct peer *)); static void acts_receive P((struct recvbuf *)); static void acts_poll P((int, struct peer *)); static void acts_timeout P((struct peer *)); static void acts_disc P((struct peer *)); static int acts_write P((struct peer *, const char *)); /* * Transfer vector (conditional structure name) */ struct refclock REF_ENTRY = { acts_start, /* start up driver */ acts_shutdown, /* shut down driver */ acts_poll, /* transmit poll message */ noentry, /* not used (old acts_control) */ noentry, /* not used (old acts_init) */ noentry, /* not used (old acts_buginfo) */ NOFLAGS /* not used */ }; /* * acts_start - open the devices and initialize data for processing */ static int acts_start ( int unit, struct peer *peer ) { register struct actsunit *up; struct refclockproc *pp; int fd; char device[20]; int dtr = TIOCM_DTR; /* * Open serial port. Use ACTS line discipline, if available. It * pumps a timestamp into the data stream at every on-time * character '*' found. Note: the port must have modem control * or deep pockets for the phone bill. HP-UX 9.03 users should * have very deep pockets. */ (void)sprintf(device, DEVICE, unit); if (!(fd = refclock_open(device, SPEED232, LDISC_ACTS))) return (0); if (ioctl(fd, TIOCMBIS, (char *)&dtr) < 0) { msyslog(LOG_ERR, "clock %s ACTS no modem control", ntoa(&peer->srcadr)); return (0); } /* * Allocate and initialize unit structure */ if (!(up = (struct actsunit *) emalloc(sizeof(struct actsunit)))) { (void) close(fd); return (0); } memset((char *)up, 0, sizeof(struct actsunit)); pp = peer->procptr; pp->io.clock_recv = acts_receive; pp->io.srcclock = (caddr_t)peer; pp->io.datalen = 0; pp->io.fd = fd; if (!io_addclock(&pp->io)) { (void) close(fd); free(up); return (0); } pp->unitptr = (caddr_t)up; /* * Initialize miscellaneous variables */ peer->precision = PRECISION; pp->clockdesc = DESCRIPTION; memcpy((char *)&pp->refid, REFID, 4); peer->minpoll = ACTS_MINPOLL; peer->maxpoll = ACTS_MAXPOLL; peer->sstclktype = CTL_SST_TS_TELEPHONE; /* * Initialize modem and kill DTR. We skedaddle if this comes * bum. */ if (!acts_write(peer, MODEM_SETUP)) { (void) close(fd); free(up); return (0); } /* * Set up the driver timeout */ peer->nextdate = current_time + WAIT; return (1); } /* * acts_shutdown - shut down the clock */ static void acts_shutdown ( int unit, struct peer *peer ) { register struct actsunit *up; struct refclockproc *pp; pp = peer->procptr; up = (struct actsunit *)pp->unitptr; io_closeclock(&pp->io); free(up); } /* * acts_receive - receive data from the serial interface */ static void acts_receive ( struct recvbuf *rbufp ) { register struct actsunit *up; struct refclockproc *pp; struct peer *peer; char str[SMAX]; int i; char hangup = '%'; /* ACTS hangup */ int day; /* day of the month */ int month; /* month of the year */ u_long mjd; /* Modified Julian Day */ double dut1; /* DUT adjustment */ double msADV; /* ACTS transmit advance (ms) */ char flag; /* calibration flag */ #ifndef CLOCK_PTBACTS char utc[10]; /* this is NIST and you're not */ u_int dst; /* daylight/standard time indicator */ u_int leap; /* leap-second indicator */ #else char leapdir; /* leap direction */ u_int leapmonth; /* month of leap */ #endif /* * Initialize pointers and read the timecode and timestamp. If * the OK modem status code, leave it where folks can find it. */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct actsunit *)pp->unitptr; pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &pp->lastrec); if (pp->lencode == 0) { if (strcmp(pp->a_lastcode, "OK") == 0) pp->lencode = 2; return; } #ifdef DEBUG if (debug) printf("acts: state %d timecode %d %*s\n", up->state, pp->lencode, pp->lencode, pp->a_lastcode); #endif switch (up->state) { case 0: /* * State 0. We are not expecting anything. Probably * modem disconnect noise. Go back to sleep. */ return; case 1: /* * State 1. We are waiting for the call to be answered. * All we care about here is CONNECT as the first token * in the string. If the modem signals BUSY, ERROR, NO * ANSWER, NO CARRIER or NO DIALTONE, we immediately * hang up the phone. If CONNECT doesn't happen after * ANSWER seconds, hang up the phone. If everything is * okay, start the connect timeout and slide into state * 2. */ if( strcmp(pp->a_lastcode, " ") == 0) { acts_disc(peer); return; } if( strcmp(sys_phone[0],"DIRECT") != 0 ) { (void)strncpy(str, strtok(pp->a_lastcode, " "), SMAX); if (strcmp(str, "BUSY") == 0 || strcmp(str, "ERROR") == 0 || strcmp(str, "NO") == 0) { NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS modem status %s", ntoa(&peer->srcadr), pp->a_lastcode); acts_disc(peer); } else if (strcmp(str, "CONNECT") == 0) { peer->nextdate = current_time + CONNECT; up->msgcnt = 0; up->state++; } } else { (void) strncpy(str,"CONNECT",7); peer->nextdate = current_time + CONNECT; up->msgcnt = 0; up->state++; } return; case 2: /* * State 2. The call has been answered and we are * waiting for the first ACTS message. If this doesn't * happen within the timecode timeout, hang up the * phone. We probably got a wrong number or ACTS is * down. */ peer->nextdate = current_time + TIMECODE; up->state++; } /* * Real yucky things here. Ignore everything except timecode * messages, as determined by the message length. We told the * terminal routines to end the line with '*' and the line * discipline to strike a timestamp on that character. However, * when the ACTS echo-delay scheme works, the '*' eventually * becomes a '#'. In this case the message is ended by the <CR> * that comes about 200 ms after the '#' and the '#' cannot be * echoed at the proper time. But, this may not be a lose, since * we already have good data from prior messages and only need * the millisecond advance calculated by ACTS. So, if the * message is long enough and has an on-time character at the * right place, we consider the message (but not neccesarily the * timestmap) to be valid. */ if (pp->lencode != LENCODE) return; #ifndef CLOCK_PTBACTS /* * We apparently have a valid timecode message, so dismember it * with sscan(). This routine does a good job in spotting syntax * errors without becoming overly pedantic. * * D L D * MJD YR MO DA H M S ST S UT1 msADV OTM * 47222 88-03-02 21:39:15 83 0 +.3 045.0 UTC(NBS) * */ if (sscanf(pp->a_lastcode, "%5ld %2d-%2d-%2d %2d:%2d:%2d %2d %1d %3lf %5lf %s %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; } #else /* * Data format * 0000000000111111111122222222223333333333444444444455555555556666666666777777777 7 * 0123456789012345678901234567890123456789012345678901234567890123456789012345678 9 * 1995-01-23 20:58:51 MEZ 10402303260219950123195849740+40000500 * */ if (sscanf(pp->a_lastcode, "%*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; } #endif /* * Some modems can't be trusted (the Practical Peripherals * 9600SA comes to mind) and, even if they manage to unstick * ACTS, the millisecond advance is wrong, so we use CLK_FLAG2 * to disable echoes, if neccessary. */ if ((flag == '*' || flag == '#') && !(pp->sloppyclockflag & CLK_FLAG2)) (void)write(pp->io.fd, &flag, 1); /* * Yes, I know this code incorrectly thinks that 2000 is a leap * year. The ACTS timecode format croaks then anyway. Life is * short. Would only the timecode mavens resist the urge to * express months of the year and days of the month in favor of * days of the year. */ if (month < 1 || month > 12 || day < 1) { refclock_report(peer, CEVNT_BADTIME); return; } if (pp->year % 4) { if (day > day1tab[month - 1]) { refclock_report(peer, CEVNT_BADTIME); return; } for (i = 0; i < month - 1; i++) day += day1tab[i]; } else { if (day > day2tab[month - 1]) { refclock_report(peer, CEVNT_BADTIME); return; } for (i = 0; i < month - 1; i++) day += day2tab[i]; } pp->day = day; #ifndef CLOCK_PTBACTS if (leap == 1) pp->leap = LEAP_ADDSECOND; else if (pp->leap == 2) pp->leap = LEAP_DELSECOND; #else if (leapmonth == month) { if (leapdir == '+') pp->leap = LEAP_ADDSECOND; else if (leapdir == '-') pp->leap = LEAP_DELSECOND; } #endif /* * Colossal hack here. We process each sample in a trimmed-mean * filter and determine the reference clock offset and * dispersion. The fudge time1 value is added to each sample as * received. If we collect MSGCNT samples before the '#' on-time * character, we use the results of the filter as is. If the '#' * is found before that, the adjusted msADV is used to correct * the propagation delay. */ up->msgcnt++; if (flag == '#') { pp->offset += (msADV - up->msADV) * 1000 * 1e-6; } else { up->msADV = msADV; pp->nstages = up->msgcnt; pp->nskeep = up->msgcnt * 2 / 3; if (!refclock_process(pp)) { refclock_report(peer, CEVNT_BADTIME); return; } else if (up->msgcnt < MSGCNT) return; } /* * We have a filtered sample offset ready for peer processing. * We use lastrec as both the reference time and receive time in * order to avoid being cute, like setting the reference time * later than the receive time, which may cause a paranoid * protocol module to chuck out the data. Finaly, we unhook the * timeout, arm for the next call, fold the tent and go home. * The little dance with the '%' character is an undocumented * ACTS feature that hangs up the phone real quick without * waiting for carrier loss or long-space disconnect, but we do * these clumsy things anyway. */ record_clock_stats(&peer->srcadr, pp->a_lastcode); refclock_receive(peer); pp->sloppyclockflag &= ~CLK_FLAG1; up->pollcnt = 0; (void)write(pp->io.fd, &hangup, 1); up->state = 0; acts_disc(peer); } /* * acts_poll - called by the transmit routine */ static void acts_poll ( int unit, struct peer *peer ) { register struct actsunit *up; struct refclockproc *pp; /* * If the driver is running, we set the enable flag (fudge * flag1), which causes the driver timeout routine to initiate a * call to ACTS. If not, the enable flag can be set using * ntpdc. If this is the sustem peer, then follow the system * poll interval. */ pp = peer->procptr; up = (struct actsunit *)pp->unitptr; if (up->run) { pp->sloppyclockflag |= CLK_FLAG1; if (peer == sys_peer) peer->hpoll = sys_poll; else peer->hpoll = peer->minpoll; } acts_timeout (peer); return; } /* * acts_timeout - called by the timer interrupt */ static void acts_timeout ( struct peer *peer ) { register struct actsunit *up; struct refclockproc *pp; int dtr = TIOCM_DTR; /* * If a timeout occurs in other than state 0, the call has * failed. If in state 0, we just see if there is other work to * do. */ pp = peer->procptr; up = (struct actsunit *)pp->unitptr; if (up->state) { acts_disc(peer); return; } switch (peer->ttl) { /* * In manual mode the ACTS calling program is activated * by the ntpdc program using the enable flag (fudge * flag1), either manually or by a cron job. */ case MODE_MANUAL: up->run = 0; break; /* * In automatic mode the ACTS calling program runs * continuously at intervals determined by the sys_poll * variable. */ case MODE_AUTO: if (!up->run) pp->sloppyclockflag |= CLK_FLAG1; up->run = 1; break; /* * In backup mode the ACTS calling program is disabled, * unless no system peer has been selected for MAXOUTAGE * (3600 s). Once enabled, it runs until some other NTP * peer shows up. */ case MODE_BACKUP: if (!up->run && sys_peer == 0) { if (current_time - last_time > MAXOUTAGE) { up->run = 1; peer->hpoll = peer->minpoll; NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS backup started ", ntoa(&peer->srcadr)); } } else if (up->run && sys_peer->sstclktype != CTL_SST_TS_TELEPHONE) { peer->hpoll = peer->minpoll; up->run = 0; NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS backup stopped", ntoa(&peer->srcadr)); } break; default: msyslog(LOG_ERR, "clock %s ACTS invalid mode", ntoa(&peer->srcadr)); } /* * The fudge flag1 is used as an enable/disable; if set either * by the code or via ntpdc, the ACTS calling program is * started; if reset, the phones stop ringing. */ if (!(pp->sloppyclockflag & CLK_FLAG1)) { up->pollcnt = 0; peer->nextdate = current_time + IDLE; return; } /* * Initiate a call to the ACTS service. If we wind up here in * other than state 0, a successful call could not be completed * within minpoll seconds. We advance to the next modem dial * string. If none are left, we log a notice and clear the * enable flag. For future enhancement: call the site RP and * leave an obscene message in his voicemail. */ if (sys_phone[up->pollcnt][0] == '\0') { refclock_report(peer, CEVNT_TIMEOUT); NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS calling program terminated", ntoa(&peer->srcadr)); pp->sloppyclockflag &= ~CLK_FLAG1; #ifdef DEBUG if (debug) printf("acts: calling program terminated\n"); #endif up->pollcnt = 0; peer->nextdate = current_time + IDLE; return; } /* * Raise DTR, call ACTS and start the answer timeout. We think * it strange if the OK status has not been received from the * modem, but plow ahead anyway. */ if (strcmp(pp->a_lastcode, "OK") != 0) NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS no modem status", ntoa(&peer->srcadr)); (void)ioctl(pp->io.fd, TIOCMBIS, (char *)&dtr); (void)acts_write(peer, sys_phone[up->pollcnt]); NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS calling %s\n", ntoa(&peer->srcadr), sys_phone[up->pollcnt]); up->state = 1; up->pollcnt++; pp->polls++; peer->nextdate = current_time + ANSWER; return; } /* * acts_disc - disconnect the call and wait for the ruckus to cool */ static void acts_disc ( struct peer *peer ) { register struct actsunit *up; struct refclockproc *pp; int dtr = TIOCM_DTR; /* * We should never get here other than in state 0, unless a call * has timed out. We drop DTR, which will reliably get the modem * off the air, even while ACTS is hammering away full tilt. */ pp = peer->procptr; up = (struct actsunit *)pp->unitptr; (void)ioctl(pp->io.fd, TIOCMBIC, (char *)&dtr); if (up->state > 0) { NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */ msyslog(LOG_NOTICE, "clock %s ACTS call failed %d", ntoa(&peer->srcadr), up->state); #ifdef DEBUG if (debug) printf("acts: call failed %d\n", up->state); #endif up->state = 0; } peer->nextdate = current_time + WAIT; } /* * acts_write - write a message to the serial port */ static int acts_write ( struct peer *peer, const char *str ) { register struct actsunit *up; struct refclockproc *pp; int len; int code; char cr = '\r'; /* * Not much to do here, other than send the message, handle * debug and report faults. */ pp = peer->procptr; up = (struct actsunit *)pp->unitptr; len = strlen(str); #ifdef DEBUG if (debug) printf("acts: state %d send %d %s\n", up->state, len, str); #endif code = write(pp->io.fd, str, (unsigned)len) == len; code &= write(pp->io.fd, &cr, 1) == 1; if (!code) refclock_report(peer, CEVNT_FAULT); return (code); } #else int refclock_acts_bs; #endif /* REFCLOCK */