contrib/ntp/ntpd/refclock_parse.c

   1 /*
   2  * /src/NTP/REPOSITORY/ntp4-dev/ntpd/refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A
   3  *
   4  * refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A
   5  *
   6  * generic reference clock driver for several DCF/GPS/MSF/... receivers
   7  *
   8  * PPS notes:
   9  *   On systems that support PPSAPI (RFC2783) PPSAPI is the
  10  *   preferred interface.
  11  *
  12  *   Optionally make use of a STREAMS module for input processing where
  13  *   available and configured. This STREAMS module reduces the time
  14  *   stamp latency for serial and PPS events.
  15  *   Currently the STREAMS module is only available for Suns running
  16  *   SunOS 4.x and SunOS5.x.
  17  *
  18  * Copyright (c) 1995-2015 by Frank Kardel <kardel <AT> ntp.org>
  19  * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universitaet Erlangen-Nuernberg, Germany
  20  *
  21  * Redistribution and use in source and binary forms, with or without
  22  * modification, are permitted provided that the following conditions
  23  * are met:
  24  * 1. Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  * 2. Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in the
  28  *    documentation and/or other materials provided with the distribution.
  29  * 3. Neither the name of the author nor the names of its contributors
  30  *    may be used to endorse or promote products derived from this software
  31  *    without specific prior written permission.
  32  *
  33  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  34  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  35  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  36  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  37  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  38  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  39  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  41  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  42  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  43  * SUCH DAMAGE.
  44  *
  45  */
  46
  47 #ifdef HAVE_CONFIG_H
  48 # include "config.h"
  49 #endif
  50
  51 #include "ntp_types.h"
  52
  53 #if defined(REFCLOCK) && defined(CLOCK_PARSE)
  54
  55 /*
  56  * This driver currently provides the support for
  57  *   - Meinberg receiver DCF77 PZF535 (TCXO version)        (DCF)
  58  *   - Meinberg receiver DCF77 PZF535 (OCXO version)        (DCF)
  59  *   - Meinberg receiver DCF77 PZF509                       (DCF)
  60  *   - Meinberg receiver DCF77 AM receivers (e.g. C51)      (DCF)
  61  *   - IGEL CLOCK                                           (DCF)
  62  *   - ELV DCF7000                                          (DCF)
  63  *   - Schmid clock                                         (DCF)
  64  *   - Conrad DCF77 receiver module                         (DCF)
  65  *   - FAU DCF77 NTP receiver (TimeBrick)                   (DCF)
  66  *   - WHARTON 400A Series clock                            (DCF)
  67  *
  68  *   - Meinberg GPS receivers                               (GPS)
  69  *   - Trimble (TSIP and TAIP protocol)                     (GPS)
  70  *
  71  *   - RCC8000 MSF Receiver                                 (MSF)
  72  *   - VARITEXT clock                                       (MSF)
  73  */
  74
  75 /*
  76  * Meinberg receivers are usually connected via a
  77  * 9600/7E1 or 19200/8N1 serial line.
  78  *
  79  * The Meinberg GPS receivers also have a special NTP time stamp
  80  * format. The firmware release is Uni-Erlangen.
  81  *
  82  * Meinberg generic receiver setup:
  83  *      output time code every second
  84  *      Baud rate 9600 7E2S
  85  *
  86  * Meinberg GPS receiver setup:
  87  *      output time code every second
  88  *      Baudrate 19200 8N1
  89  *
  90  * This software supports the standard data formats used
  91  * in Meinberg receivers.
  92  *
  93  * Special software versions are only sensible for the
  94  * oldest GPS receiver, GPS16x. For newer receiver types
  95  * the output string format can be configured at the device,
  96  * and the device name is generally GPSxxx instead of GPS16x.
  97  *
  98  * Meinberg can be reached via: http://www.meinberg.de/
  99  */
 100
 101 #include "ntpd.h"
 102 #include "ntp_refclock.h"
 103 #include "timevalops.h"         /* includes <sys/time.h> */
 104 #include "ntp_control.h"
 105 #include "ntp_string.h"
 106
 107 #include <stdio.h>
 108 #include <ctype.h>
 109 #ifndef TM_IN_SYS_TIME
 110 # include <time.h>
 111 #endif
 112
 113 #ifdef HAVE_UNISTD_H
 114 # include <unistd.h>
 115 #endif
 116
 117 #if !defined(STREAM) && !defined(HAVE_SYSV_TTYS) && !defined(HAVE_BSD_TTYS) && !defined(HAVE_TERMIOS)
 118 # include "Bletch:  Define one of {STREAM,HAVE_SYSV_TTYS,HAVE_TERMIOS}"
 119 #endif
 120
 121 #ifdef STREAM
 122 # include <sys/stream.h>
 123 # include <sys/stropts.h>
 124 #endif
 125
 126 #ifdef HAVE_TERMIOS
 127 # include <termios.h>
 128 # define TTY_GETATTR(_FD_, _ARG_) tcgetattr((_FD_), (_ARG_))
 129 # define TTY_SETATTR(_FD_, _ARG_) tcsetattr((_FD_), TCSANOW, (_ARG_))
 130 # undef HAVE_SYSV_TTYS
 131 #endif
 132
 133 #ifdef HAVE_SYSV_TTYS
 134 # define TTY_GETATTR(_FD_, _ARG_) ioctl((_FD_), TCGETA, (_ARG_))
 135 # define TTY_SETATTR(_FD_, _ARG_) ioctl((_FD_), TCSETAW, (_ARG_))
 136 #endif
 137
 138 #ifdef HAVE_BSD_TTYS
 139 /* #error CURRENTLY NO BSD TTY SUPPORT */
 140 # include "Bletch: BSD TTY not currently supported"
 141 #endif
 142
 143 #ifdef HAVE_SYS_IOCTL_H
 144 # include <sys/ioctl.h>
 145 #endif
 146
 147 #ifdef HAVE_PPSAPI
 148 # include "ppsapi_timepps.h"
 149 # include "refclock_atom.h"
 150 #endif
 151
 152 #ifdef PPS
 153 # ifdef HAVE_SYS_PPSCLOCK_H
 154 #  include <sys/ppsclock.h>
 155 # endif
 156 # ifdef HAVE_TIO_SERIAL_STUFF
 157 #  include <linux/serial.h>
 158 # endif
 159 #endif
 160
 161 # define BUFFER_SIZE(_BUF, _PTR)       ((int)((_BUF) + sizeof(_BUF) - (_PTR)))
 162 # define BUFFER_SIZES(_BUF, _PTR, _SZ) ((int)((_BUF) + (_SZ) - (_PTR)))
 163
 164 /*
 165  * document type of PPS interfacing - copy of ifdef mechanism in local_input()
 166  */
 167 #undef PPS_METHOD
 168
 169 #ifdef HAVE_PPSAPI
 170 #define PPS_METHOD "PPS API"
 171 #else
 172 #ifdef TIOCDCDTIMESTAMP
 173 #define PPS_METHOD "TIOCDCDTIMESTAMP"
 174 #else /* TIOCDCDTIMESTAMP */
 175 #if defined(HAVE_STRUCT_PPSCLOCKEV) && (defined(HAVE_CIOGETEV) || defined(HAVE_TIOCGPPSEV))
 176 #ifdef HAVE_CIOGETEV
 177 #define PPS_METHOD "CIOGETEV"
 178 #endif
 179 #ifdef HAVE_TIOCGPPSEV
 180 #define PPS_METHOD "TIOCGPPSEV"
 181 #endif
 182 #endif
 183 #endif /* TIOCDCDTIMESTAMP */
 184 #endif /* HAVE_PPSAPI */
 185
 186 /*
 187  * COND_DEF can be conditionally defined as DEF or 0. If defined as DEF
 188  * then some more parse-specific variables are flagged to be printed with
 189  * "ntpq -c cv <assid>". This can be lengthy, so by default COND_DEF
 190  * should be defined as 0.
 191  */
 192 #if 0
 193 # define COND_DEF   DEF   // enable this for testing
 194 #else
 195 # define COND_DEF   0     // enable this by default
 196 #endif
 197
 198 #include "ntp_io.h"
 199 #include "ntp_stdlib.h"
 200
 201 #include "parse.h"
 202 #include "mbg_gps166.h"
 203 #include "trimble.h"
 204 #include "binio.h"
 205 #include "ascii.h"
 206 #include "ieee754io.h"
 207 #include "recvbuff.h"
 208
 209 static char rcsid[] = "refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A+POWERUPTRUST";
 210
 211 /**===========================================================================
 212  ** external interface to ntp mechanism
 213  **/
 214
 215 static  int     parse_start     (int, struct peer *);
 216 static  void    parse_shutdown  (int, struct peer *);
 217 static  void    parse_poll      (int, struct peer *);
 218 static  void    parse_control   (int, const struct refclockstat *, struct refclockstat *, struct peer *);
 219
 220 struct  refclock refclock_parse = {
 221         parse_start,
 222         parse_shutdown,
 223         parse_poll,
 224         parse_control,
 225         noentry,
 226         noentry,
 227         NOFLAGS
 228 };
 229
 230 /*
 231  * Definitions
 232  */
 233 #define MAXUNITS        4       /* maximum number of "PARSE" units permitted */
 234 #define PARSEDEVICE     "/dev/refclock-%d" /* device to open %d is unit number */
 235 #define PARSEPPSDEVICE  "/dev/refclockpps-%d" /* optional pps device to open %d is unit number */
 236
 237 #undef ABS
 238 #define ABS(_X_) (((_X_) < 0) ? -(_X_) : (_X_))
 239
 240 #define PARSE_HARDPPS_DISABLE 0
 241 #define PARSE_HARDPPS_ENABLE  1
 242
 243 /**===========================================================================
 244  ** function vector for dynamically binding io handling mechanism
 245  **/
 246
 247 struct parseunit;               /* to keep inquiring minds happy */
 248
 249 typedef struct bind
 250 {
 251   const char *bd_description;                                   /* name of type of binding */
 252   int   (*bd_init)     (struct parseunit *);                    /* initialize */
 253   void  (*bd_end)      (struct parseunit *);                    /* end */
 254   int   (*bd_setcs)    (struct parseunit *, parsectl_t *);      /* set character size */
 255   int   (*bd_disable)  (struct parseunit *);                    /* disable */
 256   int   (*bd_enable)   (struct parseunit *);                    /* enable */
 257   int   (*bd_getfmt)   (struct parseunit *, parsectl_t *);      /* get format */
 258   int   (*bd_setfmt)   (struct parseunit *, parsectl_t *);      /* setfmt */
 259   int   (*bd_timecode) (struct parseunit *, parsectl_t *);      /* get time code */
 260   void  (*bd_receive)  (struct recvbuf *);                      /* receive operation */
 261   int   (*bd_io_input) (struct recvbuf *);                      /* input operation */
 262 } bind_t;
 263
 264 #define PARSE_END(_X_)                  (*(_X_)->binding->bd_end)(_X_)
 265 #define PARSE_SETCS(_X_, _CS_)          (*(_X_)->binding->bd_setcs)(_X_, _CS_)
 266 #define PARSE_ENABLE(_X_)               (*(_X_)->binding->bd_enable)(_X_)
 267 #define PARSE_DISABLE(_X_)              (*(_X_)->binding->bd_disable)(_X_)
 268 #define PARSE_GETFMT(_X_, _DCT_)        (*(_X_)->binding->bd_getfmt)(_X_, _DCT_)
 269 #define PARSE_SETFMT(_X_, _DCT_)        (*(_X_)->binding->bd_setfmt)(_X_, _DCT_)
 270 #define PARSE_GETTIMECODE(_X_, _DCT_)   (*(_X_)->binding->bd_timecode)(_X_, _DCT_)
 271
 272 /*
 273  * special handling flags
 274  */
 275 #define PARSE_F_PPSONSECOND     0x00000001 /* PPS pulses are on second */
 276 #define PARSE_F_POWERUPTRUST    0x00000100 /* POWERUP state ist trusted for */
 277                                            /* trusttime after SYNC was seen */
 278 /**===========================================================================
 279  ** error message regression handling
 280  **
 281  ** there are quite a few errors that can occur in rapid succession such as
 282  ** noisy input data or no data at all. in order to reduce the amount of
 283  ** syslog messages in such case, we are using a backoff algorithm. We limit
 284  ** the number of error messages of a certain class to 1 per time unit. if a
 285  ** configurable number of messages is displayed that way, we move on to the
 286  ** next time unit / count for that class. a count of messages that have been
 287  ** suppressed is held and displayed whenever a corresponding message is
 288  ** displayed. the time units for a message class will also be displayed.
 289  ** whenever an error condition clears we reset the error message state,
 290  ** thus we would still generate much output on pathological conditions
 291  ** where the system oscillates between OK and NOT OK states. coping
 292  ** with that condition is currently considered too complicated.
 293  **/
 294
 295 #define ERR_ALL         (unsigned)~0    /* "all" errors */
 296 #define ERR_BADDATA     (unsigned)0     /* unusable input data/conversion errors */
 297 #define ERR_NODATA      (unsigned)1     /* no input data */
 298 #define ERR_BADIO       (unsigned)2     /* read/write/select errors */
 299 #define ERR_BADSTATUS   (unsigned)3     /* unsync states */
 300 #define ERR_BADEVENT    (unsigned)4     /* non nominal events */
 301 #define ERR_INTERNAL    (unsigned)5     /* internal error */
 302 #define ERR_CNT         (unsigned)(ERR_INTERNAL+1)
 303
 304 #define ERR(_X_)        if (list_err(parse, (_X_)))
 305
 306 struct errorregression
 307 {
 308         u_long err_count;       /* number of repititions per class */
 309         u_long err_delay;       /* minimum delay between messages */
 310 };
 311
 312 static struct errorregression
 313 err_baddata[] =                 /* error messages for bad input data */
 314 {
 315         { 1,       0 },         /* output first message immediately */
 316         { 5,      60 },         /* output next five messages in 60 second intervals */
 317         { 3,    3600 },         /* output next 3 messages in hour intervals */
 318         { 0, 12*3600 }          /* repeat messages only every 12 hours */
 319 };
 320
 321 static struct errorregression
 322 err_nodata[] =                  /* error messages for missing input data */
 323 {
 324         { 1,       0 },         /* output first message immediately */
 325         { 5,      60 },         /* output next five messages in 60 second intervals */
 326         { 3,    3600 },         /* output next 3 messages in hour intervals */
 327         { 0, 12*3600 }          /* repeat messages only every 12 hours */
 328 };
 329
 330 static struct errorregression
 331 err_badstatus[] =               /* unsynchronized state messages */
 332 {
 333         { 1,       0 },         /* output first message immediately */
 334         { 5,      60 },         /* output next five messages in 60 second intervals */
 335         { 3,    3600 },         /* output next 3 messages in hour intervals */
 336         { 0, 12*3600 }          /* repeat messages only every 12 hours */
 337 };
 338
 339 static struct errorregression
 340 err_badio[] =                   /* io failures (bad reads, selects, ...) */
 341 {
 342         { 1,       0 },         /* output first message immediately */
 343         { 5,      60 },         /* output next five messages in 60 second intervals */
 344         { 5,    3600 },         /* output next 3 messages in hour intervals */
 345         { 0, 12*3600 }          /* repeat messages only every 12 hours */
 346 };
 347
 348 static struct errorregression
 349 err_badevent[] =                /* non nominal events */
 350 {
 351         { 20,      0 },         /* output first message immediately */
 352         { 6,      60 },         /* output next five messages in 60 second intervals */
 353         { 5,    3600 },         /* output next 3 messages in hour intervals */
 354         { 0, 12*3600 }          /* repeat messages only every 12 hours */
 355 };
 356
 357 static struct errorregression
 358 err_internal[] =                /* really bad things - basically coding/OS errors */
 359 {
 360         { 0,       0 },         /* output all messages immediately */
 361 };
 362
 363 static struct errorregression *
 364 err_tbl[] =
 365 {
 366         err_baddata,
 367         err_nodata,
 368         err_badio,
 369         err_badstatus,
 370         err_badevent,
 371         err_internal
 372 };
 373
 374 struct errorinfo
 375 {
 376         u_long err_started;     /* begin time (ntp) of error condition */
 377         u_long err_last;        /* last time (ntp) error occurred */
 378         u_long err_cnt; /* number of error repititions */
 379         u_long err_suppressed;  /* number of suppressed messages */
 380         struct errorregression *err_stage; /* current error stage */
 381 };
 382
 383 /**===========================================================================
 384  ** refclock instance data
 385  **/
 386
 387 struct parseunit
 388 {
 389         /*
 390          * NTP management
 391          */
 392         struct peer         *peer;              /* backlink to peer structure - refclock inactive if 0  */
 393         struct refclockproc *generic;           /* backlink to refclockproc structure */
 394
 395         /*
 396          * PARSE io
 397          */
 398         bind_t       *binding;          /* io handling binding */
 399
 400         /*
 401          * parse state
 402          */
 403         parse_t       parseio;          /* io handling structure (user level parsing) */
 404
 405         /*
 406          * type specific parameters
 407          */
 408         struct parse_clockinfo   *parse_type;           /* link to clock description */
 409
 410         /*
 411          * clock state handling/reporting
 412          */
 413         u_char        flags;            /* flags (leap_control) */
 414         u_long        lastchange;       /* time (ntp) when last state change accured */
 415         u_long        statetime[CEVNT_MAX+1]; /* accumulated time of clock states */
 416         u_long        pollneeddata;     /* current_time(!=0) for receive sample expected in PPS mode */
 417         u_short       lastformat;       /* last format used */
 418         u_long        lastsync;         /* time (ntp) when clock was last seen fully synchronized */
 419         u_long        maxunsync;        /* max time in seconds a receiver is trusted after loosing synchronisation */
 420         double        ppsphaseadjust;   /* phase adjustment of PPS time stamp */
 421         u_long        lastmissed;       /* time (ntp) when poll didn't get data (powerup heuristic) */
 422         u_long        ppsserial;        /* magic cookie for ppsclock serials (avoids stale ppsclock data) */
 423         int           ppsfd;            /* fd to ise for PPS io */
 424 #ifdef HAVE_PPSAPI
 425         int           hardppsstate;     /* current hard pps state */
 426         struct refclock_atom atom;      /* PPSAPI structure */
 427 #endif
 428         parsetime_t   timedata;         /* last (parse module) data */
 429         void         *localdata;        /* optional local, receiver-specific data */
 430         unsigned long localstate;       /* private local state */
 431         struct errorinfo errors[ERR_CNT];  /* error state table for suppressing excessive error messages */
 432         struct ctl_var *kv;             /* additional pseudo variables */
 433         u_long        laststatistic;    /* time when staticstics where output */
 434 };
 435
 436
 437 /**===========================================================================
 438  ** Clockinfo section all parameter for specific clock types
 439  ** includes NTP parameters, TTY parameters and IO handling parameters
 440  **/
 441
 442 static  void    poll_dpoll      (struct parseunit *);
 443 static  void    poll_poll       (struct peer *);
 444 static  int     poll_init       (struct parseunit *);
 445
 446 typedef struct poll_info
 447 {
 448         u_long      rate;               /* poll rate - once every "rate" seconds - 0 off */
 449         const char *string;             /* string to send for polling */
 450         u_long      count;              /* number of characters in string */
 451 } poll_info_t;
 452
 453 #define NO_CL_FLAGS     0
 454 #define NO_POLL         0
 455 #define NO_INIT         0
 456 #define NO_END          0
 457 #define NO_EVENT        0
 458 #define NO_LCLDATA      0
 459 #define NO_MESSAGE      0
 460 #define NO_PPSDELAY     0
 461
 462 #define DCF_ID          "DCF"   /* generic DCF */
 463 #define DCF_A_ID        "DCFa"  /* AM demodulation */
 464 #define DCF_P_ID        "DCFp"  /* psuedo random phase shift */
 465 #define GPS_ID          "GPS"   /* GPS receiver */
 466
 467 #define NOCLOCK_ROOTDELAY       0.0
 468 #define NOCLOCK_BASEDELAY       0.0
 469 #define NOCLOCK_DESCRIPTION     0
 470 #define NOCLOCK_MAXUNSYNC       0
 471 #define NOCLOCK_CFLAG           0
 472 #define NOCLOCK_IFLAG           0
 473 #define NOCLOCK_OFLAG           0
 474 #define NOCLOCK_LFLAG           0
 475 #define NOCLOCK_ID              "TILT"
 476 #define NOCLOCK_POLL            NO_POLL
 477 #define NOCLOCK_INIT            NO_INIT
 478 #define NOCLOCK_END             NO_END
 479 #define NOCLOCK_DATA            NO_LCLDATA
 480 #define NOCLOCK_FORMAT          ""
 481 #define NOCLOCK_TYPE            CTL_SST_TS_UNSPEC
 482 #define NOCLOCK_SAMPLES         0
 483 #define NOCLOCK_KEEP            0
 484
 485 #define DCF_TYPE                CTL_SST_TS_LF
 486 #define GPS_TYPE                CTL_SST_TS_UHF
 487
 488 /*
 489  * receiver specific constants
 490  */
 491 #define MBG_SPEED               (B9600)
 492 #define MBG_CFLAG               (CS7|PARENB|CREAD|CLOCAL|HUPCL|CSTOPB)
 493 #define MBG_IFLAG               (IGNBRK|IGNPAR|ISTRIP)
 494 #define MBG_OFLAG               0
 495 #define MBG_LFLAG               0
 496 #define MBG_FLAGS               PARSE_F_PPSONSECOND
 497
 498 /*
 499  * Meinberg DCF77 receivers
 500  */
 501 #define DCFUA31_ROOTDELAY       0.0  /* 0 */
 502 #define DCFUA31_BASEDELAY       0.010  /* 10.7421875ms: 10 ms (+/- 3 ms) */
 503 #define DCFUA31_DESCRIPTION     "Meinberg DCF77 C51 or compatible"
 504 #define DCFUA31_MAXUNSYNC       60*30       /* only trust clock for 1/2 hour */
 505 #define DCFUA31_SPEED           MBG_SPEED
 506 #define DCFUA31_CFLAG           MBG_CFLAG
 507 #define DCFUA31_IFLAG           MBG_IFLAG
 508 #define DCFUA31_OFLAG           MBG_OFLAG
 509 #define DCFUA31_LFLAG           MBG_LFLAG
 510 #define DCFUA31_SAMPLES         5
 511 #define DCFUA31_KEEP            3
 512 #define DCFUA31_FORMAT          "Meinberg Standard"
 513
 514 /*
 515  * Meinberg DCF PZF535/TCXO (FM/PZF) receiver
 516  */
 517 #define DCFPZF535_ROOTDELAY     0.0
 518 #define DCFPZF535_BASEDELAY     0.001968  /* 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
 519 #define DCFPZF535_DESCRIPTION   "Meinberg DCF PZF 535/509 / TCXO"
 520 #define DCFPZF535_MAXUNSYNC     60*60*12           /* only trust clock for 12 hours
 521                                                     * @ 5e-8df/f we have accumulated
 522                                                     * at most 2.16 ms (thus we move to
 523                                                     * NTP synchronisation */
 524 #define DCFPZF535_SPEED         MBG_SPEED
 525 #define DCFPZF535_CFLAG         MBG_CFLAG
 526 #define DCFPZF535_IFLAG         MBG_IFLAG
 527 #define DCFPZF535_OFLAG         MBG_OFLAG
 528 #define DCFPZF535_LFLAG         MBG_LFLAG
 529 #define DCFPZF535_SAMPLES              5
 530 #define DCFPZF535_KEEP                 3
 531 #define DCFPZF535_FORMAT        "Meinberg Standard"
 532
 533 /*
 534  * Meinberg DCF PZF535/OCXO receiver
 535  */
 536 #define DCFPZF535OCXO_ROOTDELAY 0.0
 537 #define DCFPZF535OCXO_BASEDELAY 0.001968 /* 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
 538 #define DCFPZF535OCXO_DESCRIPTION "Meinberg DCF PZF 535/509 / OCXO"
 539 #define DCFPZF535OCXO_MAXUNSYNC     60*60*96       /* only trust clock for 4 days
 540                                                     * @ 5e-9df/f we have accumulated
 541                                                     * at most an error of 1.73 ms
 542                                                     * (thus we move to NTP synchronisation) */
 543 #define DCFPZF535OCXO_SPEED         MBG_SPEED
 544 #define DCFPZF535OCXO_CFLAG         MBG_CFLAG
 545 #define DCFPZF535OCXO_IFLAG         MBG_IFLAG
 546 #define DCFPZF535OCXO_OFLAG         MBG_OFLAG
 547 #define DCFPZF535OCXO_LFLAG         MBG_LFLAG
 548 #define DCFPZF535OCXO_SAMPLES              5
 549 #define DCFPZF535OCXO_KEEP                 3
 550 #define DCFPZF535OCXO_FORMAT        "Meinberg Standard"
 551
 552 /*
 553  * Meinberg GPS receivers
 554  */
 555 static  void    gps16x_message   (struct parseunit *, parsetime_t *);
 556 static  int     gps16x_poll_init (struct parseunit *);
 557
 558 #define GPS16X_ROOTDELAY        0.0         /* nothing here */
 559 #define GPS16X_BASEDELAY        0.001968         /* XXX to be fixed ! 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
 560 #define GPS16X_DESCRIPTION      "Meinberg GPS receiver"
 561 #define GPS16X_MAXUNSYNC        60*60*96       /* only trust clock for 4 days
 562                                                 * @ 5e-9df/f we have accumulated
 563                                                 * at most an error of 1.73 ms
 564                                                 * (thus we move to NTP synchronisation) */
 565 #define GPS16X_SPEED            B19200
 566 #define GPS16X_CFLAG            (CS8|CREAD|CLOCAL|HUPCL)
 567 #define GPS16X_IFLAG            (IGNBRK|IGNPAR)
 568 #define GPS16X_OFLAG            MBG_OFLAG
 569 #define GPS16X_LFLAG            MBG_LFLAG
 570 #define GPS16X_POLLRATE 6
 571 #define GPS16X_POLLCMD  ""
 572 #define GPS16X_CMDSIZE  0
 573
 574 static poll_info_t gps16x_pollinfo = { GPS16X_POLLRATE, GPS16X_POLLCMD, GPS16X_CMDSIZE };
 575
 576 #define GPS16X_INIT             gps16x_poll_init
 577 #define GPS16X_POLL             0
 578 #define GPS16X_END              0
 579 #define GPS16X_DATA             ((void *)(&gps16x_pollinfo))
 580 #define GPS16X_MESSAGE          gps16x_message
 581 #define GPS16X_ID               GPS_ID
 582 #define GPS16X_FORMAT           "Meinberg GPS Extended"
 583 #define GPS16X_SAMPLES          5
 584 #define GPS16X_KEEP             3
 585
 586 /*
 587  * ELV DCF7000 Wallclock-Receiver/Switching Clock (Kit)
 588  *
 589  * This is really not the hottest clock - but before you have nothing ...
 590  */
 591 #define DCF7000_ROOTDELAY       0.0 /* 0 */
 592 #define DCF7000_BASEDELAY       0.405 /* slow blow */
 593 #define DCF7000_DESCRIPTION     "ELV DCF7000"
 594 #define DCF7000_MAXUNSYNC       (60*5) /* sorry - but it just was not build as a clock */
 595 #define DCF7000_SPEED           (B9600)
 596 #define DCF7000_CFLAG           (CS8|CREAD|PARENB|PARODD|CLOCAL|HUPCL)
 597 #define DCF7000_IFLAG           (IGNBRK)
 598 #define DCF7000_OFLAG           0
 599 #define DCF7000_LFLAG           0
 600 #define DCF7000_SAMPLES         5
 601 #define DCF7000_KEEP            3
 602 #define DCF7000_FORMAT          "ELV DCF7000"
 603
 604 /*
 605  * Schmid DCF Receiver Kit
 606  *
 607  * When the WSDCF clock is operating optimally we want the primary clock
 608  * distance to come out at 300 ms.  Thus, peer.distance in the WSDCF peer
 609  * structure is set to 290 ms and we compute delays which are at least
 610  * 10 ms long.  The following are 290 ms and 10 ms expressed in u_fp format
 611  */
 612 #define WS_POLLRATE     1       /* every second - watch interdependency with poll routine */
 613 #define WS_POLLCMD      "\163"
 614 #define WS_CMDSIZE      1
 615
 616 static poll_info_t wsdcf_pollinfo = { WS_POLLRATE, WS_POLLCMD, WS_CMDSIZE };
 617
 618 #define WSDCF_INIT              poll_init
 619 #define WSDCF_POLL              poll_dpoll
 620 #define WSDCF_END               0
 621 #define WSDCF_DATA              ((void *)(&wsdcf_pollinfo))
 622 #define WSDCF_ROOTDELAY         0.0     /* 0 */
 623 #define WSDCF_BASEDELAY         0.010   /*  ~  10ms */
 624 #define WSDCF_DESCRIPTION       "WS/DCF Receiver"
 625 #define WSDCF_FORMAT            "Schmid"
 626 #define WSDCF_MAXUNSYNC         (60*60) /* assume this beast hold at 1 h better than 2 ms XXX-must verify */
 627 #define WSDCF_SPEED             (B1200)
 628 #define WSDCF_CFLAG             (CS8|CREAD|CLOCAL)
 629 #define WSDCF_IFLAG             0
 630 #define WSDCF_OFLAG             0
 631 #define WSDCF_LFLAG             0
 632 #define WSDCF_SAMPLES           5
 633 #define WSDCF_KEEP              3
 634
 635 /*
 636  * RAW DCF77 - input of DCF marks via RS232 - many variants
 637  */
 638 #define RAWDCF_FLAGS            0
 639 #define RAWDCF_ROOTDELAY        0.0 /* 0 */
 640 #define RAWDCF_BASEDELAY        0.258
 641 #define RAWDCF_FORMAT           "RAW DCF77 Timecode"
 642 #define RAWDCF_MAXUNSYNC        (0) /* sorry - its a true receiver - no signal - no time */
 643 #define RAWDCF_SPEED            (B50)
 644 #ifdef NO_PARENB_IGNPAR /* Was: defined(SYS_IRIX4) || defined(SYS_IRIX5) */
 645 /* somehow doesn't grok PARENB & IGNPAR (mj) */
 646 # define RAWDCF_CFLAG            (CS8|CREAD|CLOCAL)
 647 #else
 648 # define RAWDCF_CFLAG            (CS8|CREAD|CLOCAL|PARENB)
 649 #endif
 650 #ifdef RAWDCF_NO_IGNPAR /* Was: defined(SYS_LINUX) && defined(CLOCK_RAWDCF) */
 651 # define RAWDCF_IFLAG           0
 652 #else
 653 # define RAWDCF_IFLAG           (IGNPAR)
 654 #endif
 655 #define RAWDCF_OFLAG            0
 656 #define RAWDCF_LFLAG            0
 657 #define RAWDCF_SAMPLES          20
 658 #define RAWDCF_KEEP             12
 659 #define RAWDCF_INIT             0
 660
 661 /*
 662  * RAW DCF variants
 663  */
 664 /*
 665  * Conrad receiver
 666  *
 667  * simplest (cheapest) DCF clock - e. g. DCF77 receiver by Conrad
 668  * (~40DM - roughly $30 ) followed by a level converter for RS232
 669  */
 670 #define CONRAD_BASEDELAY        0.292 /* Conrad receiver @ 50 Baud on a Sun */
 671 #define CONRAD_DESCRIPTION      "RAW DCF77 CODE (Conrad DCF77 receiver module)"
 672
 673 /* Gude Analog- und Digitalsystem GmbH 'Expert mouseCLOCK USB v2.0' */
 674 #define GUDE_EMC_USB_V20_SPEED            (B4800)
 675 #define GUDE_EMC_USB_V20_BASEDELAY        0.425 /* USB serial<->USB converter FTDI232R */
 676 #define GUDE_EMC_USB_V20_DESCRIPTION      "RAW DCF77 CODE (Expert mouseCLOCK USB v2.0)"
 677
 678 /*
 679  * TimeBrick receiver
 680  */
 681 #define TIMEBRICK_BASEDELAY     0.210 /* TimeBrick @ 50 Baud on a Sun */
 682 #define TIMEBRICK_DESCRIPTION   "RAW DCF77 CODE (TimeBrick)"
 683
 684 /*
 685  * IGEL:clock receiver
 686  */
 687 #define IGELCLOCK_BASEDELAY     0.258 /* IGEL:clock receiver */
 688 #define IGELCLOCK_DESCRIPTION   "RAW DCF77 CODE (IGEL:clock)"
 689 #define IGELCLOCK_SPEED         (B1200)
 690 #define IGELCLOCK_CFLAG         (CS8|CREAD|HUPCL|CLOCAL)
 691
 692 /*
 693  * RAWDCF receivers that need to be powered from DTR
 694  * (like Expert mouse clock)
 695  */
 696 static  int     rawdcf_init_1   (struct parseunit *);
 697 #define RAWDCFDTRSET_DESCRIPTION        "RAW DCF77 CODE (DTR SET/RTS CLR)"
 698 #define RAWDCFDTRSET75_DESCRIPTION      "RAW DCF77 CODE (DTR SET/RTS CLR @ 75 baud)"
 699 #define RAWDCFDTRSET_INIT               rawdcf_init_1
 700
 701 /*
 702  * RAWDCF receivers that need to be powered from
 703  * DTR CLR and RTS SET
 704  */
 705 static  int     rawdcf_init_2   (struct parseunit *);
 706 #define RAWDCFDTRCLRRTSSET_DESCRIPTION  "RAW DCF77 CODE (DTR CLR/RTS SET)"
 707 #define RAWDCFDTRCLRRTSSET75_DESCRIPTION "RAW DCF77 CODE (DTR CLR/RTS SET @ 75 baud)"
 708 #define RAWDCFDTRCLRRTSSET_INIT rawdcf_init_2
 709
 710 /*
 711  * Trimble GPS receivers (TAIP and TSIP protocols)
 712  */
 713 #ifndef TRIM_POLLRATE
 714 #define TRIM_POLLRATE   0       /* only true direct polling */
 715 #endif
 716
 717 #define TRIM_TAIPPOLLCMD        ">SRM;FR_FLAG=F;EC_FLAG=F<>QTM<"
 718 #define TRIM_TAIPCMDSIZE        (sizeof(TRIM_TAIPPOLLCMD)-1)
 719
 720 static poll_info_t trimbletaip_pollinfo = { TRIM_POLLRATE, TRIM_TAIPPOLLCMD, TRIM_TAIPCMDSIZE };
 721 static  int     trimbletaip_init        (struct parseunit *);
 722 static  void    trimbletaip_event       (struct parseunit *, int);
 723
 724 /* query time & UTC correction data */
 725 static char tsipquery[] = { DLE, 0x21, DLE, ETX, DLE, 0x2F, DLE, ETX };
 726
 727 static poll_info_t trimbletsip_pollinfo = { TRIM_POLLRATE, tsipquery, sizeof(tsipquery) };
 728 static  int     trimbletsip_init        (struct parseunit *);
 729 static  void    trimbletsip_end         (struct parseunit *);
 730 static  void    trimbletsip_message     (struct parseunit *, parsetime_t *);
 731 static  void    trimbletsip_event       (struct parseunit *, int);
 732
 733 #define TRIMBLETSIP_IDLE_TIME       (300) /* 5 minutes silence at most */
 734 #define TRIMBLE_RESET_HOLDOFF       TRIMBLETSIP_IDLE_TIME
 735
 736 #define TRIMBLETAIP_SPEED           (B4800)
 737 #define TRIMBLETAIP_CFLAG           (CS8|CREAD|CLOCAL)
 738 #define TRIMBLETAIP_IFLAG           (BRKINT|IGNPAR|ISTRIP|ICRNL|IXON)
 739 #define TRIMBLETAIP_OFLAG           (OPOST|ONLCR)
 740 #define TRIMBLETAIP_LFLAG           (0)
 741
 742 #define TRIMBLETSIP_SPEED           (B9600)
 743 #define TRIMBLETSIP_CFLAG           (CS8|CLOCAL|CREAD|PARENB|PARODD)
 744 #define TRIMBLETSIP_IFLAG           (IGNBRK)
 745 #define TRIMBLETSIP_OFLAG           (0)
 746 #define TRIMBLETSIP_LFLAG           (ICANON)
 747
 748 #define TRIMBLETSIP_SAMPLES         5
 749 #define TRIMBLETSIP_KEEP            3
 750 #define TRIMBLETAIP_SAMPLES         5
 751 #define TRIMBLETAIP_KEEP            3
 752
 753 #define TRIMBLETAIP_FLAGS           (PARSE_F_PPSONSECOND)
 754 #define TRIMBLETSIP_FLAGS           (TRIMBLETAIP_FLAGS)
 755
 756 #define TRIMBLETAIP_POLL            poll_dpoll
 757 #define TRIMBLETSIP_POLL            poll_dpoll
 758
 759 #define TRIMBLETAIP_INIT            trimbletaip_init
 760 #define TRIMBLETSIP_INIT            trimbletsip_init
 761
 762 #define TRIMBLETAIP_EVENT           trimbletaip_event
 763
 764 #define TRIMBLETSIP_EVENT           trimbletsip_event
 765 #define TRIMBLETSIP_MESSAGE         trimbletsip_message
 766
 767 #define TRIMBLETAIP_END             0
 768 #define TRIMBLETSIP_END             trimbletsip_end
 769
 770 #define TRIMBLETAIP_DATA            ((void *)(&trimbletaip_pollinfo))
 771 #define TRIMBLETSIP_DATA            ((void *)(&trimbletsip_pollinfo))
 772
 773 #define TRIMBLETAIP_ID              GPS_ID
 774 #define TRIMBLETSIP_ID              GPS_ID
 775
 776 #define TRIMBLETAIP_FORMAT          "Trimble TAIP"
 777 #define TRIMBLETSIP_FORMAT          "Trimble TSIP"
 778
 779 #define TRIMBLETAIP_ROOTDELAY        0x0
 780 #define TRIMBLETSIP_ROOTDELAY        0x0
 781
 782 #define TRIMBLETAIP_BASEDELAY        0.0
 783 #define TRIMBLETSIP_BASEDELAY        0.020      /* GPS time message latency */
 784
 785 #define TRIMBLETAIP_DESCRIPTION      "Trimble GPS (TAIP) receiver"
 786 #define TRIMBLETSIP_DESCRIPTION      "Trimble GPS (TSIP) receiver"
 787
 788 #define TRIMBLETAIP_MAXUNSYNC        0
 789 #define TRIMBLETSIP_MAXUNSYNC        0
 790
 791 #define TRIMBLETAIP_EOL             '<'
 792
 793 /*
 794  * RadioCode Clocks RCC 800 receiver
 795  */
 796 #define RCC_POLLRATE   0       /* only true direct polling */
 797 #define RCC_POLLCMD    "\r"
 798 #define RCC_CMDSIZE    1
 799
 800 static poll_info_t rcc8000_pollinfo = { RCC_POLLRATE, RCC_POLLCMD, RCC_CMDSIZE };
 801 #define RCC8000_FLAGS           0
 802 #define RCC8000_POLL            poll_dpoll
 803 #define RCC8000_INIT            poll_init
 804 #define RCC8000_END             0
 805 #define RCC8000_DATA            ((void *)(&rcc8000_pollinfo))
 806 #define RCC8000_ROOTDELAY       0.0
 807 #define RCC8000_BASEDELAY       0.0
 808 #define RCC8000_ID              "MSF"
 809 #define RCC8000_DESCRIPTION     "RCC 8000 MSF Receiver"
 810 #define RCC8000_FORMAT          "Radiocode RCC8000"
 811 #define RCC8000_MAXUNSYNC       (60*60) /* should be ok for an hour */
 812 #define RCC8000_SPEED           (B2400)
 813 #define RCC8000_CFLAG           (CS8|CREAD|CLOCAL)
 814 #define RCC8000_IFLAG           (IGNBRK|IGNPAR)
 815 #define RCC8000_OFLAG           0
 816 #define RCC8000_LFLAG           0
 817 #define RCC8000_SAMPLES         5
 818 #define RCC8000_KEEP            3
 819
 820 /*
 821  * Hopf Radio clock 6021 Format
 822  *
 823  */
 824 #define HOPF6021_ROOTDELAY      0.0
 825 #define HOPF6021_BASEDELAY      0.0
 826 #define HOPF6021_DESCRIPTION    "HOPF 6021"
 827 #define HOPF6021_FORMAT         "hopf Funkuhr 6021"
 828 #define HOPF6021_MAXUNSYNC      (60*60)  /* should be ok for an hour */
 829 #define HOPF6021_SPEED         (B9600)
 830 #define HOPF6021_CFLAG          (CS8|CREAD|CLOCAL)
 831 #define HOPF6021_IFLAG          (IGNBRK|ISTRIP)
 832 #define HOPF6021_OFLAG          0
 833 #define HOPF6021_LFLAG          0
 834 #define HOPF6021_FLAGS          0
 835 #define HOPF6021_SAMPLES        5
 836 #define HOPF6021_KEEP           3
 837
 838 /*
 839  * Diem's Computime Radio Clock Receiver
 840  */
 841 #define COMPUTIME_FLAGS       0
 842 #define COMPUTIME_ROOTDELAY   0.0
 843 #define COMPUTIME_BASEDELAY   0.0
 844 #define COMPUTIME_ID          DCF_ID
 845 #define COMPUTIME_DESCRIPTION "Diem's Computime receiver"
 846 #define COMPUTIME_FORMAT      "Diem's Computime Radio Clock"
 847 #define COMPUTIME_TYPE        DCF_TYPE
 848 #define COMPUTIME_MAXUNSYNC   (60*60)       /* only trust clock for 1 hour */
 849 #define COMPUTIME_SPEED       (B9600)
 850 #define COMPUTIME_CFLAG       (CSTOPB|CS7|CREAD|CLOCAL)
 851 #define COMPUTIME_IFLAG       (IGNBRK|IGNPAR|ISTRIP)
 852 #define COMPUTIME_OFLAG       0
 853 #define COMPUTIME_LFLAG       0
 854 #define COMPUTIME_SAMPLES     5
 855 #define COMPUTIME_KEEP        3
 856
 857 /*
 858  * Varitext Radio Clock Receiver
 859  */
 860 #define VARITEXT_FLAGS       0
 861 #define VARITEXT_ROOTDELAY   0.0
 862 #define VARITEXT_BASEDELAY   0.0
 863 #define VARITEXT_ID          "MSF"
 864 #define VARITEXT_DESCRIPTION "Varitext receiver"
 865 #define VARITEXT_FORMAT      "Varitext Radio Clock"
 866 #define VARITEXT_TYPE        DCF_TYPE
 867 #define VARITEXT_MAXUNSYNC   (60*60)       /* only trust clock for 1 hour */
 868 #define VARITEXT_SPEED       (B9600)
 869 #define VARITEXT_CFLAG       (CS7|CREAD|CLOCAL|PARENB|PARODD)
 870 #define VARITEXT_IFLAG       (IGNPAR|IGNBRK|INPCK) /*|ISTRIP)*/
 871 #define VARITEXT_OFLAG       0
 872 #define VARITEXT_LFLAG       0
 873 #define VARITEXT_SAMPLES     32
 874 #define VARITEXT_KEEP        20
 875
 876 /*
 877  * SEL240x Satellite Sychronized Clock
 878  */
 879 #define SEL240X_POLLRATE        0 /* only true direct polling */
 880 #define SEL240X_POLLCMD         "BUB8"
 881 #define SEL240X_CMDSIZE         4
 882
 883 static poll_info_t sel240x_pollinfo = { SEL240X_POLLRATE,
 884                                         SEL240X_POLLCMD,
 885                                         SEL240X_CMDSIZE };
 886 #define SEL240X_FLAGS           (PARSE_F_PPSONSECOND)
 887 #define SEL240X_POLL            poll_dpoll
 888 #define SEL240X_INIT            poll_init
 889 #define SEL240X_END             0
 890 #define SEL240X_DATA            ((void *)(&sel240x_pollinfo))
 891 #define SEL240X_ROOTDELAY       0.0
 892 #define SEL240X_BASEDELAY       0.0
 893 #define SEL240X_ID              GPS_ID
 894 #define SEL240X_DESCRIPTION     "SEL240x Satellite Synchronized Clock"
 895 #define SEL240X_FORMAT          "SEL B8"
 896 #define SEL240X_MAXUNSYNC       60*60*12 /* only trust clock for 12 hours */
 897 #define SEL240X_SPEED           (B9600)
 898 #define SEL240X_CFLAG           (CS8|CREAD|CLOCAL)
 899 #define SEL240X_IFLAG           (IGNBRK|IGNPAR)
 900 #define SEL240X_OFLAG           (0)
 901 #define SEL240X_LFLAG           (0)
 902 #define SEL240X_SAMPLES         5
 903 #define SEL240X_KEEP            3
 904
 905 static struct parse_clockinfo
 906 {
 907         u_long  cl_flags;               /* operation flags (PPS interpretation, trust handling) */
 908   void  (*cl_poll)    (struct parseunit *);                     /* active poll routine */
 909   int   (*cl_init)    (struct parseunit *);                     /* active poll init routine */
 910   void  (*cl_event)   (struct parseunit *, int);                /* special event handling (e.g. reset clock) */
 911   void  (*cl_end)     (struct parseunit *);                     /* active poll end routine */
 912   void  (*cl_message) (struct parseunit *, parsetime_t *);      /* process a lower layer message */
 913         void   *cl_data;                /* local data area for "poll" mechanism */
 914         double    cl_rootdelay;         /* rootdelay */
 915         double    cl_basedelay;         /* current offset by which the RS232
 916                                 time code is delayed from the actual time */
 917         const char *cl_id;              /* ID code */
 918         const char *cl_description;             /* device name */
 919         const char *cl_format;          /* fixed format */
 920         u_char  cl_type;                /* clock type (ntp control) */
 921         u_long  cl_maxunsync;           /* time to trust oscillator after losing synch */
 922         u_long  cl_speed;               /* terminal input & output baudrate */
 923         u_long  cl_cflag;             /* terminal control flags */
 924         u_long  cl_iflag;             /* terminal input flags */
 925         u_long  cl_oflag;             /* terminal output flags */
 926         u_long  cl_lflag;             /* terminal local flags */
 927         u_long  cl_samples;           /* samples for median filter */
 928         u_long  cl_keep;              /* samples for median filter to keep */
 929 } parse_clockinfo[] =
 930 {
 931         {                               /* mode 0 */
 932                 MBG_FLAGS,
 933                 NO_POLL,
 934                 NO_INIT,
 935                 NO_EVENT,
 936                 NO_END,
 937                 NO_MESSAGE,
 938                 NO_LCLDATA,
 939                 DCFPZF535_ROOTDELAY,
 940                 DCFPZF535_BASEDELAY,
 941                 DCF_P_ID,
 942                 DCFPZF535_DESCRIPTION,
 943                 DCFPZF535_FORMAT,
 944                 DCF_TYPE,
 945                 DCFPZF535_MAXUNSYNC,
 946                 DCFPZF535_SPEED,
 947                 DCFPZF535_CFLAG,
 948                 DCFPZF535_IFLAG,
 949                 DCFPZF535_OFLAG,
 950                 DCFPZF535_LFLAG,
 951                 DCFPZF535_SAMPLES,
 952                 DCFPZF535_KEEP
 953         },
 954         {                               /* mode 1 */
 955                 MBG_FLAGS,
 956                 NO_POLL,
 957                 NO_INIT,
 958                 NO_EVENT,
 959                 NO_END,
 960                 NO_MESSAGE,
 961                 NO_LCLDATA,
 962                 DCFPZF535OCXO_ROOTDELAY,
 963                 DCFPZF535OCXO_BASEDELAY,
 964                 DCF_P_ID,
 965                 DCFPZF535OCXO_DESCRIPTION,
 966                 DCFPZF535OCXO_FORMAT,
 967                 DCF_TYPE,
 968                 DCFPZF535OCXO_MAXUNSYNC,
 969                 DCFPZF535OCXO_SPEED,
 970                 DCFPZF535OCXO_CFLAG,
 971                 DCFPZF535OCXO_IFLAG,
 972                 DCFPZF535OCXO_OFLAG,
 973                 DCFPZF535OCXO_LFLAG,
 974                 DCFPZF535OCXO_SAMPLES,
 975                 DCFPZF535OCXO_KEEP
 976         },
 977         {                               /* mode 2 */
 978                 MBG_FLAGS,
 979                 NO_POLL,
 980                 NO_INIT,
 981                 NO_EVENT,
 982                 NO_END,
 983                 NO_MESSAGE,
 984                 NO_LCLDATA,
 985                 DCFUA31_ROOTDELAY,
 986                 DCFUA31_BASEDELAY,
 987                 DCF_A_ID,
 988                 DCFUA31_DESCRIPTION,
 989                 DCFUA31_FORMAT,
 990                 DCF_TYPE,
 991                 DCFUA31_MAXUNSYNC,
 992                 DCFUA31_SPEED,
 993                 DCFUA31_CFLAG,
 994                 DCFUA31_IFLAG,
 995                 DCFUA31_OFLAG,
 996                 DCFUA31_LFLAG,
 997                 DCFUA31_SAMPLES,
 998                 DCFUA31_KEEP
 999         },
1000         {                               /* mode 3 */
1001                 MBG_FLAGS,
1002                 NO_POLL,
1003                 NO_INIT,
1004                 NO_EVENT,
1005                 NO_END,
1006                 NO_MESSAGE,
1007                 NO_LCLDATA,
1008                 DCF7000_ROOTDELAY,
1009                 DCF7000_BASEDELAY,
1010                 DCF_A_ID,
1011                 DCF7000_DESCRIPTION,
1012                 DCF7000_FORMAT,
1013                 DCF_TYPE,
1014                 DCF7000_MAXUNSYNC,
1015                 DCF7000_SPEED,
1016                 DCF7000_CFLAG,
1017                 DCF7000_IFLAG,
1018                 DCF7000_OFLAG,
1019                 DCF7000_LFLAG,
1020                 DCF7000_SAMPLES,
1021                 DCF7000_KEEP
1022         },
1023         {                               /* mode 4 */
1024                 NO_CL_FLAGS,
1025                 WSDCF_POLL,
1026                 WSDCF_INIT,
1027                 NO_EVENT,
1028                 WSDCF_END,
1029                 NO_MESSAGE,
1030                 WSDCF_DATA,
1031                 WSDCF_ROOTDELAY,
1032                 WSDCF_BASEDELAY,
1033                 DCF_A_ID,
1034                 WSDCF_DESCRIPTION,
1035                 WSDCF_FORMAT,
1036                 DCF_TYPE,
1037                 WSDCF_MAXUNSYNC,
1038                 WSDCF_SPEED,
1039                 WSDCF_CFLAG,
1040                 WSDCF_IFLAG,
1041                 WSDCF_OFLAG,
1042                 WSDCF_LFLAG,
1043                 WSDCF_SAMPLES,
1044                 WSDCF_KEEP
1045         },
1046         {                               /* mode 5 */
1047                 RAWDCF_FLAGS,
1048                 NO_POLL,
1049                 RAWDCF_INIT,
1050                 NO_EVENT,
1051                 NO_END,
1052                 NO_MESSAGE,
1053                 NO_LCLDATA,
1054                 RAWDCF_ROOTDELAY,
1055                 CONRAD_BASEDELAY,
1056                 DCF_A_ID,
1057                 CONRAD_DESCRIPTION,
1058                 RAWDCF_FORMAT,
1059                 DCF_TYPE,
1060                 RAWDCF_MAXUNSYNC,
1061                 RAWDCF_SPEED,
1062                 RAWDCF_CFLAG,
1063                 RAWDCF_IFLAG,
1064                 RAWDCF_OFLAG,
1065                 RAWDCF_LFLAG,
1066                 RAWDCF_SAMPLES,
1067                 RAWDCF_KEEP
1068         },
1069         {                               /* mode 6 */
1070                 RAWDCF_FLAGS,
1071                 NO_POLL,
1072                 RAWDCF_INIT,
1073                 NO_EVENT,
1074                 NO_END,
1075                 NO_MESSAGE,
1076                 NO_LCLDATA,
1077                 RAWDCF_ROOTDELAY,
1078                 TIMEBRICK_BASEDELAY,
1079                 DCF_A_ID,
1080                 TIMEBRICK_DESCRIPTION,
1081                 RAWDCF_FORMAT,
1082                 DCF_TYPE,
1083                 RAWDCF_MAXUNSYNC,
1084                 RAWDCF_SPEED,
1085                 RAWDCF_CFLAG,
1086                 RAWDCF_IFLAG,
1087                 RAWDCF_OFLAG,
1088                 RAWDCF_LFLAG,
1089                 RAWDCF_SAMPLES,
1090                 RAWDCF_KEEP
1091         },
1092         {                               /* mode 7 */
1093                 MBG_FLAGS,
1094                 GPS16X_POLL,
1095                 GPS16X_INIT,
1096                 NO_EVENT,
1097                 GPS16X_END,
1098                 GPS16X_MESSAGE,
1099                 GPS16X_DATA,
1100                 GPS16X_ROOTDELAY,
1101                 GPS16X_BASEDELAY,
1102                 GPS16X_ID,
1103                 GPS16X_DESCRIPTION,
1104                 GPS16X_FORMAT,
1105                 GPS_TYPE,
1106                 GPS16X_MAXUNSYNC,
1107                 GPS16X_SPEED,
1108                 GPS16X_CFLAG,
1109                 GPS16X_IFLAG,
1110                 GPS16X_OFLAG,
1111                 GPS16X_LFLAG,
1112                 GPS16X_SAMPLES,
1113                 GPS16X_KEEP
1114         },
1115         {                               /* mode 8 */
1116                 RAWDCF_FLAGS,
1117                 NO_POLL,
1118                 NO_INIT,
1119                 NO_EVENT,
1120                 NO_END,
1121                 NO_MESSAGE,
1122                 NO_LCLDATA,
1123                 RAWDCF_ROOTDELAY,
1124                 IGELCLOCK_BASEDELAY,
1125                 DCF_A_ID,
1126                 IGELCLOCK_DESCRIPTION,
1127                 RAWDCF_FORMAT,
1128                 DCF_TYPE,
1129                 RAWDCF_MAXUNSYNC,
1130                 IGELCLOCK_SPEED,
1131                 IGELCLOCK_CFLAG,
1132                 RAWDCF_IFLAG,
1133                 RAWDCF_OFLAG,
1134                 RAWDCF_LFLAG,
1135                 RAWDCF_SAMPLES,
1136                 RAWDCF_KEEP
1137         },
1138         {                               /* mode 9 */
1139                 TRIMBLETAIP_FLAGS,
1140 #if TRIM_POLLRATE               /* DHD940515: Allow user config */
1141                 NO_POLL,
1142 #else
1143                 TRIMBLETAIP_POLL,
1144 #endif
1145                 TRIMBLETAIP_INIT,
1146                 TRIMBLETAIP_EVENT,
1147                 TRIMBLETAIP_END,
1148                 NO_MESSAGE,
1149                 TRIMBLETAIP_DATA,
1150                 TRIMBLETAIP_ROOTDELAY,
1151                 TRIMBLETAIP_BASEDELAY,
1152                 TRIMBLETAIP_ID,
1153                 TRIMBLETAIP_DESCRIPTION,
1154                 TRIMBLETAIP_FORMAT,
1155                 GPS_TYPE,
1156                 TRIMBLETAIP_MAXUNSYNC,
1157                 TRIMBLETAIP_SPEED,
1158                 TRIMBLETAIP_CFLAG,
1159                 TRIMBLETAIP_IFLAG,
1160                 TRIMBLETAIP_OFLAG,
1161                 TRIMBLETAIP_LFLAG,
1162                 TRIMBLETAIP_SAMPLES,
1163                 TRIMBLETAIP_KEEP
1164         },
1165         {                               /* mode 10 */
1166                 TRIMBLETSIP_FLAGS,
1167 #if TRIM_POLLRATE               /* DHD940515: Allow user config */
1168                 NO_POLL,
1169 #else
1170                 TRIMBLETSIP_POLL,
1171 #endif
1172                 TRIMBLETSIP_INIT,
1173                 TRIMBLETSIP_EVENT,
1174                 TRIMBLETSIP_END,
1175                 TRIMBLETSIP_MESSAGE,
1176                 TRIMBLETSIP_DATA,
1177                 TRIMBLETSIP_ROOTDELAY,
1178                 TRIMBLETSIP_BASEDELAY,
1179                 TRIMBLETSIP_ID,
1180                 TRIMBLETSIP_DESCRIPTION,
1181                 TRIMBLETSIP_FORMAT,
1182                 GPS_TYPE,
1183                 TRIMBLETSIP_MAXUNSYNC,
1184                 TRIMBLETSIP_SPEED,
1185                 TRIMBLETSIP_CFLAG,
1186                 TRIMBLETSIP_IFLAG,
1187                 TRIMBLETSIP_OFLAG,
1188                 TRIMBLETSIP_LFLAG,
1189                 TRIMBLETSIP_SAMPLES,
1190                 TRIMBLETSIP_KEEP
1191         },
1192         {                             /* mode 11 */
1193                 NO_CL_FLAGS,
1194                 RCC8000_POLL,
1195                 RCC8000_INIT,
1196                 NO_EVENT,
1197                 RCC8000_END,
1198                 NO_MESSAGE,
1199                 RCC8000_DATA,
1200                 RCC8000_ROOTDELAY,
1201                 RCC8000_BASEDELAY,
1202                 RCC8000_ID,
1203                 RCC8000_DESCRIPTION,
1204                 RCC8000_FORMAT,
1205                 DCF_TYPE,
1206                 RCC8000_MAXUNSYNC,
1207                 RCC8000_SPEED,
1208                 RCC8000_CFLAG,
1209                 RCC8000_IFLAG,
1210                 RCC8000_OFLAG,
1211                 RCC8000_LFLAG,
1212                 RCC8000_SAMPLES,
1213                 RCC8000_KEEP
1214         },
1215         {                             /* mode 12 */
1216                 HOPF6021_FLAGS,
1217                 NO_POLL,
1218                 NO_INIT,
1219                 NO_EVENT,
1220                 NO_END,
1221                 NO_MESSAGE,
1222                 NO_LCLDATA,
1223                 HOPF6021_ROOTDELAY,
1224                 HOPF6021_BASEDELAY,
1225                 DCF_ID,
1226                 HOPF6021_DESCRIPTION,
1227                 HOPF6021_FORMAT,
1228                 DCF_TYPE,
1229                 HOPF6021_MAXUNSYNC,
1230                 HOPF6021_SPEED,
1231                 HOPF6021_CFLAG,
1232                 HOPF6021_IFLAG,
1233                 HOPF6021_OFLAG,
1234                 HOPF6021_LFLAG,
1235                 HOPF6021_SAMPLES,
1236                 HOPF6021_KEEP
1237         },
1238         {                            /* mode 13 */
1239                 COMPUTIME_FLAGS,
1240                 NO_POLL,
1241                 NO_INIT,
1242                 NO_EVENT,
1243                 NO_END,
1244                 NO_MESSAGE,
1245                 NO_LCLDATA,
1246                 COMPUTIME_ROOTDELAY,
1247                 COMPUTIME_BASEDELAY,
1248                 COMPUTIME_ID,
1249                 COMPUTIME_DESCRIPTION,
1250                 COMPUTIME_FORMAT,
1251                 COMPUTIME_TYPE,
1252                 COMPUTIME_MAXUNSYNC,
1253                 COMPUTIME_SPEED,
1254                 COMPUTIME_CFLAG,
1255                 COMPUTIME_IFLAG,
1256                 COMPUTIME_OFLAG,
1257                 COMPUTIME_LFLAG,
1258                 COMPUTIME_SAMPLES,
1259                 COMPUTIME_KEEP
1260         },
1261         {                               /* mode 14 */
1262                 RAWDCF_FLAGS,
1263                 NO_POLL,
1264                 RAWDCFDTRSET_INIT,
1265                 NO_EVENT,
1266                 NO_END,
1267                 NO_MESSAGE,
1268                 NO_LCLDATA,
1269                 RAWDCF_ROOTDELAY,
1270                 RAWDCF_BASEDELAY,
1271                 DCF_A_ID,
1272                 RAWDCFDTRSET_DESCRIPTION,
1273                 RAWDCF_FORMAT,
1274                 DCF_TYPE,
1275                 RAWDCF_MAXUNSYNC,
1276                 RAWDCF_SPEED,
1277                 RAWDCF_CFLAG,
1278                 RAWDCF_IFLAG,
1279                 RAWDCF_OFLAG,
1280                 RAWDCF_LFLAG,
1281                 RAWDCF_SAMPLES,
1282                 RAWDCF_KEEP
1283         },
1284         {                               /* mode 15 */
1285                 0,                              /* operation flags (io modes) */
1286                 NO_POLL,                        /* active poll routine */
1287                 NO_INIT,                        /* active poll init routine */
1288                 NO_EVENT,                       /* special event handling (e.g. reset clock) */
1289                 NO_END,                         /* active poll end routine */
1290                 NO_MESSAGE,                     /* process a lower layer message */
1291                 NO_LCLDATA,                     /* local data area for "poll" mechanism */
1292                 0,                              /* rootdelay */
1293                 11.0 /* bits */ / 9600,         /* current offset by which the RS232
1294                                                 time code is delayed from the actual time */
1295                 DCF_ID,                         /* ID code */
1296                 "WHARTON 400A Series clock",    /* device name */
1297                 "WHARTON 400A Series clock Output Format 1",    /* fixed format */
1298                         /* Must match a format-name in a libparse/clk_xxx.c file */
1299                 DCF_TYPE,                       /* clock type (ntp control) */
1300                 (1*60*60),                      /* time to trust oscillator after losing synch */
1301                 B9600,                          /* terminal input & output baudrate */
1302                 (CS8|CREAD|PARENB|CLOCAL|HUPCL),/* terminal control flags */
1303                 0,                              /* terminal input flags */
1304                 0,                              /* terminal output flags */
1305                 0,                              /* terminal local flags */
1306                 5,                              /* samples for median filter */
1307                 3,                              /* samples for median filter to keep */
1308         },
1309         {                               /* mode 16 - RAWDCF RTS set, DTR clr */
1310                 RAWDCF_FLAGS,
1311                 NO_POLL,
1312                 RAWDCFDTRCLRRTSSET_INIT,
1313                 NO_EVENT,
1314                 NO_END,
1315                 NO_MESSAGE,
1316                 NO_LCLDATA,
1317                 RAWDCF_ROOTDELAY,
1318                 RAWDCF_BASEDELAY,
1319                 DCF_A_ID,
1320                 RAWDCFDTRCLRRTSSET_DESCRIPTION,
1321                 RAWDCF_FORMAT,
1322                 DCF_TYPE,
1323                 RAWDCF_MAXUNSYNC,
1324                 RAWDCF_SPEED,
1325                 RAWDCF_CFLAG,
1326                 RAWDCF_IFLAG,
1327                 RAWDCF_OFLAG,
1328                 RAWDCF_LFLAG,
1329                 RAWDCF_SAMPLES,
1330                 RAWDCF_KEEP
1331         },
1332         {                            /* mode 17 */
1333                 VARITEXT_FLAGS,
1334                 NO_POLL,
1335                 NO_INIT,
1336                 NO_EVENT,
1337                 NO_END,
1338                 NO_MESSAGE,
1339                 NO_LCLDATA,
1340                 VARITEXT_ROOTDELAY,
1341                 VARITEXT_BASEDELAY,
1342                 VARITEXT_ID,
1343                 VARITEXT_DESCRIPTION,
1344                 VARITEXT_FORMAT,
1345                 VARITEXT_TYPE,
1346                 VARITEXT_MAXUNSYNC,
1347                 VARITEXT_SPEED,
1348                 VARITEXT_CFLAG,
1349                 VARITEXT_IFLAG,
1350                 VARITEXT_OFLAG,
1351                 VARITEXT_LFLAG,
1352                 VARITEXT_SAMPLES,
1353                 VARITEXT_KEEP
1354         },
1355         {                               /* mode 18 */
1356                 MBG_FLAGS,
1357                 NO_POLL,
1358                 NO_INIT,
1359                 NO_EVENT,
1360                 GPS16X_END,
1361                 GPS16X_MESSAGE,
1362                 GPS16X_DATA,
1363                 GPS16X_ROOTDELAY,
1364                 GPS16X_BASEDELAY,
1365                 GPS16X_ID,
1366                 GPS16X_DESCRIPTION,
1367                 GPS16X_FORMAT,
1368                 GPS_TYPE,
1369                 GPS16X_MAXUNSYNC,
1370                 GPS16X_SPEED,
1371                 GPS16X_CFLAG,
1372                 GPS16X_IFLAG,
1373                 GPS16X_OFLAG,
1374                 GPS16X_LFLAG,
1375                 GPS16X_SAMPLES,
1376                 GPS16X_KEEP
1377         },
1378         {                               /* mode 19 */
1379                 RAWDCF_FLAGS,
1380                 NO_POLL,
1381                 RAWDCF_INIT,
1382                 NO_EVENT,
1383                 NO_END,
1384                 NO_MESSAGE,
1385                 NO_LCLDATA,
1386                 RAWDCF_ROOTDELAY,
1387                 GUDE_EMC_USB_V20_BASEDELAY,
1388                 DCF_A_ID,
1389                 GUDE_EMC_USB_V20_DESCRIPTION,
1390                 RAWDCF_FORMAT,
1391                 DCF_TYPE,
1392                 RAWDCF_MAXUNSYNC,
1393                 GUDE_EMC_USB_V20_SPEED,
1394                 RAWDCF_CFLAG,
1395                 RAWDCF_IFLAG,
1396                 RAWDCF_OFLAG,
1397                 RAWDCF_LFLAG,
1398                 RAWDCF_SAMPLES,
1399                 RAWDCF_KEEP
1400         },
1401         {                               /* mode 20, like mode 14 but driven by 75 baud */
1402                 RAWDCF_FLAGS,
1403                 NO_POLL,
1404                 RAWDCFDTRSET_INIT,
1405                 NO_EVENT,
1406                 NO_END,
1407                 NO_MESSAGE,
1408                 NO_LCLDATA,
1409                 RAWDCF_ROOTDELAY,
1410                 RAWDCF_BASEDELAY,
1411                 DCF_A_ID,
1412                 RAWDCFDTRSET75_DESCRIPTION,
1413                 RAWDCF_FORMAT,
1414                 DCF_TYPE,
1415                 RAWDCF_MAXUNSYNC,
1416                 B75,
1417                 RAWDCF_CFLAG,
1418                 RAWDCF_IFLAG,
1419                 RAWDCF_OFLAG,
1420                 RAWDCF_LFLAG,
1421                 RAWDCF_SAMPLES,
1422                 RAWDCF_KEEP
1423         },
1424         {                               /* mode 21, like mode 16 but driven by 75 baud
1425                                          - RAWDCF RTS set, DTR clr */
1426                 RAWDCF_FLAGS,
1427                 NO_POLL,
1428                 RAWDCFDTRCLRRTSSET_INIT,
1429                 NO_EVENT,
1430                 NO_END,
1431                 NO_MESSAGE,
1432                 NO_LCLDATA,
1433                 RAWDCF_ROOTDELAY,
1434                 RAWDCF_BASEDELAY,
1435                 DCF_A_ID,
1436                 RAWDCFDTRCLRRTSSET75_DESCRIPTION,
1437                 RAWDCF_FORMAT,
1438                 DCF_TYPE,
1439                 RAWDCF_MAXUNSYNC,
1440                 B75,
1441                 RAWDCF_CFLAG,
1442                 RAWDCF_IFLAG,
1443                 RAWDCF_OFLAG,
1444                 RAWDCF_LFLAG,
1445                 RAWDCF_SAMPLES,
1446                 RAWDCF_KEEP
1447         },
1448         {                               /* mode 22 - like 2 with POWERUP trust */
1449                 MBG_FLAGS | PARSE_F_POWERUPTRUST,
1450                 NO_POLL,
1451                 NO_INIT,
1452                 NO_EVENT,
1453                 NO_END,
1454                 NO_MESSAGE,
1455                 NO_LCLDATA,
1456                 DCFUA31_ROOTDELAY,
1457                 DCFUA31_BASEDELAY,
1458                 DCF_A_ID,
1459                 DCFUA31_DESCRIPTION,
1460                 DCFUA31_FORMAT,
1461                 DCF_TYPE,
1462                 DCFUA31_MAXUNSYNC,
1463                 DCFUA31_SPEED,
1464                 DCFUA31_CFLAG,
1465                 DCFUA31_IFLAG,
1466                 DCFUA31_OFLAG,
1467                 DCFUA31_LFLAG,
1468                 DCFUA31_SAMPLES,
1469                 DCFUA31_KEEP
1470         },
1471         {                               /* mode 23 - like 7 with POWERUP trust */
1472                 MBG_FLAGS | PARSE_F_POWERUPTRUST,
1473                 GPS16X_POLL,
1474                 GPS16X_INIT,
1475                 NO_EVENT,
1476                 GPS16X_END,
1477                 GPS16X_MESSAGE,
1478                 GPS16X_DATA,
1479                 GPS16X_ROOTDELAY,
1480                 GPS16X_BASEDELAY,
1481                 GPS16X_ID,
1482                 GPS16X_DESCRIPTION,
1483                 GPS16X_FORMAT,
1484                 GPS_TYPE,
1485                 GPS16X_MAXUNSYNC,
1486                 GPS16X_SPEED,
1487                 GPS16X_CFLAG,
1488                 GPS16X_IFLAG,
1489                 GPS16X_OFLAG,
1490                 GPS16X_LFLAG,
1491                 GPS16X_SAMPLES,
1492                 GPS16X_KEEP
1493         },
1494         {                               /* mode 24 */
1495                 SEL240X_FLAGS,
1496                 SEL240X_POLL,
1497                 SEL240X_INIT,
1498                 NO_EVENT,
1499                 SEL240X_END,
1500                 NO_MESSAGE,
1501                 SEL240X_DATA,
1502                 SEL240X_ROOTDELAY,
1503                 SEL240X_BASEDELAY,
1504                 SEL240X_ID,
1505                 SEL240X_DESCRIPTION,
1506                 SEL240X_FORMAT,
1507                 GPS_TYPE,
1508                 SEL240X_MAXUNSYNC,
1509                 SEL240X_SPEED,
1510                 SEL240X_CFLAG,
1511                 SEL240X_IFLAG,
1512                 SEL240X_OFLAG,
1513                 SEL240X_LFLAG,
1514                 SEL240X_SAMPLES,
1515                 SEL240X_KEEP
1516         },
1517 };
1518
1519 static int ncltypes = sizeof(parse_clockinfo) / sizeof(struct parse_clockinfo);
1520
1521 #define CLK_REALTYPE(x) ((int)(((x)->ttl) & 0x7F))
1522 #define CLK_TYPE(x)     ((CLK_REALTYPE(x) >= ncltypes) ? ~0 : CLK_REALTYPE(x))
1523 #define CLK_UNIT(x)     ((int)REFCLOCKUNIT(&(x)->srcadr))
1524 #define CLK_PPS(x)      (((x)->ttl) & 0x80)
1525
1526 /*
1527  * Other constant stuff
1528  */
1529 #define PARSEHSREFID    0x7f7f08ff      /* 127.127.8.255 refid for hi strata */
1530
1531 #define PARSESTATISTICS   (60*60)               /* output state statistics every hour */
1532
1533 static int notice = 0;
1534
1535 #define PARSE_STATETIME(parse, i) ((parse->generic->currentstatus == i) ? parse->statetime[i] + current_time - parse->lastchange : parse->statetime[i])
1536
1537 static void parse_event   (struct parseunit *, int);
1538 static void parse_process (struct parseunit *, parsetime_t *);
1539 static void clear_err     (struct parseunit *, u_long);
1540 static int  list_err      (struct parseunit *, u_long);
1541 static char * l_mktime    (u_long);
1542
1543 /**===========================================================================
1544  ** implementation error message regression module
1545  **/
1546 static void
1547 clear_err(
1548         struct parseunit *parse,
1549         u_long            lstate
1550         )
1551 {
1552         if (lstate == ERR_ALL)
1553         {
1554                 size_t i;
1555
1556                 for (i = 0; i < ERR_CNT; i++)
1557                 {
1558                         parse->errors[i].err_stage   = err_tbl[i];
1559                         parse->errors[i].err_cnt     = 0;
1560                         parse->errors[i].err_last    = 0;
1561                         parse->errors[i].err_started = 0;
1562                         parse->errors[i].err_suppressed = 0;
1563                 }
1564         }
1565         else
1566         {
1567                 parse->errors[lstate].err_stage   = err_tbl[lstate];
1568                 parse->errors[lstate].err_cnt     = 0;
1569                 parse->errors[lstate].err_last    = 0;
1570                 parse->errors[lstate].err_started = 0;
1571                 parse->errors[lstate].err_suppressed = 0;
1572         }
1573 }
1574
1575 static int
1576 list_err(
1577         struct parseunit *parse,
1578         u_long            lstate
1579         )
1580 {
1581         int do_it;
1582         struct errorinfo *err = &parse->errors[lstate];
1583
1584         if (err->err_started == 0)
1585         {
1586                 err->err_started = current_time;
1587         }
1588
1589         do_it = (current_time - err->err_last) >= err->err_stage->err_delay;
1590
1591         if (do_it)
1592             err->err_cnt++;
1593
1594         if (err->err_stage->err_count &&
1595             (err->err_cnt >= err->err_stage->err_count))
1596         {
1597                 err->err_stage++;
1598                 err->err_cnt = 0;
1599         }
1600
1601         if (!err->err_cnt && do_it)
1602             msyslog(LOG_INFO, "PARSE receiver #%d: interval for following error message class is at least %s",
1603                     CLK_UNIT(parse->peer), l_mktime(err->err_stage->err_delay));
1604
1605         if (!do_it)
1606             err->err_suppressed++;
1607         else
1608             err->err_last = current_time;
1609
1610         if (do_it && err->err_suppressed)
1611         {
1612                 msyslog(LOG_INFO, "PARSE receiver #%d: %ld message%s suppressed, error condition class persists for %s",
1613                         CLK_UNIT(parse->peer), err->err_suppressed, (err->err_suppressed == 1) ? " was" : "s where",
1614                         l_mktime(current_time - err->err_started));
1615                 err->err_suppressed = 0;
1616         }
1617
1618         return do_it;
1619 }
1620
1621 /*--------------------------------------------------
1622  * mkreadable - make a printable ascii string (without
1623  * embedded quotes so that the ntpq protocol isn't
1624  * fooled
1625  */
1626 #ifndef isprint
1627 #define isprint(_X_) (((_X_) > 0x1F) && ((_X_) < 0x7F))
1628 #endif
1629
1630 static char *
1631 mkreadable(
1632         char  *buffer,
1633         size_t blen,
1634         const char  *src,
1635         size_t srclen,
1636         int hex
1637         )
1638 {
1639         static const char ellipsis[] = "...";
1640         char *b    = buffer;
1641         char *endb = NULL;
1642
1643         if (blen < 4)
1644                 return NULL;            /* don't bother with mini buffers */
1645
1646         endb = buffer + blen - sizeof(ellipsis);
1647
1648         blen--;                 /* account for '\0' */
1649
1650         while (blen && srclen--)
1651         {
1652                 if (!hex &&             /* no binary only */
1653                     (*src != '\\') &&   /* no plain \ */
1654                     (*src != '"') &&    /* no " */
1655                     isprint((unsigned char)*src))       /* only printables */
1656                 {                       /* they are easy... */
1657                         *buffer++ = *src++;
1658                         blen--;
1659                 }
1660                 else
1661                 {
1662                         if (blen < 4)
1663                         {
1664                                 while (blen--)
1665                                 {
1666                                         *buffer++ = '.';
1667                                 }
1668                                 *buffer = '\0';
1669                                 return b;
1670                         }
1671                         else
1672                         {
1673                                 if (*src == '\\')
1674                                 {
1675                                         memcpy(buffer, "\\\\", 2);
1676                                         buffer += 2;
1677                                         blen   -= 2;
1678                                         src++;
1679                                 }
1680                                 else
1681                                 {
1682                                         snprintf(buffer, blen, "\\x%02x", *src++);
1683                                         blen   -= 4;
1684                                         buffer += 4;
1685                                 }
1686                         }
1687                 }
1688                 if (srclen && !blen && endb) /* overflow - set last chars to ... */
1689                         memcpy(endb, ellipsis, sizeof(ellipsis));
1690         }
1691
1692         *buffer = '\0';
1693         return b;
1694 }
1695
1696
1697 /*--------------------------------------------------
1698  * mkascii - make a printable ascii string
1699  * assumes (unless defined better) 7-bit ASCII
1700  */
1701 static char *
1702 mkascii(
1703         char  *buffer,
1704         long  blen,
1705         const char  *src,
1706         u_long  srclen
1707         )
1708 {
1709         return mkreadable(buffer, blen, src, srclen, 0);
1710 }
1711
1712 /**===========================================================================
1713  ** implementation of i/o handling methods
1714  ** (all STREAM, partial STREAM, user level)
1715  **/
1716
1717 /*
1718  * define possible io handling methods
1719  */
1720 #ifdef STREAM
1721 static int  ppsclock_init   (struct parseunit *);
1722 static int  stream_init     (struct parseunit *);
1723 static void stream_end      (struct parseunit *);
1724 static int  stream_enable   (struct parseunit *);
1725 static int  stream_disable  (struct parseunit *);
1726 static int  stream_setcs    (struct parseunit *, parsectl_t *);
1727 static int  stream_getfmt   (struct parseunit *, parsectl_t *);
1728 static int  stream_setfmt   (struct parseunit *, parsectl_t *);
1729 static int  stream_timecode (struct parseunit *, parsectl_t *);
1730 static void stream_receive  (struct recvbuf *);
1731 #endif
1732
1733 static int  local_init     (struct parseunit *);
1734 static void local_end      (struct parseunit *);
1735 static int  local_nop      (struct parseunit *);
1736 static int  local_setcs    (struct parseunit *, parsectl_t *);
1737 static int  local_getfmt   (struct parseunit *, parsectl_t *);
1738 static int  local_setfmt   (struct parseunit *, parsectl_t *);
1739 static int  local_timecode (struct parseunit *, parsectl_t *);
1740 static void local_receive  (struct recvbuf *);
1741 static int  local_input    (struct recvbuf *);
1742
1743 static bind_t io_bindings[] =
1744 {
1745 #ifdef STREAM
1746         {
1747                 "parse STREAM",
1748                 stream_init,
1749                 stream_end,
1750                 stream_setcs,
1751                 stream_disable,
1752                 stream_enable,
1753                 stream_getfmt,
1754                 stream_setfmt,
1755                 stream_timecode,
1756                 stream_receive,
1757                 0,
1758         },
1759         {
1760                 "ppsclock STREAM",
1761                 ppsclock_init,
1762                 local_end,
1763                 local_setcs,
1764                 local_nop,
1765                 local_nop,
1766                 local_getfmt,
1767                 local_setfmt,
1768                 local_timecode,
1769                 local_receive,
1770                 local_input,
1771         },
1772 #endif
1773         {
1774                 "normal",
1775                 local_init,
1776                 local_end,
1777                 local_setcs,
1778                 local_nop,
1779                 local_nop,
1780                 local_getfmt,
1781                 local_setfmt,
1782                 local_timecode,
1783                 local_receive,
1784                 local_input,
1785         },
1786         {
1787                 (char *)0,
1788                 NULL,
1789                 NULL,
1790                 NULL,
1791                 NULL,
1792                 NULL,
1793                 NULL,
1794                 NULL,
1795                 NULL,
1796                 NULL,
1797                 NULL,
1798         }
1799 };
1800
1801 #ifdef STREAM
1802
1803 /*--------------------------------------------------
1804  * ppsclock STREAM init
1805  */
1806 static int
1807 ppsclock_init(
1808         struct parseunit *parse
1809         )
1810 {
1811         static char m1[] = "ppsclocd";
1812         static char m2[] = "ppsclock";
1813
1814         /*
1815          * now push the parse streams module
1816          * it will ensure exclusive access to the device
1817          */
1818         if (ioctl(parse->ppsfd, I_PUSH, (caddr_t)m1) == -1 &&
1819             ioctl(parse->ppsfd, I_PUSH, (caddr_t)m2) == -1)
1820         {
1821                 if (errno != EINVAL)
1822                 {
1823                         msyslog(LOG_ERR, "PARSE receiver #%d: ppsclock_init: ioctl(fd, I_PUSH, \"ppsclock\"): %m",
1824                                 CLK_UNIT(parse->peer));
1825                 }
1826                 return 0;
1827         }
1828         if (!local_init(parse))
1829         {
1830                 (void)ioctl(parse->ppsfd, I_POP, (caddr_t)0);
1831                 return 0;
1832         }
1833
1834         parse->flags |= PARSE_PPSCLOCK;
1835         return 1;
1836 }
1837
1838 /*--------------------------------------------------
1839  * parse STREAM init
1840  */
1841 static int
1842 stream_init(
1843         struct parseunit *parse
1844         )
1845 {
1846         static char m1[] = "parse";
1847         /*
1848          * now push the parse streams module
1849          * to test whether it is there (neat interface 8-( )
1850          */
1851         if (ioctl(parse->generic->io.fd, I_PUSH, (caddr_t)m1) == -1)
1852         {
1853                 if (errno != EINVAL) /* accept non-existence */
1854                 {
1855                         msyslog(LOG_ERR, "PARSE receiver #%d: stream_init: ioctl(fd, I_PUSH, \"parse\"): %m", CLK_UNIT(parse->peer));
1856                 }
1857                 return 0;
1858         }
1859         else
1860         {
1861                 while(ioctl(parse->generic->io.fd, I_POP, (caddr_t)0) == 0)
1862                     /* empty loop */;
1863
1864                 /*
1865                  * now push it a second time after we have removed all
1866                  * module garbage
1867                  */
1868                 if (ioctl(parse->generic->io.fd, I_PUSH, (caddr_t)m1) == -1)
1869                 {
1870                         msyslog(LOG_ERR, "PARSE receiver #%d: stream_init: ioctl(fd, I_PUSH, \"parse\"): %m", CLK_UNIT(parse->peer));
1871                         return 0;
1872                 }
1873                 else
1874                 {
1875                         return 1;
1876                 }
1877         }
1878 }
1879
1880 /*--------------------------------------------------
1881  * parse STREAM end
1882  */
1883 static void
1884 stream_end(
1885         struct parseunit *parse
1886         )
1887 {
1888         while(ioctl(parse->generic->io.fd, I_POP, (caddr_t)0) == 0)
1889             /* empty loop */;
1890 }
1891
1892 /*--------------------------------------------------
1893  * STREAM setcs
1894  */
1895 static int
1896 stream_setcs(
1897         struct parseunit *parse,
1898         parsectl_t  *tcl
1899         )
1900 {
1901         struct strioctl strioc;
1902
1903         strioc.ic_cmd     = PARSEIOC_SETCS;
1904         strioc.ic_timout  = 0;
1905         strioc.ic_dp      = (char *)tcl;
1906         strioc.ic_len     = sizeof (*tcl);
1907
1908         if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1909         {
1910                 msyslog(LOG_ERR, "PARSE receiver #%d: stream_setcs: ioctl(fd, I_STR, PARSEIOC_SETCS): %m", CLK_UNIT(parse->peer));
1911                 return 0;
1912         }
1913         return 1;
1914 }
1915
1916 /*--------------------------------------------------
1917  * STREAM enable
1918  */
1919 static int
1920 stream_enable(
1921         struct parseunit *parse
1922         )
1923 {
1924         struct strioctl strioc;
1925
1926         strioc.ic_cmd     = PARSEIOC_ENABLE;
1927         strioc.ic_timout  = 0;
1928         strioc.ic_dp      = (char *)0;
1929         strioc.ic_len     = 0;
1930
1931         if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1932         {
1933                 msyslog(LOG_ERR, "PARSE receiver #%d: stream_enable: ioctl(fd, I_STR, PARSEIOC_ENABLE): %m", CLK_UNIT(parse->peer));
1934                 return 0;
1935         }
1936         parse->generic->io.clock_recv = stream_receive; /* ok - parse input in kernel */
1937         return 1;
1938 }
1939
1940 /*--------------------------------------------------
1941  * STREAM disable
1942  */
1943 static int
1944 stream_disable(
1945         struct parseunit *parse
1946         )
1947 {
1948         struct strioctl strioc;
1949
1950         strioc.ic_cmd     = PARSEIOC_DISABLE;
1951         strioc.ic_timout  = 0;
1952         strioc.ic_dp      = (char *)0;
1953         strioc.ic_len     = 0;
1954
1955         if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1956         {
1957                 msyslog(LOG_ERR, "PARSE receiver #%d: stream_disable: ioctl(fd, I_STR, PARSEIOC_DISABLE): %m", CLK_UNIT(parse->peer));
1958                 return 0;
1959         }
1960         parse->generic->io.clock_recv = local_receive; /* ok - parse input in daemon */
1961         return 1;
1962 }
1963
1964 /*--------------------------------------------------
1965  * STREAM getfmt
1966  */
1967 static int
1968 stream_getfmt(
1969         struct parseunit *parse,
1970         parsectl_t  *tcl
1971         )
1972 {
1973         struct strioctl strioc;
1974
1975         strioc.ic_cmd     = PARSEIOC_GETFMT;
1976         strioc.ic_timout  = 0;
1977         strioc.ic_dp      = (char *)tcl;
1978         strioc.ic_len     = sizeof (*tcl);
1979         if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1980         {
1981                 msyslog(LOG_ERR, "PARSE receiver #%d: ioctl(fd, I_STR, PARSEIOC_GETFMT): %m", CLK_UNIT(parse->peer));
1982                 return 0;
1983         }
1984         return 1;
1985 }
1986
1987 /*--------------------------------------------------
1988  * STREAM setfmt
1989  */
1990 static int
1991 stream_setfmt(
1992         struct parseunit *parse,
1993         parsectl_t  *tcl
1994         )
1995 {
1996         struct strioctl strioc;
1997
1998         strioc.ic_cmd     = PARSEIOC_SETFMT;
1999         strioc.ic_timout  = 0;
2000         strioc.ic_dp      = (char *)tcl;
2001         strioc.ic_len     = sizeof (*tcl);
2002
2003         if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
2004         {
2005                 msyslog(LOG_ERR, "PARSE receiver #%d: stream_setfmt: ioctl(fd, I_STR, PARSEIOC_SETFMT): %m", CLK_UNIT(parse->peer));
2006                 return 0;
2007         }
2008         return 1;
2009 }
2010
2011
2012 /*--------------------------------------------------
2013  * STREAM timecode
2014  */
2015 static int
2016 stream_timecode(
2017         struct parseunit *parse,
2018         parsectl_t  *tcl
2019         )
2020 {
2021         struct strioctl strioc;
2022
2023         strioc.ic_cmd     = PARSEIOC_TIMECODE;
2024         strioc.ic_timout  = 0;
2025         strioc.ic_dp      = (char *)tcl;
2026         strioc.ic_len     = sizeof (*tcl);
2027
2028         if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
2029         {
2030                 ERR(ERR_INTERNAL)
2031                         msyslog(LOG_ERR, "PARSE receiver #%d: stream_timecode: ioctl(fd, I_STR, PARSEIOC_TIMECODE): %m", CLK_UNIT(parse->peer));
2032                 return 0;
2033         }
2034         clear_err(parse, ERR_INTERNAL);
2035         return 1;
2036 }
2037
2038 /*--------------------------------------------------
2039  * STREAM receive
2040  */
2041 static void
2042 stream_receive(
2043         struct recvbuf *rbufp
2044         )
2045 {
2046         struct parseunit * parse;
2047         parsetime_t parsetime;
2048
2049         parse = (struct parseunit *)rbufp->recv_peer->procptr->unitptr;
2050         if (!parse->peer)
2051             return;
2052
2053         if (rbufp->recv_length != sizeof(parsetime_t))
2054         {
2055                 ERR(ERR_BADIO)
2056                         msyslog(LOG_ERR,"PARSE receiver #%d: stream_receive: bad size (got %d expected %d)",
2057                                 CLK_UNIT(parse->peer), rbufp->recv_length, (int)sizeof(parsetime_t));
2058                 parse_event(parse, CEVNT_BADREPLY);
2059                 return;
2060         }
2061         clear_err(parse, ERR_BADIO);
2062
2063         memmove((caddr_t)&parsetime,
2064                 (caddr_t)rbufp->recv_buffer,
2065                 sizeof(parsetime_t));
2066
2067 #ifdef DEBUG
2068         if (debug > 3)
2069           {
2070             printf("PARSE receiver #%d: status %06x, state %08x, time %lx.%08lx, stime %lx.%08lx, ptime %lx.%08lx\n",
2071                    CLK_UNIT(parse->peer),
2072                    (unsigned int)parsetime.parse_status,
2073                    (unsigned int)parsetime.parse_state,
2074                    (unsigned long)parsetime.parse_time.tv.tv_sec,
2075                    (unsigned long)parsetime.parse_time.tv.tv_usec,
2076                    (unsigned long)parsetime.parse_stime.tv.tv_sec,
2077                    (unsigned long)parsetime.parse_stime.tv.tv_usec,
2078                    (unsigned long)parsetime.parse_ptime.tv.tv_sec,
2079                    (unsigned long)parsetime.parse_ptime.tv.tv_usec);
2080           }
2081 #endif
2082
2083         /*
2084          * switch time stamp world - be sure to normalize small usec field
2085          * errors.
2086          */
2087
2088         parsetime.parse_stime.fp = tval_stamp_to_lfp(parsetime.parse_stime.tv);
2089
2090         if (PARSE_TIMECODE(parsetime.parse_state))
2091         {
2092                 parsetime.parse_time.fp = tval_stamp_to_lfp(parsetime.parse_time.tv);
2093         }
2094
2095         if (PARSE_PPS(parsetime.parse_state))
2096         {
2097                 parsetime.parse_ptime.fp = tval_stamp_to_lfp(parsetime.parse_ptime.tv);
2098         }
2099
2100         parse_process(parse, &parsetime);
2101 }
2102 #endif
2103
2104 /*--------------------------------------------------
2105  * local init
2106  */
2107 static int
2108 local_init(
2109         struct parseunit *parse
2110         )
2111 {
2112         return parse_ioinit(&parse->parseio);
2113 }
2114
2115 /*--------------------------------------------------
2116  * local end
2117  */
2118 static void
2119 local_end(
2120         struct parseunit *parse
2121         )
2122 {
2123         parse_ioend(&parse->parseio);
2124 }
2125
2126
2127 /*--------------------------------------------------
2128  * local nop
2129  */
2130 static int
2131 local_nop(
2132         struct parseunit *parse
2133         )
2134 {
2135         return 1;
2136 }
2137
2138 /*--------------------------------------------------
2139  * local setcs
2140  */
2141 static int
2142 local_setcs(
2143         struct parseunit *parse,
2144         parsectl_t  *tcl
2145         )
2146 {
2147         return parse_setcs(tcl, &parse->parseio);
2148 }
2149
2150 /*--------------------------------------------------
2151  * local getfmt
2152  */
2153 static int
2154 local_getfmt(
2155         struct parseunit *parse,
2156         parsectl_t  *tcl
2157         )
2158 {
2159         return parse_getfmt(tcl, &parse->parseio);
2160 }
2161
2162 /*--------------------------------------------------
2163  * local setfmt
2164  */
2165 static int
2166 local_setfmt(
2167         struct parseunit *parse,
2168         parsectl_t  *tcl
2169         )
2170 {
2171         return parse_setfmt(tcl, &parse->parseio);
2172 }
2173
2174 /*--------------------------------------------------
2175  * local timecode
2176  */
2177 static int
2178 local_timecode(
2179         struct parseunit *parse,
2180         parsectl_t  *tcl
2181         )
2182 {
2183         return parse_timecode(tcl, &parse->parseio);
2184 }
2185
2186
2187 /*--------------------------------------------------
2188  * local input
2189  */
2190 static int
2191 local_input(
2192         struct recvbuf *rbufp
2193         )
2194 {
2195         struct parseunit * parse;
2196
2197         int count;
2198         unsigned char *s;
2199         timestamp_t ts;
2200
2201         parse = (struct parseunit *)rbufp->recv_peer->procptr->unitptr;
2202         if (!parse->peer)
2203                 return 0;
2204
2205         /*
2206          * eat all characters, parsing then and feeding complete samples
2207          */
2208         count = rbufp->recv_length;
2209         s = (unsigned char *)rbufp->recv_buffer;
2210         ts.fp = rbufp->recv_time;
2211
2212         while (count--)
2213         {
2214                 if (parse_ioread(&parse->parseio, (unsigned int)(*s++), &ts))
2215                 {
2216                         struct recvbuf *buf;
2217
2218                         /*
2219                          * got something good to eat
2220                          */
2221                         if (!PARSE_PPS(parse->parseio.parse_dtime.parse_state))
2222                         {
2223 #ifdef HAVE_PPSAPI
2224                                 if (parse->flags & PARSE_PPSCLOCK)
2225                                 {
2226                                         struct timespec pps_timeout;
2227                                         pps_info_t      pps_info;
2228
2229                                         pps_timeout.tv_sec  = 0;
2230                                         pps_timeout.tv_nsec = 0;
2231
2232                                         if (time_pps_fetch(parse->atom.handle, PPS_TSFMT_TSPEC, &pps_info,
2233                                                            &pps_timeout) == 0)
2234                                         {
2235                                                 if (pps_info.assert_sequence + pps_info.clear_sequence != parse->ppsserial)
2236                                                 {
2237                                                         double dtemp;
2238
2239                                                         struct timespec pts;
2240                                                         /*
2241                                                          * add PPS time stamp if available via ppsclock module
2242                                                          * and not supplied already.
2243                                                          */
2244                                                         if (parse->flags & PARSE_CLEAR)
2245                                                           pts = pps_info.clear_timestamp;
2246                                                         else
2247                                                           pts = pps_info.assert_timestamp;
2248
2249                                                         parse->parseio.parse_dtime.parse_ptime.fp.l_ui = (uint32_t) (pts.tv_sec + JAN_1970);
2250
2251                                                         dtemp = (double) pts.tv_nsec / 1e9;
2252                                                         if (dtemp < 0.) {
2253                                                                 dtemp += 1;
2254                                                                 parse->parseio.parse_dtime.parse_ptime.fp.l_ui--;
2255                                                         }
2256                                                         if (dtemp > 1.) {
2257                                                                 dtemp -= 1;
2258                                                                 parse->parseio.parse_dtime.parse_ptime.fp.l_ui++;
2259                                                         }
2260                                                         parse->parseio.parse_dtime.parse_ptime.fp.l_uf = (uint32_t)(dtemp * FRAC);
2261
2262                                                         parse->parseio.parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
2263 #ifdef DEBUG
2264                                                         if (debug > 3)
2265                                                         {
2266                                                                 printf(
2267                                                                        "parse: local_receive: fd %ld PPSAPI seq %ld - PPS %s\n",
2268                                                                        (long)rbufp->fd,
2269                                                                        (long)pps_info.assert_sequence + (long)pps_info.clear_sequence,
2270                                                                        lfptoa(&parse->parseio.parse_dtime.parse_ptime.fp, 6));
2271                                                         }
2272 #endif
2273                                                 }
2274 #ifdef DEBUG
2275                                                 else
2276                                                 {
2277                                                         if (debug > 3)
2278                                                         {
2279                                                                 printf(
2280                                                                        "parse: local_receive: fd %ld PPSAPI seq assert %ld, seq clear %ld - NO PPS event\n",
2281                                                                        (long)rbufp->fd,
2282                                                                        (long)pps_info.assert_sequence, (long)pps_info.clear_sequence);
2283                                                         }
2284                                                 }
2285 #endif
2286                                                 parse->ppsserial = pps_info.assert_sequence + pps_info.clear_sequence;
2287                                         }
2288 #ifdef DEBUG
2289                                         else
2290                                         {
2291                                                 if (debug > 3)
2292                                                 {
2293                                                         printf(
2294                                                                "parse: local_receive: fd %ld PPSAPI time_pps_fetch errno = %d\n",
2295                                                                (long)rbufp->fd,
2296                                                                errno);
2297                                                 }
2298                                         }
2299 #endif
2300                                 }
2301 #else
2302 #ifdef TIOCDCDTIMESTAMP
2303                                 struct timeval dcd_time;
2304
2305                                 if (ioctl(parse->ppsfd, TIOCDCDTIMESTAMP, &dcd_time) != -1)
2306                                 {
2307                                         l_fp tstmp;
2308
2309                                         TVTOTS(&dcd_time, &tstmp);
2310                                         tstmp.l_ui += JAN_1970;
2311                                         L_SUB(&ts.fp, &tstmp);
2312                                         if (ts.fp.l_ui == 0)
2313                                         {
2314 #ifdef DEBUG
2315                                                 if (debug)
2316                                                 {
2317                                                         printf(
2318                                                                "parse: local_receive: fd %d DCDTIMESTAMP %s\n",
2319                                                                parse->ppsfd,
2320                                                                lfptoa(&tstmp, 6));
2321                                                         printf(" sigio %s\n",
2322                                                                lfptoa(&ts.fp, 6));
2323                                                 }
2324 #endif
2325                                                 parse->parseio.parse_dtime.parse_ptime.fp = tstmp;
2326                                                 parse->parseio.parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
2327                                         }
2328                                 }
2329 #else /* TIOCDCDTIMESTAMP */
2330 #if defined(HAVE_STRUCT_PPSCLOCKEV) && (defined(HAVE_CIOGETEV) || defined(HAVE_TIOCGPPSEV))
2331                                 if (parse->flags & PARSE_PPSCLOCK)
2332                                   {
2333                                     l_fp tts;
2334                                     struct ppsclockev ev;
2335
2336 #ifdef HAVE_CIOGETEV
2337                                     if (ioctl(parse->ppsfd, CIOGETEV, (caddr_t)&ev) == 0)
2338 #endif
2339 #ifdef HAVE_TIOCGPPSEV
2340                                     if (ioctl(parse->ppsfd, TIOCGPPSEV, (caddr_t)&ev) == 0)
2341 #endif
2342                                         {
2343                                           if (ev.serial != parse->ppsserial)
2344                                             {
2345                                               /*
2346                                                * add PPS time stamp if available via ppsclock module
2347                                                * and not supplied already.
2348                                                */
2349                                               if (!buftvtots((const char *)&ev.tv, &tts))
2350                                                 {
2351                                                   ERR(ERR_BADDATA)
2352                                                     msyslog(LOG_ERR,"parse: local_receive: timestamp conversion error (buftvtots) (ppsclockev.tv)");
2353                                                 }
2354                                               else
2355                                                 {
2356                                                   parse->parseio.parse_dtime.parse_ptime.fp = tts;
2357                                                   parse->parseio.parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
2358                                                 }
2359                                             }
2360                                           parse->ppsserial = ev.serial;
2361                                         }
2362                                   }
2363 #endif
2364 #endif /* TIOCDCDTIMESTAMP */
2365 #endif /* !HAVE_PPSAPI */
2366                         }
2367                         if (count)
2368                         {       /* simulate receive */
2369                                 buf = get_free_recv_buffer();
2370                                 if (buf != NULL) {
2371                                         memmove((caddr_t)buf->recv_buffer,
2372                                                 (caddr_t)&parse->parseio.parse_dtime,
2373                                                 sizeof(parsetime_t));
2374                                         buf->recv_length  = sizeof(parsetime_t);
2375                                         buf->recv_time    = rbufp->recv_time;
2376 #ifndef HAVE_IO_COMPLETION_PORT
2377                                         buf->srcadr       = rbufp->srcadr;
2378 #endif
2379                                         buf->dstadr       = rbufp->dstadr;
2380                                         buf->receiver     = rbufp->receiver;
2381                                         buf->fd           = rbufp->fd;
2382                                         buf->X_from_where = rbufp->X_from_where;
2383                                         parse->generic->io.recvcount++;
2384                                         packets_received++;
2385                                         add_full_recv_buffer(buf);
2386 #ifdef HAVE_IO_COMPLETION_PORT
2387                                         SetEvent(WaitableIoEventHandle);
2388 #endif
2389                                 }
2390                                 parse_iodone(&parse->parseio);
2391                         }
2392                         else
2393                         {
2394                                 memmove((caddr_t)rbufp->recv_buffer,
2395                                         (caddr_t)&parse->parseio.parse_dtime,
2396                                         sizeof(parsetime_t));
2397                                 parse_iodone(&parse->parseio);
2398                                 rbufp->recv_length = sizeof(parsetime_t);
2399                                 return 1; /* got something & in place return */
2400                         }
2401                 }
2402         }
2403         return 0;               /* nothing to pass up */
2404 }
2405
2406 /*--------------------------------------------------
2407  * local receive
2408  */
2409 static void
2410 local_receive(
2411         struct recvbuf *rbufp
2412         )
2413 {
2414         struct parseunit * parse;
2415         parsetime_t parsetime;
2416
2417         parse = (struct parseunit *)rbufp->recv_peer->procptr->unitptr;
2418         if (!parse->peer)
2419             return;
2420
2421         if (rbufp->recv_length != sizeof(parsetime_t))
2422         {
2423                 ERR(ERR_BADIO)
2424                         msyslog(LOG_ERR,"PARSE receiver #%d: local_receive: bad size (got %d expected %d)",
2425                                 CLK_UNIT(parse->peer), rbufp->recv_length, (int)sizeof(parsetime_t));
2426                 parse_event(parse, CEVNT_BADREPLY);
2427                 return;
2428         }
2429         clear_err(parse, ERR_BADIO);
2430
2431         memmove((caddr_t)&parsetime,
2432                 (caddr_t)rbufp->recv_buffer,
2433                 sizeof(parsetime_t));
2434
2435 #ifdef DEBUG
2436         if (debug > 3)
2437           {
2438             printf("PARSE receiver #%d: status %06x, state %08x, time(fp) %lx.%08lx, stime(fp) %lx.%08lx, ptime(fp) %lx.%08lx\n",
2439                    CLK_UNIT(parse->peer),
2440                    (unsigned int)parsetime.parse_status,
2441                    (unsigned int)parsetime.parse_state,
2442                    (unsigned long)parsetime.parse_time.fp.l_ui,
2443                    (unsigned long)parsetime.parse_time.fp.l_uf,
2444                    (unsigned long)parsetime.parse_stime.fp.l_ui,
2445                    (unsigned long)parsetime.parse_stime.fp.l_uf,
2446                    (unsigned long)parsetime.parse_ptime.fp.l_ui,
2447                    (unsigned long)parsetime.parse_ptime.fp.l_uf);
2448           }
2449 #endif
2450
2451         parse_process(parse, &parsetime);
2452 }
2453
2454 /*--------------------------------------------------
2455  * init_iobinding - find and initialize lower layers
2456  */
2457 static bind_t *
2458 init_iobinding(
2459         struct parseunit *parse
2460         )
2461 {
2462   bind_t *b = io_bindings;
2463
2464         while (b->bd_description != (char *)0)
2465         {
2466                 if ((*b->bd_init)(parse))
2467                 {
2468                         return b;
2469                 }
2470                 b++;
2471         }
2472         return (bind_t *)0;
2473 }
2474
2475 /**===========================================================================
2476  ** support routines
2477  **/
2478
2479 static NTP_PRINTF(4, 5) char *
2480 ap(char *buffer, size_t len, char *pos, const char *fmt, ...)
2481 {
2482         va_list va;
2483         int l;
2484         size_t rem = len - (pos - buffer);
2485
2486         if (rem == 0)
2487                 return pos;
2488
2489         va_start(va, fmt);
2490         l = vsnprintf(pos, rem, fmt, va);
2491         va_end(va);
2492
2493         if (l != -1) {
2494                 rem--;
2495                 if (rem >= (size_t)l)
2496                         pos += l;
2497                 else
2498                         pos += rem;
2499         }
2500
2501         return pos;
2502 }
2503
2504 /*--------------------------------------------------
2505  * convert a flag field to a string
2506  */
2507 static char *
2508 parsestate(
2509         u_long lstate,
2510         char *buffer,
2511         int size
2512         )
2513 {
2514         static struct bits
2515         {
2516                 u_long      bit;
2517                 const char *name;
2518         } flagstrings[] =
2519           {
2520                   { PARSEB_ANNOUNCE,   "DST SWITCH WARNING" },
2521                   { PARSEB_POWERUP,    "NOT SYNCHRONIZED" },
2522                   { PARSEB_NOSYNC,     "TIME CODE NOT CONFIRMED" },
2523                   { PARSEB_DST,        "DST" },
2524                   { PARSEB_UTC,        "UTC DISPLAY" },
2525                   { PARSEB_LEAPADD,    "LEAP ADD WARNING" },
2526                   { PARSEB_LEAPDEL,    "LEAP DELETE WARNING" },
2527                   { PARSEB_LEAPSECOND, "LEAP SECOND" },
2528                   { PARSEB_CALLBIT,    "CALL BIT" },
2529                   { PARSEB_TIMECODE,   "TIME CODE" },
2530                   { PARSEB_PPS,        "PPS" },
2531                   { PARSEB_POSITION,   "POSITION" },
2532                   { 0,                 NULL }
2533           };
2534
2535         static struct sbits
2536         {
2537                 u_long      bit;
2538                 const char *name;
2539         } sflagstrings[] =
2540           {
2541                   { PARSEB_S_LEAP,     "LEAP INDICATION" },
2542                   { PARSEB_S_PPS,      "PPS SIGNAL" },
2543                   { PARSEB_S_CALLBIT,  "CALLBIT" },
2544                   { PARSEB_S_POSITION, "POSITION" },
2545                   { 0,                 NULL }
2546           };
2547         int i;
2548         char *s, *t;
2549
2550         *buffer = '\0';
2551         s = t = buffer;
2552
2553         i = 0;
2554         while (flagstrings[i].bit)
2555         {
2556                 if (flagstrings[i].bit & lstate)
2557                 {
2558                         if (s != t)
2559                                 t = ap(buffer, size, t, "; ");
2560                         t = ap(buffer, size, t, "%s", flagstrings[i].name);
2561                 }
2562                 i++;
2563         }
2564
2565         if (lstate & (PARSEB_S_LEAP|PARSEB_S_CALLBIT|PARSEB_S_PPS|PARSEB_S_POSITION))
2566         {
2567                 if (s != t)
2568                         t = ap(buffer, size, t, "; ");
2569
2570                 t = ap(buffer, size, t, "(");
2571
2572                 s = t;
2573
2574                 i = 0;
2575                 while (sflagstrings[i].bit)
2576                 {
2577                         if (sflagstrings[i].bit & lstate)
2578                         {
2579                                 if (t != s)
2580                                 {
2581                                         t = ap(buffer, size, t, "; ");
2582                                 }
2583
2584                                 t = ap(buffer, size, t, "%s",
2585                                     sflagstrings[i].name);
2586                         }
2587                         i++;
2588                 }
2589                 t = ap(buffer, size, t, ")");
2590                 /* t is unused here, but if we don't track it and
2591                  * need it later, that's a bug waiting to happen.
2592                  */
2593         }
2594         return buffer;
2595 }
2596
2597 /*--------------------------------------------------
2598  * convert a status flag field to a string
2599  */
2600 static char *
2601 parsestatus(
2602         u_long lstate,
2603         char *buffer,
2604         int size
2605         )
2606 {
2607         static struct bits
2608         {
2609                 u_long      bit;
2610                 const char *name;
2611         } flagstrings[] =
2612           {
2613                   { CVT_OK,      "CONVERSION SUCCESSFUL" },
2614                   { CVT_NONE,    "NO CONVERSION" },
2615                   { CVT_FAIL,    "CONVERSION FAILED" },
2616                   { CVT_BADFMT,  "ILLEGAL FORMAT" },
2617                   { CVT_BADDATE, "DATE ILLEGAL" },
2618                   { CVT_BADTIME, "TIME ILLEGAL" },
2619                   { CVT_ADDITIONAL, "ADDITIONAL DATA" },
2620                   { 0,           NULL }
2621           };
2622         int i;
2623         char *t;
2624
2625         t = buffer;
2626         *buffer = '\0';
2627
2628         i = 0;
2629         while (flagstrings[i].bit)
2630         {
2631                 if (flagstrings[i].bit & lstate)
2632                 {
2633                         if (t != buffer)
2634                                 t = ap(buffer, size, t, "; ");
2635                         t = ap(buffer, size, t, "%s", flagstrings[i].name);
2636                 }
2637                 i++;
2638         }
2639
2640         return buffer;
2641 }
2642
2643 /*--------------------------------------------------
2644  * convert a clock status flag field to a string
2645  */
2646 static const char *
2647 clockstatus(
2648         u_long lstate
2649         )
2650 {
2651         static char buffer[20];
2652         static struct status
2653         {
2654                 u_long      value;
2655                 const char *name;
2656         } flagstrings[] =
2657           {
2658                   { CEVNT_NOMINAL, "NOMINAL" },
2659                   { CEVNT_TIMEOUT, "NO RESPONSE" },
2660                   { CEVNT_BADREPLY,"BAD FORMAT" },
2661                   { CEVNT_FAULT,   "FAULT" },
2662                   { CEVNT_PROP,    "PROPAGATION DELAY" },
2663                   { CEVNT_BADDATE, "ILLEGAL DATE" },
2664                   { CEVNT_BADTIME, "ILLEGAL TIME" },
2665                   { (unsigned)~0L, NULL }
2666           };
2667         int i;
2668
2669         i = 0;
2670         while (flagstrings[i].value != (u_int)~0)
2671         {
2672                 if (flagstrings[i].value == lstate)
2673                 {
2674                         return flagstrings[i].name;
2675                 }
2676                 i++;
2677         }
2678
2679         snprintf(buffer, sizeof(buffer), "unknown #%ld", (u_long)lstate);
2680
2681         return buffer;
2682 }
2683
2684
2685 /*--------------------------------------------------
2686  * l_mktime - make representation of a relative time
2687  */
2688 static char *
2689 l_mktime(
2690         u_long delta
2691         )
2692 {
2693         u_long tmp, m, s;
2694         static char buffer[40];
2695         char *t;
2696
2697         buffer[0] = '\0';
2698         t = buffer;
2699
2700         if ((tmp = delta / (60*60*24)) != 0)
2701         {
2702                 t = ap(buffer, sizeof(buffer), t, "%ldd+", (u_long)tmp);
2703                 delta -= tmp * 60*60*24;
2704         }
2705
2706         s = delta % 60;
2707         delta /= 60;
2708         m = delta % 60;
2709         delta /= 60;
2710
2711         t = ap(buffer, sizeof(buffer), t, "%02d:%02d:%02d",
2712              (int)delta, (int)m, (int)s);
2713
2714         return buffer;
2715 }
2716
2717
2718 /*--------------------------------------------------
2719  * parse_statistics - list summary of clock states
2720  */
2721 static void
2722 parse_statistics(
2723         struct parseunit *parse
2724         )
2725 {
2726         int i;
2727
2728         NLOG(NLOG_CLOCKSTATIST) /* conditional if clause for conditional syslog */
2729                 {
2730                         msyslog(LOG_INFO, "PARSE receiver #%d: running time: %s",
2731                                 CLK_UNIT(parse->peer),
2732                                 l_mktime(current_time - parse->generic->timestarted));
2733
2734                         msyslog(LOG_INFO, "PARSE receiver #%d: current status: %s",
2735                                 CLK_UNIT(parse->peer),
2736                                 clockstatus(parse->generic->currentstatus));
2737
2738                         for (i = 0; i <= CEVNT_MAX; i++)
2739                         {
2740                                 u_long s_time;
2741                                 u_long percent, d = current_time - parse->generic->timestarted;
2742
2743                                 percent = s_time = PARSE_STATETIME(parse, i);
2744
2745                                 while (((u_long)(~0) / 10000) < percent)
2746                                 {
2747                                         percent /= 10;
2748                                         d       /= 10;
2749                                 }
2750
2751                                 if (d)
2752                                     percent = (percent * 10000) / d;
2753                                 else
2754                                     percent = 10000;
2755
2756                                 if (s_time)
2757                                     msyslog(LOG_INFO, "PARSE receiver #%d: state %18s: %13s (%3ld.%02ld%%)",
2758                                             CLK_UNIT(parse->peer),
2759                                             clockstatus((unsigned int)i),
2760                                             l_mktime(s_time),
2761                                             percent / 100, percent % 100);
2762                         }
2763                 }
2764 }
2765
2766 /*--------------------------------------------------
2767  * cparse_statistics - wrapper for statistics call
2768  */
2769 static void
2770 cparse_statistics(
2771         struct parseunit *parse
2772         )
2773 {
2774         if (parse->laststatistic + PARSESTATISTICS < current_time)
2775                 parse_statistics(parse);
2776         parse->laststatistic = current_time;
2777 }
2778
2779 /**===========================================================================
2780  ** ntp interface routines
2781  **/
2782
2783 /*--------------------------------------------------
2784  * parse_shutdown - shut down a PARSE clock
2785  */
2786 static void
2787 parse_shutdown(
2788         int unit,
2789         struct peer *peer
2790         )
2791 {
2792         struct parseunit *parse = NULL;
2793
2794         if (peer && peer->procptr)
2795                 parse = peer->procptr->unitptr;
2796
2797         if (!parse)
2798         {
2799                 /* nothing to clean up */
2800                 return;
2801         }
2802
2803         if (!parse->peer)
2804         {
2805                 msyslog(LOG_INFO, "PARSE receiver #%d: INTERNAL ERROR - unit already inactive - shutdown ignored", unit);
2806                 return;
2807         }
2808
2809 #ifdef HAVE_PPSAPI
2810         if (parse->flags & PARSE_PPSCLOCK)
2811         {
2812                 (void)time_pps_destroy(parse->atom.handle);
2813         }
2814 #endif
2815         if (parse->generic->io.fd != parse->ppsfd && parse->ppsfd != -1)
2816                 (void)closeserial(parse->ppsfd);  /* close separate PPS source */
2817
2818         /*
2819          * print statistics a last time and
2820          * stop statistics machine
2821          */
2822         parse_statistics(parse);
2823
2824         if (parse->parse_type->cl_end)
2825         {
2826                 parse->parse_type->cl_end(parse);
2827         }
2828
2829         /*
2830          * cleanup before leaving this world
2831          */
2832         if (parse->binding)
2833             PARSE_END(parse);
2834
2835         /*
2836          * Tell the I/O module to turn us off.  We're history.
2837          */
2838         io_closeclock(&parse->generic->io);
2839
2840         free_varlist(parse->kv);
2841
2842         NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
2843                 msyslog(LOG_INFO, "PARSE receiver #%d: reference clock \"%s\" removed",
2844                         CLK_UNIT(parse->peer), parse->parse_type->cl_description);
2845
2846         parse->peer = (struct peer *)0; /* unused now */
2847         peer->procptr->unitptr = (caddr_t)0;
2848         free(parse);
2849 }
2850
2851 #ifdef HAVE_PPSAPI
2852 /*----------------------------------------
2853  * set up HARDPPS via PPSAPI
2854  */
2855 static void
2856 parse_hardpps(
2857               struct parseunit *parse,
2858               int mode
2859               )
2860 {
2861         if (parse->hardppsstate == mode)
2862                 return;
2863
2864         if (CLK_PPS(parse->peer) && (parse->flags & PARSE_PPSKERNEL)) {
2865                 int     i = 0;
2866
2867                 if (mode == PARSE_HARDPPS_ENABLE)
2868                         {
2869                                 if (parse->flags & PARSE_CLEAR)
2870                                         i = PPS_CAPTURECLEAR;
2871                                 else
2872                                         i = PPS_CAPTUREASSERT;
2873                         }
2874
2875                 if (time_pps_kcbind(parse->atom.handle, PPS_KC_HARDPPS, i,
2876                     PPS_TSFMT_TSPEC) < 0) {
2877                         msyslog(LOG_ERR, "PARSE receiver #%d: time_pps_kcbind failed: %m",
2878                                 CLK_UNIT(parse->peer));
2879                 } else {
2880                         NLOG(NLOG_CLOCKINFO)
2881                                 msyslog(LOG_INFO, "PARSE receiver #%d: kernel PPS synchronisation %sabled",
2882                                         CLK_UNIT(parse->peer), (mode == PARSE_HARDPPS_ENABLE) ? "en" : "dis");
2883                         /*
2884                          * tell the rest, that we have a kernel PPS source, iff we ever enable HARDPPS
2885                          */
2886                         if (mode == PARSE_HARDPPS_ENABLE)
2887                                 hardpps_enable = 1;
2888                 }
2889         }
2890
2891         parse->hardppsstate = mode;
2892 }
2893
2894 /*----------------------------------------
2895  * set up PPS via PPSAPI
2896  */
2897 static int
2898 parse_ppsapi(
2899              struct parseunit *parse
2900         )
2901 {
2902         int cap, mode_ppsoffset;
2903         const char *cp;
2904
2905         parse->flags &= (u_char) (~PARSE_PPSCLOCK);
2906
2907         /*
2908          * collect PPSAPI offset capability - should move into generic handling
2909          */
2910         if (time_pps_getcap(parse->atom.handle, &cap) < 0) {
2911                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_ppsapi: time_pps_getcap failed: %m",
2912                         CLK_UNIT(parse->peer));
2913
2914                 return 0;
2915         }
2916
2917         /*
2918          * initialize generic PPSAPI interface
2919          *
2920          * we leave out CLK_FLAG3 as time_pps_kcbind()
2921          * is handled here for now. Ideally this should also
2922          * be part of the generic PPSAPI interface
2923          */
2924         if (!refclock_params(parse->flags & (CLK_FLAG1|CLK_FLAG2|CLK_FLAG4), &parse->atom))
2925                 return 0;
2926
2927         /* nb. only turn things on, if someone else has turned something
2928          *      on before we get here, leave it alone!
2929          */
2930
2931         if (parse->flags & PARSE_CLEAR) {
2932                 cp = "CLEAR";
2933                 mode_ppsoffset = PPS_OFFSETCLEAR;
2934         } else {
2935                 cp = "ASSERT";
2936                 mode_ppsoffset = PPS_OFFSETASSERT;
2937         }
2938
2939         msyslog(LOG_INFO, "PARSE receiver #%d: initializing PPS to %s",
2940                 CLK_UNIT(parse->peer), cp);
2941
2942         if (!(mode_ppsoffset & cap)) {
2943           msyslog(LOG_WARNING, "PARSE receiver #%d: Cannot set PPS_%sCLEAR, this will increase jitter (PPS API capabilities=0x%x)",
2944                   CLK_UNIT(parse->peer), cp, cap);
2945                 mode_ppsoffset = 0;
2946         } else {
2947                 if (mode_ppsoffset == PPS_OFFSETCLEAR)
2948                         {
2949                                 parse->atom.pps_params.clear_offset.tv_sec = (time_t)(-parse->ppsphaseadjust);
2950                                 parse->atom.pps_params.clear_offset.tv_nsec = (long)(-1e9*(parse->ppsphaseadjust - (double)(long)parse->ppsphaseadjust));
2951                         }
2952
2953                 if (mode_ppsoffset == PPS_OFFSETASSERT)
2954                         {
2955                                 parse->atom.pps_params.assert_offset.tv_sec = (time_t)(-parse->ppsphaseadjust);
2956                                 parse->atom.pps_params.assert_offset.tv_nsec = (long)(-1e9*(parse->ppsphaseadjust - (double)(long)parse->ppsphaseadjust));
2957                         }
2958         }
2959
2960         parse->atom.pps_params.mode |= mode_ppsoffset;
2961
2962         if (time_pps_setparams(parse->atom.handle, &parse->atom.pps_params) < 0) {
2963           msyslog(LOG_ERR, "PARSE receiver #%d: FAILED set PPS parameters: %m",
2964                   CLK_UNIT(parse->peer));
2965                 return 0;
2966         }
2967
2968         parse->flags |= PARSE_PPSCLOCK;
2969         return 1;
2970 }
2971 #else
2972 #define parse_hardpps(_PARSE_, _MODE_) /* empty */
2973 #endif
2974
2975 /*--------------------------------------------------
2976  * parse_start - open the PARSE devices and initialize data for processing
2977  */
2978 static int
2979 parse_start(
2980         int sysunit,
2981         struct peer *peer
2982         )
2983 {
2984         u_int unit;
2985         int fd232;
2986 #ifdef HAVE_TERMIOS
2987         struct termios tio;             /* NEEDED FOR A LONG TIME ! */
2988 #endif
2989 #ifdef HAVE_SYSV_TTYS
2990         struct termio tio;              /* NEEDED FOR A LONG TIME ! */
2991 #endif
2992         struct parseunit * parse;
2993         char parsedev[sizeof(PARSEDEVICE)+20];
2994         char parseppsdev[sizeof(PARSEPPSDEVICE)+20];
2995         parsectl_t tmp_ctl;
2996         u_int type;
2997
2998         /*
2999          * get out Copyright information once
3000          */
3001         if (!notice)
3002         {
3003                 NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3004                         msyslog(LOG_INFO, "NTP PARSE support: Copyright (c) 1989-2015, Frank Kardel");
3005                 notice = 1;
3006         }
3007
3008         type = CLK_TYPE(peer);
3009         unit = CLK_UNIT(peer);
3010
3011         if ((type == (u_int)~0) || (parse_clockinfo[type].cl_description == (char *)0))
3012         {
3013                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: unsupported clock type %d (max %d)",
3014                         unit, CLK_REALTYPE(peer), ncltypes-1);
3015                 return 0;
3016         }
3017
3018         /*
3019          * Unit okay, attempt to open the device.
3020          */
3021         (void) snprintf(parsedev, sizeof(parsedev), PARSEDEVICE, unit);
3022         (void) snprintf(parseppsdev, sizeof(parsedev), PARSEPPSDEVICE, unit);
3023
3024 #ifndef O_NOCTTY
3025 #define O_NOCTTY 0
3026 #endif
3027 #ifndef O_NONBLOCK
3028 #define O_NONBLOCK 0
3029 #endif
3030
3031         fd232 = tty_open(parsedev, O_RDWR | O_NOCTTY | O_NONBLOCK, 0777);
3032
3033         if (fd232 == -1)
3034         {
3035                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: open of %s failed: %m", unit, parsedev);
3036                 return 0;
3037         }
3038
3039         parse = emalloc_zero(sizeof(*parse));
3040
3041         parse->generic = peer->procptr;  /* link up */
3042         parse->generic->unitptr = (caddr_t)parse; /* link down */
3043
3044         /*
3045          * Set up the structures
3046          */
3047         parse->generic->timestarted    = current_time;
3048         parse->lastchange     = current_time;
3049
3050         parse->flags          = 0;
3051         parse->pollneeddata   = 0;
3052         parse->laststatistic  = current_time;
3053         parse->lastformat     = (unsigned short)~0;     /* assume no format known */
3054         parse->timedata.parse_status = (unsigned short)~0;      /* be sure to mark initial status change */
3055         parse->lastmissed     = 0;      /* assume got everything */
3056         parse->ppsserial      = 0;
3057         parse->ppsfd          = -1;
3058         parse->localdata      = (void *)0;
3059         parse->localstate     = 0;
3060         parse->kv             = (struct ctl_var *)0;
3061
3062         clear_err(parse, ERR_ALL);
3063
3064         parse->parse_type     = &parse_clockinfo[type];
3065
3066         parse->maxunsync      = parse->parse_type->cl_maxunsync;
3067
3068         parse->generic->fudgetime1 = parse->parse_type->cl_basedelay;
3069
3070         parse->generic->fudgetime2 = 0.0;
3071         parse->ppsphaseadjust = parse->generic->fudgetime2;
3072         parse->generic->fudgeminjitter = 0.0;
3073
3074         parse->generic->clockdesc  = parse->parse_type->cl_description;
3075
3076         peer->rootdelay       = parse->parse_type->cl_rootdelay;
3077         peer->sstclktype      = parse->parse_type->cl_type;
3078         peer->precision       = sys_precision;
3079
3080         peer->stratum         = STRATUM_REFCLOCK;
3081
3082         if (peer->stratum <= 1)
3083             memmove((char *)&parse->generic->refid, parse->parse_type->cl_id, 4);
3084         else
3085             parse->generic->refid = htonl(PARSEHSREFID);
3086
3087         parse->generic->io.fd = fd232;
3088
3089         parse->peer = peer;             /* marks it also as busy */
3090
3091         /*
3092          * configure terminal line
3093          */
3094         if (TTY_GETATTR(fd232, &tio) == -1)
3095         {
3096                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: tcgetattr(%d, &tio): %m", unit, fd232);
3097                 parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3098                 return 0;
3099         }
3100         else
3101         {
3102 #ifndef _PC_VDISABLE
3103                 memset((char *)tio.c_cc, 0, sizeof(tio.c_cc));
3104 #else
3105                 int disablec;
3106                 errno = 0;              /* pathconf can deliver -1 without changing errno ! */
3107
3108                 disablec = fpathconf(parse->generic->io.fd, _PC_VDISABLE);
3109                 if (disablec == -1 && errno)
3110                 {
3111                         msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: fpathconf(fd, _PC_VDISABLE): %m", CLK_UNIT(parse->peer));
3112                         memset((char *)tio.c_cc, 0, sizeof(tio.c_cc)); /* best guess */
3113                 }
3114                 else
3115                     if (disablec != -1)
3116                         memset((char *)tio.c_cc, disablec, sizeof(tio.c_cc));
3117 #endif
3118
3119 #if defined (VMIN) || defined(VTIME)
3120                 if ((parse_clockinfo[type].cl_lflag & ICANON) == 0)
3121                 {
3122 #ifdef VMIN
3123                         tio.c_cc[VMIN]   = 1;
3124 #endif
3125 #ifdef VTIME
3126                         tio.c_cc[VTIME]  = 0;
3127 #endif
3128                 }
3129 #endif
3130
3131                 tio.c_cflag = (tcflag_t) parse_clockinfo[type].cl_cflag;
3132                 tio.c_iflag = (tcflag_t) parse_clockinfo[type].cl_iflag;
3133                 tio.c_oflag = (tcflag_t) parse_clockinfo[type].cl_oflag;
3134                 tio.c_lflag = (tcflag_t) parse_clockinfo[type].cl_lflag;
3135
3136
3137 #ifdef HAVE_TERMIOS
3138                 if ((cfsetospeed(&tio, (speed_t) parse_clockinfo[type].cl_speed) == -1) ||
3139                     (cfsetispeed(&tio, (speed_t) parse_clockinfo[type].cl_speed) == -1))
3140                 {
3141                         msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: tcset{i,o}speed(&tio, speed): %m", unit);
3142                         parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3143                         return 0;
3144                 }
3145 #else
3146                 tio.c_cflag     |= parse_clockinfo[type].cl_speed;
3147 #endif
3148
3149                 /*
3150                  * set up pps device
3151                  * if the PARSEPPSDEVICE can be opened that will be used
3152                  * for PPS else PARSEDEVICE will be used
3153                  */
3154                 parse->ppsfd = tty_open(parseppsdev, O_RDWR | O_NOCTTY | O_NONBLOCK, 0777);
3155
3156                 if (parse->ppsfd == -1)
3157                 {
3158                         parse->ppsfd = fd232;
3159                 }
3160
3161 /*
3162  * Linux PPS - the old way
3163  */
3164 #if defined(HAVE_TIO_SERIAL_STUFF)              /* Linux hack: define PPS interface */
3165                 {
3166                         struct serial_struct    ss;
3167                         if (ioctl(parse->ppsfd, TIOCGSERIAL, &ss) < 0 ||
3168                             (
3169 #ifdef ASYNC_LOW_LATENCY
3170                              ss.flags |= ASYNC_LOW_LATENCY,
3171 #endif
3172 #ifndef HAVE_PPSAPI
3173 #ifdef ASYNC_PPS_CD_NEG
3174                              ss.flags |= ASYNC_PPS_CD_NEG,
3175 #endif
3176 #endif
3177                              ioctl(parse->ppsfd, TIOCSSERIAL, &ss)) < 0) {
3178                                 msyslog(LOG_NOTICE, "refclock_parse: TIOCSSERIAL fd %d, %m", parse->ppsfd);
3179                                 msyslog(LOG_NOTICE,
3180                                         "refclock_parse: optional PPS processing not available");
3181                         } else {
3182                                 parse->flags    |= PARSE_PPSCLOCK;
3183 #ifdef ASYNC_PPS_CD_NEG
3184                                 NLOG(NLOG_CLOCKINFO)
3185                                   msyslog(LOG_INFO,
3186                                           "refclock_parse: PPS detection on");
3187 #endif
3188                         }
3189                 }
3190 #endif
3191
3192 /*
3193  * SUN the Solaris way
3194  */
3195 #ifdef HAVE_TIOCSPPS                    /* SUN PPS support */
3196                 if (CLK_PPS(parse->peer))
3197                     {
3198                         int i = 1;
3199
3200                         if (ioctl(parse->ppsfd, TIOCSPPS, (caddr_t)&i) == 0)
3201                             {
3202                                 parse->flags |= PARSE_PPSCLOCK;
3203                             }
3204                     }
3205 #endif
3206
3207 /*
3208  * PPS via PPSAPI
3209  */
3210 #if defined(HAVE_PPSAPI)
3211                 parse->hardppsstate = PARSE_HARDPPS_DISABLE;
3212                 if (CLK_PPS(parse->peer))
3213                 {
3214                   if (!refclock_ppsapi(parse->ppsfd, &parse->atom))
3215                     {
3216                       msyslog(LOG_NOTICE, "PARSE receiver #%d: parse_start: could not set up PPS: %m", CLK_UNIT(parse->peer));
3217                     }
3218                   else
3219                     {
3220                       parse_ppsapi(parse);
3221                     }
3222                 }
3223 #endif
3224
3225                 if (TTY_SETATTR(fd232, &tio) == -1)
3226                 {
3227                         msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: tcsetattr(%d, &tio): %m", unit, fd232);
3228                         parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3229                         return 0;
3230                 }
3231         }
3232
3233         /*
3234          * pick correct input machine
3235          */
3236         parse->generic->io.srcclock = peer;
3237         parse->generic->io.datalen = 0;
3238
3239         parse->binding = init_iobinding(parse);
3240
3241         if (parse->binding == (bind_t *)0)
3242                 {
3243                         msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: io sub system initialisation failed.", CLK_UNIT(parse->peer));
3244                         parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3245                         return 0;                       /* well, ok - special initialisation broke */
3246                 }
3247
3248         parse->generic->io.clock_recv = parse->binding->bd_receive; /* pick correct receive routine */
3249         parse->generic->io.io_input   = parse->binding->bd_io_input; /* pick correct input routine */
3250
3251         /*
3252          * as we always(?) get 8 bit chars we want to be
3253          * sure, that the upper bits are zero for less
3254          * than 8 bit I/O - so we pass that information on.
3255          * note that there can be only one bit count format
3256          * per file descriptor
3257          */
3258
3259         switch (tio.c_cflag & CSIZE)
3260         {
3261             case CS5:
3262                 tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS5;
3263                 break;
3264
3265             case CS6:
3266                 tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS6;
3267                 break;
3268
3269             case CS7:
3270                 tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS7;
3271                 break;
3272
3273             case CS8:
3274                 tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS8;
3275                 break;
3276         }
3277
3278         if (!PARSE_SETCS(parse, &tmp_ctl))
3279         {
3280                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: parse_setcs() FAILED.", unit);
3281                 parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3282                 return 0;                       /* well, ok - special initialisation broke */
3283         }
3284
3285         strlcpy(tmp_ctl.parseformat.parse_buffer, parse->parse_type->cl_format, sizeof(tmp_ctl.parseformat.parse_buffer));
3286         tmp_ctl.parseformat.parse_count = (u_short) strlen(tmp_ctl.parseformat.parse_buffer);
3287
3288         if (!PARSE_SETFMT(parse, &tmp_ctl))
3289         {
3290                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: parse_setfmt() FAILED.", unit);
3291                 parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3292                 return 0;                       /* well, ok - special initialisation broke */
3293         }
3294
3295         /*
3296          * get rid of all IO accumulated so far
3297          */
3298 #ifdef HAVE_TERMIOS
3299         (void) tcflush(parse->generic->io.fd, TCIOFLUSH);
3300 #else
3301 #if defined(TCFLSH) && defined(TCIOFLUSH)
3302         {
3303                 int flshcmd = TCIOFLUSH;
3304
3305                 (void) ioctl(parse->generic->io.fd, TCFLSH, (caddr_t)&flshcmd);
3306         }
3307 #endif
3308 #endif
3309
3310         /*
3311          * try to do any special initializations
3312          */
3313         if (parse->parse_type->cl_init)
3314                 {
3315                         if (parse->parse_type->cl_init(parse))
3316                                 {
3317                                         parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3318                                         return 0;               /* well, ok - special initialisation broke */
3319                                 }
3320                 }
3321
3322         /*
3323          * Insert in async io device list.
3324          */
3325         if (!io_addclock(&parse->generic->io))
3326         {
3327                 msyslog(LOG_ERR,
3328                         "PARSE receiver #%d: parse_start: addclock %s fails (ABORT - clock type requires async io)", CLK_UNIT(parse->peer), parsedev);
3329                 parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3330                 return 0;
3331         }
3332
3333         /*
3334          * print out configuration
3335          */
3336         NLOG(NLOG_CLOCKINFO)
3337                 {
3338                         /* conditional if clause for conditional syslog */
3339                         msyslog(LOG_INFO, "PARSE receiver #%d: reference clock \"%s\" (I/O device %s, PPS device %s) added",
3340                                 CLK_UNIT(parse->peer),
3341                                 parse->parse_type->cl_description, parsedev,
3342                                 (parse->ppsfd != parse->generic->io.fd) ? parseppsdev : parsedev);
3343
3344                         msyslog(LOG_INFO, "PARSE receiver #%d: Stratum %d, trust time %s, precision %d",
3345                                 CLK_UNIT(parse->peer),
3346                                 parse->peer->stratum,
3347                                 l_mktime(parse->maxunsync), parse->peer->precision);
3348
3349                         msyslog(LOG_INFO, "PARSE receiver #%d: rootdelay %.6f s, phase adjustment %.6f s, PPS phase adjustment %.6f s, %s IO handling",
3350                                 CLK_UNIT(parse->peer),
3351                                 parse->parse_type->cl_rootdelay,
3352                                 parse->generic->fudgetime1,
3353                                 parse->ppsphaseadjust,
3354                                 parse->binding->bd_description);
3355
3356                         msyslog(LOG_INFO, "PARSE receiver #%d: Format recognition: %s", CLK_UNIT(parse->peer),
3357                                 parse->parse_type->cl_format);
3358                         msyslog(LOG_INFO, "PARSE receiver #%d: %sPPS support%s", CLK_UNIT(parse->peer),
3359                                 CLK_PPS(parse->peer) ? "" : "NO ",
3360                                 CLK_PPS(parse->peer) ?
3361 #ifdef PPS_METHOD
3362                                 " (implementation " PPS_METHOD ")"
3363 #else
3364                                 ""
3365 #endif
3366                                 : ""
3367                                 );
3368                 }
3369
3370         return 1;
3371 }
3372
3373 /*--------------------------------------------------
3374  * parse_ctl - process changes on flags/time values
3375  */
3376 static void
3377 parse_ctl(
3378             struct parseunit *parse,
3379             const struct refclockstat *in
3380             )
3381 {
3382         if (in)
3383         {
3384                 if (in->haveflags & (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4))
3385                 {
3386                   u_char mask = CLK_FLAG1|CLK_FLAG2|CLK_FLAG3|CLK_FLAG4;
3387                   parse->flags = (parse->flags & (u_char)(~mask)) | (in->flags & mask);
3388 #if defined(HAVE_PPSAPI)
3389                   if (CLK_PPS(parse->peer))
3390                     {
3391                       parse_ppsapi(parse);
3392                     }
3393 #endif
3394                 }
3395
3396                 if (in->haveflags & CLK_HAVETIME1)
3397                 {
3398                   parse->generic->fudgetime1 = in->fudgetime1;
3399                   msyslog(LOG_INFO, "PARSE receiver #%d: new phase adjustment %.6f s",
3400                           CLK_UNIT(parse->peer),
3401                           parse->generic->fudgetime1);
3402                 }
3403
3404                 if (in->haveflags & CLK_HAVETIME2)
3405                 {
3406                   parse->generic->fudgetime2 = in->fudgetime2;
3407                   if (parse->flags & PARSE_TRUSTTIME)
3408                     {
3409                       parse->maxunsync = (u_long)ABS(in->fudgetime2);
3410                       msyslog(LOG_INFO, "PARSE receiver #%d: new trust time %s",
3411                               CLK_UNIT(parse->peer),
3412                               l_mktime(parse->maxunsync));
3413                     }
3414                   else
3415                     {
3416                       parse->ppsphaseadjust = in->fudgetime2;
3417                       msyslog(LOG_INFO, "PARSE receiver #%d: new PPS phase adjustment %.6f s",
3418                           CLK_UNIT(parse->peer),
3419                               parse->ppsphaseadjust);
3420 #if defined(HAVE_PPSAPI)
3421                       if (CLK_PPS(parse->peer))
3422                       {
3423                               parse_ppsapi(parse);
3424                       }
3425 #endif
3426                     }
3427                 }
3428
3429                 parse->generic->fudgeminjitter = in->fudgeminjitter;
3430         }
3431 }
3432
3433 /*--------------------------------------------------
3434  * parse_poll - called by the transmit procedure
3435  */
3436 static void
3437 parse_poll(
3438         int unit,
3439         struct peer *peer
3440         )
3441 {
3442         struct parseunit *parse = peer->procptr->unitptr;
3443
3444         if (peer != parse->peer)
3445         {
3446                 msyslog(LOG_ERR,
3447                         "PARSE receiver #%d: poll: INTERNAL: peer incorrect",
3448                         unit);
3449                 return;
3450         }
3451
3452         /*
3453          * Update clock stat counters
3454          */
3455         parse->generic->polls++;
3456
3457         if (parse->pollneeddata &&
3458             ((int)(current_time - parse->pollneeddata) > (1<<(max(min(parse->peer->hpoll, parse->peer->ppoll), parse->peer->minpoll)))))
3459         {
3460                 /*
3461                  * start worrying when exceeding a poll inteval
3462                  * bad news - didn't get a response last time
3463                  */
3464                 parse->lastmissed = current_time;
3465                 parse_event(parse, CEVNT_TIMEOUT);
3466
3467                 ERR(ERR_NODATA)
3468                         msyslog(LOG_WARNING, "PARSE receiver #%d: no data from device within poll interval (check receiver / wiring)", CLK_UNIT(parse->peer));
3469         }
3470
3471         /*
3472          * we just mark that we want the next sample for the clock filter
3473          */
3474         parse->pollneeddata = current_time;
3475
3476         if (parse->parse_type->cl_poll)
3477         {
3478                 parse->parse_type->cl_poll(parse);
3479         }
3480
3481         cparse_statistics(parse);
3482
3483         return;
3484 }
3485
3486 #define LEN_STATES 300          /* length of state string */
3487
3488 /*--------------------------------------------------
3489  * parse_control - set fudge factors, return statistics
3490  */
3491 static void
3492 parse_control(
3493         int unit,
3494         const struct refclockstat *in,
3495         struct refclockstat *out,
3496         struct peer *peer
3497         )
3498 {
3499         struct parseunit *parse = peer->procptr->unitptr;
3500         parsectl_t tmpctl;
3501
3502         static char outstatus[400];     /* status output buffer */
3503
3504         if (out)
3505         {
3506                 out->lencode       = 0;
3507                 out->p_lastcode    = 0;
3508                 out->kv_list       = (struct ctl_var *)0;
3509         }
3510
3511         if (!parse || !parse->peer)
3512         {
3513                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: unit invalid (UNIT INACTIVE)",
3514                         unit);
3515                 return;
3516         }
3517
3518         unit = CLK_UNIT(parse->peer);
3519
3520         /*
3521          * handle changes
3522          */
3523         parse_ctl(parse, in);
3524
3525         /*
3526          * supply data
3527          */
3528         if (out)
3529         {
3530                 u_long sum = 0;
3531                 char *tt, *start;
3532                 int i;
3533
3534                 outstatus[0] = '\0';
3535
3536                 out->type       = REFCLK_PARSE;
3537
3538                 /*
3539                  * keep fudgetime2 in sync with TRUSTTIME/MAXUNSYNC flag1
3540                  */
3541                 parse->generic->fudgetime2 = (parse->flags & PARSE_TRUSTTIME) ? (double)parse->maxunsync : parse->ppsphaseadjust;
3542
3543                 /*
3544                  * figure out skew between PPS and RS232 - just for informational
3545                  * purposes
3546                  */
3547                 if (PARSE_SYNC(parse->timedata.parse_state))
3548                 {
3549                         if (PARSE_PPS(parse->timedata.parse_state) && PARSE_TIMECODE(parse->timedata.parse_state))
3550                         {
3551                                 l_fp off;
3552
3553                                 /*
3554                                  * we have a PPS and RS232 signal - calculate the skew
3555                                  * WARNING: assumes on TIMECODE == PULSE (timecode after pulse)
3556                                  */
3557                                 off = parse->timedata.parse_stime.fp;
3558                                 L_SUB(&off, &parse->timedata.parse_ptime.fp); /* true offset */
3559                                 tt = add_var(&out->kv_list, 80, RO);
3560                                 snprintf(tt, 80, "refclock_ppsskew=%s", lfptoms(&off, 6));
3561                         }
3562                 }
3563
3564                 if (PARSE_PPS(parse->timedata.parse_state))
3565                 {
3566                         tt = add_var(&out->kv_list, 80, RO|DEF);
3567                         snprintf(tt, 80, "refclock_ppstime=\"%s\"", gmprettydate(&parse->timedata.parse_ptime.fp));
3568                 }
3569
3570                 start = tt = add_var(&out->kv_list, 128, RO|DEF);
3571                 tt = ap(start, 128, tt, "refclock_time=\"");
3572
3573                 if (parse->timedata.parse_time.fp.l_ui == 0)
3574                 {
3575                         tt = ap(start, 128, tt, "<UNDEFINED>\"");
3576                 }
3577                 else
3578                 {
3579                         tt = ap(start, 128, tt, "%s\"",
3580                             gmprettydate(&parse->timedata.parse_time.fp));
3581                 }
3582
3583                 if (!PARSE_GETTIMECODE(parse, &tmpctl))
3584                 {
3585                         ERR(ERR_INTERNAL)
3586                                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: parse_timecode() FAILED", unit);
3587                 }
3588                 else
3589                 {
3590                         start = tt = add_var(&out->kv_list, 512, RO|DEF);
3591                         tt = ap(start, 512, tt, "refclock_status=\"");
3592
3593                         /*
3594                          * copy PPS flags from last read transaction (informational only)
3595                          */
3596                         tmpctl.parsegettc.parse_state |= parse->timedata.parse_state &
3597                                 (PARSEB_PPS|PARSEB_S_PPS);
3598
3599                         (void)parsestate(tmpctl.parsegettc.parse_state, tt, BUFFER_SIZES(start, tt, 512));
3600
3601                         tt += strlen(tt);
3602
3603                         tt = ap(start, 512, tt, "\"");
3604
3605                         if (tmpctl.parsegettc.parse_count)
3606                             mkascii(outstatus+strlen(outstatus), (int)(sizeof(outstatus)- strlen(outstatus) - 1),
3607                                     tmpctl.parsegettc.parse_buffer, (unsigned)(tmpctl.parsegettc.parse_count));
3608
3609                 }
3610
3611                 tmpctl.parseformat.parse_format = tmpctl.parsegettc.parse_format;
3612
3613                 if (!PARSE_GETFMT(parse, &tmpctl))
3614                 {
3615                         ERR(ERR_INTERNAL)
3616                                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: parse_getfmt() FAILED", unit);
3617                 }
3618                 else
3619                 {
3620                         int count = tmpctl.parseformat.parse_count;
3621                         if (count)
3622                                 --count;
3623
3624                         start = tt = add_var(&out->kv_list, 80, RO|DEF);
3625                         tt = ap(start, 80, tt, "refclock_format=\"");
3626
3627                         if (count > 0) {
3628                                 tt = ap(start, 80, tt, "%*.*s",
3629                                         count,
3630                                         count,
3631                                         tmpctl.parseformat.parse_buffer);
3632                         }
3633
3634                         tt = ap(start, 80, tt, "\"");
3635                 }
3636
3637                 /*
3638                  * gather state statistics
3639                  */
3640
3641                 start = tt = add_var(&out->kv_list, LEN_STATES, RO|DEF);
3642                 tt = ap(start, LEN_STATES, tt, "refclock_states=\"");
3643
3644                 for (i = 0; i <= CEVNT_MAX; i++)
3645                 {
3646                         u_long s_time;
3647                         u_long d = current_time - parse->generic->timestarted;
3648                         u_long percent;
3649
3650                         percent = s_time = PARSE_STATETIME(parse, i);
3651
3652                         while (((u_long)(~0) / 10000) < percent)
3653                         {
3654                                 percent /= 10;
3655                                 d       /= 10;
3656                         }
3657
3658                         if (d)
3659                             percent = (percent * 10000) / d;
3660                         else
3661                             percent = 10000;
3662
3663                         if (s_time)
3664                         {
3665                                 char item[80];
3666                                 int count;
3667
3668                                 snprintf(item, 80, "%s%s%s: %s (%d.%02d%%)",
3669                                         sum ? "; " : "",
3670                                         (parse->generic->currentstatus == i) ? "*" : "",
3671                                         clockstatus((unsigned int)i),
3672                                         l_mktime(s_time),
3673                                         (int)(percent / 100), (int)(percent % 100));
3674                                 if ((count = (int) strlen(item)) < (LEN_STATES - 40 - (tt - start)))
3675                                         {
3676                                                 tt = ap(start, LEN_STATES, tt,
3677                                                     "%s", item);
3678                                         }
3679                                 sum += s_time;
3680                         }
3681                 }
3682
3683                 ap(start, LEN_STATES, tt, "; running time: %s\"", l_mktime(sum));
3684
3685                 tt = add_var(&out->kv_list, 32, RO);
3686                 snprintf(tt, 32,  "refclock_id=\"%s\"", parse->parse_type->cl_id);
3687
3688                 tt = add_var(&out->kv_list, 80, RO);
3689                 snprintf(tt, 80,  "refclock_iomode=\"%s\"", parse->binding->bd_description);
3690
3691                 tt = add_var(&out->kv_list, 128, RO);
3692                 snprintf(tt, 128, "refclock_driver_version=\"%s\"", rcsid);
3693
3694                 {
3695                         struct ctl_var *k;
3696
3697                         k = parse->kv;
3698                         while (k && !(k->flags & EOV))
3699                         {
3700                                 set_var(&out->kv_list, k->text, strlen(k->text)+1, k->flags);
3701                                 k++;
3702                         }
3703                 }
3704
3705                 out->lencode       = (u_short) strlen(outstatus);
3706                 out->p_lastcode    = outstatus;
3707         }
3708 }
3709
3710 /**===========================================================================
3711  ** processing routines
3712  **/
3713
3714 /*--------------------------------------------------
3715  * event handling - note that nominal events will also be posted
3716  * keep track of state dwelling times
3717  */
3718 static void
3719 parse_event(
3720         struct parseunit *parse,
3721         int event
3722         )
3723 {
3724         if (parse->generic->currentstatus != (u_char) event)
3725         {
3726                 parse->statetime[parse->generic->currentstatus] += current_time - parse->lastchange;
3727                 parse->lastchange              = current_time;
3728
3729                 if (parse->parse_type->cl_event)
3730                     parse->parse_type->cl_event(parse, event);
3731
3732                 if (event == CEVNT_NOMINAL)
3733                 {
3734                         NLOG(NLOG_CLOCKSTATUS)
3735                                 msyslog(LOG_INFO, "PARSE receiver #%d: SYNCHRONIZED",
3736                                         CLK_UNIT(parse->peer));
3737                 }
3738
3739                 refclock_report(parse->peer, event);
3740         }
3741 }
3742
3743 /*--------------------------------------------------
3744  * process a PARSE time sample
3745  */
3746 static void
3747 parse_process(
3748         struct parseunit *parse,
3749         parsetime_t      *parsetime
3750         )
3751 {
3752         l_fp off, rectime, reftime;
3753         double fudge;
3754
3755         /* silence warning: 'off.Ul_i.Xl_i' may be used uninitialized in this function */
3756         ZERO(off);
3757
3758         /*
3759          * check for changes in conversion status
3760          * (only one for each new status !)
3761          */
3762         if (((parsetime->parse_status & CVT_MASK) != CVT_OK) &&
3763             ((parsetime->parse_status & CVT_MASK) != CVT_NONE) &&
3764             (parse->timedata.parse_status != parsetime->parse_status))
3765         {
3766                 char buffer[400];
3767
3768                 NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3769                         msyslog(LOG_WARNING, "PARSE receiver #%d: conversion status \"%s\"",
3770                                 CLK_UNIT(parse->peer), parsestatus(parsetime->parse_status, buffer, sizeof(buffer)));
3771
3772                 if ((parsetime->parse_status & CVT_MASK) == CVT_FAIL)
3773                 {
3774                         /*
3775                          * tell more about the story - list time code
3776                          * there is a slight change for a race condition and
3777                          * the time code might be overwritten by the next packet
3778                          */
3779                         parsectl_t tmpctl;
3780
3781                         if (!PARSE_GETTIMECODE(parse, &tmpctl))
3782                         {
3783                                 ERR(ERR_INTERNAL)
3784                                         msyslog(LOG_ERR, "PARSE receiver #%d: parse_process: parse_timecode() FAILED", CLK_UNIT(parse->peer));
3785                         }
3786                         else
3787                         {
3788                                 unsigned int count = tmpctl.parsegettc.parse_count;
3789                                 if (count)
3790                                         --count;
3791                                 ERR(ERR_BADDATA)
3792                                     msyslog(LOG_WARNING, "PARSE receiver #%d: FAILED TIMECODE: \"%s\" (check receiver configuration / wiring)",
3793                                             CLK_UNIT(parse->peer),
3794                                             mkascii(buffer, sizeof(buffer),
3795                                                     tmpctl.parsegettc.parse_buffer, count));
3796                         }
3797                         /* copy status to show only changes in case of failures */
3798                         parse->timedata.parse_status = parsetime->parse_status;
3799                 }
3800         }
3801
3802         /*
3803          * examine status and post appropriate events
3804          */
3805         if ((parsetime->parse_status & CVT_MASK) != CVT_OK)
3806         {
3807                 /*
3808                  * got bad data - tell the rest of the system
3809                  */
3810                 switch (parsetime->parse_status & CVT_MASK)
3811                 {
3812                 case CVT_NONE:
3813                         if ((parsetime->parse_status & CVT_ADDITIONAL) &&
3814                             parse->parse_type->cl_message)
3815                                 parse->parse_type->cl_message(parse, parsetime);
3816                         /*
3817                          * save PPS information that comes piggyback
3818                          */
3819                         if (PARSE_PPS(parsetime->parse_state))
3820                           {
3821                             parse->timedata.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
3822                             parse->timedata.parse_ptime  = parsetime->parse_ptime;
3823                           }
3824                         break;          /* well, still waiting - timeout is handled at higher levels */
3825
3826                 case CVT_FAIL:
3827                         if (parsetime->parse_status & CVT_BADFMT)
3828                         {
3829                                 parse_event(parse, CEVNT_BADREPLY);
3830                         }
3831                         else
3832                                 if (parsetime->parse_status & CVT_BADDATE)
3833                                 {
3834                                         parse_event(parse, CEVNT_BADDATE);
3835                                 }
3836                                 else
3837                                         if (parsetime->parse_status & CVT_BADTIME)
3838                                         {
3839                                                 parse_event(parse, CEVNT_BADTIME);
3840                                         }
3841                                         else
3842                                         {
3843                                                 parse_event(parse, CEVNT_BADREPLY); /* for the lack of something better */
3844                                         }
3845                 }
3846                 return;                 /* skip the rest - useless */
3847         }
3848
3849         /*
3850          * check for format changes
3851          * (in case somebody has swapped clocks 8-)
3852          */
3853         if (parse->lastformat != parsetime->parse_format)
3854         {
3855                 parsectl_t tmpctl;
3856
3857                 tmpctl.parseformat.parse_format = parsetime->parse_format;
3858
3859                 if (!PARSE_GETFMT(parse, &tmpctl))
3860                 {
3861                         ERR(ERR_INTERNAL)
3862                                 msyslog(LOG_ERR, "PARSE receiver #%d: parse_getfmt() FAILED", CLK_UNIT(parse->peer));
3863                 }
3864                 else
3865                 {
3866                         NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3867                                 msyslog(LOG_INFO, "PARSE receiver #%d: packet format \"%s\"",
3868                                         CLK_UNIT(parse->peer), tmpctl.parseformat.parse_buffer);
3869                 }
3870                 parse->lastformat = parsetime->parse_format;
3871         }
3872
3873         /*
3874          * now, any changes ?
3875          */
3876         if ((parse->timedata.parse_state ^ parsetime->parse_state) &
3877             ~(unsigned)(PARSEB_PPS|PARSEB_S_PPS))
3878         {
3879                 char tmp1[200];
3880                 char tmp2[200];
3881                 /*
3882                  * something happend - except for PPS events
3883                  */
3884
3885                 (void) parsestate(parsetime->parse_state, tmp1, sizeof(tmp1));
3886                 (void) parsestate(parse->timedata.parse_state, tmp2, sizeof(tmp2));
3887
3888                 NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3889                         msyslog(LOG_INFO,"PARSE receiver #%d: STATE CHANGE: %s -> %s",
3890                                 CLK_UNIT(parse->peer), tmp2, tmp1);
3891         }
3892
3893         /*
3894          * carry on PPS information if still usable
3895          */
3896         if (PARSE_PPS(parse->timedata.parse_state) && !PARSE_PPS(parsetime->parse_state))
3897         {
3898                 parsetime->parse_state |= PARSEB_PPS|PARSEB_S_PPS;
3899                 parsetime->parse_ptime  = parse->timedata.parse_ptime;
3900         }
3901
3902         /*
3903          * remember for future
3904          */
3905         parse->timedata = *parsetime;
3906
3907         /*
3908          * check to see, whether the clock did a complete powerup or lost PZF signal
3909          * and post correct events for current condition
3910          */
3911         if (PARSE_POWERUP(parsetime->parse_state))
3912         {
3913                 /*
3914                  * this is bad, as we have completely lost synchronisation
3915                  * well this is a problem with the receiver here
3916                  * for PARSE Meinberg DCF77 receivers the lost synchronisation
3917                  * is true as it is the powerup state and the time is taken
3918                  * from a crude real time clock chip
3919                  * for the PZF/GPS series this is only partly true, as
3920                  * PARSE_POWERUP only means that the pseudo random
3921                  * phase shift sequence cannot be found. this is only
3922                  * bad, if we have never seen the clock in the SYNC
3923                  * state, where the PHASE and EPOCH are correct.
3924                  * for reporting events the above business does not
3925                  * really matter, but we can use the time code
3926                  * even in the POWERUP state after having seen
3927                  * the clock in the synchronized state (PZF class
3928                  * receivers) unless we have had a telegram disruption
3929                  * after having seen the clock in the SYNC state. we
3930                  * thus require having seen the clock in SYNC state
3931                  * *after* having missed telegrams (noresponse) from
3932                  * the clock. one problem remains: we might use erroneously
3933                  * POWERUP data if the disruption is shorter than 1 polling
3934                  * interval. fortunately powerdowns last usually longer than 64
3935                  * seconds and the receiver is at least 2 minutes in the
3936                  * POWERUP or NOSYNC state before switching to SYNC
3937                  * for GPS receivers this can mean antenna problems and other causes.
3938                  * the additional grace period can be enables by a clock
3939                  * mode having the PARSE_F_POWERUPTRUST flag in cl_flag set.
3940                  */
3941                 parse_event(parse, CEVNT_FAULT);
3942                 NLOG(NLOG_CLOCKSTATUS)
3943                         ERR(ERR_BADSTATUS)
3944                         msyslog(LOG_ERR,"PARSE receiver #%d: NOT SYNCHRONIZED/RECEIVER PROBLEMS",
3945                                 CLK_UNIT(parse->peer));
3946         }
3947         else
3948         {
3949                 /*
3950                  * we have two states left
3951                  *
3952                  * SYNC:
3953                  *  this state means that the EPOCH (timecode) and PHASE
3954                  *  information has be read correctly (at least two
3955                  *  successive PARSE timecodes were received correctly)
3956                  *  this is the best possible state - full trust
3957                  *
3958                  * NOSYNC:
3959                  *  The clock should be on phase with respect to the second
3960                  *  signal, but the timecode has not been received correctly within
3961                  *  at least the last two minutes. this is a sort of half baked state
3962                  *  for PARSE Meinberg DCF77 clocks this is bad news (clock running
3963                  *  without timecode confirmation)
3964                  *  PZF 535 has also no time confirmation, but the phase should be
3965                  *  very precise as the PZF signal can be decoded
3966                  */
3967
3968                 if (PARSE_SYNC(parsetime->parse_state))
3969                 {
3970                         /*
3971                          * currently completely synchronized - best possible state
3972                          */
3973                         parse->lastsync = current_time;
3974                         clear_err(parse, ERR_BADSTATUS);
3975                 }
3976                 else
3977                 {
3978                         /*
3979                          * we have had some problems receiving the time code
3980                          */
3981                         parse_event(parse, CEVNT_PROP);
3982                         NLOG(NLOG_CLOCKSTATUS)
3983                                 ERR(ERR_BADSTATUS)
3984                                 msyslog(LOG_ERR,"PARSE receiver #%d: TIMECODE NOT CONFIRMED",
3985                                         CLK_UNIT(parse->peer));
3986                 }
3987         }
3988
3989         fudge = parse->generic->fudgetime1; /* standard RS232 Fudgefactor */
3990
3991         if (PARSE_TIMECODE(parsetime->parse_state))
3992         {
3993                 rectime = parsetime->parse_stime.fp;
3994                 off = reftime = parsetime->parse_time.fp;
3995
3996                 L_SUB(&off, &rectime); /* prepare for PPS adjustments logic */
3997
3998 #ifdef DEBUG
3999                 if (debug > 3)
4000                         printf("PARSE receiver #%d: Reftime %s, Recvtime %s - initial offset %s\n",
4001                                CLK_UNIT(parse->peer),
4002                                prettydate(&reftime),
4003                                prettydate(&rectime),
4004                                lfptoa(&off,6));
4005 #endif
4006         }
4007
4008         if (PARSE_PPS(parsetime->parse_state) && CLK_PPS(parse->peer))
4009         {
4010                 l_fp offset;
4011                 double ppsphaseadjust = parse->ppsphaseadjust;
4012
4013 #ifdef HAVE_PPSAPI
4014                 /*
4015                  * set fudge = 0.0 if already included in PPS time stamps
4016                  */
4017                 if (parse->atom.pps_params.mode & (PPS_OFFSETCLEAR|PPS_OFFSETASSERT))
4018                         {
4019                                 ppsphaseadjust = 0.0;
4020                         }
4021 #endif
4022
4023                 /*
4024                  * we have a PPS signal - much better than the RS232 stuff (we hope)
4025                  */
4026                 offset = parsetime->parse_ptime.fp;
4027
4028 #ifdef DEBUG
4029                 if (debug > 3)
4030                         printf("PARSE receiver #%d: PPStime %s\n",
4031                                 CLK_UNIT(parse->peer),
4032                                 prettydate(&offset));
4033 #endif
4034                 if (PARSE_TIMECODE(parsetime->parse_state))
4035                 {
4036                         if (M_ISGEQ(off.l_i, off.l_uf, -1, 0x80000000) &&
4037                             M_ISGEQ(0, 0x7fffffff, off.l_i, off.l_uf))
4038                         {
4039                                 fudge = ppsphaseadjust; /* pick PPS fudge factor */
4040
4041                                 /*
4042                                  * RS232 offsets within [-0.5..0.5[ - take PPS offsets
4043                                  */
4044
4045                                 if (parse->parse_type->cl_flags & PARSE_F_PPSONSECOND)
4046                                 {
4047                                         reftime = off = offset;
4048                                         if (reftime.l_uf & 0x80000000)
4049                                                 reftime.l_ui++;
4050                                         reftime.l_uf = 0;
4051
4052
4053                                         /*
4054                                          * implied on second offset
4055                                          */
4056                                         off.l_uf = ~off.l_uf; /* map [0.5..1[ -> [-0.5..0[ */
4057                                         off.l_i = (off.l_uf & 0x80000000) ? -1 : 0; /* sign extend */
4058                                 }
4059                                 else
4060                                 {
4061                                         /*
4062                                          * time code describes pulse
4063                                          */
4064                                         reftime = off = parsetime->parse_time.fp;
4065
4066                                         L_SUB(&off, &offset); /* true offset */
4067                                 }
4068                         }
4069                         /*
4070                          * take RS232 offset when PPS when out of bounds
4071                          */
4072                 }
4073                 else
4074                 {
4075                         fudge = ppsphaseadjust; /* pick PPS fudge factor */
4076                         /*
4077                          * Well, no time code to guide us - assume on second pulse
4078                          * and pray, that we are within [-0.5..0.5[
4079                          */
4080                         off = offset;
4081                         reftime = offset;
4082                         if (reftime.l_uf & 0x80000000)
4083                                 reftime.l_ui++;
4084                         reftime.l_uf = 0;
4085                         /*
4086                          * implied on second offset
4087                          */
4088                         off.l_uf = ~off.l_uf; /* map [0.5..1[ -> [-0.5..0[ */
4089                         off.l_i = (off.l_uf & 0x80000000) ? -1 : 0; /* sign extend */
4090                 }
4091         }
4092         else
4093         {
4094                 if (!PARSE_TIMECODE(parsetime->parse_state))
4095                 {
4096                         /*
4097                          * Well, no PPS, no TIMECODE, no more work ...
4098                          */
4099                         if ((parsetime->parse_status & CVT_ADDITIONAL) &&
4100                             parse->parse_type->cl_message)
4101                                 parse->parse_type->cl_message(parse, parsetime);
4102                         return;
4103                 }
4104         }
4105
4106 #ifdef DEBUG
4107         if (debug > 3)
4108                 printf("PARSE receiver #%d: Reftime %s, Recvtime %s - final offset %s\n",
4109                         CLK_UNIT(parse->peer),
4110                         prettydate(&reftime),
4111                         prettydate(&rectime),
4112                         lfptoa(&off,6));
4113 #endif
4114
4115
4116         rectime = reftime;
4117         L_SUB(&rectime, &off);  /* just to keep the ntp interface happy */
4118
4119 #ifdef DEBUG
4120         if (debug > 3)
4121                 printf("PARSE receiver #%d: calculated Reftime %s, Recvtime %s\n",
4122                         CLK_UNIT(parse->peer),
4123                         prettydate(&reftime),
4124                         prettydate(&rectime));
4125 #endif
4126
4127         if ((parsetime->parse_status & CVT_ADDITIONAL) &&
4128             parse->parse_type->cl_message)
4129                 parse->parse_type->cl_message(parse, parsetime);
4130
4131         if (PARSE_SYNC(parsetime->parse_state))
4132         {
4133                 /*
4134                  * log OK status
4135                  */
4136                 parse_event(parse, CEVNT_NOMINAL);
4137         }
4138
4139         clear_err(parse, ERR_BADIO);
4140         clear_err(parse, ERR_BADDATA);
4141         clear_err(parse, ERR_NODATA);
4142         clear_err(parse, ERR_INTERNAL);
4143
4144         /*
4145          * and now stick it into the clock machine
4146          * samples are only valid iff lastsync is not too old and
4147          * we have seen the clock in sync at least once
4148          * after the last time we didn't see an expected data telegram
4149          * at startup being not in sync is also bad just like
4150          * POWERUP state unless PARSE_F_POWERUPTRUST is set
4151          * see the clock states section above for more reasoning
4152          */
4153         if (((current_time - parse->lastsync) > parse->maxunsync)           ||
4154             (parse->lastsync < parse->lastmissed)                           ||
4155             ((parse->lastsync == 0) && !PARSE_SYNC(parsetime->parse_state)) ||
4156             (((parse->parse_type->cl_flags & PARSE_F_POWERUPTRUST) == 0) &&
4157              PARSE_POWERUP(parsetime->parse_state)))
4158         {
4159                 parse->generic->leap = LEAP_NOTINSYNC;
4160                 parse->lastsync = 0;    /* wait for full sync again */
4161         }
4162         else
4163         {
4164                 if (PARSE_LEAPADD(parsetime->parse_state))
4165                 {
4166                         /*
4167                          * we pick this state also for time code that pass leap warnings
4168                          * without direction information (as earth is currently slowing
4169                          * down).
4170                          */
4171                         parse->generic->leap = (parse->flags & PARSE_LEAP_DELETE) ? LEAP_DELSECOND : LEAP_ADDSECOND;
4172                 }
4173                 else
4174                     if (PARSE_LEAPDEL(parsetime->parse_state))
4175                     {
4176                             parse->generic->leap = LEAP_DELSECOND;
4177                     }
4178                     else
4179                     {
4180                             parse->generic->leap = LEAP_NOWARNING;
4181                     }
4182         }
4183
4184         if (parse->generic->leap != LEAP_NOTINSYNC)
4185         {
4186                 /*
4187                  * only good/trusted samples are interesting
4188                  */
4189 #ifdef DEBUG
4190                 if (debug > 2)
4191                         {
4192                                        printf("PARSE receiver #%d: refclock_process_offset(reftime=%s, rectime=%s, Fudge=%f)\n",
4193                                        CLK_UNIT(parse->peer),
4194                                        prettydate(&reftime),
4195                                        prettydate(&rectime),
4196                                        fudge);
4197                         }
4198 #endif
4199                 parse->generic->lastref = reftime;
4200
4201                 refclock_process_offset(parse->generic, reftime, rectime, fudge);
4202
4203 #ifdef HAVE_PPSAPI
4204                 /*
4205                  * pass PPS information on to PPS clock
4206                  */
4207                 if (PARSE_PPS(parsetime->parse_state) && CLK_PPS(parse->peer))
4208                         {
4209                                 parse->peer->flags |= (FLAG_PPS | FLAG_TSTAMP_PPS);
4210                                 parse_hardpps(parse, PARSE_HARDPPS_ENABLE);
4211                         }
4212 #endif
4213         } else {
4214                 parse_hardpps(parse, PARSE_HARDPPS_DISABLE);
4215                 parse->peer->flags &= ~(FLAG_PPS | FLAG_TSTAMP_PPS);
4216         }
4217
4218         /*
4219          * ready, unless the machine wants a sample or
4220          * we are in fast startup mode (peer->dist > MAXDISTANCE)
4221          */
4222         if (!parse->pollneeddata && parse->peer->disp <= MAXDISTANCE)
4223             return;
4224
4225         parse->pollneeddata = 0;
4226
4227         parse->timedata.parse_state &= ~(unsigned)(PARSEB_PPS|PARSEB_S_PPS);
4228
4229         refclock_receive(parse->peer);
4230 }
4231
4232 /**===========================================================================
4233  ** special code for special clocks
4234  **/
4235
4236 static void
4237 mk_utcinfo(
4238            char *t,  /* pointer to the output string buffer */
4239            uint16_t wnt,
4240            uint16_t wnlsf,
4241            int dn,
4242            int dtls,
4243            int dtlsf,
4244            int size  /* size of the output string buffer */
4245            )
4246 {
4247         /*
4248          * The week number transmitted by the GPS satellites for the leap date
4249          * is truncated to 8 bits only. If the nearest leap second date is off
4250          * the current date by more than +/- 128 weeks then conversion to a
4251          * calendar date is ambiguous. On the other hand, if a leap second is
4252          * currently being announced (i.e. dtlsf != dtls) then the week number
4253          * wnlsf is close enough, and we can unambiguously determine the date
4254          * for which the leap second is scheduled.
4255          */
4256         if ( dtlsf != dtls )
4257         {
4258                 time_t t_ls;
4259                 struct tm *tm;
4260                 int nc;
4261
4262                 wnlsf = basedate_expand_gpsweek(wnlsf);
4263                 /* 'wnt' not used here: would need the same treatment as 'wnlsf */
4264
4265                 t_ls = (time_t) wnlsf * SECSPERWEEK
4266                         + (time_t) dn * SECSPERDAY
4267                         + GPS_SEC_BIAS - 1;
4268
4269                 tm = gmtime( &t_ls );
4270                 if (tm == NULL)  /* gmtime() failed */
4271                 {
4272                         snprintf( t, size, "** (gmtime() failed in mk_utcinfo())" );
4273                         return;
4274                 }
4275
4276                 nc = snprintf( t, size, "UTC offset transition from %is to %is due to leap second %s",
4277                                 dtls, dtlsf, ( dtls < dtlsf ) ? "insertion" : "deletion" );
4278                 if (nc < 0)
4279                         nc = strlen(t);
4280                 else if (nc > size)
4281                         nc = size;
4282
4283                 snprintf( t + nc, size - nc, " at UTC midnight at the end of %s, %04i-%02i-%02i",
4284                                 daynames[tm->tm_wday], tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday );
4285         }
4286         else
4287         {
4288                 snprintf( t, size, "UTC offset parameter: %is, no leap second announced.\n", dtls );
4289         }
4290
4291 }
4292
4293 #ifdef CLOCK_MEINBERG
4294 /**===========================================================================
4295  ** Meinberg GPS receiver support
4296  **/
4297
4298 /*------------------------------------------------------------
4299  * gps16x_message - process messages from Meinberg GPS receiver
4300  */
4301 static void
4302 gps16x_message(
4303                struct parseunit *parse,
4304                parsetime_t      *parsetime
4305                )
4306 {
4307         if (parse->timedata.parse_msglen && parsetime->parse_msg[0] == SOH)
4308         {
4309                 GPS_MSG_HDR header;
4310                 unsigned char *bufp = (unsigned char *)parsetime->parse_msg + 1;
4311
4312 #ifdef DEBUG
4313                 if (debug > 2)
4314                 {
4315                         char msgbuffer[600];
4316
4317                         mkreadable(msgbuffer, sizeof(msgbuffer), (char *)parsetime->parse_msg, parsetime->parse_msglen, 1);
4318                         printf("PARSE receiver #%d: received message (%d bytes) >%s<\n",
4319                                 CLK_UNIT(parse->peer),
4320                                 parsetime->parse_msglen,
4321                                 msgbuffer);
4322                 }
4323 #endif
4324                 get_mbg_header(&bufp, &header);
4325                 if (header.hdr_csum == mbg_csum(parsetime->parse_msg + 1, 6) &&
4326                     (header.len == 0 ||
4327                      (header.len < sizeof(parsetime->parse_msg) &&
4328                       header.data_csum == mbg_csum(bufp, header.len))))
4329                 {
4330                         /*
4331                          * clean message
4332                          */
4333                         switch (header.cmd)
4334                         {
4335                         case GPS_SW_REV:
4336                                 {
4337                                         char buffer[64];
4338                                         SW_REV gps_sw_rev;
4339
4340                                         get_mbg_sw_rev(&bufp, &gps_sw_rev);
4341                                         snprintf(buffer, sizeof(buffer), "meinberg_gps_version=\"%x.%02x%s%s\"",
4342                                                 (gps_sw_rev.code >> 8) & 0xFF,
4343                                                 gps_sw_rev.code & 0xFF,
4344                                                 gps_sw_rev.name[0] ? " " : "",
4345                                                 gps_sw_rev.name);
4346                                         set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4347                                 }
4348                         break;
4349
4350                         case GPS_BVAR_STAT:
4351                                 {
4352                                         static struct state
4353                                         {
4354                                                 BVAR_STAT flag; /* status flag */
4355                                                 const char *string; /* bit name */
4356                                         } states[] =
4357                                           {
4358                                                   { BVAR_CFGH_INVALID,     "Configuration/Health" },
4359                                                   { BVAR_ALM_NOT_COMPLETE, "Almanachs" },
4360                                                   { BVAR_UTC_INVALID,      "UTC Correction" },
4361                                                   { BVAR_IONO_INVALID,     "Ionospheric Correction" },
4362                                                   { BVAR_RCVR_POS_INVALID, "Receiver Position" },
4363                                                   { 0, "" }
4364                                           };
4365                                         BVAR_STAT status;
4366                                         struct state *s = states;
4367                                         char buffer[512];
4368                                         char *p, *b;
4369
4370                                         status = (BVAR_STAT) get_lsb_short(&bufp);
4371                                         p = b = buffer;
4372                                         p = ap(buffer, sizeof(buffer), p,
4373                                             "meinberg_gps_status=\"[0x%04x] ",
4374                                             status);
4375
4376                                         if (status)
4377                                         {
4378                                                 p = ap(buffer, sizeof(buffer), p, "incomplete buffered data: ");
4379                                                 b = p;
4380                                                 while (s->flag)
4381                                                 {
4382                                                         if (status & s->flag)
4383                                                         {
4384                                                                 if (p != b)
4385                                                                 {
4386                                                                         p = ap(buffer, sizeof(buffer), p, ", ");
4387                                                                 }
4388
4389                                                                 p = ap(buffer, sizeof(buffer), p, "%s", (const char *)s->string);
4390                                                         }
4391                                                         s++;
4392                                                 }
4393                                                 p = ap(buffer, sizeof(buffer), p, "\"");
4394                                         }
4395                                         else
4396                                         {
4397                                                 p = ap(buffer, sizeof(buffer), p, "<all buffered data complete>\"");
4398                                         }
4399
4400                                         set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4401                                 }
4402                         break;
4403
4404                         case GPS_POS_XYZ:
4405                                 {
4406                                         XYZ xyz;
4407                                         char buffer[256];
4408
4409                                         get_mbg_xyz(&bufp, xyz);
4410                                         snprintf(buffer, sizeof(buffer), "gps_position(XYZ)=\"%s m, %s m, %s m\"",
4411                                                 mfptoa(xyz[XP].l_ui, xyz[XP].l_uf, 1),
4412                                                 mfptoa(xyz[YP].l_ui, xyz[YP].l_uf, 1),
4413                                                 mfptoa(xyz[ZP].l_ui, xyz[ZP].l_uf, 1));
4414
4415                                         set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4416                                 }
4417                         break;
4418
4419                         case GPS_POS_LLA:
4420                                 {
4421                                         LLA lla;
4422                                         char buffer[256];
4423
4424                                         get_mbg_lla(&bufp, lla);
4425
4426                                         snprintf(buffer, sizeof(buffer), "gps_position(LLA)=\"%s deg, %s deg, %s m\"",
4427                                                 mfptoa(lla[LAT].l_ui, lla[LAT].l_uf, 4),
4428                                                 mfptoa(lla[LON].l_ui, lla[LON].l_uf, 4),
4429                                                 mfptoa(lla[ALT].l_ui, lla[ALT].l_uf, 1));
4430
4431                                         set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4432                                 }
4433                         break;
4434
4435                         case GPS_TZDL:
4436                                 break;
4437
4438                         case GPS_PORT_PARM:
4439                                 break;
4440
4441                         case GPS_SYNTH:
4442                                 break;
4443
4444                         case GPS_ANT_INFO:
4445                                 {
4446                                         ANT_INFO antinfo;
4447                                         char buffer[512];
4448                                         char *p, *q;
4449
4450                                         get_mbg_antinfo(&bufp, &antinfo);
4451                                         p = buffer;
4452                                         p = ap(buffer, sizeof(buffer), p, "meinberg_antenna_status=\"");
4453                                         switch (antinfo.status)
4454                                         {
4455                                         case ANT_INVALID: // No other fields valid since antenna has not yet been disconnected
4456                                                 p = ap(buffer, sizeof(buffer),
4457                                                     p, "<OK>");
4458                                                 break;
4459
4460                                         case ANT_DISCONN: // Antenna is disconnected, tm_reconn and delta_t not yet set
4461                                                 q = ap(buffer, sizeof(buffer),
4462                                                     p, "DISCONNECTED since ");
4463                                                 NLOG(NLOG_CLOCKSTATUS)
4464                                                         ERR(ERR_BADSTATUS)
4465                                                         msyslog(LOG_ERR,"PARSE receiver #%d: ANTENNA FAILURE: %s",
4466                                                                 CLK_UNIT(parse->peer), p);
4467
4468                                                 p = q;
4469                                                 mbg_tm_str(&p, &antinfo.tm_disconn, BUFFER_SIZE(buffer, p), 0);
4470                                                 *p = '\0';
4471                                                 break;
4472
4473                                         case ANT_RECONN: // Antenna had been disconnect, but receiver sync. after reconnect, so all fields valid
4474                                                 p = ap(buffer, sizeof(buffer),
4475                                                     p, "SYNC AFTER RECONNECT on ");
4476                                                 mbg_tm_str(&p, &antinfo.tm_reconn, BUFFER_SIZE(buffer, p), 0);
4477                                                 p = ap(buffer, sizeof(buffer),
4478                                                         p, ", clock offset at reconnect %c%ld.%07ld s, disconnect time ",
4479                                                         (antinfo.delta_t < 0) ? '-' : '+',
4480                                                         (long) ABS(antinfo.delta_t) / 10000,
4481                                                         (long) ABS(antinfo.delta_t) % 10000);
4482                                                 mbg_tm_str(&p, &antinfo.tm_disconn, BUFFER_SIZE(buffer, p), 0);
4483                                                 *p = '\0';
4484                                                 break;
4485
4486                                         default:
4487                                                 p = ap(buffer, sizeof(buffer),
4488                                                     p, "bad status 0x%04x",
4489                                                     antinfo.status);
4490                                                 break;
4491                                         }
4492
4493                                         p = ap(buffer, sizeof(buffer), p, "\"");
4494
4495                                         set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4496                                 }
4497                         break;
4498
4499                         case GPS_UCAP:
4500                                 break;
4501
4502                         case GPS_CFGH:
4503                                 {
4504                                         CFGH cfgh;
4505                                         char buffer[512];
4506                                         char *p;
4507
4508                                         get_mbg_cfgh(&bufp, &cfgh);
4509                                         if (cfgh.valid)
4510                                         {
4511                                                 const char *cp;
4512                                                 uint16_t tmp_val;
4513                                                 int i;
4514
4515                                                 p = buffer;
4516                                                 p = ap(buffer, sizeof(buffer),
4517                                                     p, "gps_tot_51=\"");
4518                                                 mbg_tgps_str(&p, &cfgh.tot_51, BUFFER_SIZE(buffer, p));
4519                                                 p = ap(buffer, sizeof(buffer),
4520                                                     p, "\"");
4521                                                 set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
4522
4523                                                 p = buffer;
4524                                                 p = ap(buffer, sizeof(buffer),
4525                                                     p, "gps_tot_63=\"");
4526                                                 mbg_tgps_str(&p, &cfgh.tot_63, BUFFER_SIZE(buffer, p));
4527                                                 p = ap(buffer, sizeof(buffer),
4528                                                     p, "\"");
4529                                                 set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
4530
4531                                                 p = buffer;
4532                                                 p = ap(buffer, sizeof(buffer),
4533                                                     p, "gps_t0a=\"");
4534                                                 mbg_tgps_str(&p, &cfgh.t0a, BUFFER_SIZE(buffer, p));
4535                                                 p = ap(buffer, sizeof(buffer),
4536                                                     p, "\"");
4537                                                 set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
4538
4539                                                 for (i = 0; i < N_SVNO_GPS; i++)
4540                                                 {
4541                                                         p = buffer;
4542                                                         p = ap(buffer, sizeof(buffer), p, "sv_info[%d]=\"PRN%d", i, i + N_SVNO_GPS);
4543
4544                                                         tmp_val = cfgh.health[i];  /* a 6 bit SV health code */
4545                                                         p = ap(buffer, sizeof(buffer), p, "; health=0x%02x (", tmp_val);
4546                                                         /* "All Ones" has a special meaning" */
4547                                                         if (tmp_val == 0x3F) /* satellite is unusable or doesn't even exist */
4548                                                                 cp = "SV UNAVAILABLE";
4549                                                         else {
4550                                                                 /* The MSB contains a summary of the 3 MSBs of the 8 bit health code,
4551                                                                  * indicating if the data sent by the satellite is OK or not. */
4552                                                                 p = ap(buffer, sizeof(buffer), p, "DATA %s, ", (tmp_val & 0x20) ? "BAD" : "OK" );
4553
4554                                                                 /* The 5 LSBs contain the status of the different signals sent by the satellite. */
4555                                                                 switch (tmp_val & 0x1F)
4556                                                                 {
4557                                                                         case 0x00: cp = "SIGNAL OK";              break;
4558                                                                         /* codes 0x01 through 0x1B indicate that one or more
4559                                                                          * specific signal components are weak or dead.
4560                                                                          * We don't decode this here in detail. */
4561                                                                         case 0x1C: cp = "SV IS TEMP OUT";         break;
4562                                                                         case 0x1D: cp = "SV WILL BE TEMP OUT";    break;
4563                                                                         default:   cp = "TRANSMISSION PROBLEMS";  break;
4564                                                                 }
4565                                                         }
4566                                                         p = ap(buffer, sizeof(buffer), p, "%s)", cp );
4567
4568                                                         tmp_val = cfgh.cfg[i];  /* a 4 bit SV configuration/type code */
4569                                                         p = ap(buffer, sizeof(buffer), p, "; cfg=0x%02x (", tmp_val);
4570                                                         switch (tmp_val & 0x7)
4571                                                         {
4572                                                                 case 0x00:  cp = "(reserved)";        break;
4573                                                                 case 0x01:  cp = "BLOCK II/IIA/IIR";  break;
4574                                                                 case 0x02:  cp = "BLOCK IIR-M";       break;
4575                                                                 case 0x03:  cp = "BLOCK IIF";         break;
4576                                                                 case 0x04:  cp = "BLOCK III";         break;
4577                                                                 default:   cp = "unknown SV type";   break;
4578                                                         }
4579                                                         p = ap(buffer, sizeof(buffer), p, "%s", cp );
4580                                                         if (tmp_val & 0x08)  /* A-S is on, P-code is encrypted */
4581                                                                 p = ap( buffer, sizeof(buffer), p, ", A-S on" );
4582
4583                                                         p = ap(buffer, sizeof(buffer), p, ")\"");
4584                                                         set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
4585                                                 }
4586                                         }
4587                                 }
4588                         break;
4589
4590                         case GPS_ALM:
4591                                 break;
4592
4593                         case GPS_EPH:
4594                                 break;
4595
4596                         case GPS_UTC:
4597                                 {
4598                                         UTC utc;
4599                                         char buffer[512];
4600                                         char *p;
4601
4602                                         p = buffer;
4603
4604                                         get_mbg_utc(&bufp, &utc);
4605
4606                                         if (utc.valid)
4607                                         {
4608                                                 p = ap(buffer, sizeof(buffer), p, "gps_utc_correction=\"");
4609                                                 mk_utcinfo(p, utc.t0t.wn, utc.WNlsf, utc.DNt, utc.delta_tls, utc.delta_tlsf, BUFFER_SIZE(buffer, p));
4610                                                 p += strlen(p);
4611                                                 p = ap(buffer, sizeof(buffer), p, "\"");
4612                                         }
4613                                         else
4614                                         {
4615                                                 p = ap(buffer, sizeof(buffer), p, "gps_utc_correction=\"<NO UTC DATA>\"");
4616                                         }
4617                                         set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4618                                 }
4619                         break;
4620
4621                         case GPS_IONO:
4622                                 break;
4623
4624                         case GPS_ASCII_MSG:
4625                                 {
4626                                         ASCII_MSG gps_ascii_msg;
4627                                         char buffer[128];
4628
4629                                         get_mbg_ascii_msg(&bufp, &gps_ascii_msg);
4630
4631                                         if (gps_ascii_msg.valid)
4632                                                 {
4633                                                         char buffer1[128];
4634                                                         mkreadable(buffer1, sizeof(buffer1), gps_ascii_msg.s, strlen(gps_ascii_msg.s), (int)0);
4635
4636                                                         snprintf(buffer, sizeof(buffer), "gps_message=\"%s\"", buffer1);
4637                                                 }
4638                                         else
4639                                                 snprintf(buffer, sizeof(buffer), "gps_message=<NONE>");
4640
4641                                         set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4642                                 }
4643
4644                         break;
4645
4646                         default:
4647                                 break;
4648                         }
4649                 }
4650                 else
4651                 {
4652                         msyslog(LOG_DEBUG, "PARSE receiver #%d: gps16x_message: message checksum error: hdr_csum = 0x%x (expected 0x%x), "
4653                                            "data_len = %d, data_csum = 0x%x (expected 0x%x)",
4654                                 CLK_UNIT(parse->peer),
4655                                 header.hdr_csum, mbg_csum(parsetime->parse_msg + 1, 6),
4656                                 header.len,
4657                                 header.data_csum, mbg_csum(bufp, (unsigned)((header.len < sizeof(parsetime->parse_msg)) ? header.len : 0)));
4658                 }
4659         }
4660
4661         return;
4662 }
4663
4664 /*------------------------------------------------------------
4665  * gps16x_poll - query the reciver peridically
4666  */
4667 static void
4668 gps16x_poll(
4669             struct peer *peer
4670             )
4671 {
4672         struct parseunit *parse = peer->procptr->unitptr;
4673
4674         static GPS_MSG_HDR sequence[] =
4675         {
4676                 { GPS_SW_REV,          0, 0, 0 },
4677                 { GPS_BVAR_STAT,       0, 0, 0 },
4678                 { GPS_UTC,             0, 0, 0 },
4679                 { GPS_ASCII_MSG,       0, 0, 0 },
4680                 { GPS_ANT_INFO,        0, 0, 0 },
4681                 { GPS_CFGH,            0, 0, 0 },
4682                 { GPS_POS_XYZ,         0, 0, 0 },
4683                 { GPS_POS_LLA,         0, 0, 0 },
4684                 { (unsigned short)~0,  0, 0, 0 }
4685         };
4686
4687         int rtc;
4688         unsigned char cmd_buffer[64];
4689         unsigned char *outp = cmd_buffer;
4690         GPS_MSG_HDR *header;
4691
4692         if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4693         {
4694                 parse->peer->procptr->nextaction = current_time + ((poll_info_t *)parse->parse_type->cl_data)->rate;
4695         }
4696
4697         if (sequence[parse->localstate].cmd == (unsigned short)~0)
4698                 parse->localstate = 0;
4699
4700         header = sequence + parse->localstate++;
4701
4702         *outp++ = SOH;          /* start command */
4703
4704         put_mbg_header(&outp, header);
4705         outp = cmd_buffer + 1;
4706
4707         header->hdr_csum = (short)mbg_csum(outp, 6);
4708         put_mbg_header(&outp, header);
4709
4710 #ifdef DEBUG
4711         if (debug > 2)
4712         {
4713                 char buffer[128];
4714
4715                 mkreadable(buffer, sizeof(buffer), (char *)cmd_buffer, (unsigned)(outp - cmd_buffer), 1);
4716                 printf("PARSE receiver #%d: transmitted message #%ld (%d bytes) >%s<\n",
4717                        CLK_UNIT(parse->peer),
4718                        parse->localstate - 1,
4719                        (int)(outp - cmd_buffer),
4720                        buffer);
4721         }
4722 #endif
4723
4724         rtc = (int) write(parse->generic->io.fd, cmd_buffer, (unsigned long)(outp - cmd_buffer));
4725
4726         if (rtc < 0)
4727         {
4728                 ERR(ERR_BADIO)
4729                         msyslog(LOG_ERR, "PARSE receiver #%d: gps16x_poll: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4730         }
4731         else
4732         if (rtc != outp - cmd_buffer)
4733         {
4734                 ERR(ERR_BADIO)
4735                         msyslog(LOG_ERR, "PARSE receiver #%d: gps16x_poll: failed to send cmd incomplete (%d of %d bytes sent)", CLK_UNIT(parse->peer), rtc, (int)(outp - cmd_buffer));
4736         }
4737
4738         clear_err(parse, ERR_BADIO);
4739         return;
4740 }
4741
4742 /*--------------------------------------------------
4743  * init routine - setup timer
4744  */
4745 static int
4746 gps16x_poll_init(
4747         struct parseunit *parse
4748         )
4749 {
4750         if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4751         {
4752                 parse->peer->procptr->action = gps16x_poll;
4753                 gps16x_poll(parse->peer);
4754         }
4755
4756         return 0;
4757 }
4758
4759 #else
4760 static void
4761 gps16x_message(
4762                struct parseunit *parse,
4763                parsetime_t      *parsetime
4764                )
4765 {}
4766 static int
4767 gps16x_poll_init(
4768         struct parseunit *parse
4769         )
4770 {
4771         return 1;
4772 }
4773 #endif /* CLOCK_MEINBERG */
4774
4775 /**===========================================================================
4776  ** clock polling support
4777  **/
4778
4779 /*--------------------------------------------------
4780  * direct poll routine
4781  */
4782 static void
4783 poll_dpoll(
4784         struct parseunit *parse
4785         )
4786 {
4787         long rtc;
4788         const char *ps = ((poll_info_t *)parse->parse_type->cl_data)->string;
4789         long ct = ((poll_info_t *)parse->parse_type->cl_data)->count;
4790
4791         rtc = write(parse->generic->io.fd, ps, ct);
4792         if (rtc < 0)
4793         {
4794                 ERR(ERR_BADIO)
4795                         msyslog(LOG_ERR, "PARSE receiver #%d: poll_dpoll: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4796         }
4797         else
4798             if (rtc != ct)
4799             {
4800                     ERR(ERR_BADIO)
4801                             msyslog(LOG_ERR, "PARSE receiver #%d: poll_dpoll: failed to send cmd incomplete (%ld of %ld bytes sent)", CLK_UNIT(parse->peer), rtc, ct);
4802             }
4803         clear_err(parse, ERR_BADIO);
4804 }
4805
4806 /*--------------------------------------------------
4807  * periodic poll routine
4808  */
4809 static void
4810 poll_poll(
4811         struct peer *peer
4812         )
4813 {
4814         struct parseunit *parse = peer->procptr->unitptr;
4815
4816         if (parse->parse_type->cl_poll)
4817                 parse->parse_type->cl_poll(parse);
4818
4819         if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4820         {
4821                 parse->peer->procptr->nextaction = current_time + ((poll_info_t *)parse->parse_type->cl_data)->rate;
4822         }
4823 }
4824
4825 /*--------------------------------------------------
4826  * init routine - setup timer
4827  */
4828 static int
4829 poll_init(
4830         struct parseunit *parse
4831         )
4832 {
4833         if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4834         {
4835                 parse->peer->procptr->action = poll_poll;
4836                 poll_poll(parse->peer);
4837         }
4838
4839         return 0;
4840 }
4841
4842 /**===========================================================================
4843  ** Trimble support
4844  **/
4845
4846 /*-------------------------------------------------------------
4847  * trimble TAIP init routine - setup EOL and then do poll_init.
4848  */
4849 static int
4850 trimbletaip_init(
4851         struct parseunit *parse
4852         )
4853 {
4854 #ifdef HAVE_TERMIOS
4855         struct termios tio;
4856 #endif
4857 #ifdef HAVE_SYSV_TTYS
4858         struct termio tio;
4859 #endif
4860         /*
4861          * configure terminal line for trimble receiver
4862          */
4863         if (TTY_GETATTR(parse->generic->io.fd, &tio) == -1)
4864         {
4865                 msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_init: tcgetattr(fd, &tio): %m", CLK_UNIT(parse->peer));
4866                 return 0;
4867         }
4868         else
4869         {
4870                 tio.c_cc[VEOL] = TRIMBLETAIP_EOL;
4871
4872                 if (TTY_SETATTR(parse->generic->io.fd, &tio) == -1)
4873                 {
4874                         msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_init: tcsetattr(fd, &tio): %m", CLK_UNIT(parse->peer));
4875                         return 0;
4876                 }
4877         }
4878         return poll_init(parse);
4879 }
4880
4881 /*--------------------------------------------------
4882  * trimble TAIP event routine - reset receiver upon data format trouble
4883  */
4884 static const char *taipinit[] = {
4885         ">FPV00000000<",
4886         ">SRM;ID_FLAG=F;CS_FLAG=T;EC_FLAG=F;FR_FLAG=T;CR_FLAG=F<",
4887         ">FTM00020001<",
4888         (char *)0
4889 };
4890
4891 static void
4892 trimbletaip_event(
4893         struct parseunit *parse,
4894         int event
4895         )
4896 {
4897         switch (event)
4898         {
4899             case CEVNT_BADREPLY:        /* reset on garbled input */
4900             case CEVNT_TIMEOUT:         /* reset on no input */
4901                     {
4902                             const char **iv;
4903
4904                             iv = taipinit;
4905                             while (*iv)
4906                             {
4907                                     int rtc = (int) write(parse->generic->io.fd, *iv, strlen(*iv));
4908                                     if (rtc < 0)
4909                                     {
4910                                             msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4911                                             return;
4912                                     }
4913                                     else
4914                                     {
4915                                             if (rtc != (int)strlen(*iv))
4916                                             {
4917                                                     msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: failed to send cmd incomplete (%d of %d bytes sent)",
4918                                                             CLK_UNIT(parse->peer), rtc, (int)strlen(*iv));
4919                                                     return;
4920                                             }
4921                                     }
4922                                     iv++;
4923                             }
4924
4925                             NLOG(NLOG_CLOCKINFO)
4926                                     ERR(ERR_BADIO)
4927                                     msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: RECEIVER INITIALIZED",
4928                                             CLK_UNIT(parse->peer));
4929                     }
4930                     break;
4931
4932             default:                    /* ignore */
4933                 break;
4934         }
4935 }
4936
4937 /*
4938  * This driver supports the Trimble SVee Six Plus GPS receiver module.
4939  * It should support other Trimble receivers which use the Trimble Standard
4940  * Interface Protocol (see below).
4941  *
4942  * The module has a serial I/O port for command/data and a 1 pulse-per-second
4943  * output, about 1 microsecond wide. The leading edge of the pulse is
4944  * coincident with the change of the GPS second. This is the same as
4945  * the change of the UTC second +/- ~1 microsecond. Some other clocks
4946  * specifically use a feature in the data message as a timing reference, but
4947  * the SVee Six Plus does not do this. In fact there is considerable jitter
4948  * on the timing of the messages, so this driver only supports the use
4949  * of the PPS pulse for accurate timing. Where it is determined that
4950  * the offset is way off, when first starting up ntpd for example,
4951  * the timing of the data stream is used until the offset becomes low enough
4952  * (|offset| < CLOCK_MAX), at which point the pps offset is used.
4953  *
4954  * It can use either option for receiving PPS information - the 'ppsclock'
4955  * stream pushed onto the serial data interface to timestamp the Carrier
4956  * Detect interrupts, where the 1PPS connects to the CD line. This only
4957  * works on SunOS 4.1.x currently. To select this, define PPSPPS in
4958  * Config.local. The other option is to use a pulse-stretcher/level-converter
4959  * to convert the PPS pulse into a RS232 start pulse & feed this into another
4960  * tty port. To use this option, define PPSCLK in Config.local. The pps input,
4961  * by whichever method, is handled in ntp_loopfilter.c
4962  *
4963  * The receiver uses a serial message protocol called Trimble Standard
4964  * Interface Protocol (it can support others but this driver only supports
4965  * TSIP). Messages in this protocol have the following form:
4966  *
4967  * <DLE><id> ... <data> ... <DLE><ETX>
4968  *
4969  * Any bytes within the <data> portion of value 10 hex (<DLE>) are doubled
4970  * on transmission and compressed back to one on reception. Otherwise
4971  * the values of data bytes can be anything. The serial interface is RS-422
4972  * asynchronous using 9600 baud, 8 data bits with odd party (**note** 9 bits
4973  * in total!), and 1 stop bit. The protocol supports byte, integer, single,
4974  * and double datatypes. Integers are two bytes, sent most significant first.
4975  * Singles are IEEE754 single precision floating point numbers (4 byte) sent
4976  * sign & exponent first. Doubles are IEEE754 double precision floating point
4977  * numbers (8 byte) sent sign & exponent first.
4978  * The receiver supports a large set of messages, only a small subset of
4979  * which are used here. From driver to receiver the following are used:
4980  *
4981  *  ID    Description
4982  *
4983  *  21    Request current time
4984  *  22    Mode Select
4985  *  2C    Set/Request operating parameters
4986  *  2F    Request UTC info
4987  *  35    Set/Request I/O options
4988
4989  * From receiver to driver the following are recognised:
4990  *
4991  *  ID    Description
4992  *
4993  *  41    GPS Time
4994  *  44    Satellite selection, PDOP, mode
4995  *  46    Receiver health
4996  *  4B    Machine code/status
4997  *  4C    Report operating parameters (debug only)
4998  *  4F    UTC correction data (used to get leap second warnings)
4999  *  55    I/O options (debug only)
5000  *
5001  * All others are accepted but ignored.
5002  *
5003  */
5004
5005 #define PI              3.1415926535898 /* lots of sig figs */
5006 #define D2R             PI/180.0
5007
5008 /*-------------------------------------------------------------------
5009  * sendcmd, sendbyte, sendetx, sendflt, sendint implement the command
5010  * interface to the receiver.
5011  *
5012  * CAVEAT: the sendflt, sendint routines are byte order dependend and
5013  * float implementation dependend - these must be converted to portable
5014  * versions !
5015  *
5016  * CURRENT LIMITATION: float implementation. This runs only on systems
5017  * with IEEE754 floats as native floats
5018  */
5019
5020 typedef struct trimble
5021 {
5022         u_long last_msg;        /* last message received */
5023         u_long last_reset;      /* last time a reset was issued */
5024         u_char qtracking;       /* query tracking status */
5025         u_long ctrack;          /* current tracking set */
5026         u_long ltrack;          /* last tracking set */
5027 } trimble_t;
5028
5029 union uval {
5030         u_char  bd[8];
5031         int     iv;
5032         float   fv;
5033         double  dv;
5034 };
5035
5036 struct txbuf
5037 {
5038         short idx;                      /* index to first unused byte */
5039         u_char *txt;                    /* pointer to actual data buffer */
5040 };
5041
5042 void    sendcmd         (struct txbuf *buf, int c);
5043 void    sendbyte        (struct txbuf *buf, int b);
5044 void    sendetx         (struct txbuf *buf, struct parseunit *parse);
5045 void    sendint         (struct txbuf *buf, int a);
5046 void    sendflt         (struct txbuf *buf, double a);
5047
5048 void
5049 sendcmd(
5050         struct txbuf *buf,
5051         int c
5052         )
5053 {
5054         buf->txt[0] = DLE;
5055         buf->txt[1] = (u_char)c;
5056         buf->idx = 2;
5057 }
5058
5059 void    sendcmd         (struct txbuf *buf, int c);
5060 void    sendbyte        (struct txbuf *buf, int b);
5061 void    sendetx         (struct txbuf *buf, struct parseunit *parse);
5062 void    sendint         (struct txbuf *buf, int a);
5063 void    sendflt         (struct txbuf *buf, double a);
5064
5065 void
5066 sendbyte(
5067         struct txbuf *buf,
5068         int b
5069         )
5070 {
5071         if (b == DLE)
5072             buf->txt[buf->idx++] = DLE;
5073         buf->txt[buf->idx++] = (u_char)b;
5074 }
5075
5076 void
5077 sendetx(
5078         struct txbuf *buf,
5079         struct parseunit *parse
5080         )
5081 {
5082         buf->txt[buf->idx++] = DLE;
5083         buf->txt[buf->idx++] = ETX;
5084
5085         if (write(parse->generic->io.fd, buf->txt, (unsigned long)buf->idx) != buf->idx)
5086         {
5087                 ERR(ERR_BADIO)
5088                         msyslog(LOG_ERR, "PARSE receiver #%d: sendetx: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
5089         }
5090         else
5091         {
5092 #ifdef DEBUG
5093           if (debug > 2)
5094           {
5095                   char buffer[256];
5096
5097                   mkreadable(buffer, sizeof(buffer), (char *)buf->txt, (unsigned)buf->idx, 1);
5098                   printf("PARSE receiver #%d: transmitted message (%d bytes) >%s<\n",
5099                          CLK_UNIT(parse->peer),
5100                          buf->idx, buffer);
5101           }
5102 #endif
5103                 clear_err(parse, ERR_BADIO);
5104         }
5105 }
5106
5107 void
5108 sendint(
5109         struct txbuf *buf,
5110         int a
5111         )
5112 {
5113         /* send 16bit int, msbyte first */
5114         sendbyte(buf, (u_char)((a>>8) & 0xff));
5115         sendbyte(buf, (u_char)(a & 0xff));
5116 }
5117
5118 void
5119 sendflt(
5120         struct txbuf *buf,
5121         double a
5122         )
5123 {
5124         int i;
5125         union uval uval;
5126
5127         uval.fv = (float) a;
5128 #ifdef WORDS_BIGENDIAN
5129         for (i=0; i<=3; i++)
5130 #else
5131             for (i=3; i>=0; i--)
5132 #endif
5133                 sendbyte(buf, uval.bd[i]);
5134 }
5135
5136 #define TRIM_POS_OPT    0x13    /* output position with high precision */
5137 #define TRIM_TIME_OPT   0x03    /* use UTC time stamps, on second */
5138
5139 /*--------------------------------------------------
5140  * trimble TSIP setup routine
5141  */
5142 static int
5143 trimbletsip_setup(
5144                   struct parseunit *parse,
5145                   const char *reason
5146                   )
5147 {
5148         u_char buffer[256];
5149         struct txbuf buf;
5150         trimble_t *t = parse->localdata;
5151
5152         if (t && t->last_reset &&
5153             ((t->last_reset + TRIMBLE_RESET_HOLDOFF) > current_time)) {
5154                 return 1;       /* not yet */
5155         }
5156
5157         if (t)
5158                 t->last_reset = current_time;
5159
5160         buf.txt = buffer;
5161
5162         sendcmd(&buf, CMD_CVERSION);    /* request software versions */
5163         sendetx(&buf, parse);
5164
5165         sendcmd(&buf, CMD_COPERPARAM);  /* set operating parameters */
5166         sendbyte(&buf, 4);      /* static */
5167         sendflt(&buf, 5.0*D2R); /* elevation angle mask = 10 deg XXX */
5168         sendflt(&buf, 4.0);     /* s/n ratio mask = 6 XXX */
5169         sendflt(&buf, 12.0);    /* PDOP mask = 12 */
5170         sendflt(&buf, 8.0);     /* PDOP switch level = 8 */
5171         sendetx(&buf, parse);
5172
5173         sendcmd(&buf, CMD_CMODESEL);    /* fix mode select */
5174         sendbyte(&buf, 1);      /* time transfer mode */
5175         sendetx(&buf, parse);
5176
5177         sendcmd(&buf, CMD_CMESSAGE);    /* request system message */
5178         sendetx(&buf, parse);
5179
5180         sendcmd(&buf, CMD_CSUPER);      /* superpacket fix */
5181         sendbyte(&buf, 0x2);    /* binary mode */
5182         sendetx(&buf, parse);
5183
5184         sendcmd(&buf, CMD_CIOOPTIONS);  /* set I/O options */
5185         sendbyte(&buf, TRIM_POS_OPT);   /* position output */
5186         sendbyte(&buf, 0x00);   /* no velocity output */
5187         sendbyte(&buf, TRIM_TIME_OPT);  /* UTC, compute on seconds */
5188         sendbyte(&buf, 0x00);   /* no raw measurements */
5189         sendetx(&buf, parse);
5190
5191         sendcmd(&buf, CMD_CUTCPARAM);   /* request UTC correction data */
5192         sendetx(&buf, parse);
5193
5194         NLOG(NLOG_CLOCKINFO)
5195                 ERR(ERR_BADIO)
5196                 msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_setup: RECEIVER RE-INITIALIZED (%s)", CLK_UNIT(parse->peer), reason);
5197
5198         return 0;
5199 }
5200
5201 /*--------------------------------------------------
5202  * TRIMBLE TSIP check routine
5203  */
5204 static void
5205 trimble_check(
5206               struct peer *peer
5207               )
5208 {
5209         struct parseunit *parse = peer->procptr->unitptr;
5210         trimble_t *t = parse->localdata;
5211         u_char buffer[256];
5212         struct txbuf buf;
5213         buf.txt = buffer;
5214
5215         if (t)
5216         {
5217                 if (current_time > t->last_msg + TRIMBLETSIP_IDLE_TIME)
5218                         (void)trimbletsip_setup(parse, "message timeout");
5219         }
5220
5221         poll_poll(parse->peer); /* emit query string and re-arm timer */
5222
5223         if (t && t->qtracking)
5224         {
5225                 u_long oldsats = t->ltrack & ~t->ctrack;
5226
5227                 t->qtracking = 0;
5228                 t->ltrack = t->ctrack;
5229
5230                 if (oldsats)
5231                 {
5232                         int i;
5233
5234                         for (i = 0; oldsats; i++) {
5235                                 if (oldsats & (1 << i))
5236                                         {
5237                                                 sendcmd(&buf, CMD_CSTATTRACK);
5238                                                 sendbyte(&buf, i+1);    /* old sat */
5239                                                 sendetx(&buf, parse);
5240                                         }
5241                                 oldsats &= ~(1 << i);
5242                         }
5243                 }
5244
5245                 sendcmd(&buf, CMD_CSTATTRACK);
5246                 sendbyte(&buf, 0x00);   /* current tracking set */
5247                 sendetx(&buf, parse);
5248         }
5249 }
5250
5251 /*--------------------------------------------------
5252  * TRIMBLE TSIP end routine
5253  */
5254 static void
5255 trimbletsip_end(
5256               struct parseunit *parse
5257               )
5258 {       trimble_t *t = parse->localdata;
5259
5260         if (t)
5261         {
5262                 free(t);
5263                 parse->localdata = NULL;
5264         }
5265         parse->peer->procptr->nextaction = 0;
5266         parse->peer->procptr->action = NULL;
5267 }
5268
5269 /*--------------------------------------------------
5270  * TRIMBLE TSIP init routine
5271  */
5272 static int
5273 trimbletsip_init(
5274         struct parseunit *parse
5275         )
5276 {
5277 #if defined(VEOL) || defined(VEOL2)
5278 #ifdef HAVE_TERMIOS
5279         struct termios tio;             /* NEEDED FOR A LONG TIME ! */
5280 #endif
5281 #ifdef HAVE_SYSV_TTYS
5282         struct termio tio;              /* NEEDED FOR A LONG TIME ! */
5283 #endif
5284         /*
5285          * allocate local data area
5286          */
5287         if (!parse->localdata)
5288         {
5289                 trimble_t *t;
5290
5291                 t = (trimble_t *)(parse->localdata = emalloc(sizeof(trimble_t)));
5292
5293                 if (t)
5294                 {
5295                         memset((char *)t, 0, sizeof(trimble_t));
5296                         t->last_msg = current_time;
5297                 }
5298         }
5299
5300         parse->peer->procptr->action     = trimble_check;
5301         parse->peer->procptr->nextaction = current_time;
5302
5303         /*
5304          * configure terminal line for ICANON mode with VEOL characters
5305          */
5306         if (TTY_GETATTR(parse->generic->io.fd, &tio) == -1)
5307         {
5308                 msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_init: tcgetattr(%d, &tio): %m", CLK_UNIT(parse->peer), parse->generic->io.fd);
5309                 return 0;
5310         }
5311         else
5312         {
5313                 if ((parse_clockinfo[CLK_TYPE(parse->peer)].cl_lflag & ICANON))
5314                 {
5315 #ifdef VEOL
5316                         tio.c_cc[VEOL]  = ETX;
5317 #endif
5318 #ifdef VEOL2
5319                         tio.c_cc[VEOL2]  = DLE;
5320 #endif
5321                 }
5322
5323                 if (TTY_SETATTR(parse->generic->io.fd, &tio) == -1)
5324                 {
5325                         msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_init: tcsetattr(%d, &tio): %m", CLK_UNIT(parse->peer), parse->generic->io.fd);
5326                         return 0;
5327                 }
5328         }
5329 #endif
5330         return trimbletsip_setup(parse, "initial startup");
5331 }
5332
5333 /*------------------------------------------------------------
5334  * trimbletsip_event - handle Trimble events
5335  * simple evente handler - attempt to re-initialize receiver
5336  */
5337 static void
5338 trimbletsip_event(
5339         struct parseunit *parse,
5340         int event
5341         )
5342 {
5343         switch (event)
5344         {
5345             case CEVNT_BADREPLY:        /* reset on garbled input */
5346             case CEVNT_TIMEOUT:         /* reset on no input */
5347                     (void)trimbletsip_setup(parse, "event BAD_REPLY/TIMEOUT");
5348                     break;
5349
5350             default:                    /* ignore */
5351                 break;
5352         }
5353 }
5354
5355 /*
5356  * getflt, getint convert fields in the incoming data into the
5357  * appropriate type of item
5358  *
5359  * CAVEAT: these routines are currently definitely byte order dependent
5360  * and assume Representation(float) == IEEE754
5361  * These functions MUST be converted to portable versions (especially
5362  * converting the float representation into ntp_fp formats in order
5363  * to avoid floating point operations at all!
5364  */
5365
5366 static float
5367 getflt(
5368         u_char *bp
5369         )
5370 {
5371         union uval uval;
5372
5373 #ifdef WORDS_BIGENDIAN
5374         uval.bd[0] = *bp++;
5375         uval.bd[1] = *bp++;
5376         uval.bd[2] = *bp++;
5377         uval.bd[3] = *bp;
5378 #else  /* ! WORDS_BIGENDIAN */
5379         uval.bd[3] = *bp++;
5380         uval.bd[2] = *bp++;
5381         uval.bd[1] = *bp++;
5382         uval.bd[0] = *bp;
5383 #endif /* ! WORDS_BIGENDIAN */
5384         return uval.fv;
5385 }
5386
5387 static double
5388 getdbl(
5389         u_char *bp
5390         )
5391 {
5392         union uval uval;
5393
5394 #ifdef WORDS_BIGENDIAN
5395         uval.bd[0] = *bp++;
5396         uval.bd[1] = *bp++;
5397         uval.bd[2] = *bp++;
5398         uval.bd[3] = *bp++;
5399         uval.bd[4] = *bp++;
5400         uval.bd[5] = *bp++;
5401         uval.bd[6] = *bp++;
5402         uval.bd[7] = *bp;
5403 #else  /* ! WORDS_BIGENDIAN */
5404         uval.bd[7] = *bp++;
5405         uval.bd[6] = *bp++;
5406         uval.bd[5] = *bp++;
5407         uval.bd[4] = *bp++;
5408         uval.bd[3] = *bp++;
5409         uval.bd[2] = *bp++;
5410         uval.bd[1] = *bp++;
5411         uval.bd[0] = *bp;
5412 #endif /* ! WORDS_BIGENDIAN */
5413         return uval.dv;
5414 }
5415
5416 static int
5417 getshort(
5418          unsigned char *p
5419          )
5420 {
5421         return (int) get_msb_short(&p);
5422 }
5423
5424 /*--------------------------------------------------
5425  * trimbletsip_message - process trimble messages
5426  */
5427 #define RTOD (180.0 / 3.1415926535898)
5428 #define mb(_X_) (buffer[2+(_X_)]) /* shortcut for buffer access */
5429
5430 static void
5431 trimbletsip_message(
5432                     struct parseunit *parse,
5433                     parsetime_t      *parsetime
5434                     )
5435 {
5436         unsigned char *buffer = parsetime->parse_msg;
5437         unsigned int   size   = parsetime->parse_msglen;
5438
5439         if ((size < 4) ||
5440             (buffer[0]      != DLE) ||
5441             (buffer[size-1] != ETX) ||
5442             (buffer[size-2] != DLE))
5443         {
5444 #ifdef DEBUG
5445                 if (debug > 2) {
5446                         size_t i;
5447
5448                         printf("TRIMBLE BAD packet, size %d:\n  ", size);
5449                         for (i = 0; i < size; i++) {
5450                                 printf ("%2.2x, ", buffer[i]&0xff);
5451                                 if (i%16 == 15) printf("\n\t");
5452                         }
5453                         printf("\n");
5454                 }
5455 #endif
5456                 return;
5457         }
5458         else
5459         {
5460                 u_short var_flag;
5461                 trimble_t *tr = parse->localdata;
5462                 unsigned int cmd = buffer[1];
5463                 char pbuffer[200];
5464                 char *t = pbuffer;
5465                 cmd_info_t *s;
5466
5467 #ifdef DEBUG
5468                 if (debug > 3) {
5469                         size_t i;
5470
5471                         printf("TRIMBLE packet 0x%02x, size %d:\n       ", cmd, size);
5472                         for (i = 0; i < size; i++) {
5473                                 printf ("%2.2x, ", buffer[i]&0xff);
5474                                 if (i%16 == 15) printf("\n\t");
5475                         }
5476                         printf("\n");
5477                 }
5478 #endif
5479
5480                 if (tr)
5481                         tr->last_msg = current_time;
5482
5483                 s = trimble_convert(cmd, trimble_rcmds);
5484
5485                 if (s)
5486                 {
5487                         t = ap(pbuffer, sizeof(pbuffer), t, "%s=\"", s->varname);
5488                 }
5489                 else
5490                 {
5491                         DPRINTF(1, ("TRIMBLE UNKNOWN COMMAND 0x%02x\n", cmd));
5492                         return;
5493                 }
5494
5495                 var_flag = (u_short) s->varmode;
5496
5497                 switch(cmd)
5498                 {
5499                 case CMD_RCURTIME:
5500                         t = ap(pbuffer, sizeof(pbuffer), t, "%f, %d, %f",
5501                                  getflt((unsigned char *)&mb(0)), getshort((unsigned char *)&mb(4)),
5502                                  getflt((unsigned char *)&mb(6)));
5503                         break;
5504
5505                 case CMD_RBEST4:
5506                         t = ap(pbuffer, sizeof(pbuffer), t, "mode: ");
5507                         switch (mb(0) & 0xF)
5508                         {
5509                         default:
5510                                 t = ap(pbuffer, sizeof(pbuffer), t,
5511                                     "0x%x", mb(0) & 0x7);
5512                                 break;
5513
5514                         case 1:
5515                                 t = ap(pbuffer, sizeof(pbuffer), t, "0D");
5516                                 break;
5517
5518                         case 3:
5519                                 t = ap(pbuffer, sizeof(pbuffer), t, "2D");
5520                                 break;
5521
5522                         case 4:
5523                                 t = ap(pbuffer, sizeof(pbuffer), t, "3D");
5524                                 break;
5525                         }
5526                         if (mb(0) & 0x10)
5527                                 t = ap(pbuffer, sizeof(pbuffer), t, "-MANUAL, ");
5528                         else
5529                                 t = ap(pbuffer, sizeof(pbuffer), t, "-AUTO, ");
5530
5531                         t = ap(pbuffer, sizeof(pbuffer), t, "satellites %02d %02d %02d %02d, PDOP %.2f, HDOP %.2f, VDOP %.2f, TDOP %.2f",
5532                                 mb(1), mb(2), mb(3), mb(4),
5533                                 getflt((unsigned char *)&mb(5)),
5534                                 getflt((unsigned char *)&mb(9)),
5535                                 getflt((unsigned char *)&mb(13)),
5536                                 getflt((unsigned char *)&mb(17)));
5537
5538                         break;
5539
5540                 case CMD_RVERSION:
5541                         t = ap(pbuffer, sizeof(pbuffer), t, "%d.%d (%d/%d/%d)",
5542                                 mb(0)&0xff, mb(1)&0xff, 1900+(mb(4)&0xff), mb(2)&0xff, mb(3)&0xff);
5543                         break;
5544
5545                 case CMD_RRECVHEALTH:
5546                 {
5547                         static const char *msgs[] =
5548                         {
5549                                 "Battery backup failed",
5550                                 "Signal processor error",
5551                                 "Alignment error, channel or chip 1",
5552                                 "Alignment error, channel or chip 2",
5553                                 "Antenna feed line fault",
5554                                 "Excessive ref freq. error",
5555                                 "<BIT 6>",
5556                                 "<BIT 7>"
5557                         };
5558
5559                         int i, bits;
5560
5561                         switch (mb(0) & 0xFF)
5562                         {
5563                         default:
5564                                 t = ap(pbuffer, sizeof(pbuffer), t, "illegal value 0x%02x", mb(0) & 0xFF);
5565                                 break;
5566                         case 0x00:
5567                                 t = ap(pbuffer, sizeof(pbuffer), t, "doing position fixes");
5568                                 break;
5569                         case 0x01:
5570                                 t = ap(pbuffer, sizeof(pbuffer), t, "no GPS time yet");
5571                                 break;
5572                         case 0x03:
5573                                 t = ap(pbuffer, sizeof(pbuffer), t, "PDOP too high");
5574                                 break;
5575                         case 0x08:
5576                                 t = ap(pbuffer, sizeof(pbuffer), t, "no usable satellites");
5577                                 break;
5578                         case 0x09:
5579                                 t = ap(pbuffer, sizeof(pbuffer), t, "only ONE usable satellite");
5580                                 break;
5581                         case 0x0A:
5582                                 t = ap(pbuffer, sizeof(pbuffer), t, "only TWO usable satellites");
5583                                 break;
5584                         case 0x0B:
5585                                 t = ap(pbuffer, sizeof(pbuffer), t, "only THREE usable satellites");
5586                                 break;
5587                         case 0x0C:
5588                                 t = ap(pbuffer, sizeof(pbuffer), t, "the chosen satellite is unusable");
5589                                 break;
5590                         }
5591
5592                         bits = mb(1) & 0xFF;
5593
5594                         for (i = 0; i < 8; i++)
5595                                 if (bits & (0x1<<i))
5596                                 {
5597                                         t = ap(pbuffer, sizeof(pbuffer), t, ", %s", msgs[i]);
5598                                 }
5599                 }
5600                 break;
5601
5602                 case CMD_RMESSAGE:
5603                         mkreadable(t, (int)BUFFER_SIZE(pbuffer, t), (char *)&mb(0), (unsigned)(size - 2 - (&mb(0) - buffer)), 0);
5604                         break;
5605
5606                 case CMD_RMACHSTAT:
5607                 {
5608                         static const char *msgs[] =
5609                         {
5610                                 "Synthesizer Fault",
5611                                 "Battery Powered Time Clock Fault",
5612                                 "A-to-D Converter Fault",
5613                                 "The almanac stored in the receiver is not complete and current",
5614                                 "<BIT 4>",
5615                                 "<BIT 5",
5616                                 "<BIT 6>",
5617                                 "<BIT 7>"
5618                         };
5619
5620                         int i, bits;
5621
5622                         t = ap(pbuffer, sizeof(pbuffer), t, "machine id 0x%02x", mb(0) & 0xFF);
5623                         bits = mb(1) & 0xFF;
5624
5625                         for (i = 0; i < 8; i++)
5626                                 if (bits & (0x1<<i))
5627                                 {
5628                                         t = ap(pbuffer, sizeof(pbuffer), t, ", %s", msgs[i]);
5629                                 }
5630
5631                         t = ap(pbuffer, sizeof(pbuffer), t, ", Superpackets %ssupported", (mb(2) & 0xFF) ? "" :"un" );
5632                 }
5633                 break;
5634
5635                 case CMD_ROPERPARAM:
5636                         t = ap(pbuffer, sizeof(pbuffer), t, "%2x %.1f %.1f %.1f %.1f",
5637                                 mb(0), getflt((unsigned char *)&mb(1)), getflt((unsigned char *)&mb(5)),
5638                                 getflt((unsigned char *)&mb(9)), getflt((unsigned char *)&mb(13)));
5639                         break;
5640
5641                 case CMD_RUTCPARAM:
5642                 {
5643                         float t0t = getflt((unsigned char *)&mb(14));
5644                         short wnt = (short) getshort((unsigned char *)&mb(18));
5645                         short dtls = (short) getshort((unsigned char *)&mb(12));
5646                         short wnlsf = (short) getshort((unsigned char *)&mb(20));
5647                         short dn = (short) getshort((unsigned char *)&mb(22));
5648                         short dtlsf = (short) getshort((unsigned char *)&mb(24));
5649
5650                         if ((int)t0t != 0)
5651                         {
5652                                 mk_utcinfo(t, wnt, wnlsf, dn, dtls, dtlsf, BUFFER_SIZE(pbuffer, t));
5653                         }
5654                         else
5655                         {
5656                                 t = ap(pbuffer, sizeof(pbuffer), t, "<NO UTC DATA>");
5657                         }
5658                 }
5659                 break;
5660
5661                 case CMD_RSAT1BIAS:
5662                         t = ap(pbuffer, sizeof(pbuffer), t, "%.1fm %.2fm/s at %.1fs",
5663                                 getflt(&mb(0)), getflt(&mb(4)), getflt(&mb(8)));
5664                         break;
5665
5666                 case CMD_RIOOPTIONS:
5667                 {
5668                         t = ap(pbuffer, sizeof(pbuffer), t, "%02x %02x %02x %02x",
5669                                 mb(0), mb(1), mb(2), mb(3));
5670                         if (mb(0) != TRIM_POS_OPT ||
5671                             mb(2) != TRIM_TIME_OPT)
5672                         {
5673                                 (void)trimbletsip_setup(parse, "bad io options");
5674                         }
5675                 }
5676                 break;
5677
5678                 case CMD_RSPOSXYZ:
5679                 {
5680                         double x = getflt((unsigned char *)&mb(0));
5681                         double y = getflt((unsigned char *)&mb(4));
5682                         double z = getflt((unsigned char *)&mb(8));
5683                         double f = getflt((unsigned char *)&mb(12));
5684
5685                         if (f > 0.0)
5686                           t = ap(pbuffer, sizeof(pbuffer), t, "x= %.1fm, y= %.1fm, z= %.1fm, time_of_fix= %f sec",
5687                                   x, y, z,
5688                                   f);
5689                         else
5690                                 return;
5691                 }
5692                 break;
5693
5694                 case CMD_RSLLAPOS:
5695                 {
5696                         double lat = getflt((unsigned char *)&mb(0));
5697                         double lng = getflt((unsigned char *)&mb(4));
5698                         double f   = getflt((unsigned char *)&mb(12));
5699
5700                         if (f > 0.0)
5701                           t = ap(pbuffer, sizeof(pbuffer), t, "lat %f %c, long %f %c, alt %.2fm",
5702                                   ((lat < 0.0) ? (-lat) : (lat))*RTOD, (lat < 0.0 ? 'S' : 'N'),
5703                                   ((lng < 0.0) ? (-lng) : (lng))*RTOD, (lng < 0.0 ? 'W' : 'E'),
5704                                   getflt((unsigned char *)&mb(8)));
5705                         else
5706                                 return;
5707                 }
5708                 break;
5709
5710                 case CMD_RDOUBLEXYZ:
5711                 {
5712                         double x = getdbl((unsigned char *)&mb(0));
5713                         double y = getdbl((unsigned char *)&mb(8));
5714                         double z = getdbl((unsigned char *)&mb(16));
5715                         t = ap(pbuffer, sizeof(pbuffer), t, "x= %.1fm, y= %.1fm, z= %.1fm",
5716                                 x, y, z);
5717                 }
5718                 break;
5719
5720                 case CMD_RDOUBLELLA:
5721                 {
5722                         double lat = getdbl((unsigned char *)&mb(0));
5723                         double lng = getdbl((unsigned char *)&mb(8));
5724                         t = ap(pbuffer, sizeof(pbuffer), t, "lat %f %c, lon %f %c, alt %.2fm",
5725                                 ((lat < 0.0) ? (-lat) : (lat))*RTOD, (lat < 0.0 ? 'S' : 'N'),
5726                                 ((lng < 0.0) ? (-lng) : (lng))*RTOD, (lng < 0.0 ? 'W' : 'E'),
5727                                 getdbl((unsigned char *)&mb(16)));
5728                 }
5729                 break;
5730
5731                 case CMD_RALLINVIEW:
5732                 {
5733                         int i, sats;
5734
5735                         t = ap(pbuffer, sizeof(pbuffer), t, "mode: ");
5736                         switch (mb(0) & 0x7)
5737                         {
5738                         default:
5739                                 t = ap(pbuffer, sizeof(pbuffer), t, "0x%x", mb(0) & 0x7);
5740                                 break;
5741
5742                         case 3:
5743                                 t = ap(pbuffer, sizeof(pbuffer), t, "2D");
5744                                 break;
5745
5746                         case 4:
5747                                 t = ap(pbuffer, sizeof(pbuffer), t, "3D");
5748                                 break;
5749                         }
5750                         if (mb(0) & 0x8)
5751                                 t = ap(pbuffer, sizeof(pbuffer), t, "-MANUAL, ");
5752                         else
5753                                 t = ap(pbuffer, sizeof(pbuffer), t, "-AUTO, ");
5754
5755                         sats = (mb(0)>>4) & 0xF;
5756
5757                         t = ap(pbuffer, sizeof(pbuffer), t, "PDOP %.2f, HDOP %.2f, VDOP %.2f, TDOP %.2f, %d satellite%s in view: ",
5758                                 getflt((unsigned char *)&mb(1)),
5759                                 getflt((unsigned char *)&mb(5)),
5760                                 getflt((unsigned char *)&mb(9)),
5761                                 getflt((unsigned char *)&mb(13)),
5762                                 sats, (sats == 1) ? "" : "s");
5763
5764                         for (i=0; i < sats; i++)
5765                         {
5766                                 t = ap(pbuffer, sizeof(pbuffer), t, "%s%02d", i ? ", " : "", mb(17+i));
5767                                 if (tr)
5768                                         tr->ctrack |= (1 << (mb(17+i)-1));
5769                         }
5770
5771                         if (tr)
5772                         {       /* mark for tracking status query */
5773                                 tr->qtracking = 1;
5774                         }
5775                 }
5776                 break;
5777
5778                 case CMD_RSTATTRACK:
5779                 {
5780                         t = ap(pbuffer, sizeof(pbuffer), t-2, "[%02d]=\"", mb(0)); /* add index to var name */
5781                         if (getflt((unsigned char *)&mb(4)) < 0.0)
5782                         {
5783                                 t = ap(pbuffer, sizeof(pbuffer), t, "<NO MEASUREMENTS>");
5784                                 var_flag &= (u_short)(~DEF);
5785                         }
5786                         else
5787                         {
5788                                 t = ap(pbuffer, sizeof(pbuffer), t, "ch=%d, acq=%s, eph=%d, signal_level= %5.2f, elevation= %5.2f, azimuth= %6.2f",
5789                                         (mb(1) & 0xFF)>>3,
5790                                         mb(2) ? ((mb(2) == 1) ? "ACQ" : "SRCH") : "NEVER",
5791                                         mb(3),
5792                                         getflt((unsigned char *)&mb(4)),
5793                                         getflt((unsigned char *)&mb(12)) * RTOD,
5794                                         getflt((unsigned char *)&mb(16)) * RTOD);
5795                                 if (mb(20))
5796                                 {
5797                                         var_flag &= (u_short)(~DEF);
5798                                         t = ap(pbuffer, sizeof(pbuffer), t, ", OLD");
5799                                 }
5800                                 if (mb(22))
5801                                 {
5802                                         if (mb(22) == 1)
5803                                                 t = ap(pbuffer, sizeof(pbuffer), t, ", BAD PARITY");
5804                                         else
5805                                                 if (mb(22) == 2)
5806                                                         t = ap(pbuffer, sizeof(pbuffer), t, ", BAD EPH HEALTH");
5807                                 }
5808                                 if (mb(23))
5809                                         t = ap(pbuffer, sizeof(pbuffer), t, ", collecting data");
5810                         }
5811                 }
5812                 break;
5813
5814                 default:
5815                         t = ap(pbuffer, sizeof(pbuffer), t, "<UNDECODED>");
5816                         break;
5817                 }
5818
5819                 t = ap(pbuffer, sizeof(pbuffer), t, "\"");
5820                 set_var(&parse->kv, pbuffer, sizeof(pbuffer), var_flag);
5821         }
5822 }
5823
5824
5825 /**============================================================
5826  ** RAWDCF support
5827  **/
5828
5829 /*--------------------------------------------------
5830  * rawdcf_init_1 - set up modem lines for RAWDCF receivers
5831  * SET DTR line
5832  */
5833 #if defined(TIOCMSET) && (defined(TIOCM_DTR) || defined(CIOCM_DTR))
5834 static int
5835 rawdcf_init_1(
5836         struct parseunit *parse
5837         )
5838 {
5839         /* fixed 2000 for using with Linux by Wolfram Pienkoss <wp@bszh.de> */
5840         /*
5841          * You can use the RS232 to supply the power for a DCF77 receiver.
5842          * Here a voltage between the DTR and the RTS line is used. Unfortunately
5843          * the name has changed from CIOCM_DTR to TIOCM_DTR recently.
5844          */
5845         int sl232;
5846
5847         if (ioctl(parse->generic->io.fd, TIOCMGET, (caddr_t)&sl232) == -1)
5848         {
5849                 msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_1: WARNING: ioctl(fd, TIOCMGET, [C|T]IOCM_DTR): %m", CLK_UNIT(parse->peer));
5850                 return 0;
5851         }
5852
5853 #ifdef TIOCM_DTR
5854         sl232 = (sl232 & ~TIOCM_RTS) | TIOCM_DTR;       /* turn on DTR, clear RTS for power supply */
5855 #else
5856         sl232 = (sl232 & ~CIOCM_RTS) | CIOCM_DTR;       /* turn on DTR, clear RTS for power supply */
5857 #endif
5858
5859         if (ioctl(parse->generic->io.fd, TIOCMSET, (caddr_t)&sl232) == -1)
5860         {
5861                 msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_1: WARNING: ioctl(fd, TIOCMSET, [C|T]IOCM_DTR): %m", CLK_UNIT(parse->peer));
5862         }
5863         return 0;
5864 }
5865 #else
5866 static int
5867 rawdcfdtr_init_1(
5868         struct parseunit *parse
5869         )
5870 {
5871         msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_1: WARNING: OS interface incapable of setting DTR to power DCF modules", CLK_UNIT(parse->peer));
5872         return 0;
5873 }
5874 #endif  /* DTR initialisation type */
5875
5876 /*--------------------------------------------------
5877  * rawdcf_init_2 - set up modem lines for RAWDCF receivers
5878  * CLR DTR line, SET RTS line
5879  */
5880 #if defined(TIOCMSET) &&  (defined(TIOCM_RTS) || defined(CIOCM_RTS))
5881 static int
5882 rawdcf_init_2(
5883         struct parseunit *parse
5884         )
5885 {
5886         /* fixed 2000 for using with Linux by Wolfram Pienkoss <wp@bszh.de> */
5887         /*
5888          * You can use the RS232 to supply the power for a DCF77 receiver.
5889          * Here a voltage between the DTR and the RTS line is used. Unfortunately
5890          * the name has changed from CIOCM_DTR to TIOCM_DTR recently.
5891          */
5892         int sl232;
5893
5894         if (ioctl(parse->generic->io.fd, TIOCMGET, (caddr_t)&sl232) == -1)
5895         {
5896                 msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_2: WARNING: ioctl(fd, TIOCMGET, [C|T]IOCM_RTS): %m", CLK_UNIT(parse->peer));
5897                 return 0;
5898         }
5899
5900 #ifdef TIOCM_RTS
5901         sl232 = (sl232 & ~TIOCM_DTR) | TIOCM_RTS;       /* turn on RTS, clear DTR for power supply */
5902 #else
5903         sl232 = (sl232 & ~CIOCM_DTR) | CIOCM_RTS;       /* turn on RTS, clear DTR for power supply */
5904 #endif
5905
5906         if (ioctl(parse->generic->io.fd, TIOCMSET, (caddr_t)&sl232) == -1)
5907         {
5908                 msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_2: WARNING: ioctl(fd, TIOCMSET, [C|T]IOCM_RTS): %m", CLK_UNIT(parse->peer));
5909         }
5910         return 0;
5911 }
5912 #else
5913 static int
5914 rawdcf_init_2(
5915         struct parseunit *parse
5916         )
5917 {
5918         msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_2: WARNING: OS interface incapable of setting RTS to power DCF modules", CLK_UNIT(parse->peer));
5919         return 0;
5920 }
5921 #endif  /* DTR initialisation type */
5922
5923 #else   /* defined(REFCLOCK) && defined(PARSE) */
5924 NONEMPTY_TRANSLATION_UNIT
5925 #endif  /* defined(REFCLOCK) && defined(PARSE) */
5926
5927 /*
5928  * History:
5929  *
5930  * refclock_parse.c,v
5931  * Revision 4.81  2009/05/01 10:15:29  kardel
5932  * use new refclock_ppsapi interface
5933  *
5934  * Revision 4.80  2007/08/11 12:06:29  kardel
5935  * update comments wrt/ to PPS
5936  *
5937  * Revision 4.79  2007/08/11 11:52:23  kardel
5938  * - terminate io bindings before io_closeclock() will close our file descriptor
5939  *
5940  * Revision 4.78  2006/12/22 20:08:27  kardel
5941  * Bug 746 (RFE): add configuration for Expert mouseCLOCK USB v2.0 as mode 19
5942  *
5943  * Revision 4.77  2006/08/05 07:44:49  kardel
5944  * support optionally separate PPS devices via /dev/refclockpps-{0..3}
5945  *
5946  * Revision 4.76  2006/06/22 18:40:47  kardel
5947  * clean up signedness (gcc 4)
5948  *
5949  * Revision 4.75  2006/06/22 16:58:10  kardel
5950  * Bug #632: call parse_ppsapi() in parse_ctl() when updating
5951  * the PPS offset. Fix sign of offset passed to kernel.
5952  *
5953  * Revision 4.74  2006/06/18 21:18:37  kardel
5954  * NetBSD Coverity CID 3796: possible NULL deref
5955  *
5956  * Revision 4.73  2006/05/26 14:23:46  kardel
5957  * cleanup of copyright info
5958  *
5959  * Revision 4.72  2006/05/26 14:19:43  kardel
5960  * cleanup of ioctl cruft
5961  *
5962  * Revision 4.71  2006/05/26 14:15:57  kardel
5963  * delay adding refclock to async refclock io after all initializations
5964  *
5965  * Revision 4.70  2006/05/25 18:20:50  kardel
5966  * bug #619
5967  * terminate parse io engine after de-registering
5968  * from refclock io engine
5969  *
5970  * Revision 4.69  2006/05/25 17:28:02  kardel
5971  * complete refclock io structure initialization *before* inserting it into the
5972  * refclock input machine (avoids null pointer deref) (bug #619)
5973  *
5974  * Revision 4.68  2006/05/01 17:02:51  kardel
5975  * copy receiver method also for newlwy created receive buffers
5976  *
5977  * Revision 4.67  2006/05/01 14:37:29  kardel
5978  * If an input buffer parses into more than one message do insert the
5979  * parsed message in a new input buffer instead of processing it
5980  * directly. This avoids deed complicated processing in signal
5981  * handling.
5982  *
5983  * Revision 4.66  2006/03/18 00:45:30  kardel
5984  * coverity fixes found in NetBSD coverity scan
5985  *
5986  * Revision 4.65  2006/01/26 06:08:33  kardel
5987  * output errno on PPS setup failure
5988  *
5989  * Revision 4.64  2005/11/09 20:44:47  kardel
5990  * utilize full PPS timestamp resolution from PPS API
5991  *
5992  * Revision 4.63  2005/10/07 22:10:25  kardel
5993  * bounded buffer implementation
5994  *
5995  * Revision 4.62.2.2  2005/09/25 10:20:16  kardel
5996  * avoid unexpected buffer overflows due to sprintf("%f") on strange floats:
5997  * replace almost all str* and *printf functions be their buffer bounded
5998  * counterparts
5999  *
6000  * Revision 4.62.2.1  2005/08/27 16:19:27  kardel
6001  * limit re-set rate of trimble clocks
6002  *
6003  * Revision 4.62  2005/08/06 17:40:00  kardel
6004  * cleanup size handling wrt/ to buffer boundaries
6005  *
6006  * Revision 4.61  2005/07/27 21:16:19  kardel
6007  * fix a long (> 11 years) misconfiguration wrt/ Meinberg cflag factory
6008  * default setup. CSTOPB was missing for the 7E2 default data format of
6009  * the DCF77 clocks.
6010  *
6011  * Revision 4.60  2005/07/17 21:14:44  kardel
6012  * change contents of version string to include the RCS/CVS Id
6013  *
6014  * Revision 4.59  2005/07/06 06:56:38  kardel
6015  * syntax error
6016  *
6017  * Revision 4.58  2005/07/04 13:10:40  kardel
6018  * fix bug 455: tripping over NULL pointer on cleanup
6019  * fix shadow storage logic for ppsphaseadjust and trustime wrt/ time2
6020  * fix compiler warnings for some platforms wrt/ printf formatstrings and
6021  *     varying structure element sizes
6022  * reorder assignment in binding to avoid tripping over NULL pointers
6023  *
6024  * Revision 4.57  2005/06/25 09:25:19  kardel
6025  * sort out log output sequence
6026  *
6027  * Revision 4.56  2005/06/14 21:47:27  kardel
6028  * collect samples only if samples are ok (sync or trusted flywheel)
6029  * propagate pps phase adjustment value to kernel via PPSAPI to help HARDPPS
6030  * en- and dis-able HARDPPS in correlation to receiver sync state
6031  *
6032  * Revision 4.55  2005/06/02 21:28:31  kardel
6033  * clarify trust logic
6034  *
6035  * Revision 4.54  2005/06/02 17:06:49  kardel
6036  * change status reporting to use fixed refclock_report()
6037  *
6038  * Revision 4.53  2005/06/02 16:33:31  kardel
6039  * fix acceptance of clocks unsync clocks right at start
6040  *
6041  * Revision 4.52  2005/05/26 21:55:06  kardel
6042  * cleanup status reporting
6043  *
6044  * Revision 4.51  2005/05/26 19:19:14  kardel
6045  * implement fast refclock startup
6046  *
6047  * Revision 4.50  2005/04/16 20:51:35  kardel
6048  * set hardpps_enable = 1 when binding a kernel PPS source
6049  *
6050  * Revision 4.49  2005/04/16 17:29:26  kardel
6051  * add non polling clock type 18 for just listenning to Meinberg clocks
6052  *
6053  * Revision 4.48  2005/04/16 16:22:27  kardel
6054  * bk sync 20050415 ntp-dev
6055  *
6056  * Revision 4.47  2004/11/29 10:42:48  kardel
6057  * bk sync ntp-dev 20041129
6058  *
6059  * Revision 4.46  2004/11/29 10:26:29  kardel
6060  * keep fudgetime2 in sync with trusttime/ppsphaseadjust depending in flag1
6061  *
6062  * Revision 4.45  2004/11/14 20:53:20  kardel
6063  * clear PPS flags after using them
6064  *
6065  * Revision 4.44  2004/11/14 15:29:41  kardel
6066  * support PPSAPI, upgrade Copyright to Berkeley style
6067  *
6068  * Revision 4.43  2001/05/26 22:53:16  kardel
6069  * 20010526 reconcilation
6070  *
6071  * Revision 4.42  2000/05/14 15:31:51  kardel
6072  * PPSAPI && RAWDCF modemline support
6073  *
6074  * Revision 4.41  2000/04/09 19:50:45  kardel
6075  * fixed rawdcfdtr_init() -> rawdcf_init_1
6076  *
6077  * Revision 4.40  2000/04/09 15:27:55  kardel
6078  * modem line fiddle in rawdcf_init_2
6079  *
6080  * Revision 4.39  2000/03/18 09:16:55  kardel
6081  * PPSAPI integration
6082  *
6083  * Revision 4.38  2000/03/05 20:25:06  kardel
6084  * support PPSAPI
6085  *
6086  * Revision 4.37  2000/03/05 20:11:14  kardel
6087  * 4.0.99g reconcilation
6088  *
6089  * Revision 4.36  1999/11/28 17:18:20  kardel
6090  * disabled burst mode
6091  *
6092  * Revision 4.35  1999/11/28 09:14:14  kardel
6093  * RECON_4_0_98F
6094  *
6095  * Revision 4.34  1999/05/14 06:08:05  kardel
6096  * store current_time in a suitable container (u_long)
6097  *
6098  * Revision 4.33  1999/05/13 21:48:38  kardel
6099  * double the no response timeout interval
6100  *
6101  * Revision 4.32  1999/05/13 20:09:13  kardel
6102  * complain only about missing polls after a full poll interval
6103  *
6104  * Revision 4.31  1999/05/13 19:59:32  kardel
6105  * add clock type 16 for RTS set DTR clr in RAWDCF
6106  *
6107  * Revision 4.30  1999/02/28 20:36:43  kardel
6108  * fixed printf fmt
6109  *
6110  * Revision 4.29  1999/02/28 19:58:23  kardel
6111  * updated copyright information
6112  *
6113  * Revision 4.28  1999/02/28 19:01:50  kardel
6114  * improved debug out on sent Meinberg messages
6115  *
6116  * Revision 4.27  1999/02/28 18:05:55  kardel
6117  * no linux/ppsclock.h stuff
6118  *
6119  * Revision 4.26  1999/02/28 15:27:27  kardel
6120  * wharton clock integration
6121  *
6122  * Revision 4.25  1999/02/28 14:04:46  kardel
6123  * added missing double quotes to UTC information string
6124  *
6125  * Revision 4.24  1999/02/28 12:06:50  kardel
6126  * (parse_control): using gmprettydate instead of prettydate()
6127  * (mk_utcinfo): new function for formatting GPS derived UTC information
6128  * (gps16x_message): changed to use mk_utcinfo()
6129  * (trimbletsip_message): changed to use mk_utcinfo()
6130  * ignoring position information in unsynchronized mode
6131  * (parse_start): augument linux support for optional ASYNC_LOW_LATENCY
6132  *
6133  * Revision 4.23  1999/02/23 19:47:53  kardel
6134  * fixed #endifs
6135  * (stream_receive): fixed formats
6136  *
6137  * Revision 4.22  1999/02/22 06:21:02  kardel
6138  * use new autoconfig symbols
6139  *
6140  * Revision 4.21  1999/02/21 12:18:13  kardel
6141  * 4.91f reconcilation
6142  *
6143  * Revision 4.20  1999/02/21 10:53:36  kardel
6144  * initial Linux PPSkit version
6145  *
6146  * Revision 4.19  1999/02/07 09:10:45  kardel
6147  * clarify STREAMS mitigation rules in comment
6148  *
6149  * Revision 4.18  1998/12/20 23:45:34  kardel
6150  * fix types and warnings
6151  *
6152  * Revision 4.17  1998/11/15 21:24:51  kardel
6153  * cannot access mbg_ routines when CLOCK_MEINBERG
6154  * is not defined
6155  *
6156  * Revision 4.16  1998/11/15 20:28:17  kardel
6157  * Release 4.0.73e13 reconcilation
6158  *
6159  * Revision 4.15  1998/08/22 21:56:08  kardel
6160  * fixed IO handling for non-STREAM IO
6161  *
6162  * Revision 4.14  1998/08/16 19:00:48  kardel
6163  * (gps16x_message): reduced UTC parameter information (dropped A0,A1)
6164  * made uval a local variable (killed one of the last globals)
6165  * (sendetx): added logging of messages when in debug mode
6166  * (trimble_check): added periodic checks to facilitate re-initialization
6167  * (trimbletsip_init): made use of EOL character if in non-kernel operation
6168  * (trimbletsip_message): extended message interpretation
6169  * (getdbl): fixed data conversion
6170  *
6171  * Revision 4.13  1998/08/09 22:29:13  kardel
6172  * Trimble TSIP support
6173  *
6174  * Revision 4.12  1998/07/11 10:05:34  kardel
6175  * Release 4.0.73d reconcilation
6176  *
6177  * Revision 4.11  1998/06/14 21:09:42  kardel
6178  * Sun acc cleanup
6179  *
6180  * Revision 4.10  1998/06/13 12:36:45  kardel
6181  * signed/unsigned, name clashes
6182  *
6183  * Revision 4.9  1998/06/12 15:30:00  kardel
6184  * prototype fixes
6185  *
6186  * Revision 4.8  1998/06/12 11:19:42  kardel
6187  * added direct input processing routine for refclocks in
6188  * order to avaiod that single character io gobbles up all
6189  * receive buffers and drops input data. (Problem started
6190  * with fast machines so a character a buffer was possible
6191  * one of the few cases where faster machines break existing
6192  * allocation algorithms)
6193  *
6194  * Revision 4.7  1998/06/06 18:35:20  kardel
6195  * (parse_start): added BURST mode initialisation
6196  *
6197  * Revision 4.6  1998/05/27 06:12:46  kardel
6198  * RAWDCF_BASEDELAY default added
6199  * old comment removed
6200  * casts for ioctl()
6201  *
6202  * Revision 4.5  1998/05/25 22:05:09  kardel
6203  * RAWDCF_SETDTR option removed
6204  * clock type 14 attempts to set DTR for
6205  * power supply of RAWDCF receivers
6206  *
6207  * Revision 4.4  1998/05/24 16:20:47  kardel
6208  * updated comments referencing Meinberg clocks
6209  * added RAWDCF clock with DTR set option as type 14
6210  *
6211  * Revision 4.3  1998/05/24 10:48:33  kardel
6212  * calibrated CONRAD RAWDCF default fudge factor
6213  *
6214  * Revision 4.2  1998/05/24 09:59:35  kardel
6215  * corrected version information (ntpq support)
6216  *
6217  * Revision 4.1  1998/05/24 09:52:31  kardel
6218  * use fixed format only (new IO model)
6219  * output debug to stdout instead of msyslog()
6220  * don't include >"< in ASCII output in order not to confuse
6221  * ntpq parsing
6222  *
6223  * Revision 4.0  1998/04/10 19:52:11  kardel
6224  * Start 4.0 release version numbering
6225  *
6226  * Revision 1.2  1998/04/10 19:28:04  kardel
6227  * initial NTP VERSION 4 integration of PARSE with GPS166 binary support
6228  * derived from 3.105.1.2 from V3 tree
6229  *
6230  * Revision information 3.1 - 3.105 from log deleted 1998/04/10 kardel
6231  *
6232  */