1/* 2 * refclock_arc - clock driver for ARCRON MSF/DCF/WWVB receivers 3 */ 4 5#ifdef HAVE_CONFIG_H 6#include <config.h> 7#endif 8 9#include "ntp_types.h" 10 11#if defined(REFCLOCK) && defined(CLOCK_ARCRON_MSF) 12 13static const char arc_version[] = { "V1.3 2003/02/21" }; 14 15/* define PRE_NTP420 for compatibility to previous versions of NTP (at least 16 to 4.1.0 */ 17#undef PRE_NTP420 18 19#ifndef ARCRON_NOT_KEEN 20#define ARCRON_KEEN 1 /* Be keen, and trusting of the clock, if defined. */ 21#endif 22 23#ifndef ARCRON_NOT_MULTIPLE_SAMPLES 24#define ARCRON_MULTIPLE_SAMPLES 1 /* Use all timestamp bytes as samples. */ 25#endif 26 27#ifndef ARCRON_NOT_LEAPSECOND_KEEN 28#ifndef ARCRON_LEAPSECOND_KEEN 29#undef ARCRON_LEAPSECOND_KEEN /* Respond quickly to leap seconds: doesn't work yet. */ 30#endif 31#endif 32 33/* 34Code by Derek Mulcahy, <derek@toybox.demon.co.uk>, 1997. 35Modifications by Damon Hart-Davis, <d@hd.org>, 1997. 36Modifications by Paul Alfille, <palfille@partners.org>, 2003. 37Modifications by Christopher Price, <cprice@cs-home.com>, 2003. 38Modifications by Nigel Roles <nigel@9fs.org>, 2003. 39 40 41THIS CODE IS SUPPLIED AS IS, WITH NO WARRANTY OF ANY KIND. USE AT 42YOUR OWN RISK. 43 44Orginally developed and used with ntp3-5.85 by Derek Mulcahy. 45 46Built against ntp3-5.90 on Solaris 2.5 using gcc 2.7.2. 47 48This code may be freely copied and used and incorporated in other 49systems providing the disclaimer and notice of authorship are 50reproduced. 51 52------------------------------------------------------------------------------- 53 54Nigel's notes: 55 561) Called tcgetattr() before modifying, so that fields correctly initialised 57 for all operating systems 58 592) Altered parsing of timestamp line so that it copes with fields which are 60 not always ASCII digits (e.g. status field when battery low) 61 62------------------------------------------------------------------------------- 63 64Christopher's notes: 65 66MAJOR CHANGES SINCE V1.2 67======================== 68 1) Applied patch by Andrey Bray <abuse@madhouse.demon.co.uk> 69 2001-02-17 comp.protocols.time.ntp 70 71 2) Added WWVB support via clock mode command, localtime/UTC time configured 72 via flag1=(0=UTC, 1=localtime) 73 74 3) Added ignore resync request via flag2=(0=resync, 1=ignore resync) 75 76 4) Added simplified conversion from localtime to UTC with dst/bst translation 77 78 5) Added average signal quality poll 79 80 6) Fixed a badformat error when no code is available due to stripping 81 \n & \r's 82 83 7) Fixed a badformat error when clearing lencode & memset a_lastcode in poll 84 routine 85 86 8) Lots of code cleanup, including standardized DEBUG macros and removal 87 of unused code 88 89------------------------------------------------------------------------------- 90 91Author's original note: 92 93I enclose my ntp driver for the Galleon Systems Arc MSF receiver. 94 95It works (after a fashion) on both Solaris-1 and Solaris-2. 96 97I am currently using ntp3-5.85. I have been running the code for 98about 7 months without any problems. Even coped with the change to BST! 99 100I had to do some funky things to read from the clock because it uses the 101power from the receive lines to drive the transmit lines. This makes the 102code look a bit stupid but it works. I also had to put in some delays to 103allow for the turnaround time from receive to transmit. These delays 104are between characters when requesting a time stamp so that shouldn't affect 105the results too drastically. 106 107... 108 109The bottom line is that it works but could easily be improved. You are 110free to do what you will with the code. I haven't been able to determine 111how good the clock is. I think that this requires a known good clock 112to compare it against. 113 114------------------------------------------------------------------------------- 115 116Damon's notes for adjustments: 117 118MAJOR CHANGES SINCE V1.0 119======================== 120 1) Removal of pollcnt variable that made the clock go permanently 121 off-line once two time polls failed to gain responses. 122 123 2) Avoiding (at least on Solaris-2) terminal becoming the controlling 124 terminal of the process when we do a low-level open(). 125 126 3) Additional logic (conditional on ARCRON_LEAPSECOND_KEEN being 127 defined) to try to resync quickly after a potential leap-second 128 insertion or deletion. 129 130 4) Code significantly slimmer at run-time than V1.0. 131 132 133GENERAL 134======= 135 136 1) The C preprocessor symbol to have the clock built has been changed 137 from ARC to ARCRON_MSF to CLOCK_ARCRON_MSF to minimise the 138 possiblity of clashes with other symbols in the future. 139 140 2) PRECISION should be -4/-5 (63ms/31ms) for the following reasons: 141 142 a) The ARC documentation claims the internal clock is (only) 143 accurate to about 20ms relative to Rugby (plus there must be 144 noticable drift and delay in the ms range due to transmission 145 delays and changing atmospheric effects). This clock is not 146 designed for ms accuracy as NTP has spoilt us all to expect. 147 148 b) The clock oscillator looks like a simple uncompensated quartz 149 crystal of the sort used in digital watches (ie 32768Hz) which 150 can have large temperature coefficients and drifts; it is not 151 clear if this oscillator is properly disciplined to the MSF 152 transmission, but as the default is to resync only once per 153 *day*, we can imagine that it is not, and is free-running. We 154 can minimise drift by resyncing more often (at the cost of 155 reduced battery life), but drift/wander may still be 156 significant. 157 158 c) Note that the bit time of 3.3ms adds to the potential error in 159 the the clock timestamp, since the bit clock of the serial link 160 may effectively be free-running with respect to the host clock 161 and the MSF clock. Actually, the error is probably 1/16th of 162 the above, since the input data is probably sampled at at least 163 16x the bit rate. 164 165 By keeping the clock marked as not very precise, it will have a 166 fairly large dispersion, and thus will tend to be used as a 167 `backup' time source and sanity checker, which this clock is 168 probably ideal for. For an isolated network without other time 169 sources, this clock can probably be expected to provide *much* 170 better than 1s accuracy, which will be fine. 171 172 By default, PRECISION is set to -4, but experience, especially at a 173 particular geographic location with a particular clock, may allow 174 this to be altered to -5. (Note that skews of +/- 10ms are to be 175 expected from the clock from time-to-time.) This improvement of 176 reported precision can be instigated by setting flag3 to 1, though 177 the PRECISION will revert to the normal value while the clock 178 signal quality is unknown whatever the flag3 setting. 179 180 IN ANY CASE, BE SURE TO SET AN APPROPRIATE FUDGE FACTOR TO REMOVE 181 ANY RESIDUAL SKEW, eg: 182 183 server 127.127.27.0 # ARCRON MSF radio clock unit 0. 184 # Fudge timestamps by about 20ms. 185 fudge 127.127.27.0 time1 0.020 186 187 You will need to observe your system's behaviour, assuming you have 188 some other NTP source to compare it with, to work out what the 189 fudge factor should be. For my Sun SS1 running SunOS 4.1.3_U1 with 190 my MSF clock with my distance from the MSF transmitter, +20ms 191 seemed about right, after some observation. 192 193 3) REFID has been made "MSFa" to reflect the MSF time source and the 194 ARCRON receiver. 195 196 4) DEFAULT_RESYNC_TIME is the time in seconds (by default) before 197 forcing a resync since the last attempt. This is picked to give a 198 little less than an hour between resyncs and to try to avoid 199 clashing with any regular event at a regular time-past-the-hour 200 which might cause systematic errors. 201 202 The INITIAL_RESYNC_DELAY is to avoid bothering the clock and 203 running down its batteries unnecesarily if ntpd is going to crash 204 or be killed or reconfigured quickly. If ARCRON_KEEN is defined 205 then this period is long enough for (with normal polling rates) 206 enough time samples to have been taken to allow ntpd to sync to 207 the clock before the interruption for the clock to resync to MSF. 208 This avoids ntpd syncing to another peer first and then 209 almost immediately hopping to the MSF clock. 210 211 The RETRY_RESYNC_TIME is used before rescheduling a resync after a 212 resync failed to reveal a statisfatory signal quality (too low or 213 unknown). 214 215 5) The clock seems quite jittery, so I have increased the 216 median-filter size from the typical (previous) value of 3. I 217 discard up to half the results in the filter. It looks like maybe 218 1 sample in 10 or so (maybe less) is a spike, so allow the median 219 filter to discard at least 10% of its entries or 1 entry, whichever 220 is greater. 221 222 6) Sleeping *before* each character sent to the unit to allow required 223 inter-character time but without introducting jitter and delay in 224 handling the response if possible. 225 226 7) If the flag ARCRON_KEEN is defined, take time samples whenever 227 possible, even while resyncing, etc. We rely, in this case, on the 228 clock always giving us a reasonable time or else telling us in the 229 status byte at the end of the timestamp that it failed to sync to 230 MSF---thus we should never end up syncing to completely the wrong 231 time. 232 233 8) If the flag ARCRON_OWN_FILTER is defined, use own versions of 234 refclock median-filter routines to get round small bug in 3-5.90 235 code which does not return the median offset. XXX Removed this 236 bit due NTP Version 4 upgrade - dlm. 237 238 9) We would appear to have a year-2000 problem with this clock since 239 it returns only the two least-significant digits of the year. But 240 ntpd ignores the year and uses the local-system year instead, so 241 this is in fact not a problem. Nevertheless, we attempt to do a 242 sensible thing with the dates, wrapping them into a 100-year 243 window. 244 245 10)Logs stats information that can be used by Derek's Tcl/Tk utility 246 to show the status of the clock. 247 248 11)The clock documentation insists that the number of bits per 249 character to be sent to the clock, and sent by it, is 11, including 250 one start bit and two stop bits. The data format is either 7+even 251 or 8+none. 252 253 254TO-DO LIST 255========== 256 257 * Eliminate use of scanf(), and maybe sprintf(). 258 259 * Allow user setting of resync interval to trade battery life for 260 accuracy; maybe could be done via fudge factor or unit number. 261 262 * Possibly note the time since the last resync of the MSF clock to 263 MSF as the age of the last reference timestamp, ie trust the 264 clock's oscillator not very much... 265 266 * Add very slow auto-adjustment up to a value of +/- time2 to correct 267 for long-term errors in the clock value (time2 defaults to 0 so the 268 correction would be disabled by default). 269 270 * Consider trying to use the tty_clk/ppsclock support. 271 272 * Possibly use average or maximum signal quality reported during 273 resync, rather than just the last one, which may be atypical. 274 275*/ 276 277 278/* Notes for HKW Elektronik GmBH Radio clock driver */ 279/* Author Lyndon David, Sentinet Ltd, Feb 1997 */ 280/* These notes seem also to apply usefully to the ARCRON clock. */ 281 282/* The HKW clock module is a radio receiver tuned into the Rugby */ 283/* MSF time signal tranmitted on 60 kHz. The clock module connects */ 284/* to the computer via a serial line and transmits the time encoded */ 285/* in 15 bytes at 300 baud 7 bits two stop bits even parity */ 286 287/* Clock communications, from the datasheet */ 288/* All characters sent to the clock are echoed back to the controlling */ 289/* device. */ 290/* Transmit time/date information */ 291/* syntax ASCII o<cr> */ 292/* Character o may be replaced if neccesary by a character whose code */ 293/* contains the lowest four bits f(hex) eg */ 294/* syntax binary: xxxx1111 00001101 */ 295 296/* DHD note: 297You have to wait for character echo + 10ms before sending next character. 298*/ 299 300/* The clock replies to this command with a sequence of 15 characters */ 301/* which contain the complete time and a final <cr> making 16 characters */ 302/* in total. */ 303/* The RC computer clock will not reply immediately to this command because */ 304/* the start bit edge of the first reply character marks the beginning of */ 305/* the second. So the RC Computer Clock will reply to this command at the */ 306/* start of the next second */ 307/* The characters have the following meaning */ 308/* 1. hours tens */ 309/* 2. hours units */ 310/* 3. minutes tens */ 311/* 4. minutes units */ 312/* 5. seconds tens */ 313/* 6. seconds units */ 314/* 7. day of week 1-monday 7-sunday */ 315/* 8. day of month tens */ 316/* 9. day of month units */ 317/* 10. month tens */ 318/* 11. month units */ 319/* 12. year tens */ 320/* 13. year units */ 321/* 14. BST/UTC status */ 322/* bit 7 parity */ 323/* bit 6 always 0 */ 324/* bit 5 always 1 */ 325/* bit 4 always 1 */ 326/* bit 3 always 0 */ 327/* bit 2 =1 if UTC is in effect, complementary to the BST bit */ 328/* bit 1 =1 if BST is in effect, according to the BST bit */ 329/* bit 0 BST/UTC change impending bit=1 in case of change impending */ 330/* 15. status */ 331/* bit 7 parity */ 332/* bit 6 always 0 */ 333/* bit 5 always 1 */ 334/* bit 4 always 1 */ 335/* bit 3 =1 if low battery is detected */ 336/* bit 2 =1 if the very last reception attempt failed and a valid */ 337/* time information already exists (bit0=1) */ 338/* =0 if the last reception attempt was successful */ 339/* bit 1 =1 if at least one reception since 2:30 am was successful */ 340/* =0 if no reception attempt since 2:30 am was successful */ 341/* bit 0 =1 if the RC Computer Clock contains valid time information */ 342/* This bit is zero after reset and one after the first */ 343/* successful reception attempt */ 344 345/* DHD note: 346Also note g<cr> command which confirms that a resync is in progress, and 347if so what signal quality (0--5) is available. 348Also note h<cr> command which starts a resync to MSF signal. 349*/ 350 351 352#include "ntpd.h" 353#include "ntp_io.h" 354#include "ntp_refclock.h" 355#include "ntp_calendar.h" 356#include "ntp_stdlib.h" 357 358#include <stdio.h> 359#include <ctype.h> 360 361#if defined(HAVE_BSD_TTYS) 362#include <sgtty.h> 363#endif /* HAVE_BSD_TTYS */ 364 365#if defined(HAVE_SYSV_TTYS) 366#include <termio.h> 367#endif /* HAVE_SYSV_TTYS */ 368 369#if defined(HAVE_TERMIOS) 370#include <termios.h> 371#endif 372 373/* 374 * This driver supports the ARCRON MSF/DCF/WWVB Radio Controlled Clock 375 */ 376 377/* 378 * Interface definitions 379 */ 380#define DEVICE "/dev/arc%d" /* Device name and unit. */ 381#define SPEED B300 /* UART speed (300 baud) */ 382#define PRECISION (-4) /* Precision (~63 ms). */ 383#define HIGHPRECISION (-5) /* If things are going well... */ 384#define REFID "MSFa" /* Reference ID. */ 385#define REFID_MSF "MSF" /* Reference ID. */ 386#define REFID_DCF77 "DCF" /* Reference ID. */ 387#define REFID_WWVB "WWVB" /* Reference ID. */ 388#define DESCRIPTION "ARCRON MSF/DCF/WWVB Receiver" 389 390#ifdef PRE_NTP420 391#define MODE ttlmax 392#else 393#define MODE ttl 394#endif 395 396#define LENARC 16 /* Format `o' timecode length. */ 397 398#define BITSPERCHAR 11 /* Bits per character. */ 399#define BITTIME 0x0DA740E /* Time for 1 bit at 300bps. */ 400#define CHARTIME10 0x8888888 /* Time for 10-bit char at 300bps. */ 401#define CHARTIME11 0x962FC96 /* Time for 11-bit char at 300bps. */ 402#define CHARTIME /* Time for char at 300bps. */ \ 403( (BITSPERCHAR == 11) ? CHARTIME11 : ( (BITSPERCHAR == 10) ? CHARTIME10 : \ 404 (BITSPERCHAR * BITTIME) ) ) 405 406 /* Allow for UART to accept char half-way through final stop bit. */ 407#define INITIALOFFSET ((u_int32)(-BITTIME/2)) 408 409 /* 410 charoffsets[x] is the time after the start of the second that byte 411 x (with the first byte being byte 1) is received by the UART, 412 assuming that the initial edge of the start bit of the first byte 413 is on-time. The values are represented as the fractional part of 414 an l_fp. 415 416 We store enough values to have the offset of each byte including 417 the trailing \r, on the assumption that the bytes follow one 418 another without gaps. 419 */ 420 static const u_int32 charoffsets[LENARC+1] = { 421#if BITSPERCHAR == 11 /* Usual case. */ 422 /* Offsets computed as accurately as possible... */ 423 0, 424 INITIALOFFSET + 0x0962fc96, /* 1 chars, 11 bits */ 425 INITIALOFFSET + 0x12c5f92c, /* 2 chars, 22 bits */ 426 INITIALOFFSET + 0x1c28f5c3, /* 3 chars, 33 bits */ 427 INITIALOFFSET + 0x258bf259, /* 4 chars, 44 bits */ 428 INITIALOFFSET + 0x2eeeeeef, /* 5 chars, 55 bits */ 429 INITIALOFFSET + 0x3851eb85, /* 6 chars, 66 bits */ 430 INITIALOFFSET + 0x41b4e81b, /* 7 chars, 77 bits */ 431 INITIALOFFSET + 0x4b17e4b1, /* 8 chars, 88 bits */ 432 INITIALOFFSET + 0x547ae148, /* 9 chars, 99 bits */ 433 INITIALOFFSET + 0x5dddddde, /* 10 chars, 110 bits */ 434 INITIALOFFSET + 0x6740da74, /* 11 chars, 121 bits */ 435 INITIALOFFSET + 0x70a3d70a, /* 12 chars, 132 bits */ 436 INITIALOFFSET + 0x7a06d3a0, /* 13 chars, 143 bits */ 437 INITIALOFFSET + 0x8369d037, /* 14 chars, 154 bits */ 438 INITIALOFFSET + 0x8ccccccd, /* 15 chars, 165 bits */ 439 INITIALOFFSET + 0x962fc963 /* 16 chars, 176 bits */ 440#else 441 /* Offsets computed with a small rounding error... */ 442 0, 443 INITIALOFFSET + 1 * CHARTIME, 444 INITIALOFFSET + 2 * CHARTIME, 445 INITIALOFFSET + 3 * CHARTIME, 446 INITIALOFFSET + 4 * CHARTIME, 447 INITIALOFFSET + 5 * CHARTIME, 448 INITIALOFFSET + 6 * CHARTIME, 449 INITIALOFFSET + 7 * CHARTIME, 450 INITIALOFFSET + 8 * CHARTIME, 451 INITIALOFFSET + 9 * CHARTIME, 452 INITIALOFFSET + 10 * CHARTIME, 453 INITIALOFFSET + 11 * CHARTIME, 454 INITIALOFFSET + 12 * CHARTIME, 455 INITIALOFFSET + 13 * CHARTIME, 456 INITIALOFFSET + 14 * CHARTIME, 457 INITIALOFFSET + 15 * CHARTIME, 458 INITIALOFFSET + 16 * CHARTIME 459#endif 460 }; 461 462#define DEFAULT_RESYNC_TIME (57*60) /* Gap between resync attempts (s). */ 463#define RETRY_RESYNC_TIME (27*60) /* Gap to emergency resync attempt. */ 464#ifdef ARCRON_KEEN 465#define INITIAL_RESYNC_DELAY 500 /* Delay before first resync. */ 466#else 467#define INITIAL_RESYNC_DELAY 50 /* Delay before first resync. */ 468#endif 469 470 static const int moff[12] = 471{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; 472/* Flags for a raw open() of the clock serial device. */ 473#ifdef O_NOCTTY /* Good, we can avoid tty becoming controlling tty. */ 474#define OPEN_FLAGS (O_RDWR | O_NOCTTY) 475#else /* Oh well, it may not matter... */ 476#define OPEN_FLAGS (O_RDWR) 477#endif 478 479 480/* Length of queue of command bytes to be sent. */ 481#define CMDQUEUELEN 4 /* Enough for two cmds + each \r. */ 482/* Queue tick time; interval in seconds between chars taken off queue. */ 483/* Must be >= 2 to allow o\r response to come back uninterrupted. */ 484#define QUEUETICK 2 /* Allow o\r reply to finish. */ 485 486/* 487 * ARC unit control structure 488 */ 489struct arcunit { 490 l_fp lastrec; /* Time tag for the receive time (system). */ 491 int status; /* Clock status. */ 492 493 int quality; /* Quality of reception 0--5 for unit. */ 494 /* We may also use the values -1 or 6 internally. */ 495 u_long quality_stamp; /* Next time to reset quality average. */ 496 497 u_long next_resync; /* Next resync time (s) compared to current_time. */ 498 int resyncing; /* Resync in progress if true. */ 499 500 /* In the outgoing queue, cmdqueue[0] is next to be sent. */ 501 char cmdqueue[CMDQUEUELEN+1]; /* Queue of outgoing commands + \0. */ 502 503 u_long saved_flags; /* Saved fudge flags. */ 504}; 505 506#ifdef ARCRON_LEAPSECOND_KEEN 507/* The flag `possible_leap' is set non-zero when any MSF unit 508 thinks a leap-second may have happened. 509 510 Set whenever we receive a valid time sample in the first hour of 511 the first day of the first/seventh months. 512 513 Outside the special hour this value is unconditionally set 514 to zero by the receive routine. 515 516 On finding itself in this timeslot, as long as the value is 517 non-negative, the receive routine sets it to a positive value to 518 indicate a resync to MSF should be performed. 519 520 In the poll routine, if this value is positive and we are not 521 already resyncing (eg from a sync that started just before 522 midnight), start resyncing and set this value negative to 523 indicate that a leap-triggered resync has been started. Having 524 set this negative prevents the receive routine setting it 525 positive and thus prevents multiple resyncs during the witching 526 hour. 527 */ 528static int possible_leap = 0; /* No resync required by default. */ 529#endif 530 531#if 0 532static void dummy_event_handler (struct peer *); 533static void arc_event_handler (struct peer *); 534#endif /* 0 */ 535 536#define QUALITY_UNKNOWN -1 /* Indicates unknown clock quality. */ 537#define MIN_CLOCK_QUALITY 0 /* Min quality clock will return. */ 538#define MIN_CLOCK_QUALITY_OK 3 /* Min quality for OK reception. */ 539#define MAX_CLOCK_QUALITY 5 /* Max quality clock will return. */ 540 541/* 542 * Function prototypes 543 */ 544static int arc_start (int, struct peer *); 545static void arc_shutdown (int, struct peer *); 546static void arc_receive (struct recvbuf *); 547static void arc_poll (int, struct peer *); 548 549/* 550 * Transfer vector 551 */ 552struct refclock refclock_arc = { 553 arc_start, /* start up driver */ 554 arc_shutdown, /* shut down driver */ 555 arc_poll, /* transmit poll message */ 556 noentry, /* not used (old arc_control) */ 557 noentry, /* initialize driver (not used) */ 558 noentry, /* not used (old arc_buginfo) */ 559 NOFLAGS /* not used */ 560}; 561 562/* Queue us up for the next tick. */ 563#define ENQUEUE(up) \ 564 do { \ 565 peer->procptr->nextaction = current_time + QUEUETICK; \ 566 } while(0) 567 568/* Placeholder event handler---does nothing safely---soaks up loose tick. */ 569static void 570dummy_event_handler( 571 struct peer *peer 572 ) 573{ 574#ifdef DEBUG 575 if(debug) { printf("arc: dummy_event_handler() called.\n"); } 576#endif 577} 578 579/* 580Normal event handler. 581 582Take first character off queue and send to clock if not a null. 583 584Shift characters down and put a null on the end. 585 586We assume that there is no parallelism so no race condition, but even 587if there is nothing bad will happen except that we might send some bad 588data to the clock once in a while. 589*/ 590static void 591arc_event_handler( 592 struct peer *peer 593 ) 594{ 595 struct refclockproc *pp = peer->procptr; 596 register struct arcunit *up = pp->unitptr; 597 int i; 598 char c; 599#ifdef DEBUG 600 if(debug > 2) { printf("arc: arc_event_handler() called.\n"); } 601#endif 602 603 c = up->cmdqueue[0]; /* Next char to be sent. */ 604 /* Shift down characters, shifting trailing \0 in at end. */ 605 for(i = 0; i < CMDQUEUELEN; ++i) 606 { up->cmdqueue[i] = up->cmdqueue[i+1]; } 607 608 /* Don't send '\0' characters. */ 609 if(c != '\0') { 610 if(write(pp->io.fd, &c, 1) != 1) { 611 msyslog(LOG_NOTICE, "ARCRON: write to fd %d failed", pp->io.fd); 612 } 613#ifdef DEBUG 614 else if(debug) { printf("arc: sent `%2.2x', fd %d.\n", c, pp->io.fd); } 615#endif 616 } 617 618 ENQUEUE(up); 619} 620 621/* 622 * arc_start - open the devices and initialize data for processing 623 */ 624static int 625arc_start( 626 int unit, 627 struct peer *peer 628 ) 629{ 630 register struct arcunit *up; 631 struct refclockproc *pp; 632 int temp_fd; 633 int fd; 634 char device[20]; 635#ifdef HAVE_TERMIOS 636 struct termios arg; 637#endif 638 639 msyslog(LOG_NOTICE, "MSF_ARCRON %s: opening unit %d", 640 arc_version, unit); 641 DPRINTF(1, ("arc: %s: attempt to open unit %d.\n", arc_version, 642 unit)); 643 644 /* 645 * Open serial port. Use CLK line discipline, if available. 646 */ 647 snprintf(device, sizeof(device), DEVICE, unit); 648 temp_fd = refclock_open(device, SPEED, LDISC_CLK); 649 if (temp_fd <= 0) 650 return 0; 651 DPRINTF(1, ("arc: unit %d using tty_open().\n", unit)); 652 fd = tty_open(device, OPEN_FLAGS, 0777); 653 if (fd < 0) { 654 msyslog(LOG_ERR, "MSF_ARCRON(%d): failed second open(%s, 0777): %m.", 655 unit, device); 656 close(temp_fd); 657 return 0; 658 } 659 close(temp_fd); 660 temp_fd = -1; /* not used after this, at *this* time. */ 661 662#ifndef SYS_WINNT 663 if (-1 == fcntl(fd, F_SETFL, 0)) /* clear the descriptor flags */ 664 msyslog(LOG_ERR, "MSF_ARCRON(%d): fcntl(F_SETFL, 0): %m.", 665 unit); 666 667#endif 668 DPRINTF(1, ("arc: opened RS232 port with file descriptor %d.\n", fd)); 669 670#ifdef HAVE_TERMIOS 671 672 if (tcgetattr(fd, &arg) < 0) { 673 msyslog(LOG_ERR, "MSF_ARCRON(%d): tcgetattr(%s): %m.", 674 unit, device); 675 close(fd); 676 return 0; 677 } 678 679 arg.c_iflag = IGNBRK | ISTRIP; 680 arg.c_oflag = 0; 681 arg.c_cflag = B300 | CS8 | CREAD | CLOCAL | CSTOPB; 682 arg.c_lflag = 0; 683 arg.c_cc[VMIN] = 1; 684 arg.c_cc[VTIME] = 0; 685 686 if (tcsetattr(fd, TCSANOW, &arg) < 0) { 687 msyslog(LOG_ERR, "MSF_ARCRON(%d): tcsetattr(%s): %m.", 688 unit, device); 689 close(fd); 690 return 0; 691 } 692 693#else 694 695 msyslog(LOG_ERR, "ARCRON: termios required by this driver"); 696 (void)close(fd); 697 698 return 0; 699 700#endif 701 702 /* Set structure to all zeros... */ 703 up = emalloc_zero(sizeof(*up)); 704 pp = peer->procptr; 705 pp->io.clock_recv = arc_receive; 706 pp->io.srcclock = peer; 707 pp->io.datalen = 0; 708 pp->io.fd = fd; 709 if (!io_addclock(&pp->io)) { 710 close(fd); 711 pp->io.fd = -1; 712 free(up); 713 return(0); 714 } 715 pp->unitptr = up; 716 717 /* 718 * Initialize miscellaneous variables 719 */ 720 peer->precision = PRECISION; 721 peer->stratum = 2; /* Default to stratum 2 not 0. */ 722 pp->clockdesc = DESCRIPTION; 723 if (peer->MODE > 3) { 724 msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d", peer->MODE); 725 return 0; 726 } 727#ifdef DEBUG 728 if(debug) { printf("arc: mode = %d.\n", peer->MODE); } 729#endif 730 switch (peer->MODE) { 731 case 1: 732 memcpy((char *)&pp->refid, REFID_MSF, 4); 733 break; 734 case 2: 735 memcpy((char *)&pp->refid, REFID_DCF77, 4); 736 break; 737 case 3: 738 memcpy((char *)&pp->refid, REFID_WWVB, 4); 739 break; 740 default: 741 memcpy((char *)&pp->refid, REFID, 4); 742 break; 743 } 744 /* Spread out resyncs so that they should remain separated. */ 745 up->next_resync = current_time + INITIAL_RESYNC_DELAY + (67*unit)%1009; 746 747#if 0 /* Not needed because of zeroing of arcunit structure... */ 748 up->resyncing = 0; /* Not resyncing yet. */ 749 up->saved_flags = 0; /* Default is all flags off. */ 750 /* Clear send buffer out... */ 751 { 752 int i; 753 for(i = CMDQUEUELEN; i >= 0; --i) { up->cmdqueue[i] = '\0'; } 754 } 755#endif 756 757#ifdef ARCRON_KEEN 758 up->quality = QUALITY_UNKNOWN; /* Trust the clock immediately. */ 759#else 760 up->quality = MIN_CLOCK_QUALITY;/* Don't trust the clock yet. */ 761#endif 762 763 peer->procptr->action = arc_event_handler; 764 765 ENQUEUE(up); 766 767 return(1); 768} 769 770 771/* 772 * arc_shutdown - shut down the clock 773 */ 774static void 775arc_shutdown( 776 int unit, 777 struct peer *peer 778 ) 779{ 780 register struct arcunit *up; 781 struct refclockproc *pp; 782 783 peer->procptr->action = dummy_event_handler; 784 785 pp = peer->procptr; 786 up = pp->unitptr; 787 if (-1 != pp->io.fd) 788 io_closeclock(&pp->io); 789 if (NULL != up) 790 free(up); 791} 792 793/* 794Compute space left in output buffer. 795*/ 796static int 797space_left( 798 register struct arcunit *up 799 ) 800{ 801 int spaceleft; 802 803 /* Compute space left in buffer after any pending output. */ 804 for(spaceleft = 0; spaceleft < CMDQUEUELEN; ++spaceleft) 805 { if(up->cmdqueue[CMDQUEUELEN - 1 - spaceleft] != '\0') { break; } } 806 return(spaceleft); 807} 808 809/* 810Send command by copying into command buffer as far forward as possible, 811after any pending output. 812 813Indicate an error by returning 0 if there is not space for the command. 814*/ 815static int 816send_slow( 817 register struct arcunit *up, 818 int fd, 819 const char *s 820 ) 821{ 822 int sl = strlen(s); 823 int spaceleft = space_left(up); 824 825#ifdef DEBUG 826 if(debug > 1) { printf("arc: spaceleft = %d.\n", spaceleft); } 827#endif 828 if(spaceleft < sl) { /* Should not normally happen... */ 829#ifdef DEBUG 830 msyslog(LOG_NOTICE, "ARCRON: send-buffer overrun (%d/%d)", 831 sl, spaceleft); 832#endif 833 return(0); /* FAILED! */ 834 } 835 836 /* Copy in the command to be sent. */ 837 while(*s && spaceleft > 0) { up->cmdqueue[CMDQUEUELEN - spaceleft--] = *s++; } 838 839 return(1); 840} 841 842 843static int 844get2(char *p, int *val) 845{ 846 if (!isdigit((unsigned char)p[0]) || !isdigit((unsigned char)p[1])) return 0; 847 *val = (p[0] - '0') * 10 + p[1] - '0'; 848 return 1; 849} 850 851static int 852get1(char *p, int *val) 853{ 854 if (!isdigit((unsigned char)p[0])) return 0; 855 *val = p[0] - '0'; 856 return 1; 857} 858 859/* Macro indicating action we will take for different quality values. */ 860#define quality_action(q) \ 861(((q) == QUALITY_UNKNOWN) ? "UNKNOWN, will use clock anyway" : \ 862 (((q) < MIN_CLOCK_QUALITY_OK) ? "TOO POOR, will not use clock" : \ 863 "OK, will use clock")) 864 865/* 866 * arc_receive - receive data from the serial interface 867 */ 868static void 869arc_receive( 870 struct recvbuf *rbufp 871 ) 872{ 873 register struct arcunit *up; 874 struct refclockproc *pp; 875 struct peer *peer; 876 char c; 877 int i, n, wday, month, flags, status; 878 int arc_last_offset; 879 static int quality_average = 0; 880 static int quality_sum = 0; 881 static int quality_polls = 0; 882 883 /* 884 * Initialize pointers and read the timecode and timestamp 885 */ 886 peer = rbufp->recv_peer; 887 pp = peer->procptr; 888 up = pp->unitptr; 889 890 891 /* 892 If the command buffer is empty, and we are resyncing, insert a 893 g\r quality request into it to poll for signal quality again. 894 */ 895 if((up->resyncing) && (space_left(up) == CMDQUEUELEN)) { 896#ifdef DEBUG 897 if(debug > 1) { printf("arc: inserting signal-quality poll.\n"); } 898#endif 899 send_slow(up, pp->io.fd, "g\r"); 900 } 901 902 /* 903 The `arc_last_offset' is the offset in lastcode[] of the last byte 904 received, and which we assume actually received the input 905 timestamp. 906 907 (When we get round to using tty_clk and it is available, we 908 assume that we will receive the whole timecode with the 909 trailing \r, and that that \r will be timestamped. But this 910 assumption also works if receive the characters one-by-one.) 911 */ 912 arc_last_offset = pp->lencode+rbufp->recv_length - 1; 913 914 /* 915 We catch a timestamp iff: 916 917 * The command code is `o' for a timestamp. 918 919 * If ARCRON_MULTIPLE_SAMPLES is undefined then we must have 920 exactly char in the buffer (the command code) so that we 921 only sample the first character of the timecode as our 922 `on-time' character. 923 924 * The first character in the buffer is not the echoed `\r' 925 from the `o` command (so if we are to timestamp an `\r' it 926 must not be first in the receive buffer with lencode==1. 927 (Even if we had other characters following it, we probably 928 would have a premature timestamp on the '\r'.) 929 930 * We have received at least one character (I cannot imagine 931 how it could be otherwise, but anyway...). 932 */ 933 c = rbufp->recv_buffer[0]; 934 if((pp->a_lastcode[0] == 'o') && 935#ifndef ARCRON_MULTIPLE_SAMPLES 936 (pp->lencode == 1) && 937#endif 938 ((pp->lencode != 1) || (c != '\r')) && 939 (arc_last_offset >= 1)) { 940 /* Note that the timestamp should be corrected if >1 char rcvd. */ 941 l_fp timestamp; 942 timestamp = rbufp->recv_time; 943#ifdef DEBUG 944 if(debug) { /* Show \r as `R', other non-printing char as `?'. */ 945 printf("arc: stamp -->%c<-- (%d chars rcvd)\n", 946 ((c == '\r') ? 'R' : (isgraph((unsigned char)c) ? c : '?')), 947 rbufp->recv_length); 948 } 949#endif 950 951 /* 952 Now correct timestamp by offset of last byte received---we 953 subtract from the receive time the delay implied by the 954 extra characters received. 955 956 Reject the input if the resulting code is too long, but 957 allow for the trailing \r, normally not used but a good 958 handle for tty_clk or somesuch kernel timestamper. 959 */ 960 if(arc_last_offset > LENARC) { 961#ifdef DEBUG 962 if(debug) { 963 printf("arc: input code too long (%d cf %d); rejected.\n", 964 arc_last_offset, LENARC); 965 } 966#endif 967 pp->lencode = 0; 968 refclock_report(peer, CEVNT_BADREPLY); 969 return; 970 } 971 972 L_SUBUF(×tamp, charoffsets[arc_last_offset]); 973#ifdef DEBUG 974 if(debug > 1) { 975 printf( 976 "arc: %s%d char(s) rcvd, the last for lastcode[%d]; -%sms offset applied.\n", 977 ((rbufp->recv_length > 1) ? "*** " : ""), 978 rbufp->recv_length, 979 arc_last_offset, 980 mfptoms((unsigned long)0, 981 charoffsets[arc_last_offset], 982 1)); 983 } 984#endif 985 986#ifdef ARCRON_MULTIPLE_SAMPLES 987 /* 988 If taking multiple samples, capture the current adjusted 989 sample iff: 990 991 * No timestamp has yet been captured (it is zero), OR 992 993 * This adjusted timestamp is earlier than the one already 994 captured, on the grounds that this one suffered less 995 delay in being delivered to us and is more accurate. 996 997 */ 998 if(L_ISZERO(&(up->lastrec)) || 999 L_ISGEQ(&(up->lastrec), ×tamp)) 1000#endif 1001 { 1002#ifdef DEBUG 1003 if(debug > 1) { 1004 printf("arc: system timestamp captured.\n"); 1005#ifdef ARCRON_MULTIPLE_SAMPLES 1006 if(!L_ISZERO(&(up->lastrec))) { 1007 l_fp diff; 1008 diff = up->lastrec; 1009 L_SUB(&diff, ×tamp); 1010 printf("arc: adjusted timestamp by -%sms.\n", 1011 mfptoms(diff.l_ui, diff.l_uf, 3)); 1012 } 1013#endif 1014 } 1015#endif 1016 up->lastrec = timestamp; 1017 } 1018 1019 } 1020 1021 /* Just in case we still have lots of rubbish in the buffer... */ 1022 /* ...and to avoid the same timestamp being reused by mistake, */ 1023 /* eg on receipt of the \r coming in on its own after the */ 1024 /* timecode. */ 1025 if(pp->lencode >= LENARC) { 1026#ifdef DEBUG 1027 if(debug && (rbufp->recv_buffer[0] != '\r')) 1028 { printf("arc: rubbish in pp->a_lastcode[].\n"); } 1029#endif 1030 pp->lencode = 0; 1031 return; 1032 } 1033 1034 /* Append input to code buffer, avoiding overflow. */ 1035 for(i = 0; i < rbufp->recv_length; i++) { 1036 if(pp->lencode >= LENARC) { break; } /* Avoid overflow... */ 1037 c = rbufp->recv_buffer[i]; 1038 1039 /* Drop trailing '\r's and drop `h' command echo totally. */ 1040 if(c != '\r' && c != 'h') { pp->a_lastcode[pp->lencode++] = c; } 1041 1042 /* 1043 If we've just put an `o' in the lastcode[0], clear the 1044 timestamp in anticipation of a timecode arriving soon. 1045 1046 We would expect to get to process this before any of the 1047 timecode arrives. 1048 */ 1049 if((c == 'o') && (pp->lencode == 1)) { 1050 L_CLR(&(up->lastrec)); 1051#ifdef DEBUG 1052 if(debug > 1) { printf("arc: clearing timestamp.\n"); } 1053#endif 1054 } 1055 } 1056 if (pp->lencode == 0) return; 1057 1058 /* Handle a quality message. */ 1059 if(pp->a_lastcode[0] == 'g') { 1060 int r, q; 1061 1062 if(pp->lencode < 3) { return; } /* Need more data... */ 1063 r = (pp->a_lastcode[1] & 0x7f); /* Strip parity. */ 1064 q = (pp->a_lastcode[2] & 0x7f); /* Strip parity. */ 1065 if(((q & 0x70) != 0x30) || ((q & 0xf) > MAX_CLOCK_QUALITY) || 1066 ((r & 0x70) != 0x30)) { 1067 /* Badly formatted response. */ 1068#ifdef DEBUG 1069 if(debug) { printf("arc: bad `g' response %2x %2x.\n", r, q); } 1070#endif 1071 return; 1072 } 1073 if(r == '3') { /* Only use quality value whilst sync in progress. */ 1074 if (up->quality_stamp < current_time) { 1075 struct calendar cal; 1076 l_fp new_stamp; 1077 1078 get_systime (&new_stamp); 1079 caljulian (new_stamp.l_ui, &cal); 1080 up->quality_stamp = 1081 current_time + 60 - cal.second + 5; 1082 quality_sum = 0; 1083 quality_polls = 0; 1084 } 1085 quality_sum += (q & 0xf); 1086 quality_polls++; 1087 quality_average = (quality_sum / quality_polls); 1088#ifdef DEBUG 1089 if(debug) { printf("arc: signal quality %d (%d).\n", quality_average, (q & 0xf)); } 1090#endif 1091 } else if( /* (r == '2') && */ up->resyncing) { 1092 up->quality = quality_average; 1093#ifdef DEBUG 1094 if(debug) 1095 { 1096 printf("arc: sync finished, signal quality %d: %s\n", 1097 up->quality, 1098 quality_action(up->quality)); 1099 } 1100#endif 1101 msyslog(LOG_NOTICE, 1102 "ARCRON: sync finished, signal quality %d: %s", 1103 up->quality, 1104 quality_action(up->quality)); 1105 up->resyncing = 0; /* Resync is over. */ 1106 quality_average = 0; 1107 quality_sum = 0; 1108 quality_polls = 0; 1109 1110#ifdef ARCRON_KEEN 1111 /* Clock quality dubious; resync earlier than usual. */ 1112 if((up->quality == QUALITY_UNKNOWN) || 1113 (up->quality < MIN_CLOCK_QUALITY_OK)) 1114 { up->next_resync = current_time + RETRY_RESYNC_TIME; } 1115#endif 1116 } 1117 pp->lencode = 0; 1118 return; 1119 } 1120 1121 /* Stop now if this is not a timecode message. */ 1122 if(pp->a_lastcode[0] != 'o') { 1123 pp->lencode = 0; 1124 refclock_report(peer, CEVNT_BADREPLY); 1125 return; 1126 } 1127 1128 /* If we don't have enough data, wait for more... */ 1129 if(pp->lencode < LENARC) { return; } 1130 1131 1132 /* WE HAVE NOW COLLECTED ONE TIMESTAMP (phew)... */ 1133#ifdef DEBUG 1134 if(debug > 1) { printf("arc: NOW HAVE TIMESTAMP...\n"); } 1135#endif 1136 1137 /* But check that we actually captured a system timestamp on it. */ 1138 if(L_ISZERO(&(up->lastrec))) { 1139#ifdef DEBUG 1140 if(debug) { printf("arc: FAILED TO GET SYSTEM TIMESTAMP\n"); } 1141#endif 1142 pp->lencode = 0; 1143 refclock_report(peer, CEVNT_BADREPLY); 1144 return; 1145 } 1146 /* 1147 Append a mark of the clock's received signal quality for the 1148 benefit of Derek Mulcahy's Tcl/Tk utility (we map the `unknown' 1149 quality value to `6' for his s/w) and terminate the string for 1150 sure. This should not go off the buffer end. 1151 */ 1152 pp->a_lastcode[pp->lencode] = ((up->quality == QUALITY_UNKNOWN) ? 1153 '6' : ('0' + up->quality)); 1154 pp->a_lastcode[pp->lencode + 1] = '\0'; /* Terminate for printf(). */ 1155 1156#ifdef PRE_NTP420 1157 /* We don't use the micro-/milli- second part... */ 1158 pp->usec = 0; 1159 pp->msec = 0; 1160#else 1161 /* We don't use the nano-second part... */ 1162 pp->nsec = 0; 1163#endif 1164 /* Validate format and numbers. */ 1165 if (pp->a_lastcode[0] != 'o' 1166 || !get2(pp->a_lastcode + 1, &pp->hour) 1167 || !get2(pp->a_lastcode + 3, &pp->minute) 1168 || !get2(pp->a_lastcode + 5, &pp->second) 1169 || !get1(pp->a_lastcode + 7, &wday) 1170 || !get2(pp->a_lastcode + 8, &pp->day) 1171 || !get2(pp->a_lastcode + 10, &month) 1172 || !get2(pp->a_lastcode + 12, &pp->year)) { 1173#ifdef DEBUG 1174 /* Would expect to have caught major problems already... */ 1175 if(debug) { printf("arc: badly formatted data.\n"); } 1176#endif 1177 pp->lencode = 0; 1178 refclock_report(peer, CEVNT_BADREPLY); 1179 return; 1180 } 1181 flags = pp->a_lastcode[14]; 1182 status = pp->a_lastcode[15]; 1183#ifdef DEBUG 1184 if(debug) { printf("arc: status 0x%.2x flags 0x%.2x\n", flags, status); } 1185#endif 1186 n = 9; 1187 1188 /* 1189 Validate received values at least enough to prevent internal 1190 array-bounds problems, etc. 1191 */ 1192 if((pp->hour < 0) || (pp->hour > 23) || 1193 (pp->minute < 0) || (pp->minute > 59) || 1194 (pp->second < 0) || (pp->second > 60) /*Allow for leap seconds.*/ || 1195 (wday < 1) || (wday > 7) || 1196 (pp->day < 1) || (pp->day > 31) || 1197 (month < 1) || (month > 12) || 1198 (pp->year < 0) || (pp->year > 99)) { 1199 /* Data out of range. */ 1200 pp->lencode = 0; 1201 refclock_report(peer, CEVNT_BADREPLY); 1202 return; 1203 } 1204 1205 1206 if(peer->MODE == 0) { /* compatiblity to original version */ 1207 int bst = flags; 1208 /* Check that BST/UTC bits are the complement of one another. */ 1209 if(!(bst & 2) == !(bst & 4)) { 1210 pp->lencode = 0; 1211 refclock_report(peer, CEVNT_BADREPLY); 1212 return; 1213 } 1214 } 1215 if(status & 0x8) { msyslog(LOG_NOTICE, "ARCRON: battery low"); } 1216 1217 /* Year-2000 alert! */ 1218 /* Attempt to wrap 2-digit date into sensible window. */ 1219 if(pp->year < YEAR_PIVOT) { pp->year += 100; } /* Y2KFixes */ 1220 pp->year += 1900; /* use full four-digit year */ /* Y2KFixes */ 1221 /* 1222 Attempt to do the right thing by screaming that the code will 1223 soon break when we get to the end of its useful life. What a 1224 hero I am... PLEASE FIX LEAP-YEAR AND WRAP CODE IN 209X! 1225 */ 1226 if(pp->year >= YEAR_PIVOT+2000-2 ) { /* Y2KFixes */ 1227 /*This should get attention B^> */ 1228 msyslog(LOG_NOTICE, 1229 "ARCRON: fix me! EITHER YOUR DATE IS BADLY WRONG or else I will break soon!"); 1230 } 1231#ifdef DEBUG 1232 if(debug) { 1233 printf("arc: n=%d %02d:%02d:%02d %02d/%02d/%04d %1d %1d\n", 1234 n, 1235 pp->hour, pp->minute, pp->second, 1236 pp->day, month, pp->year, flags, status); 1237 } 1238#endif 1239 1240 /* 1241 The status value tested for is not strictly supported by the 1242 clock spec since the value of bit 2 (0x4) is claimed to be 1243 undefined for MSF, yet does seem to indicate if the last resync 1244 was successful or not. 1245 */ 1246 pp->leap = LEAP_NOWARNING; 1247 status &= 0x7; 1248 if(status == 0x3) { 1249 if(status != up->status) 1250 { msyslog(LOG_NOTICE, "ARCRON: signal acquired"); } 1251 } else { 1252 if(status != up->status) { 1253 msyslog(LOG_NOTICE, "ARCRON: signal lost"); 1254 pp->leap = LEAP_NOTINSYNC; /* MSF clock is free-running. */ 1255 up->status = status; 1256 pp->lencode = 0; 1257 refclock_report(peer, CEVNT_FAULT); 1258 return; 1259 } 1260 } 1261 up->status = status; 1262 1263 if (peer->MODE == 0) { /* compatiblity to original version */ 1264 int bst = flags; 1265 1266 pp->day += moff[month - 1]; 1267 1268 if(isleap_4(pp->year) && month > 2) { pp->day++; }/* Y2KFixes */ 1269 1270 /* Convert to UTC if required */ 1271 if(bst & 2) { 1272 pp->hour--; 1273 if (pp->hour < 0) { 1274 pp->hour = 23; 1275 pp->day--; 1276 /* If we try to wrap round the year 1277 * (BST on 1st Jan), reject.*/ 1278 if(pp->day < 0) { 1279 pp->lencode = 0; 1280 refclock_report(peer, CEVNT_BADTIME); 1281 return; 1282 } 1283 } 1284 } 1285 } 1286 1287 if(peer->MODE > 0) { 1288 if(pp->sloppyclockflag & CLK_FLAG1) { 1289 struct tm local; 1290 struct tm *gmtp; 1291 time_t unixtime; 1292 1293 /* 1294 * Convert to GMT for sites that distribute localtime. 1295 * This means we have to do Y2K conversion on the 1296 * 2-digit year; otherwise, we get the time wrong. 1297 */ 1298 1299 memset(&local, 0, sizeof(local)); 1300 1301 local.tm_year = pp->year-1900; 1302 local.tm_mon = month-1; 1303 local.tm_mday = pp->day; 1304 local.tm_hour = pp->hour; 1305 local.tm_min = pp->minute; 1306 local.tm_sec = pp->second; 1307 switch (peer->MODE) { 1308 case 1: 1309 local.tm_isdst = (flags & 2); 1310 break; 1311 case 2: 1312 local.tm_isdst = (flags & 2); 1313 break; 1314 case 3: 1315 switch (flags & 3) { 1316 case 0: /* It is unclear exactly when the 1317 Arcron changes from DST->ST and 1318 ST->DST. Testing has shown this 1319 to be irregular. For the time 1320 being, let the OS decide. */ 1321 local.tm_isdst = 0; 1322#ifdef DEBUG 1323 if (debug) 1324 printf ("arc: DST = 00 (0)\n"); 1325#endif 1326 break; 1327 case 1: /* dst->st time */ 1328 local.tm_isdst = -1; 1329#ifdef DEBUG 1330 if (debug) 1331 printf ("arc: DST = 01 (1)\n"); 1332#endif 1333 break; 1334 case 2: /* st->dst time */ 1335 local.tm_isdst = -1; 1336#ifdef DEBUG 1337 if (debug) 1338 printf ("arc: DST = 10 (2)\n"); 1339#endif 1340 break; 1341 case 3: /* dst time */ 1342 local.tm_isdst = 1; 1343#ifdef DEBUG 1344 if (debug) 1345 printf ("arc: DST = 11 (3)\n"); 1346#endif 1347 break; 1348 } 1349 break; 1350 default: 1351 msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d", 1352 peer->MODE); 1353 return; 1354 break; 1355 } 1356 unixtime = mktime (&local); 1357 if ((gmtp = gmtime (&unixtime)) == NULL) 1358 { 1359 pp->lencode = 0; 1360 refclock_report (peer, CEVNT_FAULT); 1361 return; 1362 } 1363 pp->year = gmtp->tm_year+1900; 1364 month = gmtp->tm_mon+1; 1365 pp->day = ymd2yd(pp->year,month,gmtp->tm_mday); 1366 /* pp->day = gmtp->tm_yday; */ 1367 pp->hour = gmtp->tm_hour; 1368 pp->minute = gmtp->tm_min; 1369 pp->second = gmtp->tm_sec; 1370#ifdef DEBUG 1371 if (debug) 1372 { 1373 printf ("arc: time is %04d/%02d/%02d %02d:%02d:%02d UTC\n", 1374 pp->year,month,gmtp->tm_mday,pp->hour,pp->minute, 1375 pp->second); 1376 } 1377#endif 1378 } else 1379 { 1380 /* 1381 * For more rational sites distributing UTC 1382 */ 1383 pp->day = ymd2yd(pp->year,month,pp->day); 1384 } 1385 } 1386 1387 if (peer->MODE == 0) { /* compatiblity to original version */ 1388 /* If clock signal quality is 1389 * unknown, revert to default PRECISION...*/ 1390 if(up->quality == QUALITY_UNKNOWN) { 1391 peer->precision = PRECISION; 1392 } else { /* ...else improve precision if flag3 is set... */ 1393 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ? 1394 HIGHPRECISION : PRECISION); 1395 } 1396 } else { 1397 if ((status == 0x3) && (pp->sloppyclockflag & CLK_FLAG2)) { 1398 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ? 1399 HIGHPRECISION : PRECISION); 1400 } else if (up->quality == QUALITY_UNKNOWN) { 1401 peer->precision = PRECISION; 1402 } else { 1403 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ? 1404 HIGHPRECISION : PRECISION); 1405 } 1406 } 1407 1408 /* Notice and log any change (eg from initial defaults) for flags. */ 1409 if(up->saved_flags != pp->sloppyclockflag) { 1410#ifdef DEBUG 1411 msyslog(LOG_NOTICE, "ARCRON: flags enabled: %s%s%s%s", 1412 ((pp->sloppyclockflag & CLK_FLAG1) ? "1" : "."), 1413 ((pp->sloppyclockflag & CLK_FLAG2) ? "2" : "."), 1414 ((pp->sloppyclockflag & CLK_FLAG3) ? "3" : "."), 1415 ((pp->sloppyclockflag & CLK_FLAG4) ? "4" : ".")); 1416 /* Note effects of flags changing... */ 1417 if(debug) { 1418 printf("arc: PRECISION = %d.\n", peer->precision); 1419 } 1420#endif 1421 up->saved_flags = pp->sloppyclockflag; 1422 } 1423 1424 /* Note time of last believable timestamp. */ 1425 pp->lastrec = up->lastrec; 1426 1427#ifdef ARCRON_LEAPSECOND_KEEN 1428 /* Find out if a leap-second might just have happened... 1429 (ie is this the first hour of the first day of Jan or Jul?) 1430 */ 1431 if((pp->hour == 0) && 1432 (pp->day == 1) && 1433 ((month == 1) || (month == 7))) { 1434 if(possible_leap >= 0) { 1435 /* A leap may have happened, and no resync has started yet...*/ 1436 possible_leap = 1; 1437 } 1438 } else { 1439 /* Definitely not leap-second territory... */ 1440 possible_leap = 0; 1441 } 1442#endif 1443 1444 if (!refclock_process(pp)) { 1445 pp->lencode = 0; 1446 refclock_report(peer, CEVNT_BADTIME); 1447 return; 1448 } 1449 record_clock_stats(&peer->srcadr, pp->a_lastcode); 1450 refclock_receive(peer); 1451} 1452 1453 1454/* request_time() sends a time request to the clock with given peer. */ 1455/* This automatically reports a fault if necessary. */ 1456/* No data should be sent after this until arc_poll() returns. */ 1457static void request_time (int, struct peer *); 1458static void 1459request_time( 1460 int unit, 1461 struct peer *peer 1462 ) 1463{ 1464 struct refclockproc *pp = peer->procptr; 1465 register struct arcunit *up = pp->unitptr; 1466#ifdef DEBUG 1467 if(debug) { printf("arc: unit %d: requesting time.\n", unit); } 1468#endif 1469 if (!send_slow(up, pp->io.fd, "o\r")) { 1470#ifdef DEBUG 1471 if (debug) { 1472 printf("arc: unit %d: problem sending", unit); 1473 } 1474#endif 1475 pp->lencode = 0; 1476 refclock_report(peer, CEVNT_FAULT); 1477 return; 1478 } 1479 pp->polls++; 1480} 1481 1482/* 1483 * arc_poll - called by the transmit procedure 1484 */ 1485static void 1486arc_poll( 1487 int unit, 1488 struct peer *peer 1489 ) 1490{ 1491 register struct arcunit *up; 1492 struct refclockproc *pp; 1493 int resync_needed; /* Should we start a resync? */ 1494 1495 pp = peer->procptr; 1496 up = pp->unitptr; 1497#if 0 1498 pp->lencode = 0; 1499 memset(pp->a_lastcode, 0, sizeof(pp->a_lastcode)); 1500#endif 1501 1502#if 0 1503 /* Flush input. */ 1504 tcflush(pp->io.fd, TCIFLUSH); 1505#endif 1506 1507 /* Resync if our next scheduled resync time is here or has passed. */ 1508 resync_needed = ( !(pp->sloppyclockflag & CLK_FLAG2) && 1509 (up->next_resync <= current_time) ); 1510 1511#ifdef ARCRON_LEAPSECOND_KEEN 1512 /* 1513 Try to catch a potential leap-second insertion or deletion quickly. 1514 1515 In addition to the normal NTP fun of clocks that don't report 1516 leap-seconds spooking their hosts, this clock does not even 1517 sample the radio sugnal the whole time, so may miss a 1518 leap-second insertion or deletion for up to a whole sample 1519 time. 1520 1521 To try to minimise this effect, if in the first few minutes of 1522 the day immediately following a leap-second-insertion point 1523 (ie in the first hour of the first day of the first and sixth 1524 months), and if the last resync was in the previous day, and a 1525 resync is not already in progress, resync the clock 1526 immediately. 1527 1528 */ 1529 if((possible_leap > 0) && /* Must be 00:XX 01/0{1,7}/XXXX. */ 1530 (!up->resyncing)) { /* No resync in progress yet. */ 1531 resync_needed = 1; 1532 possible_leap = -1; /* Prevent multiple resyncs. */ 1533 msyslog(LOG_NOTICE,"ARCRON: unit %d: checking for leap second",unit); 1534 } 1535#endif 1536 1537 /* Do a resync if required... */ 1538 if(resync_needed) { 1539 /* First, reset quality value to `unknown' so we can detect */ 1540 /* when a quality message has been responded to by this */ 1541 /* being set to some other value. */ 1542 up->quality = QUALITY_UNKNOWN; 1543 1544 /* Note that we are resyncing... */ 1545 up->resyncing = 1; 1546 1547 /* Now actually send the resync command and an immediate poll. */ 1548#ifdef DEBUG 1549 if(debug) { printf("arc: sending resync command (h\\r).\n"); } 1550#endif 1551 msyslog(LOG_NOTICE, "ARCRON: unit %d: sending resync command", unit); 1552 send_slow(up, pp->io.fd, "h\r"); 1553 1554 /* Schedule our next resync... */ 1555 up->next_resync = current_time + DEFAULT_RESYNC_TIME; 1556 1557 /* Drop through to request time if appropriate. */ 1558 } 1559 1560 /* If clock quality is too poor to trust, indicate a fault. */ 1561 /* If quality is QUALITY_UNKNOWN and ARCRON_KEEN is defined,*/ 1562 /* we'll cross our fingers and just hope that the thing */ 1563 /* synced so quickly we did not catch it---we'll */ 1564 /* double-check the clock is OK elsewhere. */ 1565 if( 1566#ifdef ARCRON_KEEN 1567 (up->quality != QUALITY_UNKNOWN) && 1568#else 1569 (up->quality == QUALITY_UNKNOWN) || 1570#endif 1571 (up->quality < MIN_CLOCK_QUALITY_OK)) { 1572#ifdef DEBUG 1573 if(debug) { 1574 printf("arc: clock quality %d too poor.\n", up->quality); 1575 } 1576#endif 1577 pp->lencode = 0; 1578 refclock_report(peer, CEVNT_FAULT); 1579 return; 1580 } 1581 /* This is the normal case: request a timestamp. */ 1582 request_time(unit, peer); 1583} 1584 1585#else 1586NONEMPTY_TRANSLATION_UNIT 1587#endif 1588