external/bsd/ntp/dist/ntpd/refclock_datum.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4 ** refclock_datum - clock driver for the Datum Programmable Time Server
   5 **
   6 ** Important note: This driver assumes that you have termios. If you have
   7 ** a system that does not have termios, you will have to modify this driver.
   8 **
   9 ** Sorry, I have only tested this driver on SUN and HP platforms.
  10 */
  11
  12 #ifdef HAVE_CONFIG_H
  13 # include <config.h>
  14 #endif
  15
  16 #if defined(REFCLOCK) && defined(CLOCK_DATUM)
  17
  18 /*
  19 ** Include Files
  20 */
  21
  22 #include "ntpd.h"
  23 #include "ntp_io.h"
  24 #include "ntp_refclock.h"
  25 #include "ntp_unixtime.h"
  26 #include "ntp_stdlib.h"
  27
  28 #include <stdio.h>
  29 #include <ctype.h>
  30
  31 #if defined(HAVE_BSD_TTYS)
  32 #include <sgtty.h>
  33 #endif /* HAVE_BSD_TTYS */
  34
  35 #if defined(HAVE_SYSV_TTYS)
  36 #include <termio.h>
  37 #endif /* HAVE_SYSV_TTYS */
  38
  39 #if defined(HAVE_TERMIOS)
  40 #include <termios.h>
  41 #endif
  42 #if defined(STREAM)
  43 #include <stropts.h>
  44 #if defined(WWVBCLK)
  45 #include <sys/clkdefs.h>
  46 #endif /* WWVBCLK */
  47 #endif /* STREAM */
  48
  49 #include "ntp_stdlib.h"
  50
  51 /*
  52 ** This driver supports the Datum Programmable Time System (PTS) clock.
  53 ** The clock works in very straight forward manner. When it receives a
  54 ** time code request (e.g., the ascii string "//k/mn"), it responds with
  55 ** a seven byte BCD time code. This clock only responds with a
  56 ** time code after it first receives the "//k/mn" message. It does not
  57 ** periodically send time codes back at some rate once it is started.
  58 ** the returned time code can be broken down into the following fields.
  59 **
  60 **            _______________________________
  61 ** Bit Index | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  62 **            ===============================
  63 ** byte 0:   | -   -   -   - |      H D      |
  64 **            ===============================
  65 ** byte 1:   |      T D      |      U D      |
  66 **            ===============================
  67 ** byte 2:   | -   - |  T H  |      U H      |
  68 **            ===============================
  69 ** byte 3:   | - |    T M    |      U M      |
  70 **            ===============================
  71 ** byte 4:   | - |    T S    |      U S      |
  72 **            ===============================
  73 ** byte 5:   |      t S      |      h S      |
  74 **            ===============================
  75 ** byte 6:   |      m S      | -   -   -   - |
  76 **            ===============================
  77 **
  78 ** In the table above:
  79 **
  80 **      "-" means don't care
  81 **      "H D", "T D", and "U D" means Hundreds, Tens, and Units of Days
  82 **      "T H", and "UH" means Tens and Units of Hours
  83 **      "T M", and "U M" means Tens and Units of Minutes
  84 **      "T S", and "U S" means Tens and Units of Seconds
  85 **      "t S", "h S", and "m S" means tenths, hundredths, and thousandths
  86 **                              of seconds
  87 **
  88 ** The Datum PTS communicates throught the RS232 port on your machine.
  89 ** Right now, it assumes that you have termios. This driver has been tested
  90 ** on SUN and HP workstations. The Datum PTS supports various IRIG and
  91 ** NASA input codes. This driver assumes that the name of the device is
  92 ** /dev/datum. You will need to make a soft link to your RS232 device or
  93 ** create a new driver to use this refclock.
  94 */
  95
  96 /*
  97 ** Datum PTS defines
  98 */
  99
 100 /*
 101 ** Note that if GMT is defined, then the Datum PTS must use Greenwich
 102 ** time. Otherwise, this driver allows the Datum PTS to use the current
 103 ** wall clock for its time. It determines the time zone offset by minimizing
 104 ** the error after trying several time zone offsets. If the Datum PTS
 105 ** time is Greenwich time and GMT is not defined, everything should still
 106 ** work since the time zone will be found to be 0. What this really means
 107 ** is that your system time (at least to start with) must be within the
 108 ** correct time by less than +- 30 minutes. The default is for GMT to not
 109 ** defined. If you really want to force GMT without the funny +- 30 minute
 110 ** stuff then you must define (uncomment) GMT below.
 111 */
 112
 113 /*
 114 #define GMT
 115 #define DEBUG_DATUM_PTC
 116 #define LOG_TIME_ERRORS
 117 */
 118
 119
 120 #define PRECISION       (-10)           /* precision assumed 1/1024 ms */
 121 #define REFID "DATM"                    /* reference id */
 122 #define DATUM_DISPERSION 0              /* fixed dispersion = 0 ms */
 123 #define DATUM_MAX_ERROR 0.100           /* limits on sigma squared */
 124 #define DATUM_DEV       "/dev/datum"    /* device name */
 125
 126 #define DATUM_MAX_ERROR2 (DATUM_MAX_ERROR*DATUM_MAX_ERROR)
 127
 128 /*
 129 ** The Datum PTS structure
 130 */
 131
 132 /*
 133 ** I don't use a fixed array of MAXUNITS like everyone else just because
 134 ** I don't like to program that way. Sorry if this bothers anyone. I assume
 135 ** that you can use any id for your unit and I will search for it in a
 136 ** dynamic array of units until I find it. I was worried that users might
 137 ** enter a bad id in their configuration file (larger than MAXUNITS) and
 138 ** besides, it is just cleaner not to have to assume that you have a fixed
 139 ** number of anything in a program.
 140 */
 141
 142 struct datum_pts_unit {
 143         struct peer *peer;              /* peer used by ntp */
 144         struct refclockio io;           /* io structure used by ntp */
 145         int PTS_fd;                     /* file descriptor for PTS */
 146         u_int unit;                     /* id for unit */
 147         u_long timestarted;             /* time started */
 148         l_fp lastrec;                   /* time tag for the receive time (system) */
 149         l_fp lastref;                   /* reference time (Datum time) */
 150         u_long yearstart;               /* the year that this clock started */
 151         int coderecv;                   /* number of time codes received */
 152         int day;                        /* day */
 153         int hour;                       /* hour */
 154         int minute;                     /* minutes */
 155         int second;                     /* seconds */
 156         int msec;                       /* miliseconds */
 157         int usec;                       /* miliseconds */
 158         u_char leap;                    /* funny leap character code */
 159         char retbuf[8];         /* returned time from the datum pts */
 160         char nbytes;                    /* number of bytes received from datum pts */
 161         double sigma2;          /* average squared error (roughly) */
 162         int tzoff;                      /* time zone offest from GMT */
 163 };
 164
 165 /*
 166 ** PTS static constant variables for internal use
 167 */
 168
 169 static char TIME_REQUEST[6];    /* request message sent to datum for time */
 170 static int nunits;              /* number of active units */
 171 static struct datum_pts_unit
 172 **datum_pts_unit;       /* dynamic array of datum PTS structures */
 173
 174 /*
 175 ** Callback function prototypes that ntpd needs to know about.
 176 */
 177
 178 static  int     datum_pts_start         (int, struct peer *);
 179 static  void    datum_pts_shutdown      (int, struct peer *);
 180 static  void    datum_pts_poll          (int, struct peer *);
 181 static  void    datum_pts_control       (int, struct refclockstat *,
 182                                            struct refclockstat *, struct peer *);
 183 static  void    datum_pts_init          (void);
 184 static  void    datum_pts_buginfo       (int, struct refclockbug *, struct peer *);
 185
 186 /*
 187 ** This is the call back function structure that ntpd actually uses for
 188 ** this refclock.
 189 */
 190
 191 struct  refclock refclock_datum = {
 192         datum_pts_start,                /* start up a new Datum refclock */
 193         datum_pts_shutdown,             /* shutdown a Datum refclock */
 194         datum_pts_poll,         /* sends out the time request */
 195         datum_pts_control,              /* not used */
 196         datum_pts_init,         /* initialization (called first) */
 197         datum_pts_buginfo,              /* not used */
 198         NOFLAGS                 /* we are not setting any special flags */
 199 };
 200
 201 /*
 202 ** The datum_pts_receive callback function is handled differently from the
 203 ** rest. It is passed to the ntpd io data structure. Basically, every
 204 ** 64 seconds, the datum_pts_poll() routine is called. It sends out the time
 205 ** request message to the Datum Programmable Time System. Then, ntpd
 206 ** waits on a select() call to receive data back. The datum_pts_receive()
 207 ** function is called as data comes back. We expect a seven byte time
 208 ** code to be returned but the datum_pts_receive() function may only get
 209 ** a few bytes passed to it at a time. In other words, this routine may
 210 ** get called by the io stuff in ntpd a few times before we get all seven
 211 ** bytes. Once the last byte is received, we process it and then pass the
 212 ** new time measurement to ntpd for updating the system time. For now,
 213 ** there is no 3 state filtering done on the time measurements. The
 214 ** jitter may be a little high but at least for its current use, it is not
 215 ** a problem. We have tried to keep things as simple as possible. This
 216 ** clock should not jitter more than 1 or 2 mseconds at the most once
 217 ** things settle down. It is important to get the right drift calibrated
 218 ** in the ntpd.drift file as well as getting the right tick set up right
 219 ** using tickadj for SUNs. Tickadj is not used for the HP but you need to
 220 ** remember to bring up the adjtime daemon because HP does not support
 221 ** the adjtime() call.
 222 */
 223
 224 static  void    datum_pts_receive       (struct recvbuf *);
 225
 226 /*......................................................................*/
 227 /*      datum_pts_start - start up the datum PTS. This means open the   */
 228 /*      RS232 device and set up the data structure for my unit.         */
 229 /*......................................................................*/
 230
 231 static int
 232 datum_pts_start(
 233         int unit,
 234         struct peer *peer
 235         )
 236 {
 237         struct datum_pts_unit **temp_datum_pts_unit;
 238         struct datum_pts_unit *datum_pts;
 239         int fd;
 240 #ifdef HAVE_TERMIOS
 241         struct termios arg;
 242 #endif
 243
 244 #ifdef DEBUG_DATUM_PTC
 245         if (debug)
 246             printf("Starting Datum PTS unit %d\n", unit);
 247 #endif
 248
 249         /*
 250         ** Open the Datum PTS device
 251         */
 252         fd = open(DATUM_DEV, O_RDWR);
 253
 254         if (fd < 0) {
 255                 msyslog(LOG_ERR, "Datum_PTS: open(\"%s\", O_RDWR) failed: %m", DATUM_DEV);
 256                 return 0;
 257         }
 258
 259         /*
 260         ** Create the memory for the new unit
 261         */
 262
 263         temp_datum_pts_unit = (struct datum_pts_unit **)
 264                 emalloc((nunits+1)*sizeof(struct datum_pts_unit *));
 265         if (nunits > 0) memcpy(temp_datum_pts_unit, datum_pts_unit,
 266                                nunits*sizeof(struct datum_pts_unit *));
 267         free(datum_pts_unit);
 268         datum_pts_unit = temp_datum_pts_unit;
 269         datum_pts_unit[nunits] = (struct datum_pts_unit *)
 270                 emalloc(sizeof(struct datum_pts_unit));
 271         datum_pts = datum_pts_unit[nunits];
 272
 273         datum_pts->unit = unit; /* set my unit id */
 274         datum_pts->yearstart = 0;       /* initialize the yearstart to 0 */
 275         datum_pts->sigma2 = 0.0;        /* initialize the sigma2 to 0 */
 276
 277         datum_pts->PTS_fd = fd;
 278
 279         fcntl(datum_pts->PTS_fd, F_SETFL, 0); /* clear the descriptor flags */
 280
 281 #ifdef DEBUG_DATUM_PTC
 282         if (debug)
 283             printf("Opening RS232 port with file descriptor %d\n",
 284                    datum_pts->PTS_fd);
 285 #endif
 286
 287         /*
 288         ** Set up the RS232 terminal device information. Note that we assume that
 289         ** we have termios. This code has only been tested on SUNs and HPs. If your
 290         ** machine does not have termios this driver cannot be initialized. You can change this
 291         ** if you want by editing this source. Please give the changes back to the
 292         ** ntp folks so that it can become part of their regular distribution.
 293         */
 294
 295 #ifdef HAVE_TERMIOS
 296
 297         memset(&arg, 0, sizeof(arg));
 298
 299         arg.c_iflag = IGNBRK;
 300         arg.c_oflag = 0;
 301         arg.c_cflag = B9600 | CS8 | CREAD | PARENB | CLOCAL;
 302         arg.c_lflag = 0;
 303         arg.c_cc[VMIN] = 0;             /* start timeout timer right away (not used) */
 304         arg.c_cc[VTIME] = 30;           /* 3 second timout on reads (not used) */
 305
 306         tcsetattr(datum_pts->PTS_fd, TCSANOW, &arg);
 307
 308 #else
 309
 310         msyslog(LOG_ERR, "Datum_PTS: Termios not supported in this driver");
 311         (void)close(datum_pts->PTS_fd);
 312
 313         peer->precision = PRECISION;
 314         pp->clockdesc = DESCRIPTION;
 315         memcpy((char *)&pp->refid, REFID, 4);
 316
 317         return 0;
 318
 319 #endif
 320
 321         /*
 322         ** Initialize the ntpd IO structure
 323         */
 324
 325         datum_pts->peer = peer;
 326         datum_pts->io.clock_recv = datum_pts_receive;
 327         datum_pts->io.srcclock = (caddr_t)datum_pts;
 328         datum_pts->io.datalen = 0;
 329         datum_pts->io.fd = datum_pts->PTS_fd;
 330
 331         if (!io_addclock(&(datum_pts->io))) {
 332
 333 #ifdef DEBUG_DATUM_PTC
 334                 if (debug)
 335                     printf("Problem adding clock\n");
 336 #endif
 337
 338                 msyslog(LOG_ERR, "Datum_PTS: Problem adding clock");
 339                 (void)close(datum_pts->PTS_fd);
 340
 341                 return 0;
 342         }
 343
 344         /*
 345         ** Now add one to the number of units and return a successful code
 346         */
 347
 348         nunits++;
 349         return 1;
 350
 351 }
 352
 353
 354 /*......................................................................*/
 355 /*      datum_pts_shutdown - this routine shuts doen the device and     */
 356 /*      removes the memory for the unit.                                */
 357 /*......................................................................*/
 358
 359 static void
 360 datum_pts_shutdown(
 361         int unit,
 362         struct peer *peer
 363         )
 364 {
 365         int i,j;
 366         struct datum_pts_unit **temp_datum_pts_unit;
 367
 368 #ifdef DEBUG_DATUM_PTC
 369         if (debug)
 370             printf("Shutdown Datum PTS\n");
 371 #endif
 372
 373         msyslog(LOG_ERR, "Datum_PTS: Shutdown Datum PTS");
 374
 375         /*
 376         ** First we have to find the right unit (i.e., the one with the same id).
 377         ** We do this by looping through the dynamic array of units intil we find
 378         ** it. Note, that I don't simply use an array with a maximimum number of
 379         ** Datum PTS units. Everything is completely dynamic.
 380         */
 381
 382         for (i=0; i<nunits; i++) {
 383                 if (datum_pts_unit[i]->unit == unit) {
 384
 385                         /*
 386                         ** We found the unit so close the file descriptor and free up the memory used
 387                         ** by the structure.
 388                         */
 389
 390                         io_closeclock(&datum_pts_unit[i]->io);
 391                         close(datum_pts_unit[i]->PTS_fd);
 392                         free(datum_pts_unit[i]);
 393
 394                         /*
 395                         ** Now clean up the datum_pts_unit dynamic array so that there are no holes.
 396                         ** This may mean moving pointers around, etc., to keep things compact.
 397                         */
 398
 399                         if (nunits > 1) {
 400
 401                                 temp_datum_pts_unit = (struct datum_pts_unit **)
 402                                         emalloc((nunits-1)*sizeof(struct datum_pts_unit *));
 403                                 if (i!= 0) memcpy(temp_datum_pts_unit, datum_pts_unit,
 404                                                   i*sizeof(struct datum_pts_unit *));
 405
 406                                 for (j=i+1; j<nunits; j++) {
 407                                         temp_datum_pts_unit[j-1] = datum_pts_unit[j];
 408                                 }
 409
 410                                 free(datum_pts_unit);
 411                                 datum_pts_unit = temp_datum_pts_unit;
 412
 413                         }else{
 414
 415                                 free(datum_pts_unit);
 416                                 datum_pts_unit = NULL;
 417
 418                         }
 419
 420                         return;
 421
 422                 }
 423         }
 424
 425 #ifdef DEBUG_DATUM_PTC
 426         if (debug)
 427             printf("Error, could not shut down unit %d\n",unit);
 428 #endif
 429
 430         msyslog(LOG_ERR, "Datum_PTS: Could not shut down Datum PTS unit %d",unit);
 431
 432 }
 433
 434 /*......................................................................*/
 435 /*      datum_pts_poll - this routine sends out the time request to the */
 436 /*      Datum PTS device. The time will be passed back in the           */
 437 /*      datum_pts_receive() routine.                                    */
 438 /*......................................................................*/
 439
 440 static void
 441 datum_pts_poll(
 442         int unit,
 443         struct peer *peer
 444         )
 445 {
 446         int i;
 447         int unit_index;
 448         int error_code;
 449         struct datum_pts_unit *datum_pts;
 450
 451 #ifdef DEBUG_DATUM_PTC
 452         if (debug)
 453             printf("Poll Datum PTS\n");
 454 #endif
 455
 456         /*
 457         ** Find the right unit and send out a time request once it is found.
 458         */
 459
 460         unit_index = -1;
 461         for (i=0; i<nunits; i++) {
 462                 if (datum_pts_unit[i]->unit == unit) {
 463                         unit_index = i;
 464                         datum_pts = datum_pts_unit[i];
 465                         error_code = write(datum_pts->PTS_fd, TIME_REQUEST, 6);
 466                         if (error_code != 6) perror("TIME_REQUEST");
 467                         datum_pts->nbytes = 0;
 468                         break;
 469                 }
 470         }
 471
 472         /*
 473         ** Print out an error message if we could not find the right unit.
 474         */
 475
 476         if (unit_index == -1) {
 477
 478 #ifdef DEBUG_DATUM_PTC
 479                 if (debug)
 480                     printf("Error, could not poll unit %d\n",unit);
 481 #endif
 482
 483                 msyslog(LOG_ERR, "Datum_PTS: Could not poll unit %d",unit);
 484                 return;
 485
 486         }
 487
 488 }
 489
 490
 491 /*......................................................................*/
 492 /*      datum_pts_control - not used                                    */
 493 /*......................................................................*/
 494
 495 static void
 496 datum_pts_control(
 497         int unit,
 498         struct refclockstat *in,
 499         struct refclockstat *out,
 500         struct peer *peer
 501         )
 502 {
 503
 504 #ifdef DEBUG_DATUM_PTC
 505         if (debug)
 506             printf("Control Datum PTS\n");
 507 #endif
 508
 509 }
 510
 511
 512 /*......................................................................*/
 513 /*      datum_pts_init - initializes things for all possible Datum      */
 514 /*      time code generators that might be used. In practice, this is   */
 515 /*      only called once at the beginning before anything else is       */
 516 /*      called.                                                         */
 517 /*......................................................................*/
 518
 519 static void
 520 datum_pts_init(void)
 521 {
 522
 523         /*                                                                      */
 524         /*...... open up the log file if we are debugging ......................*/
 525         /*                                                                      */
 526
 527         /*
 528         ** Open up the log file if we are debugging. For now, send data out to the
 529         ** screen (stdout).
 530         */
 531
 532 #ifdef DEBUG_DATUM_PTC
 533         if (debug)
 534             printf("Init Datum PTS\n");
 535 #endif
 536
 537         /*
 538         ** Initialize the time request command string. This is the only message
 539         ** that we ever have to send to the Datum PTS (although others are defined).
 540         */
 541
 542         memcpy(TIME_REQUEST, "//k/mn",6);
 543
 544         /*
 545         ** Initialize the number of units to 0 and set the dynamic array of units to
 546         ** NULL since there are no units defined yet.
 547         */
 548
 549         datum_pts_unit = NULL;
 550         nunits = 0;
 551
 552 }
 553
 554
 555 /*......................................................................*/
 556 /*      datum_pts_buginfo - not used                                    */
 557 /*......................................................................*/
 558
 559 static void
 560 datum_pts_buginfo(
 561         int unit,
 562         register struct refclockbug *bug,
 563         register struct peer *peer
 564         )
 565 {
 566
 567 #ifdef DEBUG_DATUM_PTC
 568         if (debug)
 569             printf("Buginfo Datum PTS\n");
 570 #endif
 571
 572 }
 573
 574
 575 /*......................................................................*/
 576 /*      datum_pts_receive - receive the time buffer that was read in    */
 577 /*      by the ntpd io handling routines. When 7 bytes have been        */
 578 /*      received (it may take several tries before all 7 bytes are      */
 579 /*      received), then the time code must be unpacked and sent to      */
 580 /*      the ntpd clock_receive() routine which causes the systems       */
 581 /*      clock to be updated (several layers down).                      */
 582 /*......................................................................*/
 583
 584 static void
 585 datum_pts_receive(
 586         struct recvbuf *rbufp
 587         )
 588 {
 589         int i;
 590         l_fp tstmp;
 591         struct datum_pts_unit *datum_pts;
 592         char *dpt;
 593         int dpend;
 594         int tzoff;
 595         int timerr;
 596         double ftimerr, abserr;
 597 #ifdef DEBUG_DATUM_PTC
 598         double dispersion;
 599 #endif
 600         int goodtime;
 601       /*double doffset;*/
 602
 603         /*
 604         ** Get the time code (maybe partial) message out of the rbufp buffer.
 605         */
 606
 607         datum_pts = (struct datum_pts_unit *)rbufp->recv_srcclock;
 608         dpt = (char *)&rbufp->recv_space;
 609         dpend = rbufp->recv_length;
 610
 611 #ifdef DEBUG_DATUM_PTC
 612         if (debug)
 613             printf("Receive Datum PTS: %d bytes\n", dpend);
 614 #endif
 615
 616         /*                                                                      */
 617         /*...... save the ntp system time when the first byte is received ......*/
 618         /*                                                                      */
 619
 620         /*
 621         ** Save the ntp system time when the first byte is received. Note that
 622         ** because it may take several calls to this routine before all seven
 623         ** bytes of our return message are finally received by the io handlers in
 624         ** ntpd, we really do want to use the time tag when the first byte is
 625         ** received to reduce the jitter.
 626         */
 627
 628         if (datum_pts->nbytes == 0) {
 629                 datum_pts->lastrec = rbufp->recv_time;
 630         }
 631
 632         /*
 633         ** Increment our count to the number of bytes received so far. Return if we
 634         ** haven't gotten all seven bytes yet.
 635         */
 636
 637         for (i=0; i<dpend; i++) {
 638                 datum_pts->retbuf[datum_pts->nbytes+i] = dpt[i];
 639         }
 640
 641         datum_pts->nbytes += dpend;
 642
 643         if (datum_pts->nbytes != 7) {
 644                 return;
 645         }
 646
 647         /*
 648         ** Convert the seven bytes received in our time buffer to day, hour, minute,
 649         ** second, and msecond values. The usec value is not used for anything
 650         ** currently. It is just the fractional part of the time stored in units
 651         ** of microseconds.
 652         */
 653
 654         datum_pts->day =        100*(datum_pts->retbuf[0] & 0x0f) +
 655                 10*((datum_pts->retbuf[1] & 0xf0)>>4) +
 656                 (datum_pts->retbuf[1] & 0x0f);
 657
 658         datum_pts->hour =       10*((datum_pts->retbuf[2] & 0x30)>>4) +
 659                 (datum_pts->retbuf[2] & 0x0f);
 660
 661         datum_pts->minute =     10*((datum_pts->retbuf[3] & 0x70)>>4) +
 662                 (datum_pts->retbuf[3] & 0x0f);
 663
 664         datum_pts->second =     10*((datum_pts->retbuf[4] & 0x70)>>4) +
 665                 (datum_pts->retbuf[4] & 0x0f);
 666
 667         datum_pts->msec =       100*((datum_pts->retbuf[5] & 0xf0) >> 4) +
 668                 10*(datum_pts->retbuf[5] & 0x0f) +
 669                 ((datum_pts->retbuf[6] & 0xf0)>>4);
 670
 671         datum_pts->usec =       1000*datum_pts->msec;
 672
 673 #ifdef DEBUG_DATUM_PTC
 674         if (debug)
 675             printf("day %d, hour %d, minute %d, second %d, msec %d\n",
 676                    datum_pts->day,
 677                    datum_pts->hour,
 678                    datum_pts->minute,
 679                    datum_pts->second,
 680                    datum_pts->msec);
 681 #endif
 682
 683         /*
 684         ** Get the GMT time zone offset. Note that GMT should be zero if the Datum
 685         ** reference time is using GMT as its time base. Otherwise we have to
 686         ** determine the offset if the Datum PTS is using time of day as its time
 687         ** base.
 688         */
 689
 690         goodtime = 0;           /* We are not sure about the time and offset yet */
 691
 692 #ifdef GMT
 693
 694         /*
 695         ** This is the case where the Datum PTS is using GMT so there is no time
 696         ** zone offset.
 697         */
 698
 699         tzoff = 0;              /* set time zone offset to 0 */
 700
 701 #else
 702
 703         /*
 704         ** This is the case where the Datum PTS is using regular time of day for its
 705         ** time so we must compute the time zone offset. The way we do it is kind of
 706         ** funny but it works. We loop through different time zones (0 to 24) and
 707         ** pick the one that gives the smallest error (+- one half hour). The time
 708         ** zone offset is stored in the datum_pts structure for future use. Normally,
 709         ** the clocktime() routine is only called once (unless the time zone offset
 710         ** changes due to daylight savings) since the goodtime flag is set when a
 711         ** good time is found (with a good offset). Note that even if the Datum
 712         ** PTS is using GMT, this mechanism will still work since it should come up
 713         ** with a value for tzoff = 0 (assuming that your system clock is within
 714         ** a half hour of the Datum time (even with time zone differences).
 715         */
 716
 717         for (tzoff=0; tzoff<24; tzoff++) {
 718                 if (clocktime( datum_pts->day,
 719                                datum_pts->hour,
 720                                datum_pts->minute,
 721                                datum_pts->second,
 722                                (tzoff + datum_pts->tzoff) % 24,
 723                                datum_pts->lastrec.l_ui,
 724                                &datum_pts->yearstart,
 725                                &datum_pts->lastref.l_ui) ) {
 726
 727                         datum_pts->lastref.l_uf = 0;
 728                         error = datum_pts->lastref.l_ui - datum_pts->lastrec.l_ui;
 729
 730 #ifdef DEBUG_DATUM_PTC
 731                         printf("Time Zone (clocktime method) = %d, error = %d\n", tzoff, error);
 732 #endif
 733
 734                         if ((error < 1799) && (error > -1799)) {
 735                                 tzoff = (tzoff + datum_pts->tzoff) % 24;
 736                                 datum_pts->tzoff = tzoff;
 737                                 goodtime = 1;
 738
 739 #ifdef DEBUG_DATUM_PTC
 740                                 printf("Time Zone found (clocktime method) = %d\n",tzoff);
 741 #endif
 742
 743                                 break;
 744                         }
 745
 746                 }
 747         }
 748
 749 #endif
 750
 751         /*
 752         ** Make sure that we have a good time from the Datum PTS. Clocktime() also
 753         ** sets yearstart and lastref.l_ui. We will have to set astref.l_uf (i.e.,
 754         ** the fraction of a second) stuff later.
 755         */
 756
 757         if (!goodtime) {
 758
 759                 if (!clocktime( datum_pts->day,
 760                                 datum_pts->hour,
 761                                 datum_pts->minute,
 762                                 datum_pts->second,
 763                                 tzoff,
 764                                 datum_pts->lastrec.l_ui,
 765                                 &datum_pts->yearstart,
 766                                 &datum_pts->lastref.l_ui) ) {
 767
 768 #ifdef DEBUG_DATUM_PTC
 769                         if (debug)
 770                         {
 771                                 printf("Error: bad clocktime\n");
 772                                 printf("GMT %d, lastrec %d, yearstart %d, lastref %d\n",
 773                                        tzoff,
 774                                        datum_pts->lastrec.l_ui,
 775                                        datum_pts->yearstart,
 776                                        datum_pts->lastref.l_ui);
 777                         }
 778 #endif
 779
 780                         msyslog(LOG_ERR, "Datum_PTS: Bad clocktime");
 781
 782                         return;
 783
 784                 }else{
 785
 786 #ifdef DEBUG_DATUM_PTC
 787                         if (debug)
 788                             printf("Good clocktime\n");
 789 #endif
 790
 791                 }
 792
 793         }
 794
 795         /*
 796         ** We have datum_pts->lastref.l_ui set (which is the integer part of the
 797         ** time. Now set the microseconds field.
 798         */
 799
 800         TVUTOTSF(datum_pts->usec, datum_pts->lastref.l_uf);
 801
 802         /*
 803         ** Compute the time correction as the difference between the reference
 804         ** time (i.e., the Datum time) minus the receive time (system time).
 805         */
 806
 807         tstmp = datum_pts->lastref;             /* tstmp is the datum ntp time */
 808         L_SUB(&tstmp, &datum_pts->lastrec);     /* tstmp is now the correction */
 809         datum_pts->coderecv++;          /* increment a counter */
 810
 811 #ifdef DEBUG_DATUM_PTC
 812         dispersion = DATUM_DISPERSION;  /* set the dispersion to 0 */
 813         ftimerr = dispersion;
 814         ftimerr /= (1024.0 * 64.0);
 815         if (debug)
 816             printf("dispersion = %d, %f\n", dispersion, ftimerr);
 817 #endif
 818
 819         /*
 820         ** Pass the new time to ntpd through the refclock_receive function. Note
 821         ** that we are not trying to make any corrections due to the time it takes
 822         ** for the Datum PTS to send the message back. I am (erroneously) assuming
 823         ** that the time for the Datum PTS to send the time back to us is negligable.
 824         ** I suspect that this time delay may be as much as 15 ms or so (but probably
 825         ** less). For our needs at JPL, this kind of error is ok so it is not
 826         ** necessary to use fudge factors in the ntp.conf file. Maybe later we will.
 827         */
 828       /*LFPTOD(&tstmp, doffset);*/
 829         datum_pts->lastref = datum_pts->lastrec;
 830         refclock_receive(datum_pts->peer);
 831
 832         /*
 833         ** Compute sigma squared (not used currently). Maybe later, this could be
 834         ** used for the dispersion estimate. The problem is that ntpd does not link
 835         ** in the math library so sqrt() is not available. Anyway, this is useful
 836         ** for debugging. Maybe later I will just use absolute values for the time
 837         ** error to come up with my dispersion estimate. Anyway, for now my dispersion
 838         ** is set to 0.
 839         */
 840
 841         timerr = tstmp.l_ui<<20;
 842         timerr |= (tstmp.l_uf>>12) & 0x000fffff;
 843         ftimerr = timerr;
 844         ftimerr /= 1024*1024;
 845         abserr = ftimerr;
 846         if (ftimerr < 0.0) abserr = -ftimerr;
 847
 848         if (datum_pts->sigma2 == 0.0) {
 849                 if (abserr < DATUM_MAX_ERROR) {
 850                         datum_pts->sigma2 = abserr*abserr;
 851                 }else{
 852                         datum_pts->sigma2 = DATUM_MAX_ERROR2;
 853                 }
 854         }else{
 855                 if (abserr < DATUM_MAX_ERROR) {
 856                         datum_pts->sigma2 = 0.95*datum_pts->sigma2 + 0.05*abserr*abserr;
 857                 }else{
 858                         datum_pts->sigma2 = 0.95*datum_pts->sigma2 + 0.05*DATUM_MAX_ERROR2;
 859                 }
 860         }
 861
 862 #ifdef DEBUG_DATUM_PTC
 863         if (debug)
 864             printf("Time error = %f seconds\n", ftimerr);
 865 #endif
 866
 867 #if defined(DEBUG_DATUM_PTC) || defined(LOG_TIME_ERRORS)
 868         if (debug)
 869             printf("PTS: day %d, hour %d, minute %d, second %d, msec %d, Time Error %f\n",
 870                    datum_pts->day,
 871                    datum_pts->hour,
 872                    datum_pts->minute,
 873                    datum_pts->second,
 874                    datum_pts->msec,
 875                    ftimerr);
 876 #endif
 877
 878 }
 879 #else
 880 int refclock_datum_bs;
 881 #endif /* REFCLOCK */