1 /* $NetBSD: refclock_arc.c,v 1.3 2012/02/01 07:46:22 kardel Exp $ */ 2 3 /* 4 * refclock_arc - clock driver for ARCRON MSF/DCF/WWVB receivers 5 */ 6 7 #ifdef HAVE_CONFIG_H 8 #include <config.h> 9 #endif 10 11 #if defined(REFCLOCK) && defined(CLOCK_ARCRON_MSF) 12 13 static 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 /* 34 Code by Derek Mulcahy, <derek@toybox.demon.co.uk>, 1997. 35 Modifications by Damon Hart-Davis, <d@hd.org>, 1997. 36 Modifications by Paul Alfille, <palfille@partners.org>, 2003. 37 Modifications by Christopher Price, <cprice@cs-home.com>, 2003. 38 Modifications by Nigel Roles <nigel@9fs.org>, 2003. 39 40 41 THIS CODE IS SUPPLIED AS IS, WITH NO WARRANTY OF ANY KIND. USE AT 42 YOUR OWN RISK. 43 44 Orginally developed and used with ntp3-5.85 by Derek Mulcahy. 45 46 Built against ntp3-5.90 on Solaris 2.5 using gcc 2.7.2. 47 48 This code may be freely copied and used and incorporated in other 49 systems providing the disclaimer and notice of authorship are 50 reproduced. 51 52 ------------------------------------------------------------------------------- 53 54 Nigel's notes: 55 56 1) Called tcgetattr() before modifying, so that fields correctly initialised 57 for all operating systems 58 59 2) 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 64 Christopher's notes: 65 66 MAJOR 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 91 Author's original note: 92 93 I enclose my ntp driver for the Galleon Systems Arc MSF receiver. 94 95 It works (after a fashion) on both Solaris-1 and Solaris-2. 96 97 I am currently using ntp3-5.85. I have been running the code for 98 about 7 months without any problems. Even coped with the change to BST! 99 100 I had to do some funky things to read from the clock because it uses the 101 power from the receive lines to drive the transmit lines. This makes the 102 code look a bit stupid but it works. I also had to put in some delays to 103 allow for the turnaround time from receive to transmit. These delays 104 are between characters when requesting a time stamp so that shouldn't affect 105 the results too drastically. 106 107 ... 108 109 The bottom line is that it works but could easily be improved. You are 110 free to do what you will with the code. I haven't been able to determine 111 how good the clock is. I think that this requires a known good clock 112 to compare it against. 113 114 ------------------------------------------------------------------------------- 115 116 Damon's notes for adjustments: 117 118 MAJOR 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 133 GENERAL 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 254 TO-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: 297 You 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: 346 Also note g<cr> command which confirms that a resync is in progress, and 347 if so what signal quality (0--5) is available. 348 Also 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 */ 489 struct 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 */ 528 static int possible_leap = 0; /* No resync required by default. */ 529 #endif 530 531 #if 0 532 static void dummy_event_handler (struct peer *); 533 static 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 */ 544 static int arc_start (int, struct peer *); 545 static void arc_shutdown (int, struct peer *); 546 static void arc_receive (struct recvbuf *); 547 static void arc_poll (int, struct peer *); 548 549 /* 550 * Transfer vector 551 */ 552 struct 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->nextaction = current_time + QUEUETICK; \ 566 } while(0) 567 568 /* Placeholder event handler---does nothing safely---soaks up loose tick. */ 569 static void 570 dummy_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 /* 580 Normal event handler. 581 582 Take first character off queue and send to clock if not a null. 583 584 Shift characters down and put a null on the end. 585 586 We assume that there is no parallelism so no race condition, but even 587 if there is nothing bad will happen except that we might send some bad 588 data to the clock once in a while. 589 */ 590 static void 591 arc_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 */ 624 static int 625 arc_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.\n", 655 unit, device); 656 close(temp_fd); 657 return 0; 658 } 659 close(temp_fd); 660 temp_fd = -1; 661 662 #ifndef SYS_WINNT 663 fcntl(fd, F_SETFL, 0); /* clear the descriptor flags */ 664 #endif 665 DPRINTF(1, ("arc: opened RS232 port with file descriptor %d.\n", fd)); 666 667 #ifdef HAVE_TERMIOS 668 669 if (tcgetattr(fd, &arg) < 0) { 670 msyslog(LOG_ERR, "MSF_ARCRON(%d): tcgetattr(%s): %m.\n", 671 unit, device); 672 close(fd); 673 return 0; 674 } 675 676 arg.c_iflag = IGNBRK | ISTRIP; 677 arg.c_oflag = 0; 678 arg.c_cflag = B300 | CS8 | CREAD | CLOCAL | CSTOPB; 679 arg.c_lflag = 0; 680 arg.c_cc[VMIN] = 1; 681 arg.c_cc[VTIME] = 0; 682 683 if (tcsetattr(fd, TCSANOW, &arg) < 0) { 684 msyslog(LOG_ERR, "MSF_ARCRON(%d): tcsetattr(%s): %m.\n", 685 unit, device); 686 close(fd); 687 return 0; 688 } 689 690 #else 691 692 msyslog(LOG_ERR, "ARCRON: termios required by this driver"); 693 (void)close(fd); 694 695 return 0; 696 697 #endif 698 699 /* Set structure to all zeros... */ 700 up = emalloc_zero(sizeof(*up)); 701 pp = peer->procptr; 702 pp->io.clock_recv = arc_receive; 703 pp->io.srcclock = (caddr_t)peer; 704 pp->io.datalen = 0; 705 pp->io.fd = fd; 706 if (!io_addclock(&pp->io)) { 707 close(fd); 708 pp->io.fd = -1; 709 free(up); 710 return(0); 711 } 712 pp->unitptr = up; 713 714 /* 715 * Initialize miscellaneous variables 716 */ 717 peer->precision = PRECISION; 718 peer->stratum = 2; /* Default to stratum 2 not 0. */ 719 pp->clockdesc = DESCRIPTION; 720 if (peer->MODE > 3) { 721 msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d", peer->MODE); 722 return 0; 723 } 724 #ifdef DEBUG 725 if(debug) { printf("arc: mode = %d.\n", peer->MODE); } 726 #endif 727 switch (peer->MODE) { 728 case 1: 729 memcpy((char *)&pp->refid, REFID_MSF, 4); 730 break; 731 case 2: 732 memcpy((char *)&pp->refid, REFID_DCF77, 4); 733 break; 734 case 3: 735 memcpy((char *)&pp->refid, REFID_WWVB, 4); 736 break; 737 default: 738 memcpy((char *)&pp->refid, REFID, 4); 739 break; 740 } 741 /* Spread out resyncs so that they should remain separated. */ 742 up->next_resync = current_time + INITIAL_RESYNC_DELAY + (67*unit)%1009; 743 744 #if 0 /* Not needed because of zeroing of arcunit structure... */ 745 up->resyncing = 0; /* Not resyncing yet. */ 746 up->saved_flags = 0; /* Default is all flags off. */ 747 /* Clear send buffer out... */ 748 { 749 int i; 750 for(i = CMDQUEUELEN; i >= 0; --i) { up->cmdqueue[i] = '\0'; } 751 } 752 #endif 753 754 #ifdef ARCRON_KEEN 755 up->quality = QUALITY_UNKNOWN; /* Trust the clock immediately. */ 756 #else 757 up->quality = MIN_CLOCK_QUALITY;/* Don't trust the clock yet. */ 758 #endif 759 760 peer->action = arc_event_handler; 761 762 ENQUEUE(up); 763 764 return(1); 765 } 766 767 768 /* 769 * arc_shutdown - shut down the clock 770 */ 771 static void 772 arc_shutdown( 773 int unit, 774 struct peer *peer 775 ) 776 { 777 register struct arcunit *up; 778 struct refclockproc *pp; 779 780 peer->action = dummy_event_handler; 781 782 pp = peer->procptr; 783 up = pp->unitptr; 784 if (-1 != pp->io.fd) 785 io_closeclock(&pp->io); 786 if (NULL != up) 787 free(up); 788 } 789 790 /* 791 Compute space left in output buffer. 792 */ 793 static int 794 space_left( 795 register struct arcunit *up 796 ) 797 { 798 int spaceleft; 799 800 /* Compute space left in buffer after any pending output. */ 801 for(spaceleft = 0; spaceleft < CMDQUEUELEN; ++spaceleft) 802 { if(up->cmdqueue[CMDQUEUELEN - 1 - spaceleft] != '\0') { break; } } 803 return(spaceleft); 804 } 805 806 /* 807 Send command by copying into command buffer as far forward as possible, 808 after any pending output. 809 810 Indicate an error by returning 0 if there is not space for the command. 811 */ 812 static int 813 send_slow( 814 register struct arcunit *up, 815 int fd, 816 const char *s 817 ) 818 { 819 int sl = strlen(s); 820 int spaceleft = space_left(up); 821 822 #ifdef DEBUG 823 if(debug > 1) { printf("arc: spaceleft = %d.\n", spaceleft); } 824 #endif 825 if(spaceleft < sl) { /* Should not normally happen... */ 826 #ifdef DEBUG 827 msyslog(LOG_NOTICE, "ARCRON: send-buffer overrun (%d/%d)", 828 sl, spaceleft); 829 #endif 830 return(0); /* FAILED! */ 831 } 832 833 /* Copy in the command to be sent. */ 834 while(*s && spaceleft > 0) { up->cmdqueue[CMDQUEUELEN - spaceleft--] = *s++; } 835 836 return(1); 837 } 838 839 840 static int 841 get2(char *p, int *val) 842 { 843 if (!isdigit((unsigned char)p[0]) || !isdigit((unsigned char)p[1])) return 0; 844 *val = (p[0] - '0') * 10 + p[1] - '0'; 845 return 1; 846 } 847 848 static int 849 get1(char *p, int *val) 850 { 851 if (!isdigit((unsigned char)p[0])) return 0; 852 *val = p[0] - '0'; 853 return 1; 854 } 855 856 /* Macro indicating action we will take for different quality values. */ 857 #define quality_action(q) \ 858 (((q) == QUALITY_UNKNOWN) ? "UNKNOWN, will use clock anyway" : \ 859 (((q) < MIN_CLOCK_QUALITY_OK) ? "TOO POOR, will not use clock" : \ 860 "OK, will use clock")) 861 862 /* 863 * arc_receive - receive data from the serial interface 864 */ 865 static void 866 arc_receive( 867 struct recvbuf *rbufp 868 ) 869 { 870 register struct arcunit *up; 871 struct refclockproc *pp; 872 struct peer *peer; 873 char c; 874 int i, n, wday, month, flags, status; 875 int arc_last_offset; 876 static int quality_average = 0; 877 static int quality_sum = 0; 878 static int quality_polls = 0; 879 880 /* 881 * Initialize pointers and read the timecode and timestamp 882 */ 883 peer = (struct peer *)rbufp->recv_srcclock; 884 pp = peer->procptr; 885 up = pp->unitptr; 886 887 888 /* 889 If the command buffer is empty, and we are resyncing, insert a 890 g\r quality request into it to poll for signal quality again. 891 */ 892 if((up->resyncing) && (space_left(up) == CMDQUEUELEN)) { 893 #ifdef DEBUG 894 if(debug > 1) { printf("arc: inserting signal-quality poll.\n"); } 895 #endif 896 send_slow(up, pp->io.fd, "g\r"); 897 } 898 899 /* 900 The `arc_last_offset' is the offset in lastcode[] of the last byte 901 received, and which we assume actually received the input 902 timestamp. 903 904 (When we get round to using tty_clk and it is available, we 905 assume that we will receive the whole timecode with the 906 trailing \r, and that that \r will be timestamped. But this 907 assumption also works if receive the characters one-by-one.) 908 */ 909 arc_last_offset = pp->lencode+rbufp->recv_length - 1; 910 911 /* 912 We catch a timestamp iff: 913 914 * The command code is `o' for a timestamp. 915 916 * If ARCRON_MULTIPLE_SAMPLES is undefined then we must have 917 exactly char in the buffer (the command code) so that we 918 only sample the first character of the timecode as our 919 `on-time' character. 920 921 * The first character in the buffer is not the echoed `\r' 922 from the `o` command (so if we are to timestamp an `\r' it 923 must not be first in the receive buffer with lencode==1. 924 (Even if we had other characters following it, we probably 925 would have a premature timestamp on the '\r'.) 926 927 * We have received at least one character (I cannot imagine 928 how it could be otherwise, but anyway...). 929 */ 930 c = rbufp->recv_buffer[0]; 931 if((pp->a_lastcode[0] == 'o') && 932 #ifndef ARCRON_MULTIPLE_SAMPLES 933 (pp->lencode == 1) && 934 #endif 935 ((pp->lencode != 1) || (c != '\r')) && 936 (arc_last_offset >= 1)) { 937 /* Note that the timestamp should be corrected if >1 char rcvd. */ 938 l_fp timestamp; 939 timestamp = rbufp->recv_time; 940 #ifdef DEBUG 941 if(debug) { /* Show \r as `R', other non-printing char as `?'. */ 942 printf("arc: stamp -->%c<-- (%d chars rcvd)\n", 943 ((c == '\r') ? 'R' : (isgraph((unsigned char)c) ? c : '?')), 944 rbufp->recv_length); 945 } 946 #endif 947 948 /* 949 Now correct timestamp by offset of last byte received---we 950 subtract from the receive time the delay implied by the 951 extra characters received. 952 953 Reject the input if the resulting code is too long, but 954 allow for the trailing \r, normally not used but a good 955 handle for tty_clk or somesuch kernel timestamper. 956 */ 957 if(arc_last_offset > LENARC) { 958 #ifdef DEBUG 959 if(debug) { 960 printf("arc: input code too long (%d cf %d); rejected.\n", 961 arc_last_offset, LENARC); 962 } 963 #endif 964 pp->lencode = 0; 965 refclock_report(peer, CEVNT_BADREPLY); 966 return; 967 } 968 969 L_SUBUF(×tamp, charoffsets[arc_last_offset]); 970 #ifdef DEBUG 971 if(debug > 1) { 972 printf( 973 "arc: %s%d char(s) rcvd, the last for lastcode[%d]; -%sms offset applied.\n", 974 ((rbufp->recv_length > 1) ? "*** " : ""), 975 rbufp->recv_length, 976 arc_last_offset, 977 mfptoms((unsigned long)0, 978 charoffsets[arc_last_offset], 979 1)); 980 } 981 #endif 982 983 #ifdef ARCRON_MULTIPLE_SAMPLES 984 /* 985 If taking multiple samples, capture the current adjusted 986 sample iff: 987 988 * No timestamp has yet been captured (it is zero), OR 989 990 * This adjusted timestamp is earlier than the one already 991 captured, on the grounds that this one suffered less 992 delay in being delivered to us and is more accurate. 993 994 */ 995 if(L_ISZERO(&(up->lastrec)) || 996 L_ISGEQ(&(up->lastrec), ×tamp)) 997 #endif 998 { 999 #ifdef DEBUG 1000 if(debug > 1) { 1001 printf("arc: system timestamp captured.\n"); 1002 #ifdef ARCRON_MULTIPLE_SAMPLES 1003 if(!L_ISZERO(&(up->lastrec))) { 1004 l_fp diff; 1005 diff = up->lastrec; 1006 L_SUB(&diff, ×tamp); 1007 printf("arc: adjusted timestamp by -%sms.\n", 1008 mfptoms(diff.l_i, diff.l_f, 3)); 1009 } 1010 #endif 1011 } 1012 #endif 1013 up->lastrec = timestamp; 1014 } 1015 1016 } 1017 1018 /* Just in case we still have lots of rubbish in the buffer... */ 1019 /* ...and to avoid the same timestamp being reused by mistake, */ 1020 /* eg on receipt of the \r coming in on its own after the */ 1021 /* timecode. */ 1022 if(pp->lencode >= LENARC) { 1023 #ifdef DEBUG 1024 if(debug && (rbufp->recv_buffer[0] != '\r')) 1025 { printf("arc: rubbish in pp->a_lastcode[].\n"); } 1026 #endif 1027 pp->lencode = 0; 1028 return; 1029 } 1030 1031 /* Append input to code buffer, avoiding overflow. */ 1032 for(i = 0; i < rbufp->recv_length; i++) { 1033 if(pp->lencode >= LENARC) { break; } /* Avoid overflow... */ 1034 c = rbufp->recv_buffer[i]; 1035 1036 /* Drop trailing '\r's and drop `h' command echo totally. */ 1037 if(c != '\r' && c != 'h') { pp->a_lastcode[pp->lencode++] = c; } 1038 1039 /* 1040 If we've just put an `o' in the lastcode[0], clear the 1041 timestamp in anticipation of a timecode arriving soon. 1042 1043 We would expect to get to process this before any of the 1044 timecode arrives. 1045 */ 1046 if((c == 'o') && (pp->lencode == 1)) { 1047 L_CLR(&(up->lastrec)); 1048 #ifdef DEBUG 1049 if(debug > 1) { printf("arc: clearing timestamp.\n"); } 1050 #endif 1051 } 1052 } 1053 if (pp->lencode == 0) return; 1054 1055 /* Handle a quality message. */ 1056 if(pp->a_lastcode[0] == 'g') { 1057 int r, q; 1058 1059 if(pp->lencode < 3) { return; } /* Need more data... */ 1060 r = (pp->a_lastcode[1] & 0x7f); /* Strip parity. */ 1061 q = (pp->a_lastcode[2] & 0x7f); /* Strip parity. */ 1062 if(((q & 0x70) != 0x30) || ((q & 0xf) > MAX_CLOCK_QUALITY) || 1063 ((r & 0x70) != 0x30)) { 1064 /* Badly formatted response. */ 1065 #ifdef DEBUG 1066 if(debug) { printf("arc: bad `g' response %2x %2x.\n", r, q); } 1067 #endif 1068 return; 1069 } 1070 if(r == '3') { /* Only use quality value whilst sync in progress. */ 1071 if (up->quality_stamp < current_time) { 1072 struct calendar cal; 1073 l_fp new_stamp; 1074 1075 get_systime (&new_stamp); 1076 caljulian (new_stamp.l_ui, &cal); 1077 up->quality_stamp = 1078 current_time + 60 - cal.second + 5; 1079 quality_sum = 0; 1080 quality_polls = 0; 1081 } 1082 quality_sum += (q & 0xf); 1083 quality_polls++; 1084 quality_average = (quality_sum / quality_polls); 1085 #ifdef DEBUG 1086 if(debug) { printf("arc: signal quality %d (%d).\n", quality_average, (q & 0xf)); } 1087 #endif 1088 } else if( /* (r == '2') && */ up->resyncing) { 1089 up->quality = quality_average; 1090 #ifdef DEBUG 1091 if(debug) 1092 { 1093 printf("arc: sync finished, signal quality %d: %s\n", 1094 up->quality, 1095 quality_action(up->quality)); 1096 } 1097 #endif 1098 msyslog(LOG_NOTICE, 1099 "ARCRON: sync finished, signal quality %d: %s", 1100 up->quality, 1101 quality_action(up->quality)); 1102 up->resyncing = 0; /* Resync is over. */ 1103 quality_average = 0; 1104 quality_sum = 0; 1105 quality_polls = 0; 1106 1107 #ifdef ARCRON_KEEN 1108 /* Clock quality dubious; resync earlier than usual. */ 1109 if((up->quality == QUALITY_UNKNOWN) || 1110 (up->quality < MIN_CLOCK_QUALITY_OK)) 1111 { up->next_resync = current_time + RETRY_RESYNC_TIME; } 1112 #endif 1113 } 1114 pp->lencode = 0; 1115 return; 1116 } 1117 1118 /* Stop now if this is not a timecode message. */ 1119 if(pp->a_lastcode[0] != 'o') { 1120 pp->lencode = 0; 1121 refclock_report(peer, CEVNT_BADREPLY); 1122 return; 1123 } 1124 1125 /* If we don't have enough data, wait for more... */ 1126 if(pp->lencode < LENARC) { return; } 1127 1128 1129 /* WE HAVE NOW COLLECTED ONE TIMESTAMP (phew)... */ 1130 #ifdef DEBUG 1131 if(debug > 1) { printf("arc: NOW HAVE TIMESTAMP...\n"); } 1132 #endif 1133 1134 /* But check that we actually captured a system timestamp on it. */ 1135 if(L_ISZERO(&(up->lastrec))) { 1136 #ifdef DEBUG 1137 if(debug) { printf("arc: FAILED TO GET SYSTEM TIMESTAMP\n"); } 1138 #endif 1139 pp->lencode = 0; 1140 refclock_report(peer, CEVNT_BADREPLY); 1141 return; 1142 } 1143 /* 1144 Append a mark of the clock's received signal quality for the 1145 benefit of Derek Mulcahy's Tcl/Tk utility (we map the `unknown' 1146 quality value to `6' for his s/w) and terminate the string for 1147 sure. This should not go off the buffer end. 1148 */ 1149 pp->a_lastcode[pp->lencode] = ((up->quality == QUALITY_UNKNOWN) ? 1150 '6' : ('0' + up->quality)); 1151 pp->a_lastcode[pp->lencode + 1] = '\0'; /* Terminate for printf(). */ 1152 1153 #ifdef PRE_NTP420 1154 /* We don't use the micro-/milli- second part... */ 1155 pp->usec = 0; 1156 pp->msec = 0; 1157 #else 1158 /* We don't use the nano-second part... */ 1159 pp->nsec = 0; 1160 #endif 1161 /* Validate format and numbers. */ 1162 if (pp->a_lastcode[0] != 'o' 1163 || !get2(pp->a_lastcode + 1, &pp->hour) 1164 || !get2(pp->a_lastcode + 3, &pp->minute) 1165 || !get2(pp->a_lastcode + 5, &pp->second) 1166 || !get1(pp->a_lastcode + 7, &wday) 1167 || !get2(pp->a_lastcode + 8, &pp->day) 1168 || !get2(pp->a_lastcode + 10, &month) 1169 || !get2(pp->a_lastcode + 12, &pp->year)) { 1170 #ifdef DEBUG 1171 /* Would expect to have caught major problems already... */ 1172 if(debug) { printf("arc: badly formatted data.\n"); } 1173 #endif 1174 pp->lencode = 0; 1175 refclock_report(peer, CEVNT_BADREPLY); 1176 return; 1177 } 1178 flags = pp->a_lastcode[14]; 1179 status = pp->a_lastcode[15]; 1180 #ifdef DEBUG 1181 if(debug) { printf("arc: status 0x%.2x flags 0x%.2x\n", flags, status); } 1182 #endif 1183 n = 9; 1184 1185 /* 1186 Validate received values at least enough to prevent internal 1187 array-bounds problems, etc. 1188 */ 1189 if((pp->hour < 0) || (pp->hour > 23) || 1190 (pp->minute < 0) || (pp->minute > 59) || 1191 (pp->second < 0) || (pp->second > 60) /*Allow for leap seconds.*/ || 1192 (wday < 1) || (wday > 7) || 1193 (pp->day < 1) || (pp->day > 31) || 1194 (month < 1) || (month > 12) || 1195 (pp->year < 0) || (pp->year > 99)) { 1196 /* Data out of range. */ 1197 pp->lencode = 0; 1198 refclock_report(peer, CEVNT_BADREPLY); 1199 return; 1200 } 1201 1202 1203 if(peer->MODE == 0) { /* compatiblity to original version */ 1204 int bst = flags; 1205 /* Check that BST/UTC bits are the complement of one another. */ 1206 if(!(bst & 2) == !(bst & 4)) { 1207 pp->lencode = 0; 1208 refclock_report(peer, CEVNT_BADREPLY); 1209 return; 1210 } 1211 } 1212 if(status & 0x8) { msyslog(LOG_NOTICE, "ARCRON: battery low"); } 1213 1214 /* Year-2000 alert! */ 1215 /* Attempt to wrap 2-digit date into sensible window. */ 1216 if(pp->year < YEAR_PIVOT) { pp->year += 100; } /* Y2KFixes */ 1217 pp->year += 1900; /* use full four-digit year */ /* Y2KFixes */ 1218 /* 1219 Attempt to do the right thing by screaming that the code will 1220 soon break when we get to the end of its useful life. What a 1221 hero I am... PLEASE FIX LEAP-YEAR AND WRAP CODE IN 209X! 1222 */ 1223 if(pp->year >= YEAR_PIVOT+2000-2 ) { /* Y2KFixes */ 1224 /*This should get attention B^> */ 1225 msyslog(LOG_NOTICE, 1226 "ARCRON: fix me! EITHER YOUR DATE IS BADLY WRONG or else I will break soon!"); 1227 } 1228 #ifdef DEBUG 1229 if(debug) { 1230 printf("arc: n=%d %02d:%02d:%02d %02d/%02d/%04d %1d %1d\n", 1231 n, 1232 pp->hour, pp->minute, pp->second, 1233 pp->day, month, pp->year, flags, status); 1234 } 1235 #endif 1236 1237 /* 1238 The status value tested for is not strictly supported by the 1239 clock spec since the value of bit 2 (0x4) is claimed to be 1240 undefined for MSF, yet does seem to indicate if the last resync 1241 was successful or not. 1242 */ 1243 pp->leap = LEAP_NOWARNING; 1244 status &= 0x7; 1245 if(status == 0x3) { 1246 if(status != up->status) 1247 { msyslog(LOG_NOTICE, "ARCRON: signal acquired"); } 1248 } else { 1249 if(status != up->status) { 1250 msyslog(LOG_NOTICE, "ARCRON: signal lost"); 1251 pp->leap = LEAP_NOTINSYNC; /* MSF clock is free-running. */ 1252 up->status = status; 1253 pp->lencode = 0; 1254 refclock_report(peer, CEVNT_FAULT); 1255 return; 1256 } 1257 } 1258 up->status = status; 1259 1260 if (peer->MODE == 0) { /* compatiblity to original version */ 1261 int bst = flags; 1262 1263 pp->day += moff[month - 1]; 1264 1265 if(isleap_4(pp->year) && month > 2) { pp->day++; }/* Y2KFixes */ 1266 1267 /* Convert to UTC if required */ 1268 if(bst & 2) { 1269 pp->hour--; 1270 if (pp->hour < 0) { 1271 pp->hour = 23; 1272 pp->day--; 1273 /* If we try to wrap round the year 1274 * (BST on 1st Jan), reject.*/ 1275 if(pp->day < 0) { 1276 pp->lencode = 0; 1277 refclock_report(peer, CEVNT_BADTIME); 1278 return; 1279 } 1280 } 1281 } 1282 } 1283 1284 if(peer->MODE > 0) { 1285 if(pp->sloppyclockflag & CLK_FLAG1) { 1286 struct tm local; 1287 struct tm *gmtp; 1288 time_t unixtime; 1289 1290 /* 1291 * Convert to GMT for sites that distribute localtime. 1292 * This means we have to do Y2K conversion on the 1293 * 2-digit year; otherwise, we get the time wrong. 1294 */ 1295 1296 memset(&local, 0, sizeof(local)); 1297 1298 local.tm_year = pp->year-1900; 1299 local.tm_mon = month-1; 1300 local.tm_mday = pp->day; 1301 local.tm_hour = pp->hour; 1302 local.tm_min = pp->minute; 1303 local.tm_sec = pp->second; 1304 switch (peer->MODE) { 1305 case 1: 1306 local.tm_isdst = (flags & 2); 1307 break; 1308 case 2: 1309 local.tm_isdst = (flags & 2); 1310 break; 1311 case 3: 1312 switch (flags & 3) { 1313 case 0: /* It is unclear exactly when the 1314 Arcron changes from DST->ST and 1315 ST->DST. Testing has shown this 1316 to be irregular. For the time 1317 being, let the OS decide. */ 1318 local.tm_isdst = 0; 1319 #ifdef DEBUG 1320 if (debug) 1321 printf ("arc: DST = 00 (0)\n"); 1322 #endif 1323 break; 1324 case 1: /* dst->st time */ 1325 local.tm_isdst = -1; 1326 #ifdef DEBUG 1327 if (debug) 1328 printf ("arc: DST = 01 (1)\n"); 1329 #endif 1330 break; 1331 case 2: /* st->dst time */ 1332 local.tm_isdst = -1; 1333 #ifdef DEBUG 1334 if (debug) 1335 printf ("arc: DST = 10 (2)\n"); 1336 #endif 1337 break; 1338 case 3: /* dst time */ 1339 local.tm_isdst = 1; 1340 #ifdef DEBUG 1341 if (debug) 1342 printf ("arc: DST = 11 (3)\n"); 1343 #endif 1344 break; 1345 } 1346 break; 1347 default: 1348 msyslog(LOG_NOTICE, "ARCRON: Invalid mode %d", 1349 peer->MODE); 1350 return; 1351 break; 1352 } 1353 unixtime = mktime (&local); 1354 if ((gmtp = gmtime (&unixtime)) == NULL) 1355 { 1356 pp->lencode = 0; 1357 refclock_report (peer, CEVNT_FAULT); 1358 return; 1359 } 1360 pp->year = gmtp->tm_year+1900; 1361 month = gmtp->tm_mon+1; 1362 pp->day = ymd2yd(pp->year,month,gmtp->tm_mday); 1363 /* pp->day = gmtp->tm_yday; */ 1364 pp->hour = gmtp->tm_hour; 1365 pp->minute = gmtp->tm_min; 1366 pp->second = gmtp->tm_sec; 1367 #ifdef DEBUG 1368 if (debug) 1369 { 1370 printf ("arc: time is %04d/%02d/%02d %02d:%02d:%02d UTC\n", 1371 pp->year,month,gmtp->tm_mday,pp->hour,pp->minute, 1372 pp->second); 1373 } 1374 #endif 1375 } else 1376 { 1377 /* 1378 * For more rational sites distributing UTC 1379 */ 1380 pp->day = ymd2yd(pp->year,month,pp->day); 1381 } 1382 } 1383 1384 if (peer->MODE == 0) { /* compatiblity to original version */ 1385 /* If clock signal quality is 1386 * unknown, revert to default PRECISION...*/ 1387 if(up->quality == QUALITY_UNKNOWN) { 1388 peer->precision = PRECISION; 1389 } else { /* ...else improve precision if flag3 is set... */ 1390 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ? 1391 HIGHPRECISION : PRECISION); 1392 } 1393 } else { 1394 if ((status == 0x3) && (pp->sloppyclockflag & CLK_FLAG2)) { 1395 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ? 1396 HIGHPRECISION : PRECISION); 1397 } else if (up->quality == QUALITY_UNKNOWN) { 1398 peer->precision = PRECISION; 1399 } else { 1400 peer->precision = ((pp->sloppyclockflag & CLK_FLAG3) ? 1401 HIGHPRECISION : PRECISION); 1402 } 1403 } 1404 1405 /* Notice and log any change (eg from initial defaults) for flags. */ 1406 if(up->saved_flags != pp->sloppyclockflag) { 1407 #ifdef DEBUG 1408 msyslog(LOG_NOTICE, "ARCRON: flags enabled: %s%s%s%s", 1409 ((pp->sloppyclockflag & CLK_FLAG1) ? "1" : "."), 1410 ((pp->sloppyclockflag & CLK_FLAG2) ? "2" : "."), 1411 ((pp->sloppyclockflag & CLK_FLAG3) ? "3" : "."), 1412 ((pp->sloppyclockflag & CLK_FLAG4) ? "4" : ".")); 1413 /* Note effects of flags changing... */ 1414 if(debug) { 1415 printf("arc: PRECISION = %d.\n", peer->precision); 1416 } 1417 #endif 1418 up->saved_flags = pp->sloppyclockflag; 1419 } 1420 1421 /* Note time of last believable timestamp. */ 1422 pp->lastrec = up->lastrec; 1423 1424 #ifdef ARCRON_LEAPSECOND_KEEN 1425 /* Find out if a leap-second might just have happened... 1426 (ie is this the first hour of the first day of Jan or Jul?) 1427 */ 1428 if((pp->hour == 0) && 1429 (pp->day == 1) && 1430 ((month == 1) || (month == 7))) { 1431 if(possible_leap >= 0) { 1432 /* A leap may have happened, and no resync has started yet...*/ 1433 possible_leap = 1; 1434 } 1435 } else { 1436 /* Definitely not leap-second territory... */ 1437 possible_leap = 0; 1438 } 1439 #endif 1440 1441 if (!refclock_process(pp)) { 1442 pp->lencode = 0; 1443 refclock_report(peer, CEVNT_BADTIME); 1444 return; 1445 } 1446 record_clock_stats(&peer->srcadr, pp->a_lastcode); 1447 refclock_receive(peer); 1448 } 1449 1450 1451 /* request_time() sends a time request to the clock with given peer. */ 1452 /* This automatically reports a fault if necessary. */ 1453 /* No data should be sent after this until arc_poll() returns. */ 1454 static void request_time (int, struct peer *); 1455 static void 1456 request_time( 1457 int unit, 1458 struct peer *peer 1459 ) 1460 { 1461 struct refclockproc *pp = peer->procptr; 1462 register struct arcunit *up = pp->unitptr; 1463 #ifdef DEBUG 1464 if(debug) { printf("arc: unit %d: requesting time.\n", unit); } 1465 #endif 1466 if (!send_slow(up, pp->io.fd, "o\r")) { 1467 #ifdef DEBUG 1468 if (debug) { 1469 printf("arc: unit %d: problem sending", unit); 1470 } 1471 #endif 1472 pp->lencode = 0; 1473 refclock_report(peer, CEVNT_FAULT); 1474 return; 1475 } 1476 pp->polls++; 1477 } 1478 1479 /* 1480 * arc_poll - called by the transmit procedure 1481 */ 1482 static void 1483 arc_poll( 1484 int unit, 1485 struct peer *peer 1486 ) 1487 { 1488 register struct arcunit *up; 1489 struct refclockproc *pp; 1490 int resync_needed; /* Should we start a resync? */ 1491 1492 pp = peer->procptr; 1493 up = pp->unitptr; 1494 #if 0 1495 pp->lencode = 0; 1496 memset(pp->a_lastcode, 0, sizeof(pp->a_lastcode)); 1497 #endif 1498 1499 #if 0 1500 /* Flush input. */ 1501 tcflush(pp->io.fd, TCIFLUSH); 1502 #endif 1503 1504 /* Resync if our next scheduled resync time is here or has passed. */ 1505 resync_needed = ( !(pp->sloppyclockflag & CLK_FLAG2) && 1506 (up->next_resync <= current_time) ); 1507 1508 #ifdef ARCRON_LEAPSECOND_KEEN 1509 /* 1510 Try to catch a potential leap-second insertion or deletion quickly. 1511 1512 In addition to the normal NTP fun of clocks that don't report 1513 leap-seconds spooking their hosts, this clock does not even 1514 sample the radio sugnal the whole time, so may miss a 1515 leap-second insertion or deletion for up to a whole sample 1516 time. 1517 1518 To try to minimise this effect, if in the first few minutes of 1519 the day immediately following a leap-second-insertion point 1520 (ie in the first hour of the first day of the first and sixth 1521 months), and if the last resync was in the previous day, and a 1522 resync is not already in progress, resync the clock 1523 immediately. 1524 1525 */ 1526 if((possible_leap > 0) && /* Must be 00:XX 01/0{1,7}/XXXX. */ 1527 (!up->resyncing)) { /* No resync in progress yet. */ 1528 resync_needed = 1; 1529 possible_leap = -1; /* Prevent multiple resyncs. */ 1530 msyslog(LOG_NOTICE,"ARCRON: unit %d: checking for leap second",unit); 1531 } 1532 #endif 1533 1534 /* Do a resync if required... */ 1535 if(resync_needed) { 1536 /* First, reset quality value to `unknown' so we can detect */ 1537 /* when a quality message has been responded to by this */ 1538 /* being set to some other value. */ 1539 up->quality = QUALITY_UNKNOWN; 1540 1541 /* Note that we are resyncing... */ 1542 up->resyncing = 1; 1543 1544 /* Now actually send the resync command and an immediate poll. */ 1545 #ifdef DEBUG 1546 if(debug) { printf("arc: sending resync command (h\\r).\n"); } 1547 #endif 1548 msyslog(LOG_NOTICE, "ARCRON: unit %d: sending resync command", unit); 1549 send_slow(up, pp->io.fd, "h\r"); 1550 1551 /* Schedule our next resync... */ 1552 up->next_resync = current_time + DEFAULT_RESYNC_TIME; 1553 1554 /* Drop through to request time if appropriate. */ 1555 } 1556 1557 /* If clock quality is too poor to trust, indicate a fault. */ 1558 /* If quality is QUALITY_UNKNOWN and ARCRON_KEEN is defined,*/ 1559 /* we'll cross our fingers and just hope that the thing */ 1560 /* synced so quickly we did not catch it---we'll */ 1561 /* double-check the clock is OK elsewhere. */ 1562 if( 1563 #ifdef ARCRON_KEEN 1564 (up->quality != QUALITY_UNKNOWN) && 1565 #else 1566 (up->quality == QUALITY_UNKNOWN) || 1567 #endif 1568 (up->quality < MIN_CLOCK_QUALITY_OK)) { 1569 #ifdef DEBUG 1570 if(debug) { 1571 printf("arc: clock quality %d too poor.\n", up->quality); 1572 } 1573 #endif 1574 pp->lencode = 0; 1575 refclock_report(peer, CEVNT_FAULT); 1576 return; 1577 } 1578 /* This is the normal case: request a timestamp. */ 1579 request_time(unit, peer); 1580 } 1581 1582 #else 1583 int refclock_arc_bs; 1584 #endif 1585