2 * refclock_gpsdjson.c - clock driver as GPSD JSON client
3 * Juergen Perlinger (perlinger@ntp.org)
4 * Feb 11, 2014 for the NTP project.
5 * The contents of 'html/copyright.html' apply.
7 * Heavily inspired by refclock_nmea.c
9 * Special thanks to Gary Miller and Hal Murray for their comments and
12 * Note: This will currently NOT work with Windows due to some
15 * - There is no GPSD for Windows. (There is an unofficial port to
16 * cygwin, but Windows is not officially supported.)
18 * - To work properly, this driver needs PPS and TPV/TOFF sentences
19 * from GPSD. I don't see how the cygwin port should deal with the
22 * - The device name matching must be done in a different way for
23 * Windows. (Can be done with COMxx matching, as done for NMEA.)
25 * Apart from those minor hickups, once GPSD has been fully ported to
26 * Windows, there's no reason why this should not work there ;-) If this
27 * is ever to happen at all is a different question.
29 * ---------------------------------------------------------------------
31 * This driver works slightly different from most others, as the PPS
32 * information (if available) is also coming from GPSD via the data
33 * connection. This makes using both the PPS data and the serial data
34 * easier, but OTOH it's not possible to use the ATOM driver to feed a
35 * raw PPS stream to the core of NTPD.
37 * To go around this, the driver can use a secondary clock unit
38 * (units>=128) that operate in tandem with the primary clock unit
39 * (unit%128). The primary clock unit does all the IO stuff and data
40 * decoding; if a a secondary unit is attached to a primary unit, this
41 * secondary unit is feed with the PPS samples only and can act as a PPS
42 * source to the clock selection.
44 * The drawback is that the primary unit must be present for the
45 * secondary unit to work.
47 * This design is a compromise to reduce the IO load for both NTPD and
48 * GPSD; it also ensures that data is transmitted and evaluated only
49 * once on the side of NTPD.
51 * ---------------------------------------------------------------------
53 * trouble shooting hints:
55 * Enable and check the clock stats. Check if there are bad replies;
56 * there should be none. If there are actually bad replies, then the
57 * driver cannot parse all JSON records from GPSD, and some record
58 * types are vital for the operation of the driver. This indicates a
59 * problem on the protocol level.
61 * When started on the command line with a debug level >= 2, the
62 * driver dumps the raw received data and the parser input to
63 * stdout. Since the debug level is global, NTPD starts to create a
64 * *lot* of output. It makes sense to pipe it through '(f)grep
65 * GPSD_JSON' before writing the result to disk.
67 * A bit less intrusive is using netcat or telnet to connect to GPSD
68 * and snoop what NTPD would get. If you try this, you have to send a
69 * WATCH command to GPSD:
71 * ?WATCH={"device":"/dev/gps0","enable":true,"json":true,"pps":true};<CRLF>
73 * should show you what GPSD has to say to NTPD. Replace "/dev/gps0"
74 * with the device link used by GPSD, if necessary.
82 #include "ntp_types.h"
84 #if defined(REFCLOCK) && defined(CLOCK_GPSDJSON) && !defined(SYS_WINNT)
86 /* =====================================================================
87 * Get the little JSMN library directly into our guts. Use the 'parent
88 * link' feature for maximum speed.
90 #define JSMN_PARENT_LINKS
91 #include "../libjsmn/jsmn.c"
93 /* =====================================================================
97 #define JSMN_MAXTOK 350
98 #define INVALID_TOKEN (-1)
100 typedef struct json_ctx {
103 jsmntok_t tok[JSMN_MAXTOK];
108 /* Not all targets have 'long long', and not all of them have 'strtoll'.
109 * Sigh. We roll our own integer number parser.
111 #ifdef HAVE_LONG_LONG
112 typedef signed long long int json_int;
113 typedef unsigned long long int json_uint;
114 #define JSON_INT_MAX LLONG_MAX
115 #define JSON_INT_MIN LLONG_MIN
117 typedef signed long int json_int;
118 typedef unsigned long int json_uint;
119 #define JSON_INT_MAX LONG_MAX
120 #define JSON_INT_MIN LONG_MIN
123 /* =====================================================================
124 * header stuff we need
134 #include <sys/types.h>
135 #include <sys/socket.h>
136 #include <sys/stat.h>
137 #include <netinet/tcp.h>
139 #if defined(HAVE_SYS_POLL_H)
140 # include <sys/poll.h>
141 #elif defined(HAVE_SYS_SELECT_H)
142 # include <sys/select.h>
144 # error need poll() or select()
149 #include "ntp_unixtime.h"
150 #include "ntp_refclock.h"
151 #include "ntp_stdlib.h"
152 #include "ntp_calendar.h"
153 #include "timespecops.h"
155 /* get operation modes from mode word.
157 * + SERIAL (default) evaluates only serial time information ('STI') as
158 * provided by TPV and TOFF records. TPV evaluation suffers from a
159 * bigger jitter than TOFF, sine it does not contain the receive time
160 * from GPSD and therefore the receive time of NTPD must be
161 * substituted for it. The network latency makes this a second rate
164 * If TOFF records are detected in the data stream, the timing
165 * information is gleaned from this record -- it contains the local
166 * receive time stamp from GPSD and therefore eliminates the
167 * transmission latency between GPSD and NTPD. The timing information
168 * from TPV is ignored once a TOFF is detected or expected.
170 * TPV is still used to check the fix status, so the driver can stop
171 * feeding samples when GPSD says that the time information is
172 * effectively unreliable.
174 * + STRICT means only feed clock samples when a valid STI/PPS pair is
175 * available. Combines the reference time from STI with the pulse time
176 * from PPS. Masks the serial data jitter as long PPS is available,
177 * but can rapidly deteriorate once PPS drops out.
179 * + AUTO tries to use STI/PPS pairs if available for some time, and if
180 * this fails for too long switches back to STI only until the PPS
181 * signal becomes available again. See the HTML docs for this driver
182 * about the gotchas and why this is not the default.
184 #define MODE_OP_MASK 0x03
185 #define MODE_OP_STI 0
186 #define MODE_OP_STRICT 1
187 #define MODE_OP_AUTO 2
188 #define MODE_OP_MAXVAL 2
189 #define MODE_OP_MODE(x) ((x) & MODE_OP_MASK)
191 #define PRECISION (-9) /* precision assumed (about 2 ms) */
192 #define PPS_PRECISION (-20) /* precision assumed (about 1 us) */
193 #define REFID "GPSD" /* reference id */
194 #define DESCRIPTION "GPSD JSON client clock" /* who we are */
196 #define MAX_PDU_LEN 1600
197 #define TICKOVER_LOW 10
198 #define TICKOVER_HIGH 120
199 #define LOGTHROTTLE 3600
201 /* Primary channel PPS avilability dance:
202 * Every good PPS sample gets us a credit of PPS_INCCOUNT points, every
203 * bad/missing PPS sample costs us a debit of PPS_DECCOUNT points. When
204 * the account reaches the upper limit we change to a mode where only
205 * PPS-augmented samples are fed to the core; when the account drops to
206 * zero we switch to a mode where TPV-only timestamps are fed to the
208 * This reduces the chance of rapid alternation between raw and
209 * PPS-augmented time stamps.
211 #define PPS_MAXCOUNT 60 /* upper limit of account */
212 #define PPS_INCCOUNT 3 /* credit for good samples */
213 #define PPS_DECCOUNT 1 /* debit for bad samples */
215 /* The secondary (PPS) channel uses a different strategy to avoid old
216 * PPS samples in the median filter.
218 #define PPS2_MAXCOUNT 10
230 #define PROTO_VERSION(hi,lo) \
231 ((((uint32_t)(hi) << 16) & 0xFFFF0000u) | \
232 ((uint32_t)(lo) & 0x0FFFFu))
234 /* some local typedefs: The NTPD formatting style cries for short type
235 * names, and we provide them locally. Note:the suffix '_t' is reserved
236 * for the standard; I use a capital T instead.
238 typedef struct peer peerT;
239 typedef struct refclockproc clockprocT;
240 typedef struct addrinfo addrinfoT;
242 /* =====================================================================
243 * We use the same device name scheme as does the NMEA driver; since
244 * GPSD supports the same links, we can select devices by a fixed name.
246 static const char * s_dev_stem = "/dev/gps";
248 /* =====================================================================
249 * forward declarations for transfer vector and the vector itself
252 static void gpsd_init (void);
253 static int gpsd_start (int, peerT *);
254 static void gpsd_shutdown (int, peerT *);
255 static void gpsd_receive (struct recvbuf *);
256 static void gpsd_poll (int, peerT *);
257 static void gpsd_control (int, const struct refclockstat *,
258 struct refclockstat *, peerT *);
259 static void gpsd_timer (int, peerT *);
261 static int myasprintf(char**, char const*, ...) NTP_PRINTF(2, 3);
263 static void enter_opmode(peerT *peer, int mode);
264 static void leave_opmode(peerT *peer, int mode);
266 struct refclock refclock_gpsdjson = {
267 gpsd_start, /* start up driver */
268 gpsd_shutdown, /* shut down driver */
269 gpsd_poll, /* transmit poll message */
270 gpsd_control, /* fudge control */
271 gpsd_init, /* initialize driver */
272 noentry, /* buginfo */
273 gpsd_timer /* called once per second */
276 /* =====================================================================
277 * our local clock unit and data
280 typedef struct gpsd_unit gpsd_unitT;
283 /* links for sharing between master/slave units */
284 gpsd_unitT *next_unit;
287 /* data for the secondary PPS channel */
290 /* unit and operation modes */
293 char *logname; /* cached name for log/print */
294 char * device; /* device name of unit */
296 /* current line protocol version */
297 uint32_t proto_version;
299 /* PPS time stamps primary + secondary channel */
300 l_fp pps_local; /* when we received the PPS message */
301 l_fp pps_stamp; /* related reference time */
302 l_fp pps_recvt; /* when GPSD detected the pulse */
303 l_fp pps_stamp2;/* related reference time (secondary) */
304 l_fp pps_recvt2;/* when GPSD detected the pulse (secondary)*/
305 int ppscount; /* PPS counter (primary unit) */
306 int ppscount2; /* PPS counter (secondary unit) */
308 /* TPV or TOFF serial time information */
309 l_fp sti_local; /* when we received the TPV/TOFF message */
310 l_fp sti_stamp; /* effective GPS time stamp */
311 l_fp sti_recvt; /* when GPSD got the fix */
313 /* precision estimates */
314 int16_t sti_prec; /* serial precision based on EPT */
315 int16_t pps_prec; /* PPS precision from GPSD or above */
317 /* fudge values for correction, mirrored as 'l_fp' */
318 l_fp pps_fudge; /* PPS fudge primary channel */
319 l_fp pps_fudge2; /* PPS fudge secondary channel */
320 l_fp sti_fudge; /* TPV/TOFF serial data fudge */
322 /* Flags to indicate available data */
323 int fl_nosync: 1; /* GPSD signals bad quality */
324 int fl_sti : 1; /* valid TPV/TOFF seen (have time) */
325 int fl_pps : 1; /* valid pulse seen */
326 int fl_pps2 : 1; /* valid pulse seen for PPS channel */
327 int fl_rawsti: 1; /* permit raw TPV/TOFF time stamps */
328 int fl_vers : 1; /* have protocol version */
329 int fl_watch : 1; /* watch reply seen */
331 int pf_nsec : 1; /* have nanosec PPS info */
332 int pf_toff : 1; /* have TOFF record for timing */
334 /* admin stuff for sockets and device selection */
335 int fdt; /* current connecting socket */
336 addrinfoT * addr; /* next address to try */
337 u_int tickover; /* timeout countdown */
338 u_int tickpres; /* timeout preset */
340 /* tallies for the various events */
341 u_int tc_recv; /* received known records */
342 u_int tc_breply; /* bad replies / parsing errors */
343 u_int tc_nosync; /* TPV / sample cycles w/o fix */
344 u_int tc_sti_recv;/* received serial time info records */
345 u_int tc_sti_used;/* used --^-- */
346 u_int tc_pps_recv;/* received PPS timing info records */
347 u_int tc_pps_used;/* used --^-- */
349 /* log bloat throttle */
350 u_int logthrottle;/* seconds to next log slot */
352 /* The parse context for the current record */
355 /* record assemby buffer and saved length */
357 char buffer[MAX_PDU_LEN];
360 /* =====================================================================
361 * static local helpers forward decls
363 static void gpsd_init_socket(peerT * const peer);
364 static void gpsd_test_socket(peerT * const peer);
365 static void gpsd_stop_socket(peerT * const peer);
367 static void gpsd_parse(peerT * const peer,
368 const l_fp * const rtime);
369 static BOOL convert_ascii_time(l_fp * fp, const char * gps_time);
370 static void save_ltc(clockprocT * const pp, const char * const tc);
371 static int syslogok(clockprocT * const pp, gpsd_unitT * const up);
372 static void log_data(peerT *peer, const char *what,
373 const char *buf, size_t len);
374 static int16_t clamped_precision(int rawprec);
376 /* =====================================================================
377 * local / static stuff
380 /* The logon string is actually the ?WATCH command of GPSD, using JSON
381 * data and selecting the GPS device name we created from our unit
382 * number. We have an old a newer version that request PPS (and TOFF)
384 * Note: These are actually format strings!
386 static const char * const s_req_watch[2] = {
387 "?WATCH={\"device\":\"%s\",\"enable\":true,\"json\":true};\r\n",
388 "?WATCH={\"device\":\"%s\",\"enable\":true,\"json\":true,\"pps\":true};\r\n"
391 static const char * const s_req_version =
394 /* We keep a static list of network addresses for 'localhost:gpsd' or a
395 * fallback alias of it, and we try to connect to them in round-robin
396 * fashion. The service lookup is done during the driver init
397 * function to minmise the impact of 'getaddrinfo()'.
399 * Alas, the init function is called even if there are no clocks
400 * configured for this driver. So it makes sense to defer the logging of
401 * any errors or other notifications until the first clock unit is
402 * started -- otherwise there might be syslog entries from a driver that
403 * is not used at all.
405 static addrinfoT *s_gpsd_addr;
406 static gpsd_unitT *s_clock_units;
408 /* list of service/socket names we want to resolve against */
409 static const char * const s_svctab[][2] = {
410 { "localhost", "gpsd" },
411 { "localhost", "2947" },
412 { "127.0.0.1", "2947" },
416 /* list of address resolution errors and index of service entry that
419 static int s_svcerr[sizeof(s_svctab)/sizeof(s_svctab[0])];
422 /* =====================================================================
427 clockprocT * const pp,
428 gpsd_unitT * const up)
430 int res = (0 != (pp->sloppyclockflag & CLK_FLAG3))
431 || (0 == up->logthrottle )
432 || (LOGTHROTTLE == up->logthrottle );
434 up->logthrottle = LOGTHROTTLE;
438 /* =====================================================================
439 * the clock functions
442 /* ---------------------------------------------------------------------
443 * Init: This currently just gets the socket address for the GPS daemon
451 memset(s_svcerr, 0, sizeof(s_svcerr));
452 memset(&hints, 0, sizeof(hints));
453 hints.ai_family = AF_UNSPEC;
454 hints.ai_protocol = IPPROTO_TCP;
455 hints.ai_socktype = SOCK_STREAM;
457 for (idx = 0; s_svctab[idx][0] && !s_gpsd_addr; idx++) {
458 rc = getaddrinfo(s_svctab[idx][0], s_svctab[idx][1],
459 &hints, &s_gpsd_addr);
468 /* ---------------------------------------------------------------------
469 * Init Check: flush pending log messages and check if we can proceed
472 gpsd_init_check(void)
476 /* Check if there is something to log */
478 return (s_gpsd_addr != NULL);
480 /* spool out the resolver errors */
481 for (idx = 0; idx < s_svcidx; ++idx) {
483 "GPSD_JSON: failed to resolve '%s:%s', rc=%d (%s)",
484 s_svctab[idx][0], s_svctab[idx][1],
485 s_svcerr[idx], gai_strerror(s_svcerr[idx]));
488 /* check if it was fatal, or if we can proceed */
489 if (s_gpsd_addr == NULL)
490 msyslog(LOG_ERR, "%s",
491 "GPSD_JSON: failed to get socket address, giving up.");
494 "GPSD_JSON: using '%s:%s' instead of '%s:%s'",
495 s_svctab[idx][0], s_svctab[idx][1],
496 s_svctab[0][0], s_svctab[0][1]);
498 /* make sure this gets logged only once and tell if we can
502 return (s_gpsd_addr != NULL);
505 /* ---------------------------------------------------------------------
506 * Start: allocate a unit pointer and set up the runtime data
513 clockprocT * const pp = peer->procptr;
515 gpsd_unitT ** uscan = &s_clock_units;
519 /* check if we can proceed at all or if init failed */
520 if ( ! gpsd_init_check())
523 /* search for matching unit */
524 while ((up = *uscan) != NULL && up->unit != (unit & 0x7F))
525 uscan = &up->next_unit;
527 /* alloc unit, add to list and increment use count ASAP. */
528 up = emalloc_zero(sizeof(*up));
532 /* initialize the unit structure */
533 up->logname = estrdup(refnumtoa(&peer->srcadr));
534 up->unit = unit & 0x7F;
536 up->addr = s_gpsd_addr;
537 up->tickpres = TICKOVER_LOW;
539 /* Create the device name and check for a Character
540 * Device. It's assumed that GPSD was started with the
541 * same link, so the names match. (If this is not
542 * practicable, we will have to read the symlink, if
543 * any, so we can get the true device file.)
545 if (-1 == myasprintf(&up->device, "%s%u",
546 s_dev_stem, up->unit)) {
547 msyslog(LOG_ERR, "%s: clock device name too long",
551 if (-1 == stat(up->device, &sb) || !S_ISCHR(sb.st_mode)) {
552 msyslog(LOG_ERR, "%s: '%s' is not a character device",
553 up->logname, up->device);
557 /* All set up, just increment use count. */
561 /* setup refclock processing */
562 pp->unitptr = (caddr_t)up;
564 pp->io.clock_recv = gpsd_receive;
565 pp->io.srcclock = peer;
567 pp->a_lastcode[0] = '\0';
569 pp->clockdesc = DESCRIPTION;
570 memcpy(&pp->refid, REFID, 4);
572 /* Initialize miscellaneous variables */
574 peer->precision = PPS_PRECISION;
576 peer->precision = PRECISION;
578 /* If the daemon name lookup failed, just give up now. */
579 if (NULL == up->addr) {
580 msyslog(LOG_ERR, "%s: no GPSD socket address, giving up",
586 (LOG_NOTICE, "%s: startup, device is '%s'",
587 refnumtoa(&peer->srcadr), up->device));
588 up->mode = MODE_OP_MODE(peer->ttl);
589 if (up->mode > MODE_OP_MAXVAL)
594 enter_opmode(peer, up->mode);
598 /* On failure, remove all UNIT ressources and declare defeat. */
601 if (!--up->refcount) {
602 *uscan = up->next_unit;
607 pp->unitptr = (caddr_t)NULL;
611 /* ------------------------------------------------------------------ */
618 clockprocT * const pp = peer->procptr;
619 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
620 gpsd_unitT ** uscan = &s_clock_units;
624 /* The unit pointer might have been removed already. */
628 /* now check if we must close IO resources */
629 if (peer != up->pps_peer) {
630 if (-1 != pp->io.fd) {
631 DPRINTF(1, ("%s: closing clock, fd=%d\n",
632 up->logname, pp->io.fd));
633 io_closeclock(&pp->io);
639 /* decrement use count and eventually remove this unit. */
640 if (!--up->refcount) {
641 /* unlink this unit */
642 while (*uscan != NULL)
644 *uscan = up->next_unit;
646 uscan = &(*uscan)->next_unit;
651 pp->unitptr = (caddr_t)NULL;
653 (LOG_NOTICE, "%s: shutdown", refnumtoa(&peer->srcadr)));
656 /* ------------------------------------------------------------------ */
660 struct recvbuf * rbufp)
662 /* declare & init control structure ptrs */
663 peerT * const peer = rbufp->recv_peer;
664 clockprocT * const pp = peer->procptr;
665 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
667 const char *psrc, *esrc;
668 char *pdst, *edst, ch;
670 /* log the data stream, if this is enabled */
671 log_data(peer, "recv", (const char*)rbufp->recv_buffer,
672 (size_t)rbufp->recv_length);
675 /* Since we're getting a raw stream data, we must assemble lines
676 * in our receive buffer. We can't use neither 'refclock_gtraw'
677 * not 'refclock_gtlin' here... We process chars until we reach
678 * an EoL (that is, line feed) but we truncate the message if it
679 * does not fit the buffer. GPSD might truncate messages, too,
680 * so dealing with truncated buffers is necessary anyway.
682 psrc = (const char*)rbufp->recv_buffer;
683 esrc = psrc + rbufp->recv_length;
685 pdst = up->buffer + up->buflen;
686 edst = pdst + sizeof(up->buffer) - 1; /* for trailing NUL */
688 while (psrc != esrc) {
691 /* trim trailing whitespace & terminate buffer */
692 while (pdst != up->buffer && pdst[-1] <= ' ')
695 /* process data and reset buffer */
696 up->buflen = pdst - up->buffer;
697 gpsd_parse(peer, &rbufp->recv_time);
699 } else if (pdst != edst) {
700 /* add next char, ignoring leading whitespace */
701 if (ch > ' ' || pdst != up->buffer)
705 up->buflen = pdst - up->buffer;
706 up->tickover = TICKOVER_LOW;
709 /* ------------------------------------------------------------------ */
714 clockprocT * const pp ,
715 gpsd_unitT * const up )
717 if (pp->coderecv != pp->codeproc) {
719 pp->lastref = pp->lastrec;
720 refclock_report(peer, CEVNT_NOMINAL);
721 refclock_receive(peer);
723 /* Not working properly, admit to it. If we have no
724 * connection to GPSD, declare the clock as faulty. If
725 * there were bad replies, this is handled as the major
726 * cause, and everything else is just a timeout.
728 peer->precision = PRECISION;
730 refclock_report(peer, CEVNT_FAULT);
731 else if (0 != up->tc_breply)
732 refclock_report(peer, CEVNT_BADREPLY);
734 refclock_report(peer, CEVNT_TIMEOUT);
737 if (pp->sloppyclockflag & CLK_FLAG4)
739 &peer->srcadr,"%u %u %u %u %u %u %u",
741 up->tc_breply, up->tc_nosync,
742 up->tc_sti_recv, up->tc_sti_used,
743 up->tc_pps_recv, up->tc_pps_used);
745 /* clear tallies for next round */
758 clockprocT * const pp ,
759 gpsd_unitT * const up )
761 if (pp->coderecv != pp->codeproc) {
763 pp->lastref = pp->lastrec;
764 refclock_report(peer, CEVNT_NOMINAL);
765 refclock_receive(peer);
767 peer->precision = PPS_PRECISION;
768 peer->flags &= ~FLAG_PPS;
769 refclock_report(peer, CEVNT_TIMEOUT);
778 clockprocT * const pp = peer->procptr;
779 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
782 if (peer == up->pps_peer)
783 poll_secondary(peer, pp, up);
785 poll_primary(peer, pp, up);
788 /* ------------------------------------------------------------------ */
793 const struct refclockstat * in_st,
794 struct refclockstat * out_st,
797 clockprocT * const pp = peer->procptr;
798 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
800 if (peer == up->pps_peer) {
801 DTOLFP(pp->fudgetime1, &up->pps_fudge2);
802 if ( ! (pp->sloppyclockflag & CLK_FLAG1))
803 peer->flags &= ~FLAG_PPS;
805 /* save preprocessed fudge times */
806 DTOLFP(pp->fudgetime1, &up->pps_fudge);
807 DTOLFP(pp->fudgetime2, &up->sti_fudge);
809 if (MODE_OP_MODE(up->mode ^ peer->ttl)) {
810 leave_opmode(peer, up->mode);
811 up->mode = MODE_OP_MODE(peer->ttl);
812 enter_opmode(peer, up->mode);
817 /* ------------------------------------------------------------------ */
822 clockprocT * const pp ,
823 gpsd_unitT * const up )
827 /* This is used for timeout handling. Nothing that needs
828 * sub-second precison happens here, so receive/connect/retry
829 * timeouts are simply handled by a count down, and then we
830 * decide what to do by the socket values.
832 * Note that the timer stays at zero here, unless some of the
833 * functions set it to another value.
839 switch (up->tickover) {
841 /* If we are connected to GPSD, try to get a live signal
842 * by querying the version. Otherwise just check the
843 * socket to become ready.
845 if (-1 != pp->io.fd) {
846 size_t rlen = strlen(s_req_version);
847 DPRINTF(2, ("%s: timer livecheck: '%s'\n",
848 up->logname, s_req_version));
849 log_data(peer, "send", s_req_version, rlen);
850 rc = write(pp->io.fd, s_req_version, rlen);
852 } else if (-1 != up->fdt) {
853 gpsd_test_socket(peer);
859 gpsd_stop_socket(peer);
860 else if (-1 != up->fdt)
861 gpsd_test_socket(peer);
862 else if (NULL != s_gpsd_addr)
863 gpsd_init_socket(peer);
867 if (-1 == pp->io.fd && -1 != up->fdt)
868 gpsd_test_socket(peer);
875 clockprocT * const pp ,
876 gpsd_unitT * const up )
878 /* Reduce the count by one. Flush sample buffer and clear PPS
879 * flag when this happens.
881 up->ppscount2 = max(0, (up->ppscount2 - 1));
882 if (0 == up->ppscount2) {
883 if (pp->coderecv != pp->codeproc) {
884 refclock_report(peer, CEVNT_TIMEOUT);
885 pp->coderecv = pp->codeproc;
887 peer->flags &= ~FLAG_PPS;
896 clockprocT * const pp = peer->procptr;
897 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
899 if (peer == up->pps_peer)
900 timer_secondary(peer, pp, up);
902 timer_primary(peer, pp, up);
905 /* =====================================================================
906 * handle opmode switches
914 clockprocT * const pp = peer->procptr;
915 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
917 DPRINTF(1, ("%s: enter operation mode %d\n",
918 up->logname, MODE_OP_MODE(mode)));
920 if (MODE_OP_MODE(mode) == MODE_OP_AUTO) {
922 up->ppscount = PPS_MAXCOUNT / 2;
928 /* ------------------------------------------------------------------ */
935 clockprocT * const pp = peer->procptr;
936 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
938 DPRINTF(1, ("%s: leaving operation mode %d\n",
939 up->logname, MODE_OP_MODE(mode)));
941 if (MODE_OP_MODE(mode) == MODE_OP_AUTO) {
949 /* =====================================================================
950 * operation mode specific evaluation
956 clockprocT * const pp ,
961 if (pp->coderecv == pp->codeproc)
962 refclock_report(peer, CEVNT_NOMINAL);
963 refclock_process_offset(pp, stamp, recvt, 0.0);
966 /* ------------------------------------------------------------------ */
971 clockprocT * const pp ,
972 gpsd_unitT * const up )
974 if (up->fl_sti && up->fl_pps) {
975 /* use TPV reference time + PPS receive time */
976 add_clock_sample(peer, pp, up->sti_stamp, up->pps_recvt);
977 peer->precision = up->pps_prec;
978 /* both packets consumed now... */
985 /* ------------------------------------------------------------------ */
986 /* PPS processing for the secondary channel. GPSD provides us with full
987 * timing information, so there's no danger of PLL-locking to the wrong
988 * second. The belts and suspenders needed for the raw ATOM clock are
994 clockprocT * const pp ,
995 gpsd_unitT * const up )
999 add_clock_sample(peer, pp, up->pps_stamp2, up->pps_recvt2);
1000 peer->precision = up->pps_prec;
1001 /* PPS peer flag logic */
1002 up->ppscount2 = min(PPS2_MAXCOUNT, (up->ppscount2 + 2));
1003 if ((PPS2_MAXCOUNT == up->ppscount2) &&
1004 (pp->sloppyclockflag & CLK_FLAG1) )
1005 peer->flags |= FLAG_PPS;
1006 /* mark time stamp as burned... */
1012 /* ------------------------------------------------------------------ */
1016 peerT * const peer ,
1017 clockprocT * const pp ,
1018 gpsd_unitT * const up )
1021 add_clock_sample(peer, pp, up->sti_stamp, up->sti_recvt);
1022 peer->precision = up->sti_prec;
1023 /* mark time stamp as burned... */
1029 /* ------------------------------------------------------------------ */
1032 peerT * const peer ,
1033 clockprocT * const pp ,
1034 gpsd_unitT * const up )
1036 /* If there's no TPV available, stop working here... */
1040 /* check how to handle STI+PPS: Can PPS be used to augment STI
1041 * (or vice versae), do we drop the sample because there is a
1042 * temporary missing PPS signal, or do we feed on STI time
1045 * Do a counter/threshold dance to decide how to proceed.
1048 up->ppscount = min(PPS_MAXCOUNT,
1049 (up->ppscount + PPS_INCCOUNT));
1050 if ((PPS_MAXCOUNT == up->ppscount) && up->fl_rawsti) {
1053 "%s: expect valid PPS from now",
1057 up->ppscount = max(0, (up->ppscount - PPS_DECCOUNT));
1058 if ((0 == up->ppscount) && !up->fl_rawsti) {
1060 msyslog(LOG_WARNING,
1061 "%s: use TPV alone from now",
1066 /* now eventually feed the sample */
1068 eval_serial(peer, pp, up);
1070 eval_strict(peer, pp, up);
1073 /* =====================================================================
1074 * JSON parsing stuff
1077 /* ------------------------------------------------------------------ */
1078 /* Parse a decimal integer with a possible sign. Works like 'strtoll()'
1079 * or 'strtol()', but with a fixed base of 10 and without eating away
1080 * leading whitespace. For the error codes, the handling of the end
1081 * pointer and the return values see 'strtol()'.
1085 const char *cp, char **ep)
1087 json_uint accu, limit_lo, limit_hi;
1088 int flags; /* bit 0: overflow; bit 1: sign */
1091 /* pointer union to circumvent a tricky/sticky const issue */
1092 union { const char * c; char * v; } vep;
1094 /* store initial value of 'cp' -- see 'strtol()' */
1097 /* Eat away an optional sign and set the limits accordingly: The
1098 * high limit is the maximum absolute value that can be returned,
1099 * and the low limit is the biggest value that does not cause an
1100 * overflow when multiplied with 10. Avoid negation overflows.
1105 limit_hi = (json_uint)-(JSON_INT_MIN + 1) + 1;
1109 limit_hi = (json_uint)JSON_INT_MAX;
1111 limit_lo = limit_hi / 10;
1113 /* Now try to convert a sequence of digits. */
1116 while (isdigit(*(const unsigned char*)cp)) {
1117 flags |= (accu > limit_lo);
1118 accu = accu * 10 + (*(const unsigned char*)cp++ - '0');
1119 flags |= (accu > limit_hi);
1121 /* Check for empty conversion (no digits seen). */
1125 errno = EINVAL; /* accu is still zero */
1126 /* Check for range overflow */
1131 /* If possible, store back the end-of-conversion pointer */
1134 /* If negative, return the negated result if the accu is not
1135 * zero. Avoid negation overflows.
1137 if ((flags & 2) && accu)
1138 return -(json_int)(accu - 1) - 1;
1140 return (json_int)accu;
1143 /* ------------------------------------------------------------------ */
1147 const json_ctx * ctx,
1150 if (tid >= 0 && tid < ctx->ntok) {
1151 int len = ctx->tok[tid].size;
1152 /* For arrays and objects, the size is the number of
1153 * ITEMS in the compound. Thats the number of objects in
1154 * the array, and the number of key/value pairs for
1155 * objects. In theory, the key must be a string, and we
1156 * could simply skip one token before skipping the
1157 * value, which can be anything. We're a bit paranoid
1158 * and lazy at the same time: We simply double the
1159 * number of tokens to skip and fall through into the
1160 * array processing when encountering an object.
1162 switch (ctx->tok[tid].type) {
1167 for (++tid; len; --len)
1168 tid = json_token_skip(ctx, tid);
1175 if (tid > ctx->ntok) /* Impossible? Paranoia rulez. */
1181 /* ------------------------------------------------------------------ */
1185 const json_ctx * ctx ,
1192 if (tid < 0 || tid >= ctx->ntok ||
1193 ctx->tok[tid].type != JSMN_OBJECT)
1194 return INVALID_TOKEN;
1196 len = ctx->tok[tid].size;
1197 for (++tid; len && tid+1 < ctx->ntok; --len) {
1198 if (ctx->tok[tid].type != JSMN_STRING) { /* Blooper! */
1199 tid = json_token_skip(ctx, tid); /* skip key */
1200 tid = json_token_skip(ctx, tid); /* skip val */
1201 } else if (strcmp(key, ctx->buf + ctx->tok[tid].start)) {
1202 tid = json_token_skip(ctx, tid+1); /* skip key+val */
1203 } else if (what < 0 || what == ctx->tok[tid+1].type) {
1208 /* if skipping ahead returned an error, bail out here. */
1212 return INVALID_TOKEN;
1215 /* ------------------------------------------------------------------ */
1218 json_object_lookup_primitive(
1219 const json_ctx * ctx,
1223 tid = json_object_lookup(ctx, tid, key, JSMN_PRIMITIVE);
1224 if (INVALID_TOKEN != tid)
1225 return ctx->buf + ctx->tok[tid].start;
1229 /* ------------------------------------------------------------------ */
1230 /* look up a boolean value. This essentially returns a tribool:
1231 * 0->false, 1->true, (-1)->error/undefined
1234 json_object_lookup_bool(
1235 const json_ctx * ctx,
1240 cp = json_object_lookup_primitive(ctx, tid, key);
1241 switch ( cp ? *cp : '\0') {
1244 default : return -1;
1248 /* ------------------------------------------------------------------ */
1251 json_object_lookup_string(
1252 const json_ctx * ctx,
1256 tid = json_object_lookup(ctx, tid, key, JSMN_STRING);
1257 if (INVALID_TOKEN != tid)
1258 return ctx->buf + ctx->tok[tid].start;
1263 json_object_lookup_string_default(
1264 const json_ctx * ctx,
1269 tid = json_object_lookup(ctx, tid, key, JSMN_STRING);
1270 if (INVALID_TOKEN != tid)
1271 return ctx->buf + ctx->tok[tid].start;
1275 /* ------------------------------------------------------------------ */
1278 json_object_lookup_int(
1279 const json_ctx * ctx,
1287 cp = json_object_lookup_primitive(ctx, tid, key);
1289 ret = strtojint(cp, &ep);
1290 if (cp != ep && '\0' == *ep)
1299 json_object_lookup_int_default(
1300 const json_ctx * ctx,
1309 cp = json_object_lookup_primitive(ctx, tid, key);
1311 ret = strtojint(cp, &ep);
1312 if (cp != ep && '\0' == *ep)
1318 /* ------------------------------------------------------------------ */
1319 #if 0 /* currently unused */
1321 json_object_lookup_float(
1322 const json_ctx * ctx,
1330 cp = json_object_lookup_primitive(ctx, tid, key);
1332 ret = strtod(cp, &ep);
1333 if (cp != ep && '\0' == *ep)
1343 json_object_lookup_float_default(
1344 const json_ctx * ctx,
1353 cp = json_object_lookup_primitive(ctx, tid, key);
1355 ret = strtod(cp, &ep);
1356 if (cp != ep && '\0' == *ep)
1362 /* ------------------------------------------------------------------ */
1374 rc = jsmn_parse(&jsm, buf, len, ctx->tok, JSMN_MAXTOK);
1380 if (JSMN_OBJECT != ctx->tok[0].type)
1381 return FALSE; /* not object!?! */
1383 /* Make all tokens NUL terminated by overwriting the
1384 * terminator symbol. Makes string compares and number parsing a
1387 for (idx = 0; idx < ctx->ntok; ++idx)
1388 if (ctx->tok[idx].end > ctx->tok[idx].start)
1389 ctx->buf[ctx->tok[idx].end] = '\0';
1394 /* =====================================================================
1395 * static local helpers
1400 json_ctx * const jctx ,
1401 const char * const time_name,
1402 const char * const frac_name,
1409 ts.tv_sec = (time_t)json_object_lookup_int(jctx, 0, time_name);
1410 ts.tv_nsec = (long )json_object_lookup_int(jctx, 0, frac_name);
1412 ts.tv_nsec *= fscale;
1413 *dest = tspec_stamp_to_lfp(ts);
1419 /* ------------------------------------------------------------------ */
1420 /* Process a WATCH record
1422 * Currently this is only used to recognise that the device is present
1423 * and that we're listed subscribers.
1427 peerT * const peer ,
1428 json_ctx * const jctx ,
1429 const l_fp * const rtime)
1431 clockprocT * const pp = peer->procptr;
1432 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1436 path = json_object_lookup_string(jctx, 0, "device");
1437 if (NULL == path || strcmp(path, up->device))
1440 if (json_object_lookup_bool(jctx, 0, "enable") > 0 &&
1441 json_object_lookup_bool(jctx, 0, "json" ) > 0 )
1445 DPRINTF(2, ("%s: process_watch, enabled=%d\n",
1446 up->logname, (up->fl_watch & 1)));
1449 /* ------------------------------------------------------------------ */
1453 peerT * const peer ,
1454 json_ctx * const jctx ,
1455 const l_fp * const rtime)
1457 clockprocT * const pp = peer->procptr;
1458 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1462 const char *revision;
1463 const char *release;
1464 uint16_t pvhi, pvlo;
1466 /* get protocol version number */
1467 revision = json_object_lookup_string_default(
1468 jctx, 0, "rev", "(unknown)");
1469 release = json_object_lookup_string_default(
1470 jctx, 0, "release", "(unknown)");
1472 pvhi = (uint16_t)json_object_lookup_int(jctx, 0, "proto_major");
1473 pvlo = (uint16_t)json_object_lookup_int(jctx, 0, "proto_minor");
1478 "%s: GPSD revision=%s release=%s protocol=%u.%u",
1479 up->logname, revision, release,
1481 up->proto_version = PROTO_VERSION(pvhi, pvlo);
1484 if (syslogok(pp, up))
1486 "%s: could not evaluate version data",
1490 /* With the 3.9 GPSD protocol, '*_musec' vanished from the PPS
1491 * record and was replace by '*_nsec'.
1493 up->pf_nsec = -(up->proto_version >= PROTO_VERSION(3,9));
1495 /* With the 3.10 protocol we can get TOFF records for better
1496 * timing information.
1498 up->pf_toff = -(up->proto_version >= PROTO_VERSION(3,10));
1500 /* request watch for our GPS device if not yet watched.
1502 * The version string is also sent as a life signal, if we have
1503 * seen useable data. So if we're already watching the device,
1506 * Reuse the input buffer, which is no longer needed in the
1507 * current cycle. Also assume that we can write the watch
1508 * request in one sweep into the socket; since we do not do
1509 * output otherwise, this should always work. (Unless the
1510 * TCP/IP window size gets lower than the length of the
1511 * request. We handle that when it happens.)
1516 snprintf(up->buffer, sizeof(up->buffer),
1517 s_req_watch[up->pf_toff != 0], up->device);
1520 log_data(peer, "send", buf, len);
1521 if (len != write(pp->io.fd, buf, len) && (syslogok(pp, up))) {
1522 /* Note: if the server fails to read our request, the
1523 * resulting data timeout will take care of the
1526 msyslog(LOG_ERR, "%s: failed to write watch request (%m)",
1531 /* ------------------------------------------------------------------ */
1535 peerT * const peer ,
1536 json_ctx * const jctx ,
1537 const l_fp * const rtime)
1539 clockprocT * const pp = peer->procptr;
1540 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1542 const char * gps_time;
1547 gps_mode = (int)json_object_lookup_int_default(
1548 jctx, 0, "mode", 0);
1550 gps_time = json_object_lookup_string(
1553 /* accept time stamps only in 2d or 3d fix */
1554 if (gps_mode < 2 || NULL == gps_time) {
1555 /* receiver has no fix; tell about and avoid stale data */
1566 /* convert clock and set resulting ref time, but only if the
1567 * TOFF sentence is *not* available
1569 if ( ! up->pf_toff) {
1571 /* save last time code to clock data */
1572 save_ltc(pp, gps_time);
1573 /* now parse the time string */
1574 if (convert_ascii_time(&up->sti_stamp, gps_time)) {
1575 DPRINTF(2, ("%s: process_tpv, stamp='%s',"
1576 " recvt='%s' mode=%u\n",
1578 gmprettydate(&up->sti_stamp),
1579 gmprettydate(&up->sti_recvt),
1582 /* have to use local receive time as substitute
1583 * for the real receive time: TPV does not tell
1586 up->sti_local = *rtime;
1587 up->sti_recvt = *rtime;
1588 L_SUB(&up->sti_recvt, &up->sti_fudge);
1596 /* Set the precision from the GPSD data
1597 * Use the ETP field for an estimation of the precision of the
1598 * serial data. If ETP is not available, use the default serial
1599 * data presion instead. (Note: The PPS branch has a different
1600 * precision estimation, since it gets the proper value directly
1603 ept = json_object_lookup_float_default(jctx, 0, "ept", 2.0e-3);
1604 ept = frexp(fabs(ept)*0.70710678, &xlog2); /* ~ sqrt(0.5) */
1609 up->sti_prec = clamped_precision(xlog2);
1612 /* ------------------------------------------------------------------ */
1616 peerT * const peer ,
1617 json_ctx * const jctx ,
1618 const l_fp * const rtime)
1620 clockprocT * const pp = peer->procptr;
1621 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1627 /* Bail out if there's indication that time sync is bad or
1628 * if we're explicitely requested to ignore PPS data.
1633 up->pps_local = *rtime;
1634 /* Now grab the time values. 'clock_*' is the event time of the
1635 * pulse measured on the local system clock; 'real_*' is the GPS
1636 * reference time GPSD associated with the pulse.
1639 if ( ! get_binary_time(&up->pps_recvt2, jctx,
1640 "clock_sec", "clock_nsec", 1))
1642 if ( ! get_binary_time(&up->pps_stamp2, jctx,
1643 "real_sec", "real_nsec", 1))
1646 if ( ! get_binary_time(&up->pps_recvt2, jctx,
1647 "clock_sec", "clock_musec", 1000))
1649 if ( ! get_binary_time(&up->pps_stamp2, jctx,
1650 "real_sec", "real_musec", 1000))
1654 /* Try to read the precision field from the PPS record. If it's
1655 * not there, take the precision from the serial data.
1657 xlog2 = json_object_lookup_int_default(
1658 jctx, 0, "precision", up->sti_prec);
1659 up->pps_prec = clamped_precision(xlog2);
1661 /* Get fudged receive times for primary & secondary unit */
1662 up->pps_recvt = up->pps_recvt2;
1663 L_SUB(&up->pps_recvt , &up->pps_fudge );
1664 L_SUB(&up->pps_recvt2, &up->pps_fudge2);
1665 pp->lastrec = up->pps_recvt;
1667 /* Map to nearest full second as reference time stamp for the
1668 * primary channel. Sanity checks are done in evaluation step.
1670 up->pps_stamp = up->pps_recvt;
1671 L_ADDUF(&up->pps_stamp, 0x80000000u);
1672 up->pps_stamp.l_uf = 0;
1674 if (NULL != up->pps_peer)
1675 save_ltc(up->pps_peer->procptr,
1676 gmprettydate(&up->pps_stamp2));
1677 DPRINTF(2, ("%s: PPS record processed,"
1678 " stamp='%s', recvt='%s'\n",
1680 gmprettydate(&up->pps_stamp2),
1681 gmprettydate(&up->pps_recvt2)));
1683 up->fl_pps = (0 != (pp->sloppyclockflag & CLK_FLAG2)) - 1;
1688 DPRINTF(1, ("%s: PPS record processing FAILED\n",
1693 /* ------------------------------------------------------------------ */
1697 peerT * const peer ,
1698 json_ctx * const jctx ,
1699 const l_fp * const rtime)
1701 clockprocT * const pp = peer->procptr;
1702 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1706 /* remember this! */
1709 /* bail out if there's indication that time sync is bad */
1713 if ( ! get_binary_time(&up->sti_recvt, jctx,
1714 "clock_sec", "clock_nsec", 1))
1716 if ( ! get_binary_time(&up->sti_stamp, jctx,
1717 "real_sec", "real_nsec", 1))
1719 L_SUB(&up->sti_recvt, &up->sti_fudge);
1720 up->sti_local = *rtime;
1723 save_ltc(pp, gmprettydate(&up->sti_stamp));
1724 DPRINTF(2, ("%s: TOFF record processed,"
1725 " stamp='%s', recvt='%s'\n",
1727 gmprettydate(&up->sti_stamp),
1728 gmprettydate(&up->sti_recvt)));
1732 DPRINTF(1, ("%s: TOFF record processing FAILED\n",
1737 /* ------------------------------------------------------------------ */
1741 peerT * const peer ,
1742 const l_fp * const rtime)
1744 clockprocT * const pp = peer->procptr;
1745 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1749 DPRINTF(2, ("%s: gpsd_parse: time %s '%.*s'\n",
1750 up->logname, ulfptoa(rtime, 6),
1751 up->buflen, up->buffer));
1753 /* See if we can grab anything potentially useful. JSMN does not
1754 * need a trailing NUL, but it needs the number of bytes to
1756 if (!json_parse_record(&up->json_parse, up->buffer, up->buflen)) {
1761 /* Now dispatch over the objects we know */
1762 clsid = json_object_lookup_string(&up->json_parse, 0, "class");
1763 if (NULL == clsid) {
1768 if (!strcmp("TPV", clsid))
1769 process_tpv(peer, &up->json_parse, rtime);
1770 else if (!strcmp("PPS", clsid))
1771 process_pps(peer, &up->json_parse, rtime);
1772 else if (!strcmp("TOFF", clsid))
1773 process_toff(peer, &up->json_parse, rtime);
1774 else if (!strcmp("VERSION", clsid))
1775 process_version(peer, &up->json_parse, rtime);
1776 else if (!strcmp("WATCH", clsid))
1777 process_watch(peer, &up->json_parse, rtime);
1779 return; /* nothing we know about... */
1782 /* if possible, feed the PPS side channel */
1785 up->pps_peer, up->pps_peer->procptr, up);
1787 /* check PPS vs. STI receive times:
1788 * If STI is before PPS, then clearly the STI is too old. If PPS
1789 * is before STI by more than one second, then PPS is too old.
1790 * Weed out stale time stamps & flags.
1792 if (up->fl_pps && up->fl_sti) {
1794 diff = up->sti_local;
1795 L_SUB(&diff, &up->pps_local);
1797 up->fl_pps = 0; /* pps too old */
1798 else if (diff.l_i < 0)
1799 up->fl_sti = 0; /* serial data too old */
1802 /* dispatch to the mode-dependent processing functions */
1806 eval_serial(peer, pp, up);
1809 case MODE_OP_STRICT:
1810 eval_strict(peer, pp, up);
1814 eval_auto(peer, pp, up);
1819 /* ------------------------------------------------------------------ */
1825 clockprocT * const pp = peer->procptr;
1826 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1828 if (-1 != pp->io.fd) {
1829 if (syslogok(pp, up))
1831 "%s: closing socket to GPSD, fd=%d",
1832 up->logname, pp->io.fd);
1834 DPRINTF(1, ("%s: closing socket to GPSD, fd=%d\n",
1835 up->logname, pp->io.fd));
1836 io_closeclock(&pp->io);
1839 up->tickover = up->tickpres;
1840 up->tickpres = min(up->tickpres + 5, TICKOVER_HIGH);
1847 /* ------------------------------------------------------------------ */
1853 clockprocT * const pp = peer->procptr;
1854 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1859 /* draw next address to try */
1860 if (NULL == up->addr)
1861 up->addr = s_gpsd_addr;
1863 up->addr = ai->ai_next;
1865 /* try to create a matching socket */
1867 ai->ai_family, ai->ai_socktype, ai->ai_protocol);
1868 if (-1 == up->fdt) {
1869 if (syslogok(pp, up))
1871 "%s: cannot create GPSD socket: %m",
1876 /* Make sure the socket is non-blocking. Connect/reconnect and
1877 * IO happen in an event-driven environment, and synchronous
1878 * operations wreak havoc on that.
1880 rc = fcntl(up->fdt, F_SETFL, O_NONBLOCK, 1);
1882 if (syslogok(pp, up))
1884 "%s: cannot set GPSD socket to non-blocking: %m",
1888 /* Disable nagling. The way both GPSD and NTPD handle the
1889 * protocol makes it record-oriented, and in most cases
1890 * complete records (JSON serialised objects) will be sent in
1891 * one sweep. Nagling gives not much advantage but adds another
1892 * delay, which can worsen the situation for some packets.
1895 rc = setsockopt(up->fdt, IPPROTO_TCP, TCP_NODELAY,
1896 (char*)&ov, sizeof(ov));
1898 if (syslogok(pp, up))
1900 "%s: cannot disable TCP nagle: %m",
1904 /* Start a non-blocking connect. There might be a synchronous
1905 * connection result we have to handle.
1907 rc = connect(up->fdt, ai->ai_addr, ai->ai_addrlen);
1909 if (errno == EINPROGRESS) {
1910 DPRINTF(1, ("%s: async connect pending, fd=%d\n",
1911 up->logname, up->fdt));
1915 if (syslogok(pp, up))
1917 "%s: cannot connect GPSD socket: %m",
1922 /* We had a successful synchronous connect, so we add the
1923 * refclock processing ASAP. We still have to wait for the
1924 * version string and apply the watch command later on, but we
1925 * might as well get the show on the road now.
1927 DPRINTF(1, ("%s: new socket connection, fd=%d\n",
1928 up->logname, up->fdt));
1930 pp->io.fd = up->fdt;
1932 if (0 == io_addclock(&pp->io)) {
1933 if (syslogok(pp, up))
1935 "%s: failed to register with I/O engine",
1943 if (-1 != pp->io.fd)
1949 up->tickover = up->tickpres;
1950 up->tickpres = min(up->tickpres + 5, TICKOVER_HIGH);
1953 /* ------------------------------------------------------------------ */
1959 clockprocT * const pp = peer->procptr;
1960 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
1965 /* Check if the non-blocking connect was finished by testing the
1966 * socket for writeability. Use the 'poll()' API if available
1967 * and 'select()' otherwise.
1969 DPRINTF(2, ("%s: check connect, fd=%d\n",
1970 up->logname, up->fdt));
1972 #if defined(HAVE_SYS_POLL_H)
1976 pfd.events = POLLOUT;
1978 rc = poll(&pfd, 1, 0);
1979 if (1 != rc || !(pfd.revents & POLLOUT))
1982 #elif defined(HAVE_SYS_SELECT_H)
1984 struct timeval tout;
1987 memset(&tout, 0, sizeof(tout));
1989 FD_SET(up->fdt, &wset);
1990 rc = select(up->fdt+1, NULL, &wset, NULL, &tout);
1991 if (0 == rc || !(FD_ISSET(up->fdt, &wset)))
1995 # error Blooper! That should have been found earlier!
1998 /* next timeout is a full one... */
1999 up->tickover = TICKOVER_LOW;
2001 /* check for socket error */
2004 rc = getsockopt(up->fdt, SOL_SOCKET, SO_ERROR, &ec, &lc);
2005 if (-1 == rc || 0 != ec) {
2009 errtxt = strerror(ec);
2010 if (syslogok(pp, up))
2012 "%s: async connect to GPSD failed,"
2013 " fd=%d, ec=%d(%s)",
2014 up->logname, up->fdt, ec, errtxt);
2016 DPRINTF(1, ("%s: async connect to GPSD failed,"
2017 " fd=%d, ec=%d(%s)\n",
2018 up->logname, up->fdt, ec, errtxt));
2021 DPRINTF(1, ("%s: async connect to GPSD succeeded, fd=%d\n",
2022 up->logname, up->fdt));
2025 /* swap socket FDs, and make sure the clock was added */
2026 pp->io.fd = up->fdt;
2028 if (0 == io_addclock(&pp->io)) {
2029 if (syslogok(pp, up))
2031 "%s: failed to register with I/O engine",
2038 if (-1 != up->fdt) {
2039 DPRINTF(1, ("%s: closing socket, fd=%d\n",
2040 up->logname, up->fdt));
2044 up->tickover = up->tickpres;
2045 up->tickpres = min(up->tickpres + 5, TICKOVER_HIGH);
2048 /* =====================================================================
2052 /* -------------------------------------------------------------------
2053 * store a properly clamped precision value
2063 return (int16_t)rawprec;
2066 /* -------------------------------------------------------------------
2067 * Convert a GPSD timestamp (ISO8601 Format) to an l_fp
2072 const char * gps_time)
2079 /* Use 'strptime' to take the brunt of the work, then parse
2080 * the fractional part manually, starting with a digit weight of
2084 ep = strptime(gps_time, "%Y-%m-%dT%H:%M:%S", &gd);
2086 return FALSE; /* could not parse the mandatory stuff! */
2089 while (isdigit(*(unsigned char*)++ep)) {
2090 ts.tv_nsec += (*(unsigned char*)ep - '0') * dw;
2094 if (ep[0] != 'Z' || ep[1] != '\0')
2095 return FALSE; /* trailing garbage */
2097 /* Now convert the whole thing into a 'l_fp'. We do not use
2098 * 'mkgmtime()' since its not standard and going through the
2099 * calendar routines is not much effort, either.
2101 ts.tv_sec = (ntpcal_tm_to_rd(&gd) - DAY_NTP_STARTS) * SECSPERDAY
2102 + ntpcal_tm_to_daysec(&gd);
2103 *fp = tspec_intv_to_lfp(ts);
2108 /* -------------------------------------------------------------------
2109 * Save the last timecode string, making sure it's properly truncated
2110 * if necessary and NUL terminated in any case.
2114 clockprocT * const pp,
2115 const char * const tc)
2119 len = (tc) ? strlen(tc) : 0;
2120 if (len >= sizeof(pp->a_lastcode))
2121 len = sizeof(pp->a_lastcode) - 1;
2122 pp->lencode = (u_short)len;
2123 memcpy(pp->a_lastcode, tc, len);
2124 pp->a_lastcode[len] = '\0';
2127 /* -------------------------------------------------------------------
2128 * asprintf replacement... it's not available everywhere...
2145 *spp = (char*)malloc(alen);
2150 plen = (size_t)vsnprintf(*spp, alen, fmt, va);
2152 } while (plen >= alen);
2157 /* -------------------------------------------------------------------
2158 * dump a raw data buffer
2167 while (dp != ep && *sp)
2179 /* we're running single threaded with regards to the clocks. */
2180 static char s_lbuf[2048];
2182 clockprocT * const pp = peer->procptr;
2183 gpsd_unitT * const up = (gpsd_unitT *)pp->unitptr;
2186 const char *sptr = buf;
2187 const char *stop = buf + len;
2188 char *dptr = s_lbuf;
2189 char *dtop = s_lbuf + sizeof(s_lbuf) - 1; /* for NUL */
2191 while (sptr != stop && dptr != dtop) {
2192 if (*sptr == '\\') {
2193 dptr = add_string(dptr, dtop, "\\\\");
2194 } else if (isprint(*sptr)) {
2198 snprintf(fbuf, sizeof(fbuf), "\\%03o", *(const u_char*)sptr);
2199 dptr = add_string(dptr, dtop, fbuf);
2204 mprintf("%s[%s]: '%s'\n", up->logname, what, s_lbuf);
2209 NONEMPTY_TRANSLATION_UNIT
2210 #endif /* REFCLOCK && CLOCK_GPSDJSON */