?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Patrick Welche <prlw1@cam.ac.uk>
[netbsd-mini2440.git] / external / bsd / ntp / dist / parseutil / dcfd.c
blob88d36cceaf7ba4d24dcdf7c84772f3a1a87cb3e6
1 /* $NetBSD$ */
2
3 /*
4 * /src/NTP/REPOSITORY/ntp4-dev/parseutil/dcfd.c,v 4.18 2005/10/07 22:08:18 kardel RELEASE_20051008_A
5 *
6 * dcfd.c,v 4.18 2005/10/07 22:08:18 kardel RELEASE_20051008_A
7 *
8 * DCF77 100/200ms pulse synchronisation daemon program (via 50Baud serial line)
9 *
10 * Features:
11 * DCF77 decoding
12 * simple NTP loopfilter logic for local clock
13 * interactive display for debugging
14 *
15 * Lacks:
16 * Leap second handling (at that level you should switch to NTP Version 4 - really!)
17 *
18 * Copyright (c) 1995-2005 by Frank Kardel <kardel <AT> ntp.org>
19 * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
20 *
21 * Redistribution and use in source and binary forms, with or without
22 * modification, are permitted provided that the following conditions
23 * are met:
24 * 1. Redistributions of source code must retain the above copyright
25 * notice, this list of conditions and the following disclaimer.
26 * 2. Redistributions in binary form must reproduce the above copyright
27 * notice, this list of conditions and the following disclaimer in the
28 * documentation and/or other materials provided with the distribution.
29 * 3. Neither the name of the author nor the names of its contributors
30 * may be used to endorse or promote products derived from this software
31 * without specific prior written permission.
32 *
33 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
34 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
37 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
41 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
42 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43 * SUCH DAMAGE.
44 *
45 */
46
47 #ifdef HAVE_CONFIG_H
48 # include <config.h>
49 #endif
50
51 #include <sys/ioctl.h>
52 #include <unistd.h>
53 #include <stdio.h>
54 #include <fcntl.h>
55 #include <sys/types.h>
56 #include <sys/time.h>
57 #include <signal.h>
58 #include <syslog.h>
59 #include <time.h>
60
61 /*
62 * NTP compilation environment
63 */
64 #include "ntp_stdlib.h"
65 #include "ntpd.h" /* indirectly include ntp.h to get YEAR_PIVOT Y2KFixes */
66
67 /*
68 * select which terminal handling to use (currently only SysV variants)
69 */
70 #if defined(HAVE_TERMIOS_H) || defined(STREAM)
71 #include <termios.h>
72 #define TTY_GETATTR(_FD_, _ARG_) tcgetattr((_FD_), (_ARG_))
73 #define TTY_SETATTR(_FD_, _ARG_) tcsetattr((_FD_), TCSANOW, (_ARG_))
74 #else /* not HAVE_TERMIOS_H || STREAM */
75 # if defined(HAVE_TERMIO_H) || defined(HAVE_SYSV_TTYS)
76 # include <termio.h>
77 # define TTY_GETATTR(_FD_, _ARG_) ioctl((_FD_), TCGETA, (_ARG_))
78 # define TTY_SETATTR(_FD_, _ARG_) ioctl((_FD_), TCSETAW, (_ARG_))
79 # endif/* HAVE_TERMIO_H || HAVE_SYSV_TTYS */
80 #endif /* not HAVE_TERMIOS_H || STREAM */
81
82
83 #ifndef TTY_GETATTR
84 #include "Bletch: MUST DEFINE ONE OF 'HAVE_TERMIOS_H' or 'HAVE_TERMIO_H'"
85 #endif
86
87 #ifndef days_per_year
88 #define days_per_year(_x_) (((_x_) % 4) ? 365 : (((_x_) % 400) ? 365 : 366))
89 #endif
90
91 #define timernormalize(_a_) \
92 if ((_a_)->tv_usec >= 1000000) \
93 { \
94 (_a_)->tv_sec += (_a_)->tv_usec / 1000000; \
95 (_a_)->tv_usec = (_a_)->tv_usec % 1000000; \
96 } \
97 if ((_a_)->tv_usec < 0) \
98 { \
99 (_a_)->tv_sec -= 1 + (-(_a_)->tv_usec / 1000000); \
100 (_a_)->tv_usec = 999999 - (-(_a_)->tv_usec - 1); \
101 }
102
103 #ifdef timeradd
104 #undef timeradd
105 #endif
106 #define timeradd(_a_, _b_) \
107 (_a_)->tv_sec += (_b_)->tv_sec; \
108 (_a_)->tv_usec += (_b_)->tv_usec; \
109 timernormalize((_a_))
110
111 #ifdef timersub
112 #undef timersub
113 #endif
114 #define timersub(_a_, _b_) \
115 (_a_)->tv_sec -= (_b_)->tv_sec; \
116 (_a_)->tv_usec -= (_b_)->tv_usec; \
117 timernormalize((_a_))
118
119 /*
120 * debug macros
121 */
122 #define PRINTF if (interactive) printf
123 #define LPRINTF if (interactive && loop_filter_debug) printf
124
125 #ifdef DEBUG
126 #define dprintf(_x_) LPRINTF _x_
127 #else
128 #define dprintf(_x_)
129 #endif
130
131 #ifdef DECL_ERRNO
132 extern int errno;
133 #endif
134
135 static char *revision = "4.18";
136
137 /*
138 * display received data (avoids also detaching from tty)
139 */
140 static int interactive = 0;
141
142 /*
143 * display loopfilter (clock control) variables
144 */
145 static int loop_filter_debug = 0;
146
147 /*
148 * do not set/adjust system time
149 */
150 static int no_set = 0;
151
152 /*
153 * time that passes between start of DCF impulse and time stamping (fine
154 * adjustment) in microseconds (receiver/OS dependent)
155 */
156 #define DEFAULT_DELAY 230000 /* rough estimate */
157
158 /*
159 * The two states we can be in - eithe we receive nothing
160 * usable or we have the correct time
161 */
162 #define NO_SYNC 0x01
163 #define SYNC 0x02
164
165 static int sync_state = NO_SYNC;
166 static time_t last_sync;
167
168 static unsigned long ticks = 0;
169
170 static char pat[] = "-\\|/";
171
172 #define LINES (24-2) /* error lines after which the two headlines are repeated */
173
174 #define MAX_UNSYNC (10*60) /* allow synchronisation loss for 10 minutes */
175 #define NOTICE_INTERVAL (20*60) /* mention missing synchronisation every 20 minutes */
176
177 /*
178 * clock adjustment PLL - see NTP protocol spec (RFC1305) for details
179 */
180
181 #define USECSCALE 10
182 #define TIMECONSTANT 2
183 #define ADJINTERVAL 0
184 #define FREQ_WEIGHT 18
185 #define PHASE_WEIGHT 7
186 #define MAX_DRIFT 0x3FFFFFFF
187
188 #define R_SHIFT(_X_, _Y_) (((_X_) < 0) ? -(-(_X_) >> (_Y_)) : ((_X_) >> (_Y_)))
189
190 static long max_adj_offset_usec = 128000;
191
192 static long clock_adjust = 0; /* current adjustment value (usec * 2^USECSCALE) */
193 static long accum_drift = 0; /* accumulated drift value (usec / ADJINTERVAL) */
194 static long adjustments = 0;
195 static char skip_adjust = 1; /* discard first adjustment (bad samples) */
196
197 /*
198 * DCF77 state flags
199 */
200 #define DCFB_ANNOUNCE 0x0001 /* switch time zone warning (DST switch) */
201 #define DCFB_DST 0x0002 /* DST in effect */
202 #define DCFB_LEAP 0x0004 /* LEAP warning (1 hour prior to occurrence) */
203 #define DCFB_ALTERNATE 0x0008 /* alternate antenna used */
204
205 struct clocktime /* clock time broken up from time code */
206 {
207 long wday; /* Day of week: 1: Monday - 7: Sunday */
208 long day;
209 long month;
210 long year;
211 long hour;
212 long minute;
213 long second;
214 long usecond;
215 long utcoffset; /* in minutes */
216 long flags; /* current clock status (DCF77 state flags) */
217 };
218
219 typedef struct clocktime clocktime_t;
220
221 /*
222 * (usually) quick constant multiplications
223 */
224 #define TIMES10(_X_) (((_X_) << 3) + ((_X_) << 1)) /* *8 + *2 */
225 #define TIMES24(_X_) (((_X_) << 4) + ((_X_) << 3)) /* *16 + *8 */
226 #define TIMES60(_X_) ((((_X_) << 4) - (_X_)) << 2) /* *(16 - 1) *4 */
227 /*
228 * generic l_abs() function
229 */
230 #define l_abs(_x_) (((_x_) < 0) ? -(_x_) : (_x_))
231
232 /*
233 * conversion related return/error codes
234 */
235 #define CVT_MASK 0x0000000F /* conversion exit code */
236 #define CVT_NONE 0x00000001 /* format not applicable */
237 #define CVT_FAIL 0x00000002 /* conversion failed - error code returned */
238 #define CVT_OK 0x00000004 /* conversion succeeded */
239 #define CVT_BADFMT 0x00000010 /* general format error - (unparsable) */
240 #define CVT_BADDATE 0x00000020 /* invalid date */
241 #define CVT_BADTIME 0x00000040 /* invalid time */
242
243 /*
244 * DCF77 raw time code
245 *
246 * From "Zur Zeit", Physikalisch-Technische Bundesanstalt (PTB), Braunschweig
247 * und Berlin, Maerz 1989
248 *
249 * Timecode transmission:
250 * AM:
251 * time marks are send every second except for the second before the
252 * next minute mark
253 * time marks consist of a reduction of transmitter power to 25%
254 * of the nominal level
255 * the falling edge is the time indication (on time)
256 * time marks of a 100ms duration constitute a logical 0
257 * time marks of a 200ms duration constitute a logical 1
258 * FM:
259 * see the spec. (basically a (non-)inverted psuedo random phase shift)
260 *
261 * Encoding:
262 * Second Contents
263 * 0 - 10 AM: free, FM: 0
264 * 11 - 14 free
265 * 15 R - alternate antenna
266 * 16 A1 - expect zone change (1 hour before)
267 * 17 - 18 Z1,Z2 - time zone
268 * 0 0 illegal
269 * 0 1 MEZ (MET)
270 * 1 0 MESZ (MED, MET DST)
271 * 1 1 illegal
272 * 19 A2 - expect leap insertion/deletion (1 hour before)
273 * 20 S - start of time code (1)
274 * 21 - 24 M1 - BCD (lsb first) Minutes
275 * 25 - 27 M10 - BCD (lsb first) 10 Minutes
276 * 28 P1 - Minute Parity (even)
277 * 29 - 32 H1 - BCD (lsb first) Hours
278 * 33 - 34 H10 - BCD (lsb first) 10 Hours
279 * 35 P2 - Hour Parity (even)
280 * 36 - 39 D1 - BCD (lsb first) Days
281 * 40 - 41 D10 - BCD (lsb first) 10 Days
282 * 42 - 44 DW - BCD (lsb first) day of week (1: Monday -> 7: Sunday)
283 * 45 - 49 MO - BCD (lsb first) Month
284 * 50 MO0 - 10 Months
285 * 51 - 53 Y1 - BCD (lsb first) Years
286 * 54 - 57 Y10 - BCD (lsb first) 10 Years
287 * 58 P3 - Date Parity (even)
288 * 59 - usually missing (minute indication), except for leap insertion
289 */
290
291 /*-----------------------------------------------------------------------
292 * conversion table to map DCF77 bit stream into data fields.
293 * Encoding:
294 * Each field of the DCF77 code is described with two adjacent entries in
295 * this table. The first entry specifies the offset into the DCF77 data stream
296 * while the length is given as the difference between the start index and
297 * the start index of the following field.
298 */
299 static struct rawdcfcode
300 {
301 char offset; /* start bit */
302 } rawdcfcode[] =
303 {
304 { 0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 },
305 { 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 }
306 };
307
308 /*-----------------------------------------------------------------------
309 * symbolic names for the fields of DCF77 describes in "rawdcfcode".
310 * see comment above for the structure of the DCF77 data
311 */
312 #define DCF_M 0
313 #define DCF_R 1
314 #define DCF_A1 2
315 #define DCF_Z 3
316 #define DCF_A2 4
317 #define DCF_S 5
318 #define DCF_M1 6
319 #define DCF_M10 7
320 #define DCF_P1 8
321 #define DCF_H1 9
322 #define DCF_H10 10
323 #define DCF_P2 11
324 #define DCF_D1 12
325 #define DCF_D10 13
326 #define DCF_DW 14
327 #define DCF_MO 15
328 #define DCF_MO0 16
329 #define DCF_Y1 17
330 #define DCF_Y10 18
331 #define DCF_P3 19
332
333 /*-----------------------------------------------------------------------
334 * parity field table (same encoding as rawdcfcode)
335 * This table describes the sections of the DCF77 code that are
336 * parity protected
337 */
338 static struct partab
339 {
340 char offset; /* start bit of parity field */
341 } partab[] =
342 {
343 { 21 }, { 29 }, { 36 }, { 59 }
344 };
345
346 /*-----------------------------------------------------------------------
347 * offsets for parity field descriptions
348 */
349 #define DCF_P_P1 0
350 #define DCF_P_P2 1
351 #define DCF_P_P3 2
352
353 /*-----------------------------------------------------------------------
354 * legal values for time zone information
355 */
356 #define DCF_Z_MET 0x2
357 #define DCF_Z_MED 0x1
358
359 /*-----------------------------------------------------------------------
360 * symbolic representation if the DCF77 data stream
361 */
362 static struct dcfparam
363 {
364 unsigned char onebits[60];
365 unsigned char zerobits[60];
366 } dcfparam =
367 {
368 "###############RADMLS1248124P124812P1248121241248112481248P", /* 'ONE' representation */
369 "--------------------s-------p------p----------------------p" /* 'ZERO' representation */
370 };
371
372 /*-----------------------------------------------------------------------
373 * extract a bitfield from DCF77 datastream
374 * All numeric fields are LSB first.
375 * buf holds a pointer to a DCF77 data buffer in symbolic
376 * representation
377 * idx holds the index to the field description in rawdcfcode
378 */
379 static unsigned long
380 ext_bf(
381 register unsigned char *buf,
382 register int idx
383 )
384 {
385 register unsigned long sum = 0;
386 register int i, first;
387
388 first = rawdcfcode[idx].offset;
389
390 for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--)
391 {
392 sum <<= 1;
393 sum |= (buf[i] != dcfparam.zerobits[i]);
394 }
395 return sum;
396 }
397
398 /*-----------------------------------------------------------------------
399 * check even parity integrity for a bitfield
400 *
401 * buf holds a pointer to a DCF77 data buffer in symbolic
402 * representation
403 * idx holds the index to the field description in partab
404 */
405 static unsigned
406 pcheck(
407 register unsigned char *buf,
408 register int idx
409 )
410 {
411 register int i,last;
412 register unsigned psum = 1;
413
414 last = partab[idx+1].offset;
415
416 for (i = partab[idx].offset; i < last; i++)
417 psum ^= (buf[i] != dcfparam.zerobits[i]);
418
419 return psum;
420 }
421
422 /*-----------------------------------------------------------------------
423 * convert a DCF77 data buffer into wall clock time + flags
424 *
425 * buffer holds a pointer to a DCF77 data buffer in symbolic
426 * representation
427 * size describes the length of DCF77 information in bits (represented
428 * as chars in symbolic notation
429 * clock points to a wall clock time description of the DCF77 data (result)
430 */
431 static unsigned long
432 convert_rawdcf(
433 unsigned char *buffer,
434 int size,
435 clocktime_t *clock_time
436 )
437 {
438 if (size < 57)
439 {
440 PRINTF("%-30s", "*** INCOMPLETE");
441 return CVT_NONE;
442 }
443
444 /*
445 * check Start and Parity bits
446 */
447 if ((ext_bf(buffer, DCF_S) == 1) &&
448 pcheck(buffer, DCF_P_P1) &&
449 pcheck(buffer, DCF_P_P2) &&
450 pcheck(buffer, DCF_P_P3))
451 {
452 /*
453 * buffer OK - extract all fields and build wall clock time from them
454 */
455
456 clock_time->flags = 0;
457 clock_time->usecond= 0;
458 clock_time->second = 0;
459 clock_time->minute = ext_bf(buffer, DCF_M10);
460 clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1);
461 clock_time->hour = ext_bf(buffer, DCF_H10);
462 clock_time->hour = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1);
463 clock_time->day = ext_bf(buffer, DCF_D10);
464 clock_time->day = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1);
465 clock_time->month = ext_bf(buffer, DCF_MO0);
466 clock_time->month = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO);
467 clock_time->year = ext_bf(buffer, DCF_Y10);
468 clock_time->year = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1);
469 clock_time->wday = ext_bf(buffer, DCF_DW);
470
471 /*
472 * determine offset to UTC by examining the time zone
473 */
474 switch (ext_bf(buffer, DCF_Z))
475 {
476 case DCF_Z_MET:
477 clock_time->utcoffset = -60;
478 break;
479
480 case DCF_Z_MED:
481 clock_time->flags |= DCFB_DST;
482 clock_time->utcoffset = -120;
483 break;
484
485 default:
486 PRINTF("%-30s", "*** BAD TIME ZONE");
487 return CVT_FAIL|CVT_BADFMT;
488 }
489
490 /*
491 * extract various warnings from DCF77
492 */
493 if (ext_bf(buffer, DCF_A1))
494 clock_time->flags |= DCFB_ANNOUNCE;
495
496 if (ext_bf(buffer, DCF_A2))
497 clock_time->flags |= DCFB_LEAP;
498
499 if (ext_bf(buffer, DCF_R))
500 clock_time->flags |= DCFB_ALTERNATE;
501
502 return CVT_OK;
503 }
504 else
505 {
506 /*
507 * bad format - not for us
508 */
509 PRINTF("%-30s", "*** BAD FORMAT (invalid/parity)");
510 return CVT_FAIL|CVT_BADFMT;
511 }
512 }
513
514 /*-----------------------------------------------------------------------
515 * raw dcf input routine - fix up 50 baud
516 * characters for 1/0 decision
517 */
518 static unsigned long
519 cvt_rawdcf(
520 unsigned char *buffer,
521 int size,
522 clocktime_t *clock_time
523 )
524 {
525 register unsigned char *s = buffer;
526 register unsigned char *e = buffer + size;
527 register unsigned char *b = dcfparam.onebits;
528 register unsigned char *c = dcfparam.zerobits;
529 register unsigned rtc = CVT_NONE;
530 register unsigned int i, lowmax, highmax, cutoff, span;
531 #define BITS 9
532 unsigned char histbuf[BITS];
533 /*
534 * the input buffer contains characters with runs of consecutive
535 * bits set. These set bits are an indication of the DCF77 pulse
536 * length. We assume that we receive the pulse at 50 Baud. Thus
537 * a 100ms pulse would generate a 4 bit train (20ms per bit and
538 * start bit)
539 * a 200ms pulse would create all zeroes (and probably a frame error)
540 *
541 * The basic idea is that on corret reception we must have two
542 * maxima in the pulse length distribution histogram. (one for
543 * the zero representing pulses and one for the one representing
544 * pulses)
545 * There will always be ones in the datastream, thus we have to see
546 * two maxima.
547 * The best point to cut for a 1/0 decision is the minimum between those
548 * between the maxima. The following code tries to find this cutoff point.
549 */
550
551 /*
552 * clear histogram buffer
553 */
554 for (i = 0; i < BITS; i++)
555 {
556 histbuf[i] = 0;
557 }
558
559 cutoff = 0;
560 lowmax = 0;
561
562 /*
563 * convert sequences of set bits into bits counts updating
564 * the histogram alongway
565 */
566 while (s < e)
567 {
568 register unsigned int ch = *s ^ 0xFF;
569 /*
570 * check integrity and update histogramm
571 */
572 if (!((ch+1) & ch) || !*s)
573 {
574 /*
575 * character ok
576 */
577 for (i = 0; ch; i++)
578 {
579 ch >>= 1;
580 }
581
582 *s = i;
583 histbuf[i]++;
584 cutoff += i;
585 lowmax++;
586 }
587 else
588 {
589 /*
590 * invalid character (no consecutive bit sequence)
591 */
592 dprintf(("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, s - buffer));
593 *s = (unsigned char)~0;
594 rtc = CVT_FAIL|CVT_BADFMT;
595 }
596 s++;
597 }
598
599 /*
600 * first cutoff estimate (average bit count - must be between both
601 * maxima)
602 */
603 if (lowmax)
604 {
605 cutoff /= lowmax;
606 }
607 else
608 {
609 cutoff = 4; /* doesn't really matter - it'll fail anyway, but gives error output */
610 }
611
612 dprintf(("parse: cvt_rawdcf: average bit count: %d\n", cutoff));
613
614 lowmax = 0; /* weighted sum */
615 highmax = 0; /* bitcount */
616
617 /*
618 * collect weighted sum of lower bits (left of initial guess)
619 */
620 dprintf(("parse: cvt_rawdcf: histogram:"));
621 for (i = 0; i <= cutoff; i++)
622 {
623 lowmax += histbuf[i] * i;
624 highmax += histbuf[i];
625 dprintf((" %d", histbuf[i]));
626 }
627 dprintf((" <M>"));
628
629 /*
630 * round up
631 */
632 lowmax += highmax / 2;
633
634 /*
635 * calculate lower bit maximum (weighted sum / bit count)
636 *
637 * avoid divide by zero
638 */
639 if (highmax)
640 {
641 lowmax /= highmax;
642 }
643 else
644 {
645 lowmax = 0;
646 }
647
648 highmax = 0; /* weighted sum of upper bits counts */
649 cutoff = 0; /* bitcount */
650
651 /*
652 * collect weighted sum of lower bits (right of initial guess)
653 */
654 for (; i < BITS; i++)
655 {
656 highmax+=histbuf[i] * i;
657 cutoff +=histbuf[i];
658 dprintf((" %d", histbuf[i]));
659 }
660 dprintf(("\n"));
661
662 /*
663 * determine upper maximum (weighted sum / bit count)
664 */
665 if (cutoff)
666 {
667 highmax /= cutoff;
668 }
669 else
670 {
671 highmax = BITS-1;
672 }
673
674 /*
675 * following now holds:
676 * lowmax <= cutoff(initial guess) <= highmax
677 * best cutoff is the minimum nearest to higher bits
678 */
679
680 /*
681 * find the minimum between lowmax and highmax (detecting
682 * possibly a minimum span)
683 */
684 span = cutoff = lowmax;
685 for (i = lowmax; i <= highmax; i++)
686 {
687 if (histbuf[cutoff] > histbuf[i])
688 {
689 /*
690 * got a new minimum move beginning of minimum (cutoff) and
691 * end of minimum (span) there
692 */
693 cutoff = span = i;
694 }
695 else
696 if (histbuf[cutoff] == histbuf[i])
697 {
698 /*
699 * minimum not better yet - but it spans more than
700 * one bit value - follow it
701 */
702 span = i;
703 }
704 }
705
706 /*
707 * cutoff point for 1/0 decision is the middle of the minimum section
708 * in the histogram
709 */
710 cutoff = (cutoff + span) / 2;
711
712 dprintf(("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff));
713
714 /*
715 * convert the bit counts to symbolic 1/0 information for data conversion
716 */
717 s = buffer;
718 while ((s < e) && *c && *b)
719 {
720 if (*s == (unsigned char)~0)
721 {
722 /*
723 * invalid character
724 */
725 *s = '?';
726 }
727 else
728 {
729 /*
730 * symbolic 1/0 representation
731 */
732 *s = (*s >= cutoff) ? *b : *c;
733 }
734 s++;
735 b++;
736 c++;
737 }
738
739 /*
740 * if everything went well so far return the result of the symbolic
741 * conversion routine else just the accumulated errors
742 */
743 if (rtc != CVT_NONE)
744 {
745 PRINTF("%-30s", "*** BAD DATA");
746 }
747
748 return (rtc == CVT_NONE) ? convert_rawdcf(buffer, size, clock_time) : rtc;
749 }
750
751 /*-----------------------------------------------------------------------
752 * convert a wall clock time description of DCF77 to a Unix time (seconds
753 * since 1.1. 1970 UTC)
754 */
755 static time_t
756 dcf_to_unixtime(
757 clocktime_t *clock_time,
758 unsigned *cvtrtc
759 )
760 {
761 #define SETRTC(_X_) { if (cvtrtc) *cvtrtc = (_X_); }
762 static int days_of_month[] =
763 {
764 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
765 };
766 register int i;
767 time_t t;
768
769 /*
770 * map 2 digit years to 19xx (DCF77 is a 20th century item)
771 */
772 if ( clock_time->year < YEAR_PIVOT ) /* in case of Y2KFixes [ */
773 clock_time->year += 100; /* *year%100, make tm_year */
774 /* *(do we need this?) */
775 if ( clock_time->year < YEAR_BREAK ) /* (failsafe if) */
776 clock_time->year += 1900; /* Y2KFixes ] */
777
778 /*
779 * must have been a really bad year code - drop it
780 */
781 if (clock_time->year < (YEAR_PIVOT + 1900) ) /* Y2KFixes */
782 {
783 SETRTC(CVT_FAIL|CVT_BADDATE);
784 return -1;
785 }
786 /*
787 * sorry, slow section here - but it's not time critical anyway
788 */
789
790 /*
791 * calculate days since 1970 (watching leap years)
792 */
793 t = julian0( clock_time->year ) - julian0( 1970 );
794
795 /* month */
796 if (clock_time->month <= 0 || clock_time->month > 12)
797 {
798 SETRTC(CVT_FAIL|CVT_BADDATE);
799 return -1; /* bad month */
800 }
801 /* adjust current leap year */
802 #if 0
803 if (clock_time->month < 3 && days_per_year(clock_time->year) == 366)
804 t--;
805 #endif
806
807 /*
808 * collect days from months excluding the current one
809 */
810 for (i = 1; i < clock_time->month; i++)
811 {
812 t += days_of_month[i];
813 }
814 /* day */
815 if (clock_time->day < 1 || ((clock_time->month == 2 && days_per_year(clock_time->year) == 366) ?
816 clock_time->day > 29 : clock_time->day > days_of_month[clock_time->month]))
817 {
818 SETRTC(CVT_FAIL|CVT_BADDATE);
819 return -1; /* bad day */
820 }
821
822 /*
823 * collect days from date excluding the current one
824 */
825 t += clock_time->day - 1;
826
827 /* hour */
828 if (clock_time->hour < 0 || clock_time->hour >= 24)
829 {
830 SETRTC(CVT_FAIL|CVT_BADTIME);
831 return -1; /* bad hour */
832 }
833
834 /*
835 * calculate hours from 1. 1. 1970
836 */
837 t = TIMES24(t) + clock_time->hour;
838
839 /* min */
840 if (clock_time->minute < 0 || clock_time->minute > 59)
841 {
842 SETRTC(CVT_FAIL|CVT_BADTIME);
843 return -1; /* bad min */
844 }
845
846 /*
847 * calculate minutes from 1. 1. 1970
848 */
849 t = TIMES60(t) + clock_time->minute;
850 /* sec */
851
852 /*
853 * calculate UTC in minutes
854 */
855 t += clock_time->utcoffset;
856
857 if (clock_time->second < 0 || clock_time->second > 60) /* allow for LEAPs */
858 {
859 SETRTC(CVT_FAIL|CVT_BADTIME);
860 return -1; /* bad sec */
861 }
862
863 /*
864 * calculate UTC in seconds - phew !
865 */
866 t = TIMES60(t) + clock_time->second;
867 /* done */
868 return t;
869 }
870
871 /*-----------------------------------------------------------------------
872 * cheap half baked 1/0 decision - for interactive operation only
873 */
874 static char
875 type(
876 unsigned int c
877 )
878 {
879 c ^= 0xFF;
880 return (c > 0xF);
881 }
882
883 /*-----------------------------------------------------------------------
884 * week day representation
885 */
886 static const char *wday[8] =
887 {
888 "??",
889 "Mo",
890 "Tu",
891 "We",
892 "Th",
893 "Fr",
894 "Sa",
895 "Su"
896 };
897
898 /*-----------------------------------------------------------------------
899 * generate a string representation for a timeval
900 */
901 static char *
902 pr_timeval(
903 struct timeval *val
904 )
905 {
906 static char buf[20];
907
908 if (val->tv_sec == 0)
909 sprintf(buf, "%c0.%06ld", (val->tv_usec < 0) ? '-' : '+', (long int)l_abs(val->tv_usec));
910 else
911 sprintf(buf, "%ld.%06ld", (long int)val->tv_sec, (long int)l_abs(val->tv_usec));
912 return buf;
913 }
914
915 /*-----------------------------------------------------------------------
916 * correct the current time by an offset by setting the time rigorously
917 */
918 static void
919 set_time(
920 struct timeval *offset
921 )
922 {
923 struct timeval the_time;
924
925 if (no_set)
926 return;
927
928 LPRINTF("set_time: %s ", pr_timeval(offset));
929 syslog(LOG_NOTICE, "setting time (offset %s)", pr_timeval(offset));
930
931 if (gettimeofday(&the_time, 0L) == -1)
932 {
933 perror("gettimeofday()");
934 }
935 else
936 {
937 timeradd(&the_time, offset);
938 if (settimeofday(&the_time, 0L) == -1)
939 {
940 perror("settimeofday()");
941 }
942 }
943 }
944
945 /*-----------------------------------------------------------------------
946 * slew the time by a given offset
947 */
948 static void
949 adj_time(
950 long offset
951 )
952 {
953 struct timeval time_offset;
954
955 if (no_set)
956 return;
957
958 time_offset.tv_sec = offset / 1000000;
959 time_offset.tv_usec = offset % 1000000;
960
961 LPRINTF("adj_time: %ld us ", (long int)offset);
962 if (adjtime(&time_offset, 0L) == -1)
963 perror("adjtime()");
964 }
965
966 /*-----------------------------------------------------------------------
967 * read in a possibly previously written drift value
968 */
969 static void
970 read_drift(
971 const char *drift_file
972 )
973 {
974 FILE *df;
975
976 df = fopen(drift_file, "r");
977 if (df != NULL)
978 {
979 int idrift = 0, fdrift = 0;
980
981 fscanf(df, "%4d.%03d", &idrift, &fdrift);
982 fclose(df);
983 LPRINTF("read_drift: %d.%03d ppm ", idrift, fdrift);
984
985 accum_drift = idrift << USECSCALE;
986 fdrift = (fdrift << USECSCALE) / 1000;
987 accum_drift += fdrift & (1<<USECSCALE);
988 LPRINTF("read_drift: drift_comp %ld ", (long int)accum_drift);
989 }
990 }
991
992 /*-----------------------------------------------------------------------
993 * write out the current drift value
994 */
995 static void
996 update_drift(
997 const char *drift_file,
998 long offset,
999 time_t reftime
1000 )
1001 {
1002 FILE *df;
1003
1004 df = fopen(drift_file, "w");
1005 if (df != NULL)
1006 {
1007 int idrift = R_SHIFT(accum_drift, USECSCALE);
1008 int fdrift = accum_drift & ((1<<USECSCALE)-1);
1009
1010 LPRINTF("update_drift: drift_comp %ld ", (long int)accum_drift);
1011 fdrift = (fdrift * 1000) / (1<<USECSCALE);
1012 fprintf(df, "%4d.%03d %c%ld.%06ld %.24s\n", idrift, fdrift,
1013 (offset < 0) ? '-' : '+', (long int)(l_abs(offset) / 1000000),
1014 (long int)(l_abs(offset) % 1000000), asctime(localtime(&reftime)));
1015 fclose(df);
1016 LPRINTF("update_drift: %d.%03d ppm ", idrift, fdrift);
1017 }
1018 }
1019
1020 /*-----------------------------------------------------------------------
1021 * process adjustments derived from the DCF77 observation
1022 * (controls clock PLL)
1023 */
1024 static void
1025 adjust_clock(
1026 struct timeval *offset,
1027 const char *drift_file,
1028 time_t reftime
1029 )
1030 {
1031 struct timeval toffset;
1032 register long usecoffset;
1033 int tmp;
1034
1035 if (no_set)
1036 return;
1037
1038 if (skip_adjust)
1039 {
1040 skip_adjust = 0;
1041 return;
1042 }
1043
1044 toffset = *offset;
1045 toffset.tv_sec = l_abs(toffset.tv_sec);
1046 toffset.tv_usec = l_abs(toffset.tv_usec);
1047 if (toffset.tv_sec ||
1048 (!toffset.tv_sec && toffset.tv_usec > max_adj_offset_usec))
1049 {
1050 /*
1051 * hopeless - set the clock - and clear the timing
1052 */
1053 set_time(offset);
1054 clock_adjust = 0;
1055 skip_adjust = 1;
1056 return;
1057 }
1058
1059 usecoffset = offset->tv_sec * 1000000 + offset->tv_usec;
1060
1061 clock_adjust = R_SHIFT(usecoffset, TIMECONSTANT); /* adjustment to make for next period */
1062
1063 tmp = 0;
1064 while (adjustments > (1 << tmp))
1065 tmp++;
1066 adjustments = 0;
1067 if (tmp > FREQ_WEIGHT)
1068 tmp = FREQ_WEIGHT;
1069
1070 accum_drift += R_SHIFT(usecoffset << USECSCALE, TIMECONSTANT+TIMECONSTANT+FREQ_WEIGHT-tmp);
1071
1072 if (accum_drift > MAX_DRIFT) /* clamp into interval */
1073 accum_drift = MAX_DRIFT;
1074 else
1075 if (accum_drift < -MAX_DRIFT)
1076 accum_drift = -MAX_DRIFT;
1077
1078 update_drift(drift_file, usecoffset, reftime);
1079 LPRINTF("clock_adjust: %s, clock_adjust %ld, drift_comp %ld(%ld) ",
1080 pr_timeval(offset),(long int) R_SHIFT(clock_adjust, USECSCALE),
1081 (long int)R_SHIFT(accum_drift, USECSCALE), (long int)accum_drift);
1082 }
1083
1084 /*-----------------------------------------------------------------------
1085 * adjust the clock by a small mount to simulate frequency correction
1086 */
1087 static void
1088 periodic_adjust(
1089 void
1090 )
1091 {
1092 register long adjustment;
1093
1094 adjustments++;
1095
1096 adjustment = R_SHIFT(clock_adjust, PHASE_WEIGHT);
1097
1098 clock_adjust -= adjustment;
1099
1100 adjustment += R_SHIFT(accum_drift, USECSCALE+ADJINTERVAL);
1101
1102 adj_time(adjustment);
1103 }
1104
1105 /*-----------------------------------------------------------------------
1106 * control synchronisation status (warnings) and do periodic adjusts
1107 * (frequency control simulation)
1108 */
1109 static void
1110 tick(
1111 int signum
1112 )
1113 {
1114 static unsigned long last_notice = 0;
1115
1116 #if !defined(HAVE_SIGACTION) && !defined(HAVE_SIGVEC)
1117 (void)signal(SIGALRM, tick);
1118 #endif
1119
1120 periodic_adjust();
1121
1122 ticks += 1<<ADJINTERVAL;
1123
1124 if ((ticks - last_sync) > MAX_UNSYNC)
1125 {
1126 /*
1127 * not getting time for a while
1128 */
1129 if (sync_state == SYNC)
1130 {
1131 /*
1132 * completely lost information
1133 */
1134 sync_state = NO_SYNC;
1135 syslog(LOG_INFO, "DCF77 reception lost (timeout)");
1136 last_notice = ticks;
1137 }
1138 else
1139 /*
1140 * in NO_SYNC state - look whether its time to speak up again
1141 */
1142 if ((ticks - last_notice) > NOTICE_INTERVAL)
1143 {
1144 syslog(LOG_NOTICE, "still not synchronized to DCF77 - check receiver/signal");
1145 last_notice = ticks;
1146 }
1147 }
1148
1149 #ifndef ITIMER_REAL
1150 (void) alarm(1<<ADJINTERVAL);
1151 #endif
1152 }
1153
1154 /*-----------------------------------------------------------------------
1155 * break association from terminal to avoid catching terminal
1156 * or process group related signals (-> daemon operation)
1157 */
1158 static void
1159 detach(
1160 void
1161 )
1162 {
1163 # ifdef HAVE_DAEMON
1164 daemon(0, 0);
1165 # else /* not HAVE_DAEMON */
1166 if (fork())
1167 exit(0);
1168
1169 {
1170 u_long s;
1171 int max_fd;
1172
1173 #if defined(HAVE_SYSCONF) && defined(_SC_OPEN_MAX)
1174 max_fd = sysconf(_SC_OPEN_MAX);
1175 #else /* HAVE_SYSCONF && _SC_OPEN_MAX */
1176 max_fd = getdtablesize();
1177 #endif /* HAVE_SYSCONF && _SC_OPEN_MAX */
1178 for (s = 0; s < max_fd; s++)
1179 (void) close((int)s);
1180 (void) open("/", 0);
1181 (void) dup2(0, 1);
1182 (void) dup2(0, 2);
1183 #ifdef SYS_DOMAINOS
1184 {
1185 uid_$t puid;
1186 status_$t st;
1187
1188 proc2_$who_am_i(&puid);
1189 proc2_$make_server(&puid, &st);
1190 }
1191 #endif /* SYS_DOMAINOS */
1192 #if defined(HAVE_SETPGID) || defined(HAVE_SETSID)
1193 # ifdef HAVE_SETSID
1194 if (setsid() == (pid_t)-1)
1195 syslog(LOG_ERR, "dcfd: setsid(): %m");
1196 # else
1197 if (setpgid(0, 0) == -1)
1198 syslog(LOG_ERR, "dcfd: setpgid(): %m");
1199 # endif
1200 #else /* HAVE_SETPGID || HAVE_SETSID */
1201 {
1202 int fid;
1203
1204 fid = open("/dev/tty", 2);
1205 if (fid >= 0)
1206 {
1207 (void) ioctl(fid, (u_long) TIOCNOTTY, (char *) 0);
1208 (void) close(fid);
1209 }
1210 # ifdef HAVE_SETPGRP_0
1211 (void) setpgrp();
1212 # else /* HAVE_SETPGRP_0 */
1213 (void) setpgrp(0, getpid());
1214 # endif /* HAVE_SETPGRP_0 */
1215 }
1216 #endif /* HAVE_SETPGID || HAVE_SETSID */
1217 }
1218 #endif /* not HAVE_DAEMON */
1219 }
1220
1221 /*-----------------------------------------------------------------------
1222 * list possible arguments and options
1223 */
1224 static void
1225 usage(
1226 char *program
1227 )
1228 {
1229 fprintf(stderr, "usage: %s [-n] [-f] [-l] [-t] [-i] [-o] [-d <drift_file>] [-D <input delay>] <device>\n", program);
1230 fprintf(stderr, "\t-n do not change time\n");
1231 fprintf(stderr, "\t-i interactive\n");
1232 fprintf(stderr, "\t-t trace (print all datagrams)\n");
1233 fprintf(stderr, "\t-f print all databits (includes PTB private data)\n");
1234 fprintf(stderr, "\t-l print loop filter debug information\n");
1235 fprintf(stderr, "\t-o print offet average for current minute\n");
1236 fprintf(stderr, "\t-Y make internal Y2K checks then exit\n"); /* Y2KFixes */
1237 fprintf(stderr, "\t-d <drift_file> specify alternate drift file\n");
1238 fprintf(stderr, "\t-D <input delay>specify delay from input edge to processing in micro seconds\n");
1239 }
1240
1241 /*-----------------------------------------------------------------------
1242 * check_y2k() - internal check of Y2K logic
1243 * (a lot of this logic lifted from ../ntpd/check_y2k.c)
1244 */
1245 static int
1246 check_y2k( void )
1247 {
1248 int year; /* current working year */
1249 int year0 = 1900; /* sarting year for NTP time */
1250 int yearend; /* ending year we test for NTP time.
1251 * 32-bit systems: through 2036, the
1252 **year in which NTP time overflows.
1253 * 64-bit systems: a reasonable upper
1254 **limit (well, maybe somewhat beyond
1255 **reasonable, but well before the
1256 **max time, by which time the earth
1257 **will be dead.) */
1258 time_t Time;
1259 struct tm LocalTime;
1260
1261 int Fatals, Warnings;
1262 #define Error(year) if ( (year)>=2036 && LocalTime.tm_year < 110 ) \
1263 Warnings++; else Fatals++
1264
1265 Fatals = Warnings = 0;
1266
1267 Time = time( (time_t *)NULL );
1268 LocalTime = *localtime( &Time );
1269
1270 year = ( sizeof( u_long ) > 4 ) /* save max span using year as temp */
1271 ? ( 400 * 3 ) /* three greater gregorian cycles */
1272 : ((int)(0x7FFFFFFF / 365.242 / 24/60/60)* 2 ); /*32-bit limit*/
1273 /* NOTE: will automacially expand test years on
1274 * 64 bit machines.... this may cause some of the
1275 * existing ntp logic to fail for years beyond
1276 * 2036 (the current 32-bit limit). If all checks
1277 * fail ONLY beyond year 2036 you may ignore such
1278 * errors, at least for a decade or so. */
1279 yearend = year0 + year;
1280
1281 year = 1900+YEAR_PIVOT;
1282 printf( " starting year %04d\n", (int) year );
1283 printf( " ending year %04d\n", (int) yearend );
1284
1285 for ( ; year < yearend; year++ )
1286 {
1287 clocktime_t ct;
1288 time_t Observed;
1289 time_t Expected;
1290 unsigned Flag;
1291 unsigned long t;
1292
1293 ct.day = 1;
1294 ct.month = 1;
1295 ct.year = year;
1296 ct.hour = ct.minute = ct.second = ct.usecond = 0;
1297 ct.utcoffset = 0;
1298 ct.flags = 0;
1299
1300 Flag = 0;
1301 Observed = dcf_to_unixtime( &ct, &Flag );
1302 /* seems to be a clone of parse_to_unixtime() with
1303 * *a minor difference to arg2 type */
1304 if ( ct.year != year )
1305 {
1306 fprintf( stdout,
1307 "%04d: dcf_to_unixtime(,%d) CORRUPTED ct.year: was %d\n",
1308 (int)year, (int)Flag, (int)ct.year );
1309 Error(year);
1310 break;
1311 }
1312 t = julian0(year) - julian0(1970); /* Julian day from 1970 */
1313 Expected = t * 24 * 60 * 60;
1314 if ( Observed != Expected || Flag )
1315 { /* time difference */
1316 fprintf( stdout,
1317 "%04d: dcf_to_unixtime(,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
1318 year, (int)Flag,
1319 (unsigned long)Observed, (unsigned long)Expected,
1320 ((long)Observed - (long)Expected) );
1321 Error(year);
1322 break;
1323 }
1324
1325 if ( year >= YEAR_PIVOT+1900 )
1326 {
1327 /* check year % 100 code we put into dcf_to_unixtime() */
1328 ct.year = year % 100;
1329 Flag = 0;
1330
1331 Observed = dcf_to_unixtime( &ct, &Flag );
1332
1333 if ( Observed != Expected || Flag )
1334 { /* time difference */
1335 fprintf( stdout,
1336 "%04d: dcf_to_unixtime(%d,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
1337 year, (int)ct.year, (int)Flag,
1338 (unsigned long)Observed, (unsigned long)Expected,
1339 ((long)Observed - (long)Expected) );
1340 Error(year);
1341 break;
1342 }
1343
1344 /* check year - 1900 code we put into dcf_to_unixtime() */
1345 ct.year = year - 1900;
1346 Flag = 0;
1347
1348 Observed = dcf_to_unixtime( &ct, &Flag );
1349
1350 if ( Observed != Expected || Flag ) { /* time difference */
1351 fprintf( stdout,
1352 "%04d: dcf_to_unixtime(%d,%d) FAILURE: was=%lu s/b=%lu (%ld)\n",
1353 year, (int)ct.year, (int)Flag,
1354 (unsigned long)Observed, (unsigned long)Expected,
1355 ((long)Observed - (long)Expected) );
1356 Error(year);
1357 break;
1358 }
1359
1360
1361 }
1362 }
1363
1364 return ( Fatals );
1365 }
1366
1367 /*--------------------------------------------------
1368 * rawdcf_init - set up modem lines for RAWDCF receivers
1369 */
1370 #if defined(TIOCMSET) && (defined(TIOCM_DTR) || defined(CIOCM_DTR))
1371 static void
1372 rawdcf_init(
1373 int fd
1374 )
1375 {
1376 /*
1377 * You can use the RS232 to supply the power for a DCF77 receiver.
1378 * Here a voltage between the DTR and the RTS line is used. Unfortunately
1379 * the name has changed from CIOCM_DTR to TIOCM_DTR recently.
1380 */
1381
1382 #ifdef TIOCM_DTR
1383 int sl232 = TIOCM_DTR; /* turn on DTR for power supply */
1384 #else
1385 int sl232 = CIOCM_DTR; /* turn on DTR for power supply */
1386 #endif
1387
1388 if (ioctl(fd, TIOCMSET, (caddr_t)&sl232) == -1)
1389 {
1390 syslog(LOG_NOTICE, "rawdcf_init: WARNING: ioctl(fd, TIOCMSET, [C|T]IOCM_DTR): %m");
1391 }
1392 }
1393 #else
1394 static void
1395 rawdcf_init(
1396 int fd
1397 )
1398 {
1399 syslog(LOG_NOTICE, "rawdcf_init: WARNING: OS interface incapable of setting DTR to power DCF modules");
1400 }
1401 #endif /* DTR initialisation type */
1402
1403 /*-----------------------------------------------------------------------
1404 * main loop - argument interpreter / setup / main loop
1405 */
1406 int
1407 main(
1408 int argc,
1409 char **argv
1410 )
1411 {
1412 unsigned char c;
1413 char **a = argv;
1414 int ac = argc;
1415 char *file = NULL;
1416 const char *drift_file = "/etc/dcfd.drift";
1417 int fd;
1418 int offset = 15;
1419 int offsets = 0;
1420 int delay = DEFAULT_DELAY; /* average delay from input edge to time stamping */
1421 int trace = 0;
1422 int errs = 0;
1423
1424 /*
1425 * process arguments
1426 */
1427 while (--ac)
1428 {
1429 char *arg = *++a;
1430 if (*arg == '-')
1431 while ((c = *++arg))
1432 switch (c)
1433 {
1434 case 't':
1435 trace = 1;
1436 interactive = 1;
1437 break;
1438
1439 case 'f':
1440 offset = 0;
1441 interactive = 1;
1442 break;
1443
1444 case 'l':
1445 loop_filter_debug = 1;
1446 offsets = 1;
1447 interactive = 1;
1448 break;
1449
1450 case 'n':
1451 no_set = 1;
1452 break;
1453
1454 case 'o':
1455 offsets = 1;
1456 interactive = 1;
1457 break;
1458
1459 case 'i':
1460 interactive = 1;
1461 break;
1462
1463 case 'D':
1464 if (ac > 1)
1465 {
1466 delay = atoi(*++a);
1467 ac--;
1468 }
1469 else
1470 {
1471 fprintf(stderr, "%s: -D requires integer argument\n", argv[0]);
1472 errs=1;
1473 }
1474 break;
1475
1476 case 'd':
1477 if (ac > 1)
1478 {
1479 drift_file = *++a;
1480 ac--;
1481 }
1482 else
1483 {
1484 fprintf(stderr, "%s: -d requires file name argument\n", argv[0]);
1485 errs=1;
1486 }
1487 break;
1488
1489 case 'Y':
1490 errs=check_y2k();
1491 exit( errs ? 1 : 0 );
1492
1493 default:
1494 fprintf(stderr, "%s: unknown option -%c\n", argv[0], c);
1495 errs=1;
1496 break;
1497 }
1498 else
1499 if (file == NULL)
1500 file = arg;
1501 else
1502 {
1503 fprintf(stderr, "%s: device specified twice\n", argv[0]);
1504 errs=1;
1505 }
1506 }
1507
1508 if (errs)
1509 {
1510 usage(argv[0]);
1511 exit(1);
1512 }
1513 else
1514 if (file == NULL)
1515 {
1516 fprintf(stderr, "%s: device not specified\n", argv[0]);
1517 usage(argv[0]);
1518 exit(1);
1519 }
1520
1521 errs = LINES+1;
1522
1523 /*
1524 * get access to DCF77 tty port
1525 */
1526 fd = open(file, O_RDONLY);
1527 if (fd == -1)
1528 {
1529 perror(file);
1530 exit(1);
1531 }
1532 else
1533 {
1534 int i, rrc;
1535 struct timeval t, tt, tlast;
1536 struct timeval timeout;
1537 struct timeval phase;
1538 struct timeval time_offset;
1539 char pbuf[61]; /* printable version */
1540 char buf[61]; /* raw data */
1541 clocktime_t clock_time; /* wall clock time */
1542 time_t utc_time = 0;
1543 time_t last_utc_time = 0;
1544 long usecerror = 0;
1545 long lasterror = 0;
1546 #if defined(HAVE_TERMIOS_H) || defined(STREAM)
1547 struct termios term;
1548 #else /* not HAVE_TERMIOS_H || STREAM */
1549 # if defined(HAVE_TERMIO_H) || defined(HAVE_SYSV_TTYS)
1550 struct termio term;
1551 # endif/* HAVE_TERMIO_H || HAVE_SYSV_TTYS */
1552 #endif /* not HAVE_TERMIOS_H || STREAM */
1553 unsigned int rtc = CVT_NONE;
1554
1555 rawdcf_init(fd);
1556
1557 timeout.tv_sec = 1;
1558 timeout.tv_usec = 500000;
1559
1560 phase.tv_sec = 0;
1561 phase.tv_usec = delay;
1562
1563 /*
1564 * setup TTY (50 Baud, Read, 8Bit, No Hangup, 1 character IO)
1565 */
1566 if (TTY_GETATTR(fd, &term) == -1)
1567 {
1568 perror("tcgetattr");
1569 exit(1);
1570 }
1571
1572 memset(term.c_cc, 0, sizeof(term.c_cc));
1573 term.c_cc[VMIN] = 1;
1574 #ifdef NO_PARENB_IGNPAR
1575 term.c_cflag = CS8|CREAD|CLOCAL;
1576 #else
1577 term.c_cflag = CS8|CREAD|CLOCAL|PARENB;
1578 #endif
1579 term.c_iflag = IGNPAR;
1580 term.c_oflag = 0;
1581 term.c_lflag = 0;
1582
1583 cfsetispeed(&term, B50);
1584 cfsetospeed(&term, B50);
1585
1586 if (TTY_SETATTR(fd, &term) == -1)
1587 {
1588 perror("tcsetattr");
1589 exit(1);
1590 }
1591
1592 /*
1593 * lose terminal if in daemon operation
1594 */
1595 if (!interactive)
1596 detach();
1597
1598 /*
1599 * get syslog() initialized
1600 */
1601 #ifdef LOG_DAEMON
1602 openlog("dcfd", LOG_PID, LOG_DAEMON);
1603 #else
1604 openlog("dcfd", LOG_PID);
1605 #endif
1606
1607 /*
1608 * setup periodic operations (state control / frequency control)
1609 */
1610 #ifdef HAVE_SIGACTION
1611 {
1612 struct sigaction act;
1613
1614 # ifdef HAVE_SA_SIGACTION_IN_STRUCT_SIGACTION
1615 act.sa_sigaction = (void (*) (int, siginfo_t *, void *))0;
1616 # endif /* HAVE_SA_SIGACTION_IN_STRUCT_SIGACTION */
1617 act.sa_handler = tick;
1618 sigemptyset(&act.sa_mask);
1619 act.sa_flags = 0;
1620
1621 if (sigaction(SIGALRM, &act, (struct sigaction *)0) == -1)
1622 {
1623 syslog(LOG_ERR, "sigaction(SIGALRM): %m");
1624 exit(1);
1625 }
1626 }
1627 #else
1628 #ifdef HAVE_SIGVEC
1629 {
1630 struct sigvec vec;
1631
1632 vec.sv_handler = tick;
1633 vec.sv_mask = 0;
1634 vec.sv_flags = 0;
1635
1636 if (sigvec(SIGALRM, &vec, (struct sigvec *)0) == -1)
1637 {
1638 syslog(LOG_ERR, "sigvec(SIGALRM): %m");
1639 exit(1);
1640 }
1641 }
1642 #else
1643 (void) signal(SIGALRM, tick);
1644 #endif
1645 #endif
1646
1647 #ifdef ITIMER_REAL
1648 {
1649 struct itimerval it;
1650
1651 it.it_interval.tv_sec = 1<<ADJINTERVAL;
1652 it.it_interval.tv_usec = 0;
1653 it.it_value.tv_sec = 1<<ADJINTERVAL;
1654 it.it_value.tv_usec = 0;
1655
1656 if (setitimer(ITIMER_REAL, &it, (struct itimerval *)0) == -1)
1657 {
1658 syslog(LOG_ERR, "setitimer: %m");
1659 exit(1);
1660 }
1661 }
1662 #else
1663 (void) alarm(1<<ADJINTERVAL);
1664 #endif
1665
1666 PRINTF(" DCF77 monitor %s - Copyright (C) 1993-2005 by Frank Kardel\n\n", revision);
1667
1668 pbuf[60] = '\0';
1669 for ( i = 0; i < 60; i++)
1670 pbuf[i] = '.';
1671
1672 read_drift(drift_file);
1673
1674 /*
1675 * what time is it now (for interval measurement)
1676 */
1677 gettimeofday(&tlast, 0L);
1678 i = 0;
1679 /*
1680 * loop until input trouble ...
1681 */
1682 do
1683 {
1684 /*
1685 * get an impulse
1686 */
1687 while ((rrc = read(fd, &c, 1)) == 1)
1688 {
1689 gettimeofday(&t, 0L);
1690 tt = t;
1691 timersub(&t, &tlast);
1692
1693 if (errs > LINES)
1694 {
1695 PRINTF(" %s", &"PTB private....RADMLSMin....PHour..PMDay..DayMonthYear....P\n"[offset]);
1696 PRINTF(" %s", &"---------------RADMLS1248124P124812P1248121241248112481248P\n"[offset]);
1697 errs = 0;
1698 }
1699
1700 /*
1701 * timeout -> possible minute mark -> interpretation
1702 */
1703 if (timercmp(&t, &timeout, >))
1704 {
1705 PRINTF("%c %.*s ", pat[i % (sizeof(pat)-1)], 59 - offset, &pbuf[offset]);
1706
1707 if ((rtc = cvt_rawdcf((unsigned char *)buf, i, &clock_time)) != CVT_OK)
1708 {
1709 /*
1710 * this data was bad - well - forget synchronisation for now
1711 */
1712 PRINTF("\n");
1713 if (sync_state == SYNC)
1714 {
1715 sync_state = NO_SYNC;
1716 syslog(LOG_INFO, "DCF77 reception lost (bad data)");
1717 }
1718 errs++;
1719 }
1720 else
1721 if (trace)
1722 {
1723 PRINTF("\r %.*s ", 59 - offset, &buf[offset]);
1724 }
1725
1726
1727 buf[0] = c;
1728
1729 /*
1730 * collect first character
1731 */
1732 if (((c^0xFF)+1) & (c^0xFF))
1733 pbuf[0] = '?';
1734 else
1735 pbuf[0] = type(c) ? '#' : '-';
1736
1737 for ( i = 1; i < 60; i++)
1738 pbuf[i] = '.';
1739
1740 i = 0;
1741 }
1742 else
1743 {
1744 /*
1745 * collect character
1746 */
1747 buf[i] = c;
1748
1749 /*
1750 * initial guess (usually correct)
1751 */
1752 if (((c^0xFF)+1) & (c^0xFF))
1753 pbuf[i] = '?';
1754 else
1755 pbuf[i] = type(c) ? '#' : '-';
1756
1757 PRINTF("%c %.*s ", pat[i % (sizeof(pat)-1)], 59 - offset, &pbuf[offset]);
1758 }
1759
1760 if (i == 0 && rtc == CVT_OK)
1761 {
1762 /*
1763 * we got a good time code here - try to convert it to
1764 * UTC
1765 */
1766 if ((utc_time = dcf_to_unixtime(&clock_time, &rtc)) == -1)
1767 {
1768 PRINTF("*** BAD CONVERSION\n");
1769 }
1770
1771 if (utc_time != (last_utc_time + 60))
1772 {
1773 /*
1774 * well, two successive sucessful telegrams are not 60 seconds
1775 * apart
1776 */
1777 PRINTF("*** NO MINUTE INC\n");
1778 if (sync_state == SYNC)
1779 {
1780 sync_state = NO_SYNC;
1781 syslog(LOG_INFO, "DCF77 reception lost (data mismatch)");
1782 }
1783 errs++;
1784 rtc = CVT_FAIL|CVT_BADTIME|CVT_BADDATE;
1785 }
1786 else
1787 usecerror = 0;
1788
1789 last_utc_time = utc_time;
1790 }
1791
1792 if (rtc == CVT_OK)
1793 {
1794 if (i == 0)
1795 {
1796 /*
1797 * valid time code - determine offset and
1798 * note regained reception
1799 */
1800 last_sync = ticks;
1801 if (sync_state == NO_SYNC)
1802 {
1803 syslog(LOG_INFO, "receiving DCF77");
1804 }
1805 else
1806 {
1807 /*
1808 * we had at least one minute SYNC - thus
1809 * last error is valid
1810 */
1811 time_offset.tv_sec = lasterror / 1000000;
1812 time_offset.tv_usec = lasterror % 1000000;
1813 adjust_clock(&time_offset, drift_file, utc_time);
1814 }
1815 sync_state = SYNC;
1816 }
1817
1818 time_offset.tv_sec = utc_time + i;
1819 time_offset.tv_usec = 0;
1820
1821 timeradd(&time_offset, &phase);
1822
1823 usecerror += (time_offset.tv_sec - tt.tv_sec) * 1000000 + time_offset.tv_usec
1824 -tt.tv_usec;
1825
1826 /*
1827 * output interpreted DCF77 data
1828 */
1829 PRINTF(offsets ? "%s, %2ld:%02ld:%02d, %ld.%02ld.%02ld, <%s%s%s%s> (%c%ld.%06lds)" :
1830 "%s, %2ld:%02ld:%02d, %ld.%02ld.%02ld, <%s%s%s%s>",
1831 wday[clock_time.wday],
1832 clock_time.hour, clock_time.minute, i, clock_time.day, clock_time.month,
1833 clock_time.year,
1834 (clock_time.flags & DCFB_ALTERNATE) ? "R" : "_",
1835 (clock_time.flags & DCFB_ANNOUNCE) ? "A" : "_",
1836 (clock_time.flags & DCFB_DST) ? "D" : "_",
1837 (clock_time.flags & DCFB_LEAP) ? "L" : "_",
1838 (lasterror < 0) ? '-' : '+', l_abs(lasterror) / 1000000, l_abs(lasterror) % 1000000
1839 );
1840
1841 if (trace && (i == 0))
1842 {
1843 PRINTF("\n");
1844 errs++;
1845 }
1846 lasterror = usecerror / (i+1);
1847 }
1848 else
1849 {
1850 lasterror = 0; /* we cannot calculate phase errors on bad reception */
1851 }
1852
1853 PRINTF("\r");
1854
1855 if (i < 60)
1856 {
1857 i++;
1858 }
1859
1860 tlast = tt;
1861
1862 if (interactive)
1863 fflush(stdout);
1864 }
1865 } while ((rrc == -1) && (errno == EINTR));
1866
1867 /*
1868 * lost IO - sorry guys
1869 */
1870 syslog(LOG_ERR, "TERMINATING - cannot read from device %s (%m)", file);
1871
1872 (void)close(fd);
1873 }
1874
1875 closelog();
1876
1877 return 0;
1878 }
1879
1880 /*
1881 * History:
1882 *
1883 * dcfd.c,v
1884 * Revision 4.18 2005/10/07 22:08:18 kardel
1885 * make dcfd.c compile on NetBSD 3.99.9 again (configure/sigvec compatibility fix)
1886 *
1887 * Revision 4.17.2.1 2005/10/03 19:15:16 kardel
1888 * work around configure not detecting a missing sigvec compatibility
1889 * interface on NetBSD 3.99.9 and above
1890 *
1891 * Revision 4.17 2005/08/10 10:09:44 kardel
1892 * output revision information
1893 *
1894 * Revision 4.16 2005/08/10 06:33:25 kardel
1895 * cleanup warnings
1896 *
1897 * Revision 4.15 2005/08/10 06:28:45 kardel
1898 * fix setting of baud rate
1899 *
1900 * Revision 4.14 2005/04/16 17:32:10 kardel
1901 * update copyright
1902 *
1903 * Revision 4.13 2004/11/14 15:29:41 kardel
1904 * support PPSAPI, upgrade Copyright to Berkeley style
1905 *
1906 */
NetBSD on the FriendlyARM MINI2440