refclock_dumbclock.c revision 290001 
1/*
2 * refclock_dumbclock - clock driver for a unknown time distribution system
3 * that only provides hh:mm:ss (in local time, yet!).
4 */
5
6/*
7 * Must interpolate back to local time.  Very annoying.
8 */
9#define GET_LOCALTIME
10
11#ifdef HAVE_CONFIG_H
12#include <config.h>
13#endif
14
15#if defined(REFCLOCK) && defined(CLOCK_DUMBCLOCK)
16
17#include "ntpd.h"
18#include "ntp_io.h"
19#include "ntp_refclock.h"
20#include "ntp_calendar.h"
21#include "ntp_stdlib.h"
22
23#include <stdio.h>
24#include <ctype.h>
25
26#ifdef SYS_WINNT
27extern int async_write(int, const void *, unsigned int);
28#undef write
29#define write(fd, data, octets)	async_write(fd, data, octets)
30#endif
31
32/*
33 * This driver supports a generic dumb clock that only outputs hh:mm:ss,
34 * in local time, no less.
35 *
36 * Input format:
37 *
38 *	hh:mm:ss   <cr>
39 *
40 * hh:mm:ss -- what you'd expect, with a 24 hour clock.  (Heck, that's the only
41 * way it could get stupider.)  We take time on the <cr>.
42 *
43 * The original source of this module was the WWVB module.
44 */
45
46/*
47 * Interface definitions
48 */
49#define	DEVICE		"/dev/dumbclock%d" /* device name and unit */
50#define	SPEED232	B9600	/* uart speed (9600 baud) */
51#define	PRECISION	(-13)	/* precision assumed (about 100 us) */
52#define	REFID		"dumbclock"	/* reference ID */
53#define	DESCRIPTION	"Dumb clock" /* WRU */
54
55
56/*
57 * Insanity check.  Since the time is local, we need to make sure that during midnight
58 * transitions, we can convert back to Unix time.  If the conversion results in some number
59 * worse than this number of seconds away, assume the next day and retry.
60 */
61#define INSANE_SECONDS 3600
62
63/*
64 * Dumb clock control structure
65 */
66struct dumbclock_unit {
67	u_char	  tcswitch;	/* timecode switch */
68	l_fp	  laststamp;	/* last receive timestamp */
69	u_char	  lasthour;	/* last hour (for monitor) */
70	u_char	  linect;	/* count ignored lines (for monitor */
71	struct tm ymd;		/* struct tm for y/m/d only */
72};
73
74/*
75 * Function prototypes
76 */
77static	int	dumbclock_start		(int, struct peer *);
78static	void	dumbclock_shutdown	(int, struct peer *);
79static	void	dumbclock_receive	(struct recvbuf *);
80#if 0
81static	void	dumbclock_poll		(int, struct peer *);
82#endif
83
84/*
85 * Transfer vector
86 */
87struct	refclock refclock_dumbclock = {
88	dumbclock_start,		     /* start up driver */
89	dumbclock_shutdown,		     /* shut down driver */
90	noentry,			     /* poll the driver -- a nice fabrication */
91	noentry,			     /* not used */
92	noentry,			     /* not used */
93	noentry,			     /* not used */
94	NOFLAGS				     /* not used */
95};
96
97
98/*
99 * dumbclock_start - open the devices and initialize data for processing
100 */
101static int
102dumbclock_start(
103	int unit,
104	struct peer *peer
105	)
106{
107	register struct dumbclock_unit *up;
108	struct refclockproc *pp;
109	int fd;
110	char device[20];
111	struct tm *tm_time_p;
112	time_t     now;
113
114	/*
115	 * Open serial port. Don't bother with CLK line discipline, since
116	 * it's not available.
117	 */
118	snprintf(device, sizeof(device), DEVICE, unit);
119#ifdef DEBUG
120	if (debug)
121		printf ("starting Dumbclock with device %s\n",device);
122#endif
123	fd = refclock_open(device, SPEED232, 0);
124	if (fd <= 0)
125		return (0);
126
127	/*
128	 * Allocate and initialize unit structure
129	 */
130	up = emalloc_zero(sizeof(*up));
131	pp = peer->procptr;
132	pp->unitptr = up;
133	pp->io.clock_recv = dumbclock_receive;
134	pp->io.srcclock = peer;
135	pp->io.datalen = 0;
136	pp->io.fd = fd;
137	if (!io_addclock(&pp->io)) {
138		close(fd);
139		pp->io.fd = -1;
140		free(up);
141		pp->unitptr = NULL;
142		return (0);
143	}
144
145
146	time(&now);
147#ifdef GET_LOCALTIME
148	tm_time_p = localtime(&now);
149#else
150	tm_time_p = gmtime(&now);
151#endif
152	if (tm_time_p)
153		up->ymd = *tm_time_p;
154	else
155		return 0;
156
157	/*
158	 * Initialize miscellaneous variables
159	 */
160	peer->precision = PRECISION;
161	pp->clockdesc = DESCRIPTION;
162	memcpy((char *)&pp->refid, REFID, 4);
163	return (1);
164}
165
166
167/*
168 * dumbclock_shutdown - shut down the clock
169 */
170static void
171dumbclock_shutdown(
172	int unit,
173	struct peer *peer
174	)
175{
176	register struct dumbclock_unit *up;
177	struct refclockproc *pp;
178
179	pp = peer->procptr;
180	up = pp->unitptr;
181	if (-1 != pp->io.fd)
182		io_closeclock(&pp->io);
183	if (NULL != up)
184		free(up);
185}
186
187
188/*
189 * dumbclock_receive - receive data from the serial interface
190 */
191static void
192dumbclock_receive(
193	struct recvbuf *rbufp
194	)
195{
196	struct dumbclock_unit *up;
197	struct refclockproc *pp;
198	struct peer *peer;
199
200	l_fp	trtmp;		/* arrival timestamp */
201	int	hours;		/* hour-of-day */
202	int	minutes;	/* minutes-past-the-hour */
203	int	seconds;	/* seconds */
204	int	temp;		/* int temp */
205	int	got_good;	/* got a good time flag */
206
207	/*
208	 * Initialize pointers and read the timecode and timestamp
209	 */
210	peer = rbufp->recv_peer;
211	pp = peer->procptr;
212	up = pp->unitptr;
213	temp = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
214
215	if (temp == 0) {
216		if (up->tcswitch == 0) {
217			up->tcswitch = 1;
218			up->laststamp = trtmp;
219		} else
220			up->tcswitch = 0;
221		return;
222	}
223	pp->lencode = (u_short)temp;
224	pp->lastrec = up->laststamp;
225	up->laststamp = trtmp;
226	up->tcswitch = 1;
227
228#ifdef DEBUG
229	if (debug)
230		printf("dumbclock: timecode %d %s\n",
231		       pp->lencode, pp->a_lastcode);
232#endif
233
234	/*
235	 * We get down to business. Check the timecode format...
236	 */
237	got_good=0;
238	if (sscanf(pp->a_lastcode,"%02d:%02d:%02d",
239		   &hours,&minutes,&seconds) == 3)
240	{
241	    struct tm *gmtp;
242	    struct tm *lt_p;
243	    time_t     asserted_time;	     /* the SPM time based on the composite time+date */
244	    struct tm  asserted_tm;	     /* the struct tm of the same */
245	    int        adjyear;
246	    int        adjmon;
247	    time_t     reality_delta;
248	    time_t     now;
249
250
251	    /*
252	     * Convert to GMT for sites that distribute localtime.  This
253	     * means we have to figure out what day it is.  Easier said
254	     * than done...
255	     */
256
257	    memset(&asserted_tm, 0, sizeof(asserted_tm));
258
259	    asserted_tm.tm_year  = up->ymd.tm_year;
260	    asserted_tm.tm_mon   = up->ymd.tm_mon;
261	    asserted_tm.tm_mday  = up->ymd.tm_mday;
262	    asserted_tm.tm_hour  = hours;
263	    asserted_tm.tm_min   = minutes;
264	    asserted_tm.tm_sec   = seconds;
265	    asserted_tm.tm_isdst = -1;
266
267#ifdef GET_LOCALTIME
268	    asserted_time = mktime (&asserted_tm);
269	    time(&now);
270#else
271#include "GMT unsupported for dumbclock!"
272#endif
273	    reality_delta = asserted_time - now;
274
275	    /*
276	     * We assume that if the time is grossly wrong, it's because we got the
277	     * year/month/day wrong.
278	     */
279	    if (reality_delta > INSANE_SECONDS)
280	    {
281		asserted_time -= SECSPERDAY; /* local clock behind real time */
282	    }
283	    else if (-reality_delta > INSANE_SECONDS)
284	    {
285		asserted_time += SECSPERDAY; /* local clock ahead of real time */
286	    }
287	    lt_p = localtime(&asserted_time);
288	    if (lt_p)
289	    {
290		up->ymd = *lt_p;
291	    }
292	    else
293	    {
294		refclock_report (peer, CEVNT_FAULT);
295		return;
296	    }
297
298	    if ((gmtp = gmtime (&asserted_time)) == NULL)
299	    {
300		refclock_report (peer, CEVNT_FAULT);
301		return;
302	    }
303	    adjyear = gmtp->tm_year+1900;
304	    adjmon  = gmtp->tm_mon+1;
305	    pp->day = ymd2yd (adjyear, adjmon, gmtp->tm_mday);
306	    pp->hour   = gmtp->tm_hour;
307	    pp->minute = gmtp->tm_min;
308	    pp->second = gmtp->tm_sec;
309#ifdef DEBUG
310	    if (debug)
311		printf ("time is %04d/%02d/%02d %02d:%02d:%02d UTC\n",
312			adjyear,adjmon,gmtp->tm_mday,pp->hour,pp->minute,
313			pp->second);
314#endif
315
316	    got_good=1;
317	}
318
319	if (!got_good)
320	{
321	    if (up->linect > 0)
322	    	up->linect--;
323	    else
324	    	refclock_report(peer, CEVNT_BADREPLY);
325	    return;
326	}
327
328	/*
329	 * Process the new sample in the median filter and determine the
330	 * timecode timestamp.
331	 */
332	if (!refclock_process(pp)) {
333		refclock_report(peer, CEVNT_BADTIME);
334		return;
335	}
336	pp->lastref = pp->lastrec;
337	refclock_receive(peer);
338	record_clock_stats(&peer->srcadr, pp->a_lastcode);
339	up->lasthour = (u_char)pp->hour;
340}
341
342#if 0
343/*
344 * dumbclock_poll - called by the transmit procedure
345 */
346static void
347dumbclock_poll(
348	int unit,
349	struct peer *peer
350	)
351{
352	register struct dumbclock_unit *up;
353	struct refclockproc *pp;
354	char pollchar;
355
356	/*
357	 * Time to poll the clock. The Chrono-log clock is supposed to
358	 * respond to a 'T' by returning a timecode in the format(s)
359	 * specified above.  Ours does (can?) not, but this seems to be
360	 * an installation-specific problem.  This code is dyked out,
361	 * but may be re-enabled if anyone ever finds a Chrono-log that
362	 * actually listens to this command.
363	 */
364#if 0
365	pp = peer->procptr;
366	up = pp->unitptr;
367	if (peer->reach == 0)
368		refclock_report(peer, CEVNT_TIMEOUT);
369	if (up->linect > 0)
370		pollchar = 'R';
371	else
372		pollchar = 'T';
373	if (write(pp->io.fd, &pollchar, 1) != 1)
374		refclock_report(peer, CEVNT_FAULT);
375	else
376		pp->polls++;
377#endif
378}
379#endif
380
381#else
382int refclock_dumbclock_bs;
383#endif	/* defined(REFCLOCK) && defined(CLOCK_DUMBCLOCK) */
384