![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_acts.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd|
Return to refclock_acts.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * refclock_acts - clock driver for the NIST/USNO/PTB/NPL Computer Time
3: * Services
4: */
5: #ifdef HAVE_CONFIG_H
6: #include <config.h>
7: #endif
8:
9: #if defined(REFCLOCK) && (defined(CLOCK_ACTS) || defined(CLOCK_PTBACTS))
10:
11: #include "ntpd.h"
12: #include "ntp_io.h"
13: #include "ntp_unixtime.h"
14: #include "ntp_refclock.h"
15: #include "ntp_stdlib.h"
16: #include "ntp_control.h"
17:
18: #include <stdio.h>
19: #include <ctype.h>
20: #ifdef HAVE_SYS_IOCTL_H
21: # include <sys/ioctl.h>
22: #endif /* HAVE_SYS_IOCTL_H */
23:
24: /*
25: * This driver supports the US (NIST, USNO) and European (PTB, NPL,
26: * etc.) modem time services, as well as Spectracom GPS and WWVB
27: * receivers connected via a modem. The driver periodically dials a
28: * number from a telephone list, receives the timecode data and
29: * calculates the local clock correction. It is designed primarily for
30: * use as backup when neither a radio clock nor connectivity to Internet
31: * time servers is available.
32: *
33: * This driver requires a modem with a Hayes-compatible command set and
34: * control over the modem data terminal ready (DTR) control line. The
35: * modem setup string is hard-coded in the driver and may require
36: * changes for nonstandard modems or special circumstances. For reasons
37: * unrelated to this driver, the data set ready (DSR) control line
38: * should not be set when this driver is first started.
39: *
40: * The calling program is initiated by setting fudge flag1, either
41: * manually or automatically. When flag1 is set, the calling program
42: * dials the first number in the phone command of the configuration
43: * file. If that call fails, the calling program dials the second number
44: * and so on. The number is specified by the Hayes ATDT prefix followed
45: * by the number itself, including the prefix and long-distance digits
46: * and delay code, if necessary. The flag1 is reset and the calling
47: * program terminated if (a) a valid clock update has been determined,
48: * (b) no more numbers remain in the list, (c) a device fault or timeout
49: * occurs or (d) fudge flag1 is reset manually.
50: *
51: * The driver is transparent to each of the modem time services and
52: * Spectracom radios. It selects the parsing algorithm depending on the
53: * message length. There is some hazard should the message be corrupted.
54: * However, the data format is checked carefully and only if all checks
55: * succeed is the message accepted. Corrupted lines are discarded
56: * without complaint.
57: *
58: * Fudge controls
59: *
60: * flag1 force a call in manual mode
61: * flag2 enable port locking (not verified)
62: * flag3 no modem; port is directly connected to device
63: * flag4 not used
64: *
65: * time1 offset adjustment (s)
66: *
67: * Ordinarily, the serial port is connected to a modem; however, it can
68: * be connected directly to a device or another computer for testing and
69: * calibration. In this case set fudge flag3 and the driver will send a
70: * single character 'T' at each poll event. In principle, fudge flag2
71: * enables port locking, allowing the modem to be shared when not in use
72: * by this driver. At least on Solaris with the current NTP I/O
73: * routines, this results only in lots of ugly error messages.
74: */
75: /*
76: * National Institute of Science and Technology (NIST)
77: *
78: * Phone: (303) 494-4774 (Boulder, CO); (808) 335-4721 (Hawaii)
79: *
80: * Data Format
81: *
82: * National Institute of Standards and Technology
83: * Telephone Time Service, Generator 3B
84: * Enter question mark "?" for HELP
85: * D L D
86: * MJD YR MO DA H M S ST S UT1 msADV <OTM>
87: * 47999 90-04-18 21:39:15 50 0 +.1 045.0 UTC(NIST) *<CR><LF>
88: * ...
89: *
90: * MJD, DST, DUT1 and UTC are not used by this driver. The "*" or "#" is
91: * the on-time markers echoed by the driver and used by NIST to measure
92: * and correct for the propagation delay.
93: *
94: * US Naval Observatory (USNO)
95: *
96: * Phone: (202) 762-1594 (Washington, DC); (719) 567-6742 (Boulder, CO)
97: *
98: * Data Format (two lines, repeating at one-second intervals)
99: *
100: * jjjjj nnn hhmmss UTC<CR><LF>
101: * *<CR><LF>
102: *
103: * jjjjj modified Julian day number (not used)
104: * nnn day of year
105: * hhmmss second of day
106: * * on-time marker for previous timecode
107: * ...
108: *
109: * USNO does not correct for the propagation delay. A fudge time1 of
110: * about .06 s is advisable.
111: *
112: * European Services (PTB, NPL, etc.)
113: *
114: * PTB: +49 531 512038 (Germany)
115: * NPL: 0906 851 6333 (UK only)
116: *
117: * Data format (see the documentation for phone numbers and formats.)
118: *
119: * 1995-01-23 20:58:51 MEZ 10402303260219950123195849740+40000500<CR><LF>
120: *
121: * Spectracom GPS and WWVB Receivers
122: *
123: * If a modem is connected to a Spectracom receiver, this driver will
124: * call it up and retrieve the time in one of two formats. As this
125: * driver does not send anything, the radio will have to either be
126: * configured in continuous mode or be polled by another local driver.
127: */
128: /*
129: * Interface definitions
130: */
131: #define DEVICE "/dev/acts%d" /* device name and unit */
132: #define SPEED232 B9600 /* uart speed (9600 baud) */
133: #define PRECISION (-10) /* precision assumed (about 1 ms) */
134: #define LOCKFILE "/var/spool/locks/LCK..cua%d"
135: #define DESCRIPTION "Automated Computer Time Service" /* WRU */
136: #define REFID "NONE" /* default reference ID */
137: #define MSGCNT 20 /* max message count */
138: #define SMAX 256 /* max clockstats line length */
139: #define MAXPHONE 10 /* max number of phone numbers */
140:
141: /*
142: * Calling program modes
143: */
144: #define MODE_AUTO 0 /* automatic mode */
145: #define MODE_BACKUP 1 /* backup mode */
146: #define MODE_MANUAL 2 /* manual mode */
147:
148: /*
149: * Service identifiers.
150: */
151: #define REFACTS "NIST" /* NIST reference ID */
152: #define LENACTS 50 /* NIST format */
153: #define REFUSNO "USNO" /* USNO reference ID */
154: #define LENUSNO 20 /* USNO */
155: #define REFPTB "PTB\0" /* PTB/NPL reference ID */
156: #define LENPTB 78 /* PTB/NPL format */
157: #define REFWWVB "WWVB" /* WWVB reference ID */
158: #define LENWWVB0 22 /* WWVB format 0 */
159: #define LENWWVB2 24 /* WWVB format 2 */
160: #define LF 0x0a /* ASCII LF */
161:
162: /*
163: * Modem setup strings. These may have to be changed for some modems.
164: *
165: * AT command prefix
166: * B1 US answer tone
167: * &C0 disable carrier detect
168: * &D2 hang up and return to command mode on DTR transition
169: * E0 modem command echo disabled
170: * l1 set modem speaker volume to low level
171: * M1 speaker enabled until carrier detect
172: * Q0 return result codes
173: * V1 return result codes as English words
174: */
175: #define MODEM_SETUP "ATB1&C0&D2E0L1M1Q0V1\r" /* modem setup */
176: #define MODEM_HANGUP "ATH\r" /* modem disconnect */
177:
178: /*
179: * Timeouts (all in seconds)
180: */
181: #define SETUP 3 /* setup timeout */
182: #define DTR 1 /* DTR timeout */
183: #define ANSWER 60 /* answer timeout */
184: #define CONNECT 20 /* first valid message timeout */
185: #define TIMECODE 30 /* all valid messages timeout */
186:
187: /*
188: * State machine codes
189: */
190: #define S_IDLE 0 /* wait for poll */
191: #define S_OK 1 /* wait for modem setup */
192: #define S_DTR 2 /* wait for modem DTR */
193: #define S_CONNECT 3 /* wait for answer*/
194: #define S_FIRST 4 /* wait for first valid message */
195: #define S_MSG 5 /* wait for all messages */
196: #define S_CLOSE 6 /* wait after sending disconnect */
197:
198: /*
199: * Unit control structure
200: */
201: struct actsunit {
202: int unit; /* unit number */
203: int state; /* the first one was Delaware */
204: int timer; /* timeout counter */
205: int retry; /* retry index */
206: int msgcnt; /* count of messages received */
207: l_fp tstamp; /* on-time timestamp */
208: char *bufptr; /* buffer pointer */
209: };
210:
211: /*
212: * Function prototypes
213: */
214: static int acts_start (int, struct peer *);
215: static void acts_shutdown (int, struct peer *);
216: static void acts_receive (struct recvbuf *);
217: static void acts_message (struct peer *);
218: static void acts_timecode (struct peer *, char *);
219: static void acts_poll (int, struct peer *);
220: static void acts_timeout (struct peer *);
221: static void acts_disc (struct peer *);
222: static void acts_timer (int, struct peer *);
223:
224: /*
225: * Transfer vector (conditional structure name)
226: */
227: struct refclock refclock_acts = {
228: acts_start, /* start up driver */
229: acts_shutdown, /* shut down driver */
230: acts_poll, /* transmit poll message */
231: noentry, /* not used */
232: noentry, /* not used */
233: noentry, /* not used */
234: acts_timer /* housekeeping timer */
235: };
236:
237: /*
238: * Initialize data for processing
239: */
240: static int
241: acts_start (
242: int unit,
243: struct peer *peer
244: )
245: {
246: struct actsunit *up;
247: struct refclockproc *pp;
248:
249: /*
250: * Allocate and initialize unit structure
251: */
252: up = emalloc(sizeof(struct actsunit));
253: memset(up, 0, sizeof(struct actsunit));
254: up->unit = unit;
255: pp = peer->procptr;
256: pp->unitptr = (caddr_t)up;
257: pp->io.clock_recv = acts_receive;
258: pp->io.srcclock = (caddr_t)peer;
259: pp->io.datalen = 0;
260:
261: /*
262: * Initialize miscellaneous variables
263: */
264: peer->precision = PRECISION;
265: pp->clockdesc = DESCRIPTION;
266: memcpy((char *)&pp->refid, REFID, 4);
267: peer->sstclktype = CTL_SST_TS_TELEPHONE;
268: up->bufptr = pp->a_lastcode;
269: return (1);
270: }
271:
272:
273: /*
274: * acts_shutdown - shut down the clock
275: */
276: static void
277: acts_shutdown (
278: int unit,
279: struct peer *peer
280: )
281: {
282: struct actsunit *up;
283: struct refclockproc *pp;
284:
285: /*
286: * Warning: do this only when a call is not in progress.
287: */
288: pp = peer->procptr;
289: up = (struct actsunit *)pp->unitptr;
290: free(up);
291: }
292:
293:
294: /*
295: * acts_receive - receive data from the serial interface
296: */
297: static void
298: acts_receive (
299: struct recvbuf *rbufp
300: )
301: {
302: struct actsunit *up;
303: struct refclockproc *pp;
304: struct peer *peer;
305: char tbuf[BMAX];
306: char *tptr;
307:
308: /*
309: * Initialize pointers and read the timecode and timestamp. Note
310: * we are in raw mode and victim of whatever the terminal
311: * interface kicks up; so, we have to reassemble messages from
312: * arbitrary fragments. Capture the timecode at the beginning of
313: * the message and at the '*' and '#' on-time characters.
314: */
315: peer = (struct peer *)rbufp->recv_srcclock;
316: pp = peer->procptr;
317: up = (struct actsunit *)pp->unitptr;
318: pp->lencode = refclock_gtraw(rbufp, tbuf, BMAX - (up->bufptr -
319: pp->a_lastcode), &pp->lastrec);
320: for (tptr = tbuf; *tptr != '\0'; tptr++) {
321: if (*tptr == LF) {
322: if (up->bufptr == pp->a_lastcode) {
323: up->tstamp = pp->lastrec;
324: continue;
325:
326: } else {
327: *up->bufptr = '\0';
328: acts_message(peer);
329: up->bufptr = pp->a_lastcode;
330: }
331: } else if (!iscntrl(*tptr)) {
332: *up->bufptr++ = *tptr;
333: if (*tptr == '*' || *tptr == '#') {
334: up->tstamp = pp->lastrec;
335: write(pp->io.fd, tptr, 1);
336: }
337: }
338: }
339: }
340:
341:
342: /*
343: * acts_message - process message
344: */
345: void
346: acts_message(
347: struct peer *peer
348: )
349: {
350: struct actsunit *up;
351: struct refclockproc *pp;
352: int dtr = TIOCM_DTR;
353: char tbuf[SMAX];
354: #ifdef DEBUG
355: u_int modem;
356: #endif
357:
358: /*
359: * What to do depends on the state and the first token in the
360: * message. */
361: pp = peer->procptr;
362: up = (struct actsunit *)pp->unitptr;
363: #ifdef DEBUG
364: ioctl(pp->io.fd, TIOCMGET, (char *)&modem);
365: snprintf(tbuf, sizeof(tbuf), "acts: %04x (%d %d) %lu %s", modem,
366: up->state, up->timer, (u_long)strlen(pp->a_lastcode),
367: pp->a_lastcode);
368: if (debug)
369: printf("%s\n", tbuf);
370: #endif
371:
372: /*
373: * Extract the first token in the line. A NO token sends the
374: * message to the clockstats.
375: */
376: strncpy(tbuf, pp->a_lastcode, SMAX);
377: strtok(tbuf, " ");
378: if (strcmp(tbuf, "NO") == 0) {
379: report_event(PEVNT_CLOCK, peer, pp->a_lastcode);
380: return;
381: }
382: switch(up->state) {
383:
384: /*
385: * We are waiting for the OK response to the modem setup
386: * command. When this happens, raise DTR and dial the number
387: * followed by \r.
388: */
389: case S_OK:
390: if (strcmp(tbuf, "OK") != 0) {
391: msyslog(LOG_ERR, "acts: setup error %s",
392: pp->a_lastcode);
393: acts_disc(peer);
394: return;
395: }
396: ioctl(pp->io.fd, TIOCMBIS, (char *)&dtr);
397: up->state = S_DTR;
398: up->timer = DTR;
399: return;
400:
401: /*
402: * We are waiting for the call to be answered. All we care about
403: * here is token CONNECT. Send the message to the clockstats.
404: */
405: case S_CONNECT:
406: report_event(PEVNT_CLOCK, peer, pp->a_lastcode);
407: if (strcmp(tbuf, "CONNECT") != 0) {
408: acts_disc(peer);
409: return;
410: }
411: up->state = S_FIRST;
412: up->timer = CONNECT;
413: return;
414:
415: /*
416: * We are waiting for a timecode. Pass it to the parser.
417: */
418: case S_FIRST:
419: case S_MSG:
420: acts_timecode(peer, pp->a_lastcode);
421: break;
422: }
423: }
424:
425: /*
426: * acts_timecode - identify the service and parse the timecode message
427: */
428: void
429: acts_timecode(
430: struct peer *peer, /* peer structure pointer */
431: char *str /* timecode string */
432: )
433: {
434: struct actsunit *up;
435: struct refclockproc *pp;
436: int day; /* day of the month */
437: int month; /* month of the year */
438: u_long mjd; /* Modified Julian Day */
439: double dut1; /* DUT adjustment */
440:
441: u_int dst; /* ACTS daylight/standard time */
442: u_int leap; /* ACTS leap indicator */
443: double msADV; /* ACTS transmit advance (ms) */
444: char utc[10]; /* ACTS timescale */
445: char flag; /* ACTS on-time character (* or #) */
446:
447: char synchar; /* WWVB synchronized indicator */
448: char qualchar; /* WWVB quality indicator */
449: char leapchar; /* WWVB leap indicator */
450: char dstchar; /* WWVB daylight/savings indicator */
451: int tz; /* WWVB timezone */
452:
453: u_int leapmonth; /* PTB/NPL month of leap */
454: char leapdir; /* PTB/NPL leap direction */
455:
456: /*
457: * The parser selects the modem format based on the message
458: * length. Since the data are checked carefully, occasional
459: * errors due noise are forgivable.
460: */
461: pp = peer->procptr;
462: up = (struct actsunit *)pp->unitptr;
463: pp->nsec = 0;
464: switch(strlen(str)) {
465:
466: /*
467: * For USNO format on-time character '*', which is on a line by
468: * itself. Be sure a timecode has been received.
469: */
470: case 1:
471: if (*str == '*' && up->msgcnt > 0)
472: break;
473:
474: return;
475:
476: /*
477: * ACTS format: "jjjjj yy-mm-dd hh:mm:ss ds l uuu aaaaa
478: * UTC(NIST) *"
479: */
480: case LENACTS:
481: if (sscanf(str,
482: "%5ld %2d-%2d-%2d %2d:%2d:%2d %2d %1d %3lf %5lf %9s %c",
483: &mjd, &pp->year, &month, &day, &pp->hour,
484: &pp->minute, &pp->second, &dst, &leap, &dut1,
485: &msADV, utc, &flag) != 13) {
486: refclock_report(peer, CEVNT_BADREPLY);
487: return;
488: }
489:
490: /*
491: * Wait until ACTS has calculated the roundtrip delay.
492: * We don't need to do anything, as ACTS adjusts the
493: * on-time epoch.
494: */
495: if (flag != '#')
496: return;
497:
498: pp->day = ymd2yd(pp->year, month, day);
499: pp->leap = LEAP_NOWARNING;
500: if (leap == 1)
501: pp->leap = LEAP_ADDSECOND;
502: else if (pp->leap == 2)
503: pp->leap = LEAP_DELSECOND;
504: memcpy(&pp->refid, REFACTS, 4);
505: if (up->msgcnt == 0)
506: record_clock_stats(&peer->srcadr, str);
507: up->msgcnt++;
508: break;
509:
510: /*
511: * USNO format: "jjjjj nnn hhmmss UTC"
512: */
513: case LENUSNO:
514: if (sscanf(str, "%5ld %3d %2d%2d%2d %3s",
515: &mjd, &pp->day, &pp->hour, &pp->minute,
516: &pp->second, utc) != 6) {
517: refclock_report(peer, CEVNT_BADREPLY);
518: return;
519: }
520:
521: /*
522: * Wait for the on-time character, which follows in a
523: * separate message. There is no provision for leap
524: * warning.
525: */
526: pp->leap = LEAP_NOWARNING;
527: memcpy(&pp->refid, REFUSNO, 4);
528: if (up->msgcnt == 0)
529: record_clock_stats(&peer->srcadr, str);
530: up->msgcnt++;
531: return;
532:
533: /*
534: * PTB/NPL format: "yyyy-mm-dd hh:mm:ss MEZ"
535: */
536: case LENPTB:
537: if (sscanf(str,
538: "%*4d-%*2d-%*2d %*2d:%*2d:%2d %*5c%*12c%4d%2d%2d%2d%2d%5ld%2lf%c%2d%3lf%*15c%c",
539: &pp->second, &pp->year, &month, &day, &pp->hour,
540: &pp->minute, &mjd, &dut1, &leapdir, &leapmonth,
541: &msADV, &flag) != 12) {
542: refclock_report(peer, CEVNT_BADREPLY);
543: return;
544: }
545: pp->leap = LEAP_NOWARNING;
546: if (leapmonth == month) {
547: if (leapdir == '+')
548: pp->leap = LEAP_ADDSECOND;
549: else if (leapdir == '-')
550: pp->leap = LEAP_DELSECOND;
551: }
552: pp->day = ymd2yd(pp->year, month, day);
553: memcpy(&pp->refid, REFPTB, 4);
554: if (up->msgcnt == 0)
555: record_clock_stats(&peer->srcadr, str);
556: up->msgcnt++;
557: break;
558:
559:
560: /*
561: * WWVB format 0: "I ddd hh:mm:ss DTZ=nn"
562: */
563: case LENWWVB0:
564: if (sscanf(str, "%c %3d %2d:%2d:%2d %cTZ=%2d",
565: &synchar, &pp->day, &pp->hour, &pp->minute,
566: &pp->second, &dstchar, &tz) != 7) {
567: refclock_report(peer, CEVNT_BADREPLY);
568: return;
569: }
570: pp->leap = LEAP_NOWARNING;
571: if (synchar != ' ')
572: pp->leap = LEAP_NOTINSYNC;
573: memcpy(&pp->refid, REFWWVB, 4);
574: if (up->msgcnt == 0)
575: record_clock_stats(&peer->srcadr, str);
576: up->msgcnt++;
577: break;
578:
579: /*
580: * WWVB format 2: "IQyy ddd hh:mm:ss.mmm LD"
581: */
582: case LENWWVB2:
583: if (sscanf(str, "%c%c%2d %3d %2d:%2d:%2d.%3ld%c%c%c",
584: &synchar, &qualchar, &pp->year, &pp->day,
585: &pp->hour, &pp->minute, &pp->second, &pp->nsec,
586: &dstchar, &leapchar, &dstchar) != 11) {
587: refclock_report(peer, CEVNT_BADREPLY);
588: return;
589: }
590: pp->nsec *= 1000000;
591: pp->leap = LEAP_NOWARNING;
592: if (synchar != ' ')
593: pp->leap = LEAP_NOTINSYNC;
594: else if (leapchar == 'L')
595: pp->leap = LEAP_ADDSECOND;
596: memcpy(&pp->refid, REFWWVB, 4);
597: if (up->msgcnt == 0)
598: record_clock_stats(&peer->srcadr, str);
599: up->msgcnt++;
600: break;
601:
602: /*
603: * None of the above. Just forget about it and wait for the next
604: * message or timeout.
605: */
606: default:
607: return;
608: }
609:
610: /*
611: * We have a valid timecode. The fudge time1 value is added to
612: * each sample by the main line routines. Note that in current
613: * telephone networks the propatation time can be different for
614: * each call and can reach 200 ms for some calls.
615: */
616: peer->refid = pp->refid;
617: pp->lastrec = up->tstamp;
618: if (!refclock_process(pp)) {
619: refclock_report(peer, CEVNT_BADTIME);
620: return;
621: }
622: pp->lastref = pp->lastrec;
623: if (up->state != S_MSG) {
624: up->state = S_MSG;
625: up->timer = TIMECODE;
626: }
627: }
628:
629:
630: /*
631: * acts_poll - called by the transmit routine
632: */
633: static void
634: acts_poll (
635: int unit,
636: struct peer *peer
637: )
638: {
639: struct actsunit *up;
640: struct refclockproc *pp;
641:
642: /*
643: * This routine is called at every system poll. All it does is
644: * set flag1 under certain conditions. The real work is done by
645: * the timeout routine and state machine.
646: */
647: pp = peer->procptr;
648: up = (struct actsunit *)pp->unitptr;
649: switch (peer->ttl) {
650:
651: /*
652: * In manual mode the calling program is activated by the ntpdc
653: * program using the enable flag (fudge flag1), either manually
654: * or by a cron job.
655: */
656: case MODE_MANUAL:
657: /* fall through */
658: break;
659:
660: /*
661: * In automatic mode the calling program runs continuously at
662: * intervals determined by the poll event or specified timeout.
663: */
664: case MODE_AUTO:
665: pp->sloppyclockflag |= CLK_FLAG1;
666: break;
667:
668: /*
669: * In backup mode the calling program runs continuously as long
670: * as either no peers are available or this peer is selected.
671: */
672: case MODE_BACKUP:
673: if (sys_peer == NULL || sys_peer == peer)
674: pp->sloppyclockflag |= CLK_FLAG1;
675: break;
676: }
677: }
678:
679:
680: /*
681: * acts_timer - called at one-second intervals
682: */
683: static void
684: acts_timer(
685: int unit,
686: struct peer *peer
687: )
688: {
689: struct actsunit *up;
690: struct refclockproc *pp;
691:
692: /*
693: * This routine implments a timeout which runs for a programmed
694: * interval. The counter is initialized by the state machine and
695: * counts down to zero. Upon reaching zero, the state machine is
696: * called. If flag1 is set while in S_IDLE state, force a
697: * timeout.
698: */
699: pp = peer->procptr;
700: up = (struct actsunit *)pp->unitptr;
701: if (pp->sloppyclockflag & CLK_FLAG1 && up->state == S_IDLE) {
702: acts_timeout(peer);
703: return;
704: }
705: if (up->timer == 0)
706: return;
707:
708: up->timer--;
709: if (up->timer == 0)
710: acts_timeout(peer);
711: }
712:
713:
714: /*
715: * acts_timeout - called on timeout
716: */
717: static void
718: acts_timeout(
719: struct peer *peer
720: )
721: {
722: struct actsunit *up;
723: struct refclockproc *pp;
724: int fd;
725: char device[20];
726: char lockfile[128], pidbuf[8];
727: char tbuf[SMAX];
728:
729: /*
730: * The state machine is driven by messages from the modem, when
731: * first stated and at timeout.
732: */
733: pp = peer->procptr;
734: up = (struct actsunit *)pp->unitptr;
735: pp->sloppyclockflag &= ~CLK_FLAG1;
736: if (sys_phone[up->retry] == NULL && !(pp->sloppyclockflag &
737: CLK_FLAG3)) {
738: msyslog(LOG_ERR, "acts: no phones");
739: return;
740: }
741: switch(up->state) {
742:
743: /*
744: * System poll event. Lock the modem port and open the device.
745: */
746: case S_IDLE:
747:
748: /*
749: * Lock the modem port. If busy, retry later. Note: if
750: * something fails between here and the close, the lock
751: * file may not be removed.
752: */
753: if (pp->sloppyclockflag & CLK_FLAG2) {
754: snprintf(lockfile, sizeof(lockfile), LOCKFILE,
755: up->unit);
756: fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL,
757: 0644);
758: if (fd < 0) {
759: msyslog(LOG_ERR, "acts: port busy");
760: return;
761: }
762: snprintf(pidbuf, sizeof(pidbuf), "%d\n",
763: (u_int)getpid());
764: write(fd, pidbuf, strlen(pidbuf));
765: close(fd);
766: }
767:
768: /*
769: * Open the device in raw mode and link the I/O.
770: */
771: if (!pp->io.fd) {
772: snprintf(device, sizeof(device), DEVICE,
773: up->unit);
774: fd = refclock_open(device, SPEED232,
775: LDISC_ACTS | LDISC_RAW | LDISC_REMOTE);
776: if (fd == 0) {
777: msyslog(LOG_ERR,
778: "acts: open fails");
779: return;
780: }
781: pp->io.fd = fd;
782: if (!io_addclock(&pp->io)) {
783: msyslog(LOG_ERR,
784: "acts: addclock fails");
785: close(fd);
786: pp->io.fd = 0;
787: return;
788: }
789: }
790:
791: /*
792: * If the port is directly connected to the device, skip
793: * the modem business and send 'T' for Spectrabum.
794: */
795: if (pp->sloppyclockflag & CLK_FLAG3) {
796: if (write(pp->io.fd, "T", 1) < 0) {
797: msyslog(LOG_ERR, "acts: write %m");
798: return;
799: }
800: up->state = S_FIRST;
801: up->timer = CONNECT;
802: return;
803: }
804:
805: /*
806: * Initialize the modem. This works with Hayes commands.
807: */
808: #ifdef DEBUG
809: if (debug)
810: printf("acts: setup %s\n", MODEM_SETUP);
811: #endif
812: if (write(pp->io.fd, MODEM_SETUP, strlen(MODEM_SETUP)) <
813: 0) {
814: msyslog(LOG_ERR, "acts: write %m");
815: return;
816: }
817: up->state = S_OK;
818: up->timer = SETUP;
819: return;
820:
821: /*
822: * In OK state the modem did not respond to setup.
823: */
824: case S_OK:
825: msyslog(LOG_ERR, "acts: no modem");
826: break;
827:
828: /*
829: * In DTR state we are waiting for the modem to settle down
830: * before hammering it with a dial command.
831: */
832: case S_DTR:
833: snprintf(tbuf, sizeof(tbuf), "DIAL #%d %s", up->retry,
834: sys_phone[up->retry]);
835: report_event(PEVNT_CLOCK, peer, tbuf);
836: #ifdef DEBUG
837: if (debug)
838: printf("%s\n", tbuf);
839: #endif
840: write(pp->io.fd, sys_phone[up->retry],
841: strlen(sys_phone[up->retry]));
842: write(pp->io.fd, "\r", 1);
843: up->state = S_CONNECT;
844: up->timer = ANSWER;
845: return;
846:
847: /*
848: * In CONNECT state the call did not complete.
849: */
850: case S_CONNECT:
851: msyslog(LOG_ERR, "acts: no answer");
852: break;
853:
854: /*
855: * In FIRST state no messages were received.
856: */
857: case S_FIRST:
858: msyslog(LOG_ERR, "acts: no messages");
859: break;
860:
861: /*
862: * In CLOSE state hangup is complete. Close the doors and
863: * windows and get some air.
864: */
865: case S_CLOSE:
866:
867: /*
868: * Close the device and unlock a shared modem.
869: */
870: if (pp->io.fd) {
871: io_closeclock(&pp->io);
872: close(pp->io.fd);
873: if (pp->sloppyclockflag & CLK_FLAG2) {
874: snprintf(lockfile, sizeof(lockfile),
875: LOCKFILE, up->unit);
876: unlink(lockfile);
877: }
878: pp->io.fd = 0;
879: }
880:
881: /*
882: * If messages were received, fold the tent and wait for
883: * the next poll. If no messages and there are more
884: * numbers to dial, retry after a short wait.
885: */
886: up->bufptr = pp->a_lastcode;
887: up->timer = 0;
888: up->state = S_IDLE;
889: if ( up->msgcnt == 0) {
890: up->retry++;
891: if (sys_phone[up->retry] == NULL)
892: up->retry = 0;
893: else
894: up->timer = SETUP;
895: } else {
896: up->retry = 0;
897: }
898: up->msgcnt = 0;
899: return;
900: }
901: acts_disc(peer);
902: }
903:
904:
905: /*
906: * acts_disc - disconnect the call and clean the place up.
907: */
908: static void
909: acts_disc (
910: struct peer *peer
911: )
912: {
913: struct actsunit *up;
914: struct refclockproc *pp;
915: int dtr = TIOCM_DTR;
916:
917: /*
918: * We get here if the call terminated successfully or if an
919: * error occured. If the median filter has something in it,
920: * feed the data to the clock filter. If a modem port, drop DTR
921: * to force command mode and send modem hangup.
922: */
923: pp = peer->procptr;
924: up = (struct actsunit *)pp->unitptr;
925: if (up->msgcnt > 0)
926: refclock_receive(peer);
927: if (!(pp->sloppyclockflag & CLK_FLAG3)) {
928: ioctl(pp->io.fd, TIOCMBIC, (char *)&dtr);
929: write(pp->io.fd, MODEM_HANGUP, strlen(MODEM_HANGUP));
930: }
931: up->timer = SETUP;
932: up->state = S_CLOSE;
933: }
934: #else
935: int refclock_acts_bs;
936: #endif /* REFCLOCK */