#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_unixtime.h"
#include "ntp_tty.h"
#include "ntp_refclock.h"
#include "ntp_stdlib.h"
#include <stdio.h>
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#ifdef REFCLOCK
#ifdef TTYCLK
# ifdef HAVE_SYS_CLKDEFS_H
# include <sys/clkdefs.h>
# include <stropts.h>
# endif
# ifdef HAVE_SYS_SIO_H
# include <sys/sio.h>
# endif
#endif
#ifdef KERNEL_PLL
#include "ntp_syscall.h"
#endif
#ifdef HAVE_PPSAPI
#include "ppsapi_timepps.h"
#include "refclock_atom.h"
#endif
#define FUDGEFAC .1
#define LF 0x0a
#ifdef PPS
int fdpps;
#endif
int cal_enable;
#ifdef QSORT_USES_VOID_P
static int refclock_cmpl_fp (const void *, const void *);
#else
static int refclock_cmpl_fp (const double *, const double *);
#endif
static int refclock_sample (struct refclockproc *);
void
refclock_report(
struct peer *peer,
int code
)
{
struct refclockproc *pp;
pp = peer->procptr;
if (pp == NULL)
return;
switch (code) {
case CEVNT_TIMEOUT:
pp->noreply++;
break;
case CEVNT_BADREPLY:
pp->badformat++;
break;
case CEVNT_FAULT:
break;
case CEVNT_BADDATE:
case CEVNT_BADTIME:
pp->baddata++;
break;
default:
break;
}
if (pp->lastevent < 15)
pp->lastevent++;
if (pp->currentstatus != code) {
pp->currentstatus = (u_char)code;
report_event(PEVNT_CLOCK, peer, ceventstr(code));
}
}
void
init_refclock(void)
{
int i;
for (i = 0; i < (int)num_refclock_conf; i++)
if (refclock_conf[i]->clock_init != noentry)
(refclock_conf[i]->clock_init)();
}
int
refclock_newpeer(
struct peer *peer
)
{
struct refclockproc *pp;
u_char clktype;
int unit;
if (!ISREFCLOCKADR(&peer->srcadr)) {
msyslog(LOG_ERR,
"refclock_newpeer: clock address %s invalid",
stoa(&peer->srcadr));
return (0);
}
clktype = (u_char)REFCLOCKTYPE(&peer->srcadr);
unit = REFCLOCKUNIT(&peer->srcadr);
if (clktype >= num_refclock_conf ||
refclock_conf[clktype]->clock_start == noentry) {
msyslog(LOG_ERR,
"refclock_newpeer: clock type %d invalid\n",
clktype);
return (0);
}
pp = emalloc(sizeof(*pp));
memset(pp, 0, sizeof(*pp));
peer->procptr = pp;
peer->refclktype = clktype;
peer->refclkunit = (u_char)unit;
peer->flags |= FLAG_REFCLOCK;
peer->leap = LEAP_NOTINSYNC;
peer->stratum = STRATUM_REFCLOCK;
peer->ppoll = peer->maxpoll;
pp->type = clktype;
pp->timestarted = current_time;
switch (peer->hmode) {
case MODE_ACTIVE:
peer->pmode = MODE_PASSIVE;
break;
default:
peer->pmode = MODE_SERVER;
break;
}
if (!((refclock_conf[clktype]->clock_start)(unit, peer))) {
refclock_unpeer(peer);
return (0);
}
peer->refid = pp->refid;
return (1);
}
void
refclock_unpeer(
struct peer *peer
)
{
u_char clktype;
int unit;
if (NULL == 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 = NULL;
}
void
refclock_timer(
struct peer *peer
)
{
u_char clktype;
int unit;
clktype = peer->refclktype;
unit = peer->refclkunit;
if (refclock_conf[clktype]->clock_timer != noentry)
(refclock_conf[clktype]->clock_timer)(unit, peer);
}
void
refclock_transmit(
struct peer *peer
)
{
u_char clktype;
int unit;
clktype = peer->refclktype;
unit = peer->refclkunit;
peer->sent++;
get_systime(&peer->xmt);
if (peer->burst == 0) {
u_char oreach;
#ifdef DEBUG
if (debug)
printf("refclock_transmit: at %ld %s\n",
current_time, stoa(&(peer->srcadr)));
#endif
oreach = peer->reach & 0xfe;
peer->reach <<= 1;
if (!(peer->reach & 0x0f))
clock_filter(peer, 0., 0., MAXDISPERSE);
peer->outdate = current_time;
if (!peer->reach) {
if (oreach) {
report_event(PEVNT_UNREACH, peer, NULL);
peer->timereachable = current_time;
}
} else {
if (peer->flags & FLAG_BURST)
peer->burst = NSTAGE;
}
} else {
peer->burst--;
}
if (refclock_conf[clktype]->clock_poll != noentry)
(refclock_conf[clktype]->clock_poll)(unit, peer);
poll_update(peer, peer->hpoll);
}
#ifdef QSORT_USES_VOID_P
static int
refclock_cmpl_fp(
const void *p1,
const void *p2
)
{
const double *dp1 = (const double *)p1;
const double *dp2 = (const double *)p2;
if (*dp1 < *dp2)
return (-1);
if (*dp1 > *dp2)
return (1);
return (0);
}
#else
static int
refclock_cmpl_fp(
const double *dp1,
const double *dp2
)
{
if (*dp1 < *dp2)
return (-1);
if (*dp1 > *dp2)
return (1);
return (0);
}
#endif
void
refclock_process_offset(
struct refclockproc *pp,
l_fp lasttim,
l_fp lastrec,
double fudge
)
{
l_fp lftemp;
double doffset;
pp->lastrec = lastrec;
lftemp = lasttim;
L_SUB(&lftemp, &lastrec);
LFPTOD(&lftemp, doffset);
SAMPLE(doffset + fudge);
}
int
refclock_process_f(
struct refclockproc *pp,
double fudge
)
{
l_fp offset, ltemp;
if (!clocktime(pp->day, pp->hour, pp->minute, pp->second, GMT,
pp->lastrec.l_ui, &pp->yearstart, &offset.l_ui))
return (0);
offset.l_uf = 0;
DTOLFP(pp->nsec / 1e9, <emp);
L_ADD(&offset, <emp);
refclock_process_offset(pp, offset, pp->lastrec, fudge);
return (1);
}
int
refclock_process(
struct refclockproc *pp
)
{
return refclock_process_f(pp, pp->fudgetime1);
}
static int
refclock_sample(
struct refclockproc *pp
)
{
int i, j, k, m, n;
double off[MAXSTAGE];
double offset;
n = 0;
while (pp->codeproc != pp->coderecv) {
pp->codeproc = (pp->codeproc + 1) % MAXSTAGE;
off[n] = pp->filter[pp->codeproc];
n++;
}
if (n == 0)
return (0);
if (n > 1)
qsort(
#ifdef QSORT_USES_VOID_P
(void *)
#else
(char *)
#endif
off, (size_t)n, sizeof(double), refclock_cmpl_fp);
i = 0; j = n;
m = n - (n * 4) / 10;
while ((j - i) > m) {
offset = off[(j + i) / 2];
if (off[j - 1] - offset < offset - off[i])
i++;
else
j--;
}
pp->offset = 0;
pp->jitter = 0;
for (k = i; k < j; k++) {
pp->offset += off[k];
if (k > i)
pp->jitter += SQUARE(off[k] - off[k - 1]);
}
pp->offset /= m;
pp->jitter = max(SQRT(pp->jitter / m), LOGTOD(sys_precision));
#ifdef DEBUG
if (debug)
printf(
"refclock_sample: n %d offset %.6f disp %.6f jitter %.6f\n",
n, pp->offset, pp->disp, pp->jitter);
#endif
return (n);
}
void
refclock_receive(
struct peer *peer
)
{
struct refclockproc *pp;
#ifdef DEBUG
if (debug)
printf("refclock_receive: at %lu %s\n",
current_time, stoa(&peer->srcadr));
#endif
pp = peer->procptr;
peer->leap = pp->leap;
if (peer->leap == LEAP_NOTINSYNC)
return;
peer->received++;
peer->timereceived = current_time;
if (!peer->reach) {
report_event(PEVNT_REACH, peer, NULL);
peer->timereachable = current_time;
}
peer->reach |= 1;
peer->reftime = pp->lastref;
peer->aorg = pp->lastrec;
peer->rootdisp = pp->disp;
get_systime(&peer->dst);
if (!refclock_sample(pp))
return;
clock_filter(peer, pp->offset, 0., pp->jitter);
if (cal_enable && fabs(last_offset) < sys_mindisp && sys_peer !=
NULL) {
if (sys_peer->refclktype == REFCLK_ATOM_PPS &&
peer->refclktype != REFCLK_ATOM_PPS)
pp->fudgetime1 -= pp->offset * FUDGEFAC;
}
}
int
refclock_gtlin(
struct recvbuf *rbufp,
char *lineptr,
int bmax,
l_fp *tsptr
)
{
char s[BMAX];
char *dpt, *dpend, *dp;
dpt = s;
dpend = s + refclock_gtraw(rbufp, s, BMAX - 1, tsptr);
if (dpend - dpt > bmax - 1)
dpend = dpt + bmax - 1;
for (dp = lineptr; dpt < dpend; dpt++) {
char c;
c = *dpt & 0x7f;
if (c >= 0x20 && c < 0x7f)
*dp++ = c;
}
if (dp == lineptr)
return (0);
*dp = '\0';
return (dp - lineptr);
}
int
refclock_gtraw(
struct recvbuf *rbufp,
char *lineptr,
int bmax,
l_fp *tsptr
)
{
char *dpt, *dpend, *dp;
l_fp trtmp, tstmp;
int i;
dpt = (char *)rbufp->recv_buffer;
dpend = dpt + rbufp->recv_length;
trtmp = rbufp->recv_time;
if (dpend >= dpt + 8) {
if (buftvtots(dpend - 8, &tstmp)) {
L_SUB(&trtmp, &tstmp);
if (trtmp.l_ui == 0) {
#ifdef DEBUG
if (debug > 1) {
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;
}
}
if (dpend - dpt > bmax - 1)
dpend = dpt + bmax - 1;
for (dp = lineptr; dpt < dpend; dpt++)
*dp++ = *dpt;
*dp = '\0';
i = dp - lineptr;
#ifdef DEBUG
if (debug > 1)
printf("refclock_gtraw: fd %d time %s timecode %d %s\n",
rbufp->fd, ulfptoa(&trtmp, 6), i, lineptr);
#endif
*tsptr = trtmp;
return (i);
}
#if !defined SYS_VXWORKS && !defined SYS_WINNT
#if defined(HAVE_TERMIOS) || defined(HAVE_SYSV_TTYS) || defined(HAVE_BSD_TTYS)
int
refclock_open(
char *dev,
u_int speed,
u_int lflags
)
{
int fd;
int omode;
omode = O_RDWR;
#ifdef O_NONBLOCK
omode |= O_NONBLOCK;
#endif
#ifdef O_NOCTTY
omode |= O_NOCTTY;
#endif
fd = open(dev, omode, 0777);
if (fd < 0) {
msyslog(LOG_ERR, "refclock_open %s: %m", dev);
return (0);
}
if (!refclock_setup(fd, speed, lflags)) {
close(fd);
return (0);
}
if (!refclock_ioctl(fd, lflags)) {
close(fd);
return (0);
}
return (fd);
}
int
refclock_setup(
int fd,
u_int speed,
u_int lflags
)
{
int i;
TTY ttyb, *ttyp;
#ifdef PPS
fdpps = fd;
#endif
ttyp = &ttyb;
#ifdef HAVE_TERMIOS
if (tcgetattr(fd, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_setup fd %d tcgetattr: %m", fd);
return (0);
}
if (speed) {
u_int ltemp = 0;
ttyp->c_iflag = IGNBRK | IGNPAR | ICRNL;
ttyp->c_oflag = 0;
ttyp->c_cflag = CS8 | CLOCAL | CREAD;
if (lflags & LDISC_7O1) {
ttyp->c_cflag = CS7 | PARENB | PARODD | CLOCAL | CREAD;
}
cfsetispeed(&ttyb, speed);
cfsetospeed(&ttyb, speed);
for (i = 0; i < NCCS; ++i)
ttyp->c_cc[i] = '\0';
#if defined(TIOCMGET) && !defined(SCO5_CLOCK)
if (ioctl(fd, TIOCMGET, (char *)<emp) < 0)
msyslog(LOG_ERR,
"refclock_setup fd %d TIOCMGET: %m", fd);
#ifdef DEBUG
if (debug)
printf("refclock_setup fd %d modem status: 0x%x\n",
fd, ltemp);
#endif
if (ltemp & TIOCM_DSR && lflags & LDISC_REMOTE)
ttyp->c_cflag &= ~CLOCAL;
#endif
}
ttyp->c_lflag = ICANON;
if (lflags & LDISC_RAW) {
ttyp->c_lflag = 0;
ttyp->c_iflag = 0;
ttyp->c_cc[VMIN] = 1;
}
if (lflags & LDISC_ECHO)
ttyp->c_lflag |= ECHO;
if (tcsetattr(fd, TCSANOW, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_setup fd %d TCSANOW: %m", fd);
return (0);
}
#endif
#ifdef HAVE_SYSV_TTYS
if (ioctl(fd, TCGETA, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_setup fd %d TCGETA: %m", fd);
return (0);
}
if (speed) {
u_int ltemp = 0;
ttyp->c_iflag = IGNBRK | IGNPAR | ICRNL;
ttyp->c_oflag = 0;
ttyp->c_cflag = speed | CS8 | CLOCAL | CREAD;
for (i = 0; i < NCCS; ++i)
ttyp->c_cc[i] = '\0';
#if defined(TIOCMGET) && !defined(SCO5_CLOCK)
if (ioctl(fd, TIOCMGET, (char *)<emp) < 0)
msyslog(LOG_ERR,
"refclock_setup fd %d TIOCMGET: %m", fd);
#ifdef DEBUG
if (debug)
printf("refclock_setup fd %d modem status: %x\n",
fd, ltemp);
#endif
if (ltemp & TIOCM_DSR)
ttyp->c_cflag &= ~CLOCAL;
#endif
}
ttyp->c_lflag = ICANON;
if (lflags & LDISC_RAW) {
ttyp->c_lflag = 0;
ttyp->c_iflag = 0;
ttyp->c_cc[VMIN] = 1;
}
if (ioctl(fd, TCSETA, ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_setup fd %d TCSETA: %m", fd);
return (0);
}
#endif
#ifdef HAVE_BSD_TTYS
if (ioctl(fd, TIOCGETP, (char *)ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_setup fd %d TIOCGETP: %m", fd);
return (0);
}
if (speed)
ttyp->sg_ispeed = ttyp->sg_ospeed = speed;
ttyp->sg_flags = EVENP | ODDP | CRMOD;
if (ioctl(fd, TIOCSETP, (char *)ttyp) < 0) {
msyslog(LOG_ERR,
"refclock_setup TIOCSETP: %m");
return (0);
}
#endif
return(1);
}
#endif
#endif
int
refclock_ioctl(
int fd,
u_int lflags
)
{
#if !defined SYS_VXWORKS && !defined SYS_WINNT
#if defined(HAVE_TERMIOS) || defined(HAVE_SYSV_TTYS) || defined(HAVE_BSD_TTYS)
#ifdef DEBUG
if (debug)
printf("refclock_ioctl: fd %d flags 0x%x\n", fd,
lflags);
#endif
#ifdef TTYCLK
if (lflags & (LDISC_CLK | LDISC_CLKPPS | LDISC_ACTS)) {
int rval = 0;
if (ioctl(fd, I_PUSH, "clk") < 0) {
msyslog(LOG_NOTICE,
"refclock_ioctl fd %d I_PUSH: %m", fd);
return (0);
#ifdef CLK_SETSTR
} else {
char *str;
if (lflags & LDISC_CLKPPS)
str = "\377";
else if (lflags & LDISC_ACTS)
str = "*";
else
str = "\n";
if (ioctl(fd, CLK_SETSTR, str) < 0) {
msyslog(LOG_ERR,
"refclock_ioctl fd %d CLK_SETSTR: %m", fd);
return (0);
}
#endif
}
}
#endif
#endif
#endif
return (1);
}
void
refclock_control(
sockaddr_u *srcadr,
struct refclockstat *in,
struct refclockstat *out
)
{
struct peer *peer;
struct refclockproc *pp;
u_char clktype;
int unit;
if (!ISREFCLOCKADR(srcadr))
return;
clktype = (u_char)REFCLOCKTYPE(srcadr);
unit = REFCLOCKUNIT(srcadr);
peer = findexistingpeer(srcadr, NULL, -1);
if (NULL == peer || NULL == peer->procptr)
return;
pp = peer->procptr;
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 = pp->stratum = (u_char)in->fudgeval1;
if (in->haveflags & CLK_HAVEVAL2)
peer->refid = pp->refid = in->fudgeval2;
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 (out != 0) {
out->haveflags = CLK_HAVETIME1 | CLK_HAVEVAL1 |
CLK_HAVEVAL2 | CLK_HAVEFLAG4;
out->fudgetime1 = pp->fudgetime1;
out->fudgetime2 = pp->fudgetime2;
out->fudgeval1 = pp->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 = (u_short)pp->lencode;
out->p_lastcode = pp->a_lastcode;
}
if (refclock_conf[clktype]->clock_control != noentry)
(refclock_conf[clktype]->clock_control)(unit, in, out, peer);
}
void
refclock_buginfo(
sockaddr_u *srcadr,
struct refclockbug *bug
)
{
struct peer *peer;
struct refclockproc *pp;
int clktype;
int unit;
unsigned u;
if (!ISREFCLOCKADR(srcadr))
return;
clktype = (u_char) REFCLOCKTYPE(srcadr);
unit = REFCLOCKUNIT(srcadr);
peer = findexistingpeer(srcadr, NULL, -1);
if (NULL == peer || NULL == peer->procptr)
return;
pp = peer->procptr;
bug->nvalues = 8;
bug->svalues = 0x0000003f;
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->nsec;
bug->values[6] = pp->yearstart;
bug->values[7] = pp->coderecv;
bug->stimes = 0xfffffffc;
bug->times[0] = pp->lastref;
bug->times[1] = pp->lastrec;
for (u = 2; u < bug->ntimes; u++)
DTOLFP(pp->filter[u - 2], &bug->times[u]);
if (refclock_conf[clktype]->clock_buginfo != noentry)
(refclock_conf[clktype]->clock_buginfo)(unit, bug, peer);
}
#ifdef HAVE_PPSAPI
int
refclock_ppsapi(
int fddev,
struct refclock_atom *ap
)
{
if (ap->handle == 0) {
if (time_pps_create(fddev, &ap->handle) < 0) {
msyslog(LOG_ERR,
"refclock_ppsapi: time_pps_create: %m");
return (0);
}
}
return (1);
}
int
refclock_params(
int mode,
struct refclock_atom *ap
)
{
memset(&ap->pps_params, 0, sizeof(pps_params_t));
ap->pps_params.api_version = PPS_API_VERS_1;
if (mode & CLK_FLAG2)
ap->pps_params.mode = PPS_TSFMT_TSPEC | PPS_CAPTURECLEAR;
else
ap->pps_params.mode = PPS_TSFMT_TSPEC | PPS_CAPTUREASSERT;
if (time_pps_setparams(ap->handle, &ap->pps_params) < 0) {
msyslog(LOG_ERR,
"refclock_params: time_pps_setparams: %m");
return (0);
}
if (mode & CLK_FLAG3) {
if (time_pps_kcbind(ap->handle, PPS_KC_HARDPPS,
ap->pps_params.mode & ~PPS_TSFMT_TSPEC,
PPS_TSFMT_TSPEC) < 0) {
if (errno != EOPNOTSUPP) {
msyslog(LOG_ERR,
"refclock_params: time_pps_kcbind: %m");
return (0);
}
}
pps_enable = 1;
}
return (1);
}
int
refclock_pps(
struct peer *peer,
struct refclock_atom *ap,
int mode
)
{
struct refclockproc *pp;
pps_info_t pps_info;
struct timespec timeout;
double dtemp;
pp = peer->procptr;
if (ap->handle == 0)
return (0);
if (ap->pps_params.mode == 0 && sys_leap != LEAP_NOTINSYNC) {
if (refclock_params(pp->sloppyclockflag, ap) < 1)
return (0);
}
timeout.tv_sec = 0;
timeout.tv_nsec = 0;
memset(&pps_info, 0, sizeof(pps_info_t));
if (time_pps_fetch(ap->handle, PPS_TSFMT_TSPEC, &pps_info,
&timeout) < 0) {
refclock_report(peer, CEVNT_FAULT);
return (0);
}
timeout = ap->ts;
if (ap->pps_params.mode & PPS_CAPTUREASSERT)
ap->ts = pps_info.assert_timestamp;
else if (ap->pps_params.mode & PPS_CAPTURECLEAR)
ap->ts = pps_info.clear_timestamp;
else
return (0);
if (ap->ts.tv_sec <= timeout.tv_sec || abs(ap->ts.tv_nsec -
timeout.tv_nsec) > RANGEGATE)
return (0);
pp->lastrec.l_ui = ap->ts.tv_sec + JAN_1970;
dtemp = ap->ts.tv_nsec / 1e9;
pp->lastrec.l_uf = (u_int32)(dtemp * FRAC);
if (dtemp > .5)
dtemp -= 1.;
SAMPLE(-dtemp + pp->fudgetime1);
#ifdef DEBUG
if (debug > 1)
printf("refclock_pps: %lu %f %f\n", current_time,
dtemp, pp->fudgetime1);
#endif
return (1);
}
#endif
#endif