1424 lines
37 KiB
C
1424 lines
37 KiB
C
/* $NetBSD: ntp_refclock.c,v 1.4 1998/04/01 15:01:22 christos Exp $ */
|
|
|
|
/*
|
|
* ntp_refclock - processing support for reference clocks
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SYS_IOCTL_H
|
|
# include <sys/ioctl.h>
|
|
#endif /* HAVE_SYS_IOCTL_H */
|
|
|
|
#include "ntpd.h"
|
|
#include "ntp_io.h"
|
|
#include "ntp_unixtime.h"
|
|
#include "ntp_refclock.h"
|
|
#include "ntp_stdlib.h"
|
|
|
|
#ifdef REFCLOCK
|
|
|
|
#ifdef TTYCLK
|
|
#include <sys/clkdefs.h>
|
|
#endif /* TTYCLK */
|
|
|
|
#ifdef CHUCLK
|
|
#include <sys/chudefs.h>
|
|
#endif /* CHUCLK */
|
|
|
|
#ifdef PPS
|
|
#include <sys/ppsclock.h>
|
|
#endif /* PPS */
|
|
|
|
/*
|
|
* Reference clock support is provided here by maintaining the fiction
|
|
* that the clock is actually a peer. As no packets are exchanged with a
|
|
* reference clock, however, we replace the transmit, receive and packet
|
|
* procedures with separate code to simulate them. Routines
|
|
* refclock_transmit() and refclock_receive() maintain the peer
|
|
* variables in a state analogous to an actual peer and pass reference
|
|
* clock data on through the filters. Routines refclock_peer() and
|
|
* refclock_unpeer() are called to initialize and terminate reference
|
|
* clock associations. A set of utility routines is included to open
|
|
* serial devices, process sample data, edit input lines to extract
|
|
* embedded timestamps and to peform various debugging functions.
|
|
*
|
|
* The main interface used by these routines is the refclockproc
|
|
* structure, which contains for most drivers the decimal equivalants of
|
|
* the year, day, month, hour, second and millisecond/microsecond
|
|
* decoded from the ASCII timecode. Additional information includes the
|
|
* receive timestamp, exception report, statistics tallies, etc. In
|
|
* addition, there may be a driver-specific unit structure used for
|
|
* local control of the device.
|
|
*
|
|
* The support routines are passed a pointer to the peer structure,
|
|
* which is used for all peer-specific processing and contains a pointer
|
|
* to the refclockproc structure, which in turn containes a pointer to
|
|
* the unit structure, if used. In addition, some routines expect an
|
|
* address in the dotted quad form 127.127.t.u, where t is the clock
|
|
* type and u the unit. A table typeunit[type][unit] contains the peer
|
|
* structure pointer for each configured clock type and unit.
|
|
*
|
|
* Most drivers support the 1-pps signal provided by some radios and
|
|
* connected via a level converted described in the gadget directory.
|
|
* The signal is captured using a separate, dedicated serial port and
|
|
* the tty_clk line discipline/streams modules described in the kernel
|
|
* directory. For the highest precision, the signal is captured using
|
|
* the carrier-detect line of the same serial port using the ppsclock
|
|
* streams module described in the ppsclock directory.
|
|
*/
|
|
#define REFCLOCKMAXDISPERSE (FP_SECOND/4) /* max sample dispersion */
|
|
#define MAXUNIT 4 /* max units */
|
|
#ifndef CLKLDISC
|
|
#define CLKLDISC 10 /* XXX temp tty_clk line discipline */
|
|
#endif
|
|
#ifndef CHULDISC
|
|
#define CHULDISC 10 /* XXX temp tty_chu line discipline */
|
|
#endif
|
|
|
|
/*
|
|
* The refclock configuration table. Imported from refclock_conf
|
|
*/
|
|
extern struct refclock *refclock_conf[];
|
|
extern u_char num_refclock_conf;
|
|
|
|
/*
|
|
* Imported from the I/O module
|
|
*/
|
|
extern struct interface *any_interface;
|
|
extern struct interface *loopback_interface;
|
|
|
|
/*
|
|
* Imported from ntp_loopfilter module
|
|
*/
|
|
extern int fdpps; /* pps file descriptor */
|
|
#ifdef PPS
|
|
extern int pps_enable; /* pps enabled indicator (from ntp_loopfilter.c) */
|
|
#endif /* PPS */
|
|
|
|
/*
|
|
* Imported from the timer module
|
|
*/
|
|
extern u_long current_time;
|
|
extern struct event timerqueue[];
|
|
|
|
/*
|
|
* Imported from the main and peer modules. We use the same algorithm
|
|
* for spacing out timers at configuration time that the peer module
|
|
* does.
|
|
*/
|
|
extern u_long init_peer_starttime;
|
|
extern int initializing;
|
|
extern int debug;
|
|
|
|
|
|
/*
|
|
* Type/unit peer index. Used to find the peer structure for control and
|
|
* debugging. When all clock drivers have been converted to new style,
|
|
* this dissapears.
|
|
*/
|
|
static struct peer *typeunit[REFCLK_MAX + 1][MAXUNIT];
|
|
|
|
/*
|
|
* Forward declarations
|
|
*/
|
|
|
|
static int refclock_cmpl_fp P((const void *, const void *));
|
|
|
|
/*
|
|
* refclock_report - note the occurance of an event
|
|
*
|
|
* This routine presently just remembers the report and logs it, but
|
|
* does nothing heroic for the trap handler. It tries to be a good
|
|
* citizen and bothers the system log only if things change.
|
|
*/
|
|
void
|
|
refclock_report(peer, code)
|
|
struct peer *peer;
|
|
u_int code;
|
|
{
|
|
struct refclockproc *pp;
|
|
|
|
if (!(pp = peer->procptr))
|
|
return;
|
|
if (code == CEVNT_BADREPLY)
|
|
pp->badformat++;
|
|
if (code == CEVNT_BADTIME)
|
|
pp->baddata++;
|
|
if (code == CEVNT_TIMEOUT)
|
|
pp->noreply++;
|
|
if (pp->currentstatus != code) {
|
|
pp->currentstatus = code;
|
|
pp->lastevent = code;
|
|
|
|
if (code == CEVNT_FAULT)
|
|
NLOG(NLOG_CLOCKEVENT)
|
|
msyslog(LOG_ERR,
|
|
"clock %s fault '%s' (0x%02x)",
|
|
refnumtoa(peer->srcadr.sin_addr.s_addr), ceventstr(code), code);
|
|
else {
|
|
NLOG(NLOG_CLOCKEVENT)
|
|
msyslog(LOG_INFO,
|
|
"clock %s event '%s' (0x%02x)",
|
|
refnumtoa(peer->srcadr.sin_addr.s_addr), ceventstr(code), code);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* init_refclock - initialize the reference clock drivers
|
|
*
|
|
* This routine calls each of the drivers in turn to initialize internal
|
|
* variables, if necessary. Most drivers have nothing to say at this
|
|
* point.
|
|
*/
|
|
void
|
|
init_refclock()
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; i < (int)num_refclock_conf; i++) {
|
|
if (refclock_conf[i]->clock_init != noentry)
|
|
(refclock_conf[i]->clock_init)();
|
|
for (j = 0; j < MAXUNIT; j++)
|
|
typeunit[i][j] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_newpeer - initialize and start a reference clock
|
|
*
|
|
* This routine allocates and initializes the interface structure which
|
|
* supports a reference clock in the form of an ordinary NTP peer. A
|
|
* driver-specific support routine completes the initialization, if
|
|
* used. Default peer variables which identify the clock and establish
|
|
* its reference ID and stratum are set here. It returns one if success
|
|
* and zero if the clock address is invalid or already running,
|
|
* insufficient resources are available or the driver declares a bum
|
|
* rap.
|
|
*/
|
|
int
|
|
refclock_newpeer(peer)
|
|
struct peer *peer; /* peer structure pointer */
|
|
{
|
|
struct refclockproc *pp;
|
|
u_char clktype;
|
|
int unit;
|
|
|
|
/*
|
|
* Check for valid clock address. If already running, shut it
|
|
* down first.
|
|
*/
|
|
if (!ISREFCLOCKADR(&peer->srcadr)) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_newpeer: clock address %s invalid",
|
|
ntoa(&peer->srcadr));
|
|
return (0);
|
|
}
|
|
clktype = (u_char)REFCLOCKTYPE(&peer->srcadr);
|
|
unit = REFCLOCKUNIT(&peer->srcadr);
|
|
if (clktype >= num_refclock_conf || unit > MAXUNIT ||
|
|
refclock_conf[clktype]->clock_start == noentry) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_newpeer: clock type %d invalid\n",
|
|
clktype);
|
|
return (0);
|
|
}
|
|
refclock_unpeer(peer);
|
|
|
|
/*
|
|
* Allocate and initialize interface structure
|
|
*/
|
|
if (!(pp = (struct refclockproc *)
|
|
emalloc(sizeof(struct refclockproc))))
|
|
return (0);
|
|
memset((char *)pp, 0, sizeof(struct refclockproc));
|
|
typeunit[clktype][unit] = peer;
|
|
peer->procptr = pp;
|
|
|
|
/*
|
|
* Initialize structures
|
|
*/
|
|
peer->refclktype = clktype;
|
|
peer->refclkunit = unit;
|
|
peer->flags |= FLAG_REFCLOCK;
|
|
peer->event_timer.peer = peer;
|
|
peer->event_timer.event_handler = refclock_transmit;
|
|
pp->type = clktype;
|
|
pp->timestarted = current_time;
|
|
peer->stratum = STRATUM_REFCLOCK;
|
|
peer->refid = peer->srcadr.sin_addr.s_addr;
|
|
peer->maxpoll = peer->minpoll;
|
|
|
|
/*
|
|
* Do driver dependent initialization
|
|
*/
|
|
if (!((refclock_conf[clktype]->clock_start)(unit, peer))) {
|
|
free(pp);
|
|
return (0);
|
|
}
|
|
peer->hpoll = peer->minpoll;
|
|
peer->ppoll = peer->maxpoll;
|
|
if (peer->stratum <= 1)
|
|
peer->refid = pp->refid;
|
|
else
|
|
peer->refid = peer->srcadr.sin_addr.s_addr;
|
|
|
|
/*
|
|
* Set up the timeout for polling and reachability determination
|
|
*/
|
|
if (initializing) {
|
|
init_peer_starttime += (1 << EVENT_TIMEOUT);
|
|
if (init_peer_starttime >= (u_long)(1 << peer->minpoll))
|
|
init_peer_starttime = (1 << EVENT_TIMEOUT);
|
|
peer->event_timer.event_time = init_peer_starttime;
|
|
} else {
|
|
peer->event_timer.event_time = current_time +
|
|
(1 << peer->hpoll);
|
|
}
|
|
TIMER_ENQUEUE(timerqueue, &peer->event_timer);
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_unpeer - shut down a clock
|
|
*/
|
|
void
|
|
refclock_unpeer(peer)
|
|
struct peer *peer; /* peer structure pointer */
|
|
{
|
|
u_char clktype;
|
|
int unit;
|
|
|
|
/*
|
|
* Wiggle the driver to release its resources, then give back
|
|
* the interface structure.
|
|
*/
|
|
if (!peer->procptr)
|
|
return;
|
|
clktype = peer->refclktype;
|
|
unit = peer->refclkunit;
|
|
if (refclock_conf[clktype]->clock_shutdown != noentry)
|
|
(refclock_conf[clktype]->clock_shutdown)(unit, peer);
|
|
free(peer->procptr);
|
|
peer->procptr = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_transmit - simulate the transmit procedure
|
|
*
|
|
* This routine implements the NTP transmit procedure for a reference
|
|
* clock. This provides a mechanism to call the driver at the NTP poll
|
|
* interval, as well as provides a reachability mechanism to detect a
|
|
* broken radio or other madness.
|
|
*/
|
|
void
|
|
refclock_transmit(peer)
|
|
struct peer *peer; /* peer structure pointer */
|
|
{
|
|
struct refclockproc *pp;
|
|
u_char clktype;
|
|
int unit;
|
|
u_char opeer_reach;
|
|
|
|
pp = peer->procptr;
|
|
clktype = peer->refclktype;
|
|
unit = peer->refclkunit;
|
|
peer->sent++;
|
|
|
|
/*
|
|
* The transmit procedure is supposed to freeze a timestamp.
|
|
* Get one just for fun, and to tell when we last were here.
|
|
*/
|
|
get_systime(&peer->xmt);
|
|
|
|
/*
|
|
* Fiddle reachability.
|
|
*/
|
|
opeer_reach = peer->reach;
|
|
peer->reach <<= 1;
|
|
if (peer->reach == 0) {
|
|
/*
|
|
* Clear this one out. No need to redo selection since
|
|
* this fellow will definitely be suffering from
|
|
* dispersion madness.
|
|
*/
|
|
if (opeer_reach != 0) {
|
|
peer_clear(peer);
|
|
peer->timereachable = current_time;
|
|
report_event(EVNT_UNREACH, peer);
|
|
}
|
|
|
|
/*
|
|
* Update reachability and poll variables
|
|
*/
|
|
} else if ((opeer_reach & 3) == 0) {
|
|
l_fp off;
|
|
|
|
if (peer->valid > 0)
|
|
peer->valid--;
|
|
L_CLR(&off);
|
|
clock_filter(peer, &off, 0, NTP_MAXDISPERSE);
|
|
if (peer->flags & FLAG_SYSPEER)
|
|
clock_select();
|
|
} else if (peer->valid < NTP_SHIFT)
|
|
peer->valid++;
|
|
|
|
/*
|
|
* If he wants to be polled, do it. New style drivers do not use
|
|
* the unit argument, since the fudge stuff is in the
|
|
* refclockproc structure.
|
|
*/
|
|
if (refclock_conf[clktype]->clock_poll != noentry)
|
|
(refclock_conf[clktype]->clock_poll)(unit, peer);
|
|
|
|
/*
|
|
* Finally, reset the timer
|
|
*/
|
|
peer->event_timer.event_time += (1 << peer->hpoll);
|
|
TIMER_ENQUEUE(timerqueue, &peer->event_timer);
|
|
}
|
|
|
|
|
|
/*
|
|
* Compare two l_fp's - used with qsort()
|
|
*/
|
|
static int
|
|
refclock_cmpl_fp(p1, p2)
|
|
register const void *p1, *p2; /* l_fp to compare */
|
|
{
|
|
|
|
if (!L_ISGEQ((const l_fp *)p1, (const l_fp *)p2))
|
|
return (-1);
|
|
if (L_ISEQU((const l_fp *)p1, (const l_fp *)p2))
|
|
return (0);
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_process - process a pile of samples from the clock
|
|
*
|
|
* This routine converts the timecode in the form days, hours, miinutes,
|
|
* seconds, milliseconds/microseconds to internal timestamp format.
|
|
* Further processing is then delegated to refclock sample
|
|
*/
|
|
int
|
|
refclock_process(pp, nstart, nskeep)
|
|
struct refclockproc *pp; /* peer structure pointer */
|
|
int nstart; /* stages of median filter */
|
|
int nskeep; /* stages after outlyer trim */
|
|
{
|
|
l_fp offset;
|
|
|
|
/*
|
|
* Compute the timecode timestamp from the days, hours, minutes,
|
|
* seconds and milliseconds/microseconds of the timecode. Use
|
|
* clocktime() for the aggregate seconds and the msec/usec for
|
|
* the fraction, when present. Note that this code relies on the
|
|
* filesystem time for the years and does not use the years of
|
|
* the timecode.
|
|
*/
|
|
if (!clocktime(pp->day, pp->hour, pp->minute, pp->second, GMT,
|
|
pp->lastrec.l_ui, &pp->yearstart, &offset.l_ui))
|
|
return (0);
|
|
if (pp->usec) {
|
|
TVUTOTSF(pp->usec, offset.l_uf);
|
|
} else {
|
|
MSUTOTSF(pp->msec, offset.l_uf);
|
|
}
|
|
|
|
L_ADD(&offset, &pp->fudgetime1);
|
|
|
|
pp->lastref = offset; /* save last reference time */
|
|
|
|
/*
|
|
* Include the configured fudgetime1 adjustment.
|
|
*/
|
|
L_SUB(&offset, &pp->lastrec); /* form true offset */
|
|
|
|
return refclock_sample(&offset, pp, nstart, nskeep);
|
|
}
|
|
|
|
/*
|
|
* refclock_sample - process a pile of samples from the clock
|
|
*
|
|
* This routine converts the timecode in the form days, hours, miinutes,
|
|
* seconds, milliseconds/microseconds to internal timestamp format. It
|
|
* then calculates the difference from the receive timestamp and
|
|
* assembles the samples in a shift register. It implements a recursive
|
|
* median filter to suppress spikes in the data, as well as determine a
|
|
* rough dispersion estimate. A configuration constant time adjustment
|
|
* fudgetime1 can be added to the final offset to compensate for various
|
|
* systematic errors. The routine returns one if success and zero if
|
|
* failure due to invalid timecode data or very noisy offsets.
|
|
*
|
|
* This interface is needed to allow for clocks (e. g. parse) that can
|
|
* provide the correct offset including year information (though NTP
|
|
* usually gives up on offsets greater than 1000 seconds).
|
|
*/
|
|
int
|
|
refclock_sample(sample_offset, pp, nstart, nskeep)
|
|
l_fp *sample_offset; /* input offset (offset! - not a time stamp)
|
|
for filter machine */
|
|
struct refclockproc *pp; /* peer structure pointer */
|
|
int nstart; /* stages of median filter */
|
|
int nskeep; /* stages after outlyer trim */
|
|
{
|
|
int i, n;
|
|
l_fp offset, median, lftmp;
|
|
l_fp off[MAXSTAGE];
|
|
u_fp disp;
|
|
|
|
/*
|
|
* Subtract the receive timestamp from the timecode timestamp
|
|
* to form the raw offset. Insert in the median filter shift
|
|
* register.
|
|
*/
|
|
pp->nstages = nstart;
|
|
offset = *sample_offset;
|
|
|
|
i = ((int)(pp->coderecv)) % pp->nstages;
|
|
|
|
pp->filter[i] = offset;
|
|
if (pp->coderecv == 0)
|
|
for (i = 1; (u_int) i < pp->nstages; i++)
|
|
pp->filter[i] = pp->filter[0];
|
|
pp->coderecv++;
|
|
|
|
/*
|
|
* Copy the raw offsets and sort into ascending order
|
|
*/
|
|
for (i = 0; (u_int) i < pp->nstages; i++)
|
|
off[i] = pp->filter[i];
|
|
qsort((char *)off, pp->nstages, sizeof(l_fp), refclock_cmpl_fp);
|
|
|
|
/*
|
|
* Reject the furthest from the median of nstages samples until
|
|
* nskeep samples remain.
|
|
*/
|
|
i = 0;
|
|
n = pp->nstages;
|
|
while ((n - i) > nskeep) {
|
|
lftmp = off[n - 1];
|
|
median = off[(n + i) / 2];
|
|
L_SUB(&lftmp, &median);
|
|
L_SUB(&median, &off[i]);
|
|
if (L_ISHIS(&median, &lftmp)) {
|
|
/* reject low end */
|
|
i++;
|
|
} else {
|
|
/* reject high end */
|
|
n--;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Compute the dispersion based on the difference between the
|
|
* extremes of the remaining offsets. Add to this the time since
|
|
* the last clock update, which represents the dispersion
|
|
* increase with time. We know that NTP_MAXSKEW is 16. If the
|
|
* sum is greater than the allowed sample dispersion, bail out.
|
|
* If the loop is unlocked, return the most recent offset;
|
|
* otherwise, return the median offset.
|
|
*/
|
|
lftmp = off[n - 1];
|
|
L_SUB(&lftmp, &off[i]);
|
|
disp = LFPTOFP(&lftmp) + current_time - pp->lasttime;
|
|
if (disp > REFCLOCKMAXDISPERSE)
|
|
return (0);
|
|
|
|
pp->offset = off[(n + i) / 2];
|
|
pp->dispersion = disp;
|
|
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_receive - simulate the receive and packet procedures
|
|
*
|
|
* This routine simulates the NTP receive and packet procedures for a
|
|
* reference clock. This provides a mechanism in which the ordinary NTP
|
|
* filter, selection and combining algorithms can be used to suppress
|
|
* misbehaving radios and to mitigate between them when more than one is
|
|
* available for backup.
|
|
*/
|
|
void
|
|
refclock_receive(peer, offset, delay, dispersion, reftime, rectime, leap)
|
|
struct peer *peer; /* peer structure pointer */
|
|
l_fp *offset; /* computed offset (s) */
|
|
s_fp delay; /* computed delay to peer */
|
|
u_fp dispersion; /* computed dispersion to peer */
|
|
l_fp *reftime; /* time at last clock update */
|
|
l_fp *rectime; /* time at last peer update */
|
|
int leap; /* synchronization/leap code */
|
|
{
|
|
int restrict_addr;
|
|
int trustable;
|
|
int refclock_own_states;
|
|
u_fp precision;
|
|
|
|
peer->received++;
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("refclock_receive: %s %s %s %s)\n",
|
|
ntoa(&peer->srcadr), lfptoa(offset, 6),
|
|
fptoa(delay, 5), ufptoa(dispersion, 5));
|
|
#endif
|
|
|
|
/*
|
|
* some refclock implementations do a complete state and
|
|
* event handling. reporting events must be disabled for
|
|
* these critters (namely parse)
|
|
*/
|
|
|
|
refclock_own_states = leap & REFCLOCK_OWN_STATES;
|
|
leap &= ~REFCLOCK_OWN_STATES;
|
|
|
|
/*
|
|
* The authentication and access-control machinery works, but
|
|
* its utility may be questionable.
|
|
*/
|
|
restrict_addr = restrictions(&peer->srcadr);
|
|
if (restrict_addr & (RES_IGNORE|RES_DONTSERVE))
|
|
return;
|
|
peer->processed++;
|
|
peer->timereceived = current_time;
|
|
if (restrict & RES_DONTTRUST)
|
|
trustable = 0;
|
|
else
|
|
trustable = 1;
|
|
|
|
if (peer->flags & FLAG_AUTHENABLE) {
|
|
if (trustable)
|
|
peer->flags |= FLAG_AUTHENTIC;
|
|
else
|
|
peer->flags &= ~FLAG_AUTHENTIC;
|
|
}
|
|
peer->leap = leap;
|
|
|
|
/*
|
|
* Set the timestamps. rec and org are in local time, while ref
|
|
* is in timecode time.
|
|
*/
|
|
peer->rec = peer->org = *rectime;
|
|
peer->reftime = *reftime;
|
|
|
|
/*
|
|
* If the interface has been set to any_interface, set it to the
|
|
* loopback address if we have one. This is so that peers which
|
|
* are unreachable are easy to see in the peer display.
|
|
*/
|
|
if (peer->dstadr == any_interface && loopback_interface != 0)
|
|
peer->dstadr = loopback_interface;
|
|
|
|
/*
|
|
* Set peer.pmode based on the hmode. For appearances only.
|
|
*/
|
|
switch (peer->hmode) {
|
|
|
|
case MODE_ACTIVE:
|
|
peer->pmode = MODE_PASSIVE;
|
|
break;
|
|
|
|
default:
|
|
peer->pmode = MODE_SERVER;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Abandon ship if the radio came bum. We only got this far
|
|
* in order to make pretty billboards, even if bum.
|
|
*/
|
|
if (leap == LEAP_NOTINSYNC)
|
|
return;
|
|
/*
|
|
* If this guy was previously unreachable, report him
|
|
* reachable.
|
|
*/
|
|
if (peer->reach == 0) report_event(EVNT_REACH, peer);
|
|
peer->reach |= 1;
|
|
|
|
/*
|
|
* Give the data to the clock filter and update the clock. Note
|
|
* the clock reading precision initialized by the driver is
|
|
* added at this point.
|
|
*/
|
|
precision = FP_SECOND >> -(int)peer->precision;
|
|
if (precision == 0)
|
|
precision = 1;
|
|
|
|
if (!refclock_own_states)
|
|
refclock_report(peer, CEVNT_NOMINAL);
|
|
|
|
clock_filter(peer, offset, delay, dispersion + precision);
|
|
clock_update(peer);
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_gtlin - groom next input line and extract timestamp
|
|
*
|
|
* This routine processes the timecode received from the clock and
|
|
* removes the parity bit and control characters. If a timestamp is
|
|
* present in the timecode, as produced by the tty_clk line
|
|
* discipline/streams module, it returns that as the timestamp;
|
|
* otherwise, it returns the buffer timestamp. The routine return code
|
|
* is the number of characters in the line.
|
|
*/
|
|
int
|
|
refclock_gtlin(rbufp, lineptr, bmax, tsptr)
|
|
struct recvbuf *rbufp; /* receive buffer pointer */
|
|
char *lineptr; /* current line pointer */
|
|
int bmax; /* remaining characters in line */
|
|
l_fp *tsptr; /* pointer to timestamp returned */
|
|
{
|
|
char *dpt, *dpend, *dp;
|
|
int i;
|
|
l_fp trtmp, tstmp;
|
|
char c;
|
|
#ifdef TIOCDCDTIMESTAMP
|
|
struct timeval dcd_time;
|
|
#endif
|
|
|
|
/*
|
|
* Check for the presence of a timestamp left by the tty_clock
|
|
* line discipline/streams module and, if present, use that
|
|
* instead of the buffer timestamp captured by the I/O routines.
|
|
* We recognize a timestamp by noting its value is earlier than
|
|
* the buffer timestamp, but not more than one second earlier.
|
|
*/
|
|
dpt = (char *)&rbufp->recv_space;
|
|
dpend = dpt + rbufp->recv_length;
|
|
trtmp = rbufp->recv_time;
|
|
|
|
#ifdef TIOCDCDTIMESTAMP
|
|
if(ioctl(rbufp->fd, TIOCDCDTIMESTAMP, &dcd_time) != -1) {
|
|
TVTOTS(&dcd_time, &tstmp);
|
|
tstmp.l_ui += JAN_1970;
|
|
L_SUB(&trtmp, &tstmp);
|
|
if (trtmp.l_ui == 0) {
|
|
#ifdef DEBUG
|
|
if (debug) {
|
|
printf(
|
|
"refclock_gtlin: fd %d DCDTIMESTAMP %s",
|
|
rbufp->fd,
|
|
lfptoa(&tstmp, 6));
|
|
printf(" sigio %s\n",
|
|
lfptoa(&trtmp, 6));
|
|
}
|
|
#endif
|
|
trtmp = tstmp;
|
|
} else
|
|
trtmp = rbufp->recv_time;
|
|
}
|
|
|
|
#else /* TIOCDCDTIMESTAMP */
|
|
if (dpend >= dpt + 8) {
|
|
if (buftvtots(dpend - 8, &tstmp)) {
|
|
L_SUB(&trtmp, &tstmp);
|
|
if (trtmp.l_ui == 0) {
|
|
#ifdef DEBUG
|
|
if (debug) {
|
|
printf(
|
|
"refclock_gtlin: fd %d ldisc %s",
|
|
rbufp->fd,
|
|
lfptoa(&trtmp, 6));
|
|
get_systime(&trtmp);
|
|
L_SUB(&trtmp, &tstmp);
|
|
printf(" sigio %s\n",
|
|
lfptoa(&trtmp, 6));
|
|
}
|
|
#endif
|
|
dpend -= 8;
|
|
trtmp = tstmp;
|
|
} else
|
|
trtmp = rbufp->recv_time;
|
|
}
|
|
}
|
|
#endif /* TIOCDCDTIMESTAMP */
|
|
|
|
/*
|
|
* Edit timecode to remove control chars. Don't monkey with the
|
|
* line buffer if the input buffer contains no ASCII printing
|
|
* characters.
|
|
*/
|
|
if (dpend - dpt > bmax - 1)
|
|
dpend = dpt + bmax - 1;
|
|
for (dp = lineptr; dpt < dpend; dpt++) {
|
|
c = *dpt & 0x7f;
|
|
if (c >= ' ')
|
|
*dp++ = c;
|
|
}
|
|
i = dp - lineptr;
|
|
if (i > 0)
|
|
*dp = '\0';
|
|
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("refclock_gtlin: fd %d time %s timecode %d %s\n",
|
|
rbufp->fd, ulfptoa(&trtmp, 6), i, lineptr);
|
|
#endif
|
|
*tsptr = trtmp;
|
|
return (i);
|
|
}
|
|
|
|
/*
|
|
* The following code does not apply to WINNT & VMS ...
|
|
*/
|
|
#ifndef SYS_VXWORKS
|
|
#if defined(HAVE_TERMIOS) || defined(HAVE_SYSV_TTYS) || defined(HAVE_BSD_TTYS)
|
|
|
|
/*
|
|
* refclock_open - open serial port for reference clock
|
|
*
|
|
* This routine opens a serial port for I/O and sets default options. It
|
|
* returns the file descriptor if success and zero if failure.
|
|
*/
|
|
int
|
|
refclock_open(dev, speed, flags)
|
|
char *dev; /* device name pointer */
|
|
int speed; /* serial port speed (code) */
|
|
int flags; /* line discipline flags */
|
|
{
|
|
int fd;
|
|
#ifdef HAVE_TERMIOS
|
|
struct termios ttyb, *ttyp;
|
|
#endif /* HAVE_TERMIOS */
|
|
#ifdef HAVE_SYSV_TTYS
|
|
struct termio ttyb, *ttyp;
|
|
#endif /* HAVE_SYSV_TTYS */
|
|
#ifdef HAVE_BSD_TTYS
|
|
struct sgttyb ttyb, *ttyp;
|
|
#endif /* HAVE_BSD_TTYS */
|
|
#ifdef TIOCMGET
|
|
u_long ltemp;
|
|
#endif /* TIOCMGET */
|
|
|
|
/*
|
|
* Open serial port and set default options
|
|
*/
|
|
fd = open(dev, O_RDWR
|
|
#ifdef O_NONBLOCK
|
|
| O_NONBLOCK
|
|
#endif
|
|
, 0777);
|
|
if (fd == -1) {
|
|
msyslog(LOG_ERR, "refclock_open: %s: %m", dev);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* The following sections initialize the serial line port in
|
|
* canonical (line-oriented) mode and set the specified line
|
|
* speed, 8 bits and no parity. The modem control, break, erase
|
|
* and kill functions are normally disabled. There is a
|
|
* different section for each terminal interface, as selected at
|
|
* compile time.
|
|
*/
|
|
ttyp = &ttyb;
|
|
|
|
#ifdef HAVE_TERMIOS
|
|
/*
|
|
* POSIX serial line parameters (termios interface)
|
|
*/
|
|
if (tcgetattr(fd, ttyp) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d tcgetattr %m", fd);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Set canonical mode and local connection; set specified speed,
|
|
* 8 bits and no parity; map CR to NL; ignore break.
|
|
*/
|
|
ttyp->c_iflag = IGNBRK | IGNPAR | ICRNL;
|
|
ttyp->c_oflag = 0;
|
|
ttyp->c_cflag = CS8 | CLOCAL | CREAD;
|
|
(void)cfsetispeed(&ttyb, speed);
|
|
(void)cfsetospeed(&ttyb, speed);
|
|
ttyp->c_lflag = ICANON;
|
|
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\0';
|
|
#ifdef TIOCMGET
|
|
/*
|
|
* If we have modem control, check to see if modem leads are
|
|
* active; if so, set remote connection. This is necessary for
|
|
* the kernel pps mods to work.
|
|
*/
|
|
ltemp = 0;
|
|
if (ioctl(fd, TIOCMGET, (char *)<emp) < 0)
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TIOCMGET failed: %m", fd);
|
|
#if DEBUG
|
|
if (debug)
|
|
printf("refclock_open: fd %d modem status %lx\n",
|
|
fd, ltemp);
|
|
#endif
|
|
if (ltemp & TIOCM_DSR)
|
|
ttyp->c_cflag &= ~CLOCAL;
|
|
#endif /* TIOCMGET */
|
|
if (tcsetattr(fd, TCSANOW, ttyp) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TCSANOW failed: %m", fd);
|
|
return (0);
|
|
}
|
|
if (tcflush(fd, TCIOFLUSH) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TCIOFLUSH failed: %m", fd);
|
|
return (0);
|
|
}
|
|
#endif /* HAVE_TERMIOS */
|
|
|
|
#ifdef HAVE_SYSV_TTYS
|
|
|
|
/*
|
|
* System V serial line parameters (termio interface)
|
|
*
|
|
*/
|
|
if (ioctl(fd, TCGETA, ttyp) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TCGETA failed: %m", fd);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Set canonical mode and local connection; set specified speed,
|
|
* 8 bits and no parity; map CR to NL; ignore break.
|
|
*/
|
|
ttyp->c_iflag = IGNBRK | IGNPAR | ICRNL;
|
|
ttyp->c_oflag = 0;
|
|
ttyp->c_cflag = speed | CS8 | CLOCAL | CREAD;
|
|
ttyp->c_lflag = ICANON;
|
|
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\0';
|
|
#ifdef TIOCMGET
|
|
/*
|
|
* If we have modem control, check to see if modem leads are
|
|
* active; if so, set remote connection. This is necessary for
|
|
* the kernel pps mods to work.
|
|
*/
|
|
ltemp = 0;
|
|
if (ioctl(fd, TIOCMGET, (char *)<emp) < 0)
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TIOCMGET failed: %m", fd);
|
|
#if DEBUG
|
|
if (debug)
|
|
printf("refclock_open: fd %d modem status %lx\n",
|
|
fd, ltemp);
|
|
#endif
|
|
if (ltemp & TIOCM_DSR)
|
|
ttyp->c_cflag &= ~CLOCAL;
|
|
#endif /* TIOCMGET */
|
|
if (ioctl(fd, TCSETA, ttyp) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TCSETA failed: %m", fd);
|
|
return (0);
|
|
}
|
|
#endif /* HAVE_SYSV_TTYS */
|
|
|
|
#ifdef HAVE_BSD_TTYS
|
|
|
|
/*
|
|
* 4.3bsd serial line parameters (sgttyb interface)
|
|
*/
|
|
if (ioctl(fd, TIOCGETP, (char *)ttyp) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: fd %d TIOCGETP %m", fd);
|
|
return (0);
|
|
}
|
|
ttyp->sg_ispeed = ttyp->sg_ospeed = speed;
|
|
ttyp->sg_flags = EVENP | ODDP | CRMOD;
|
|
if (ioctl(fd, TIOCSETP, (char *)ttyp) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_open: TIOCSETP failed: %m");
|
|
return (0);
|
|
}
|
|
#endif /* HAVE_BSD_TTYS */
|
|
|
|
if (!refclock_ioctl(fd, flags)) {
|
|
(void)close(fd);
|
|
msyslog(LOG_ERR, "refclock_open: fd %d ioctl fails",
|
|
fd);
|
|
return (0);
|
|
}
|
|
return (fd);
|
|
}
|
|
#endif /* HAVE_TERMIOS || HAVE_SYSV_TTYS || HAVE_BSD_TTYS */
|
|
#endif /* SYS_VXWORKS */
|
|
|
|
/*
|
|
* refclock_ioctl - set serial port control functions
|
|
*
|
|
* This routine attempts to hide the internal, system-specific details
|
|
* of serial ports. It can handle POSIX (termios), SYSV (termio) and BSD
|
|
* (sgtty) interfaces with varying degrees of success. The routine sets
|
|
* up the tty_clk, chu_clk and ppsclock streams module/line discipline,
|
|
* if compiled in the daemon and requested in the call. The routine
|
|
* returns one if success and zero if failure.
|
|
*/
|
|
int
|
|
refclock_ioctl(fd, flags)
|
|
int fd; /* file descriptor */
|
|
int flags; /* line discipline flags */
|
|
{
|
|
/* simply return 1 if no UNIX line discipline is supported */
|
|
#ifndef SYS_VXWORKS
|
|
#if defined(HAVE_TERMIOS) || defined(HAVE_SYSV_TTYS) || defined(HAVE_BSD_TTYS)
|
|
|
|
#ifdef HAVE_TERMIOS
|
|
struct termios ttyb, *ttyp;
|
|
#endif /* HAVE_TERMIOS */
|
|
#ifdef HAVE_SYSV_TTYS
|
|
struct termio ttyb, *ttyp;
|
|
#endif /* HAVE_SYSV_TTYS */
|
|
#ifdef HAVE_BSD_TTYS
|
|
struct sgttyb ttyb, *ttyp;
|
|
#endif /* HAVE_BSD_TTYS */
|
|
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("refclock_ioctl: fd %d flags %x\n",
|
|
fd, flags);
|
|
#endif
|
|
|
|
/*
|
|
* The following sections select optional features, such as
|
|
* modem control, line discipline and so forth. Some require
|
|
* specific operating system support in the form of streams
|
|
* modules, which can be loaded and unloaded at run time without
|
|
* rebooting the kernel, or line discipline modules, which must
|
|
* be compiled in the kernel. The streams modules require System
|
|
* V STREAMS support, while the line discipline modules require
|
|
* 4.3bsd or later. The checking frenzy is attenuated here,
|
|
* since the device is already open.
|
|
*
|
|
* Note that both the clk and ppsclock modules are optional; the
|
|
* dang thing still works, but the accuracy improvement using
|
|
* them will not be available. The ppsclock module is associated
|
|
* with a specific, declared line and should be used only once.
|
|
* If requested, the chu module is mandatory, since the driver
|
|
* will not work without it.
|
|
*
|
|
* Use the LDISC_PPS option ONLY with Sun baseboard ttya or
|
|
* ttyb. Using it with the SPIF multipexor crashes the kernel.
|
|
*/
|
|
if (flags == 0)
|
|
return (1);
|
|
|
|
#if !(defined(HAVE_TERMIOS) || defined(HAVE_BSD_TTYS))
|
|
if (flags & (LDISC_CLK | LDISC_CHU | LDISC_PPS | LDISC_ACTS))
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: unsupported terminal interface");
|
|
return (0);
|
|
#endif /* HAVE_TERMIOS HAVE_BSD_TTYS */
|
|
|
|
ttyp = &ttyb;
|
|
|
|
#ifdef STREAM
|
|
#ifdef TTYCLK
|
|
/*
|
|
* The TTYCLK option provides timestamping at the driver level.
|
|
* It requires the tty_clk streams module and System V STREAMS
|
|
* support.
|
|
*/
|
|
if (flags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS))
|
|
{
|
|
if (ioctl(fd, I_PUSH, "clk") < 0)
|
|
{
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional clk streams module unavailable: %m");
|
|
}
|
|
else
|
|
{
|
|
char *str;
|
|
|
|
if (flags & LDISC_PPS)
|
|
str = "\377";
|
|
else if (flags & LDISC_ACTS)
|
|
str = "*";
|
|
else
|
|
str = "\n";
|
|
if (ioctl(fd, CLK_SETSTR, str) < 0)
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: CLK_SETSTR failed: %m");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The ACTS line discipline requires additional line-ending
|
|
* character '*'.
|
|
*/
|
|
if (flags & LDISC_ACTS) {
|
|
(void)tcgetattr(fd, ttyp);
|
|
ttyp->c_cc[VEOL] = '*';
|
|
(void)tcsetattr(fd, TCSANOW, ttyp);
|
|
}
|
|
#else
|
|
if (flags & LDISC_CLK)
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional clk streams module unsupported");
|
|
#endif /* TTYCLK */
|
|
|
|
#ifdef CHUCLK
|
|
/*
|
|
* The CHUCLK option provides timestamping and decoding for the CHU
|
|
* timecode. It requires the tty_chu streams module and System V
|
|
* STREAMS support.
|
|
*/
|
|
if (flags & LDISC_CHU)
|
|
{
|
|
(void)tcgetattr(fd, ttyp);
|
|
ttyp->c_lflag = 0;
|
|
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\0';
|
|
ttyp->c_cc[VMIN] = 1;
|
|
ttyp->c_cc[VTIME] = 0;
|
|
(void)tcsetattr(fd, TCSANOW, ttyp);
|
|
(void)tcflush(fd, TCIOFLUSH);
|
|
while (ioctl(fd, I_POP, 0) >= 0);
|
|
if (ioctl(fd, I_PUSH, "chu") < 0)
|
|
{
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: required chu streams module unavailable");
|
|
return (0);
|
|
}
|
|
}
|
|
#else
|
|
if (flags & LDISC_CHU)
|
|
{
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: required chu streams module unsupported");
|
|
return (0);
|
|
}
|
|
#endif /* CHUCLK */
|
|
|
|
#ifdef PPS
|
|
/*
|
|
* The PPS option provides timestamping at the driver level.
|
|
* It uses a 1-pps signal and level converter (gadget box) and
|
|
* requires the ppsclock streams module and System V STREAMS
|
|
* support.
|
|
*/
|
|
if (flags & LDISC_PPS)
|
|
{
|
|
if (fdpps != -1)
|
|
{
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: ppsclock already configured");
|
|
return (0);
|
|
}
|
|
if (
|
|
#ifdef SYS_SOLARIS
|
|
(ioctl(fd, TIOCSPPS, (char *)&pps_enable) < 0)
|
|
#else
|
|
(ioctl(fd, I_PUSH, "ppsclock") < 0)
|
|
#endif /* SYS_SOLARIS */
|
|
)
|
|
{
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional ppsclock streams module unavailable");
|
|
}
|
|
else
|
|
{
|
|
fdpps = fd;
|
|
}
|
|
}
|
|
#else
|
|
if (flags & LDISC_PPS)
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional ppsclock streams module unsupported");
|
|
#endif /* PPS */
|
|
|
|
#else /* not STREAM */
|
|
|
|
#ifdef HAVE_TERMIOS
|
|
#ifdef TTYCLK
|
|
/*
|
|
* The TTYCLK option provides timestamping at the driver level. It
|
|
* requires the tty_clk line discipline and 4.3bsd or later.
|
|
*/
|
|
if (flags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS)) {
|
|
(void)tcgetattr(fd, ttyp);
|
|
ttyp->c_lflag = 0;
|
|
if (flags & LDISC_CLKPPS)
|
|
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\377';
|
|
else if (flags & LDISC_ACTS) {
|
|
ttyp->c_cc[VERASE] = '*';
|
|
ttyp->c_cc[VKILL] = '#';
|
|
} else
|
|
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\n';
|
|
ttyp->c_cc[VMIN] = 1;
|
|
ttyp->c_cc[VTIME] = 0;
|
|
ttyp->c_line = CLKLDISC;
|
|
(void)tcsetattr(fd, TCSANOW, ttyp);
|
|
(void)tcflush(fd, TCIOFLUSH);
|
|
}
|
|
#else
|
|
if (flags & LDISC_CLK)
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional clk line discipline unsupported");
|
|
#endif /* TTYCLK */
|
|
#ifdef CHUCLK
|
|
/*
|
|
* The CHUCLK option provides timestamping and decoding for the CHU
|
|
* timecode. It requires the tty_chu line disciplne and 4.3bsd
|
|
* or later.
|
|
*/
|
|
if (flags & LDISC_CHU) {
|
|
(void)tcgetattr(fd, ttyp);
|
|
ttyp->c_lflag = 0;
|
|
ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\r';
|
|
ttyp->c_cc[VMIN] = 1;
|
|
ttyp->c_cc[VTIME] = 0;
|
|
ttyp->c_line = CHULDISC;
|
|
(void)tcsetattr(fd, TCSANOW, ttyp) < 0);
|
|
(void)tcflush(fd, TCIOFLUSH);
|
|
}
|
|
#else
|
|
if (flags & LDISC_CHU) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: required chu line discipline unsupported");
|
|
return (0);
|
|
}
|
|
#endif /* CHUCLK */
|
|
#endif /* HAVE_TERMIOS */
|
|
|
|
#ifdef HAVE_BSD_TTYS
|
|
#ifdef TTYCLK
|
|
/*
|
|
* The TTYCLK option provides timestamping at the driver level. It
|
|
* requires the tty_clk line discipline and 4.3bsd or later.
|
|
*/
|
|
if (flags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS)) {
|
|
int ldisc = CLKLDISC;
|
|
|
|
(void)ioctl(fd, TIOCGETP, (char *)ttyp);
|
|
if (flags & LDISC_CLKPPS)
|
|
ttyp->sg_erase = ttyp->sg_kill = '\377';
|
|
else if (flags & LDISC_ACTS) {
|
|
ttyp->sg_erase = '*';
|
|
ttyp->sg_kill = '#';
|
|
} else
|
|
ttyp->sg_erase = ttyp->sg_kill = '\r';
|
|
ttyp->sg_flags = RAW;
|
|
(void)ioctl(fd, TIOCSETP, ttyp);
|
|
if (ioctl(fd, TIOCSETD, (char *)&ldisc) < 0)
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional clk line discipline unavailable");
|
|
}
|
|
#else
|
|
if (flags & LDISC_CLK)
|
|
msyslog(LOG_NOTICE,
|
|
"refclock_ioctl: optional clk line discipline unsupported");
|
|
|
|
#endif /* TTYCLK */
|
|
#ifdef CHUCLK
|
|
|
|
/*
|
|
* The CHUCLK option provides timestamping and decoding for the CHU
|
|
* timecode. It requires the tty_chu line disciplne and 4.3bsd
|
|
* or later.
|
|
*/
|
|
if (flags & LDISC_CHU) {
|
|
int ldisc = CHULDISC;
|
|
|
|
(void)ioctl(fd, TIOCGETP, (char *)ttyp);
|
|
ttyp->sg_erase = ttyp->sg_kill = '\r';
|
|
ttyp->sg_flags = RAW;
|
|
(void)ioctl(fd, TIOCSETP, (char *)ttyp);
|
|
if (ioctl(fd, TIOCSETD, (char *)&ldisc) < 0) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: required chu line discipline unavailable");
|
|
return (0);
|
|
}
|
|
}
|
|
#else
|
|
if (flags & LDISC_CHU) {
|
|
msyslog(LOG_ERR,
|
|
"refclock_ioctl: required chu line discipline unsupported");
|
|
return (0);
|
|
}
|
|
#endif /* CHUCLK */
|
|
#endif /* HAVE_BSD_TTYS */
|
|
|
|
#endif /* STREAM */
|
|
|
|
#endif /* HAVE_TERMIOS || HAVE_SYSV_TTYS || HAVE_BSD_TTYS */
|
|
#endif /* SYS_VXWORKS */
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* refclock_control - set and/or return clock values
|
|
*
|
|
* This routine is used mainly for debugging. It returns designated
|
|
* values from the interface structure that can be displayed using
|
|
* xntpdc and the clockstat command. It can also be used to initialize
|
|
* configuration variables, such as fudgetimes, fudgevalues, reference
|
|
* ID and stratum.
|
|
*/
|
|
void
|
|
refclock_control(srcadr, in, out)
|
|
struct sockaddr_in *srcadr;
|
|
struct refclockstat *in;
|
|
struct refclockstat *out;
|
|
{
|
|
struct peer *peer;
|
|
struct refclockproc *pp;
|
|
u_char clktype;
|
|
int unit;
|
|
|
|
/*
|
|
* Check for valid address and running peer
|
|
*/
|
|
if (!ISREFCLOCKADR(srcadr))
|
|
return;
|
|
clktype = (u_char)REFCLOCKTYPE(srcadr);
|
|
unit = REFCLOCKUNIT(srcadr);
|
|
if (clktype >= num_refclock_conf || unit > MAXUNIT)
|
|
return;
|
|
if (!(peer = typeunit[clktype][unit]))
|
|
return;
|
|
pp = peer->procptr;
|
|
|
|
/*
|
|
* Initialize requested data
|
|
*/
|
|
if (in != 0) {
|
|
if (in->haveflags & CLK_HAVETIME1)
|
|
pp->fudgetime1 = in->fudgetime1;
|
|
if (in->haveflags & CLK_HAVETIME2)
|
|
pp->fudgetime2 = in->fudgetime2;
|
|
if (in->haveflags & CLK_HAVEVAL1)
|
|
peer->stratum = (u_char) in->fudgeval1;
|
|
if (in->haveflags & CLK_HAVEVAL2)
|
|
pp->refid = in->fudgeval2;
|
|
if (peer->stratum <= 1)
|
|
peer->refid = pp->refid;
|
|
else
|
|
peer->refid = peer->srcadr.sin_addr.s_addr;
|
|
if (in->haveflags & CLK_HAVEFLAG1) {
|
|
pp->sloppyclockflag &= ~CLK_FLAG1;
|
|
pp->sloppyclockflag |= in->flags & CLK_FLAG1;
|
|
}
|
|
if (in->haveflags & CLK_HAVEFLAG2) {
|
|
pp->sloppyclockflag &= ~CLK_FLAG2;
|
|
pp->sloppyclockflag |= in->flags & CLK_FLAG2;
|
|
}
|
|
if (in->haveflags & CLK_HAVEFLAG3) {
|
|
pp->sloppyclockflag &= ~CLK_FLAG3;
|
|
pp->sloppyclockflag |= in->flags & CLK_FLAG3;
|
|
}
|
|
if (in->haveflags & CLK_HAVEFLAG4) {
|
|
pp->sloppyclockflag &= ~CLK_FLAG4;
|
|
pp->sloppyclockflag |= in->flags & CLK_FLAG4;
|
|
}
|
|
if (in->flags & CLK_FLAG3)
|
|
(void)refclock_ioctl(pp->io.fd, LDISC_PPS);
|
|
}
|
|
|
|
/*
|
|
* Readback requested data
|
|
*/
|
|
if (out != 0) {
|
|
out->haveflags = CLK_HAVETIME1 | CLK_HAVEVAL1 |
|
|
CLK_HAVEVAL2 | CLK_HAVEFLAG4;
|
|
out->fudgetime1 = pp->fudgetime1;
|
|
out->fudgetime2 = pp->fudgetime2;
|
|
out->fudgeval1 = peer->stratum;
|
|
out->fudgeval2 = pp->refid;
|
|
out->flags = (u_char) pp->sloppyclockflag;
|
|
|
|
out->timereset = current_time - pp->timestarted;
|
|
out->polls = pp->polls;
|
|
out->noresponse = pp->noreply;
|
|
out->badformat = pp->badformat;
|
|
out->baddata = pp->baddata;
|
|
|
|
out->lastevent = pp->lastevent;
|
|
out->currentstatus = pp->currentstatus;
|
|
out->type = pp->type;
|
|
out->clockdesc = pp->clockdesc;
|
|
out->lencode = pp->lencode;
|
|
out->p_lastcode = pp->a_lastcode;
|
|
}
|
|
|
|
/*
|
|
* Give the stuff to the clock
|
|
*/
|
|
if (refclock_conf[clktype]->clock_control != noentry)
|
|
(refclock_conf[clktype]->clock_control)(unit, in, out);
|
|
}
|
|
|
|
|
|
/*
|
|
* refclock_buginfo - return debugging info
|
|
*
|
|
* This routine is used mainly for debugging. It returns designated
|
|
* values from the interface structure that can be displayed using
|
|
* xntpdc and the clkbug command.
|
|
*/
|
|
void
|
|
refclock_buginfo(srcadr, bug)
|
|
struct sockaddr_in *srcadr; /* clock address */
|
|
struct refclockbug *bug; /* output structure */
|
|
{
|
|
struct peer *peer;
|
|
struct refclockproc *pp;
|
|
u_char clktype;
|
|
int unit;
|
|
int i;
|
|
|
|
/*
|
|
* Check for valid address and peer structure
|
|
*/
|
|
if (!ISREFCLOCKADR(srcadr))
|
|
return;
|
|
clktype = (u_char) REFCLOCKTYPE(srcadr);
|
|
unit = REFCLOCKUNIT(srcadr);
|
|
if (clktype >= num_refclock_conf || unit > MAXUNIT)
|
|
return;
|
|
if (!(peer = typeunit[clktype][unit]))
|
|
return;
|
|
pp = peer->procptr;
|
|
|
|
/*
|
|
* Copy structure values
|
|
*/
|
|
bug->nvalues = 8;
|
|
bug->values[0] = pp->year;
|
|
bug->values[1] = pp->day;
|
|
bug->values[2] = pp->hour;
|
|
bug->values[3] = pp->minute;
|
|
bug->values[4] = pp->second;
|
|
bug->values[5] = pp->msec;
|
|
bug->values[6] = pp->yearstart;
|
|
bug->values[7] = pp->coderecv;
|
|
|
|
bug->ntimes = pp->nstages + 3;
|
|
if (bug->ntimes > NCLKBUGTIMES)
|
|
bug->ntimes = NCLKBUGTIMES;
|
|
bug->stimes = 0xfffffffc;
|
|
bug->times[0] = pp->lastref;
|
|
bug->times[1] = pp->lastrec;
|
|
UFPTOLFP(pp->dispersion, &bug->times[2]);
|
|
for (i = 0; i < (int)bug->ntimes; i++)
|
|
bug->times[i + 3] = pp->filter[i];
|
|
|
|
/*
|
|
* Give the stuff to the clock
|
|
*/
|
|
if (refclock_conf[clktype]->clock_buginfo != noentry)
|
|
(refclock_conf[clktype]->clock_buginfo)(unit, bug);
|
|
}
|
|
|
|
#endif /* REFCLOCK */
|